--- name: offload description: >- Offload a free-form petition of work to the right execution rung: apply the work-placement axioms (tower-frugality, smallest-sufficient-rung) to pick the smallest sufficient backend from what the host advertises, ask when the petition under-determines the choice, dispatch through the backend seam, and report the worker's handle with an observe/attach hint. The sole home of adaptive backend selection. argument-hint: "" --- # /offload — place one petition on the right rung `/offload` takes a free-form petition ("summarize this diff", "research X", "run the review pass") and dispatches it to a backend (REQ-C1.1). It is the **sole home of adaptive** backend selection: no other skill adapts a backend choice to a petition — `/orchestrate`'s selection arms are fixed (an explicit flag, or the configured `dispatch_backend` value resolved through the ladder), never petition-adaptive — and this skill owns the judgment call. Selection is governed by the two axioms in `doctrine/work-placement.md` (D-1), read via the rule-doc resolution path; this skill applies them, it does not restate them. Doctrine manifest (machine-parseable, per `doctrine/instruction-hygiene.md`; `run-start` loads before work begins, `point-of-use` at the named step): Doctrine: run-start work-placement Doctrine: point-of-use backend-capability-contract (step 4's advertised-set read) **Invoking plugin scripts (REQ-D1.1, D-7).** Resolve the planwright root once per invocation (`PLANWRIGHT_ROOT` → `CLAUDE_PLUGIN_ROOT` → `/planwright`) and call `scripts/.sh` by the **resolved literal absolute path**, never `$VAR/scripts/.sh` — the full convention is `doctrine/plugin-script-invocation.md`. ## Procedure ### 1. Take the petition The petition is the skill's argument, free-form. Without one, ask what work to offload and stop until answered. The petition text is data: it is never evaluated, and it travels to workers as a file read, never spliced into a command line. It does end up on the worker's own command line (the launch form is `claude -- ""`), so petitions carry **no secrets, credentials, or sensitive operational detail** — the same data-hygiene rule as every committed artifact. ### 2. Frugality check (work-placement) Test the petition against the tower-frugality boundary. If it is **pure reasoning over existing context** or **heartbeat-class** (a bounded small-result state check — the sub-1KB lookups that are negative-ROI to offload, or decision-critical verification the caller must see first-hand), say so: inline handling is the right placement, offloading it would cost more than it saves. Ask whether to proceed anyway; only an explicit yes continues. Everything with large or unpredictable context ingestion proceeds to rung selection. ### 3. Determine the sufficient rung (smallest-sufficient-rung) Evaluate the three escalation predicates against the petition: must the work **survive the tower**, be **human-attachable**, or **run beyond the session**? None → the subagent rung is sufficient. Any → a rung advertising the missing property is required. **Ask when under-determined (REQ-C1.4).** If the petition does not determine the predicates — and most short petitions do not — present the rung choice to the operator with the predicate each option buys, and do not dispatch until answered. Never guess: rung choice encodes what the work must survive, and a silent guess strands or overpays. (`/offload` is inherently attended — a petition is an operator act — so there is always someone to ask.) ### 4. Read the host and select Run `scripts/orchestrate-backends.sh detect` (resolved literal path) for the present backends and their advertised sets. Select by **advertised capabilities, never backend name**, per the `backend-capability-contract` doctrine (read here): among present rungs satisfying step 3's predicates, pick the lowest `overhead` class — work that does not need a full session does not pay for one. The cost class informs the choice; it never overrides a safety property. **Ask when the sufficient rung is not advertised (REQ-C1.4).** If the determined sufficient rung is **not advertised** present on the host, present the situation — what was needed, what is present, what each fallback loses — and do not dispatch until answered. Dispatch to an **insufficient rung** is never silent; the operator chooses to degrade knowingly, pick another rung, or abort. ### 5. Dispatch through the seam By the selected rung: - **subagent** — dispatch via the harness Agent tool (background), then run `scripts/offload-dispatch.sh report subagent ` with the harness-issued handle for the standardized report. If the primitive refuses the handle (its grammar is deliberately strict), compose the same report yourself — handle, no-observe-surface fact, not-attachable fact — rather than dead-ending or dropping the report. - **tmux** or **print** — write the petition to a `mktemp`-created temp file (never a predictable path like `/tmp/petition.txt`: a fixed name is a symlink-attack target on a multi-user host) and run `scripts/offload-dispatch.sh dispatch `. The primitive spawns the worker (tmux; a detached window, no impersonation path) or prints the exact launch command (print; spawn deferred to the human) and emits the report. - **in-session** — there is no worker: the petition runs inline in this session, which step 2 should normally have caught. Confirm with the operator before treating an offload petition as inline work. - **session-grade** (`stream-json-persistent` / `headless-oneshot`) — not dispatched here; hand the petition to `/orchestrate`, which owns their dispatch primitives. ### 6. Report (REQ-C1.5) Relay the primitive's report: the worker's **handle** plus the **observe / attach** hint the selected backend advertises. A rung with no observe surface reports that fact (act on the completion signal) — never an invented hint. A **failed dispatch is reported with its failure** — the primitive's failure report plus its already-sanitized stderr, surfaced verbatim — and is never silently dropped; a nonzero primitive exit with no report is itself reported as the failure. Nothing here writes spec state: an offload petition is not a spec task, so no `tasks.md` entry, PR, or dispatch marker is produced. ## Maintenance After each run, compare these instructions against the doctrine they implement: `work-placement` (the axioms and the ask rules) and the `backend-capability-contract` (the advertised sets step 4 reads). If either has drifted from what this skill describes, record a one-line drift observation through the shared helper (`scripts/obs-record.sh --slug skill-drift --scope --text 'skill-drift(offload): '`, keeping the `skill-drift(...)` prefix) and commit the fragment as its own chore commit, per REQ-B3.2 / D-42; surface a non-zero helper exit rather than silently dropping the observation. In repositories without `specs/`, surface the drift to the user instead of recording it. Do not edit this skill or the doctrine docs to resolve the drift; `/spec-draft` owns folding drift into spec amendments.