Delegate a playbook step

Apply the common work contract within this task’s scope. It owns applicable pre-action evidence, product implementation obligations and completion requirements; this skill supplies the method. Current common guidance already delivered or read may be reused.

The main session chooses the step and task scope; the playbook contract selects its required guidance. Use a repository-required agent when specified, otherwise worker, in a fresh context. Keep stage decisions, acceptance criteria and integration in the main session. Work directly when splitting adds no value. This skill does not require running every playbook stage.

Repository agent selection does not replace this packet procedure: an implementer, tester or verifier still receives the selected step's complete guidance. Preserve repository scope and host-enforced permissions; report conflicting instructions before dependent work instead of silently omitting guidance or widening permissions. This applies to delegated haechi playbook steps, not every repository agent invocation.

1. Select a delegated operation using a compatible playbook/step entry; an active primary playbook is not required. For its input form, run node <plugin-root>/tools/delegate-task.mjs describe <plugin-root> <playbook> <step>. This reads the authoritative contract and returns required context fields, write mode, completion criteria and guidance names, without worker procedure bodies. Read broader playbook guidance when needed to choose the workflow; do not read worker skills or helper source merely to assemble a handoff.
2. Save the returned input object as <brief.json> and fill its task-specific values: objective, named evidence/path context, owned files, authorized artifact paths, constraints and completion. Keep playbookSha256 and the exact writeScope value from the form. Use repository-relative owned paths (a trailing / means a directory); read-only work has none. Artifact paths must be explicitly authorized absolute paths. Include repo commands and forbidden commands in context.repository. Record truthful not-applicable reasons only where the task permits them; never invent reproduction or prior evidence. Add task-specific acceptance without copying the fixed criteria: assembly includes those automatically. Do not paste skill bodies or the whole conversation into the brief. For independent verifier work, put the relevant original request and agreed amendments in context.requirements, preserving their wording, or provide exact accessible source references. Include established contracts and unchanged behavior; do not replace these sources with the implementer's summary. Use a neutral objective. Provide implementation explanations and priorEvidence as deferred source references rather than inline claims, and tell the verifier to read them after establishing expected behavior under review-diff. Keep repository safety constraints, permissions and scope available from the start. Use a fresh worker without inherited implementation history when the host supports it; otherwise disclose the exposure limit. This uses the existing packet fields and review execution, not another mandatory agent or stage.
3. Run node <plugin-root>/tools/delegate-task.mjs assemble <plugin-root> <brief.json> <new-task-directory>. Choose an authorized artifact location outside others' owned files; the directory must not exist. The tool saves the complete packet and worker message and prints only the task, merged completion criteria, source hashes, guidance inventory and file locations. Inspect this compact receipt for the correct task/scope/acceptance; do not print the saved full bodies back into the main context. Missing context, changed playbook, missing sources or oversized guidance are errors, not silent omissions. If the form is stale, inspect the new contract before using it.
4. Have the host validate the saved packet with renderPacket and deliver that complete result directly to a fresh worker, without routing the full text through the main model. For an independent verifier, explicitly set fork_turns: "none" when the host's spawn_agent exposes that option; do not rely on its default. On other hosts, use the equivalent control to disable parent conversation inheritance and report unsupported or unverified isolation. Preparation is not dispatch. If the host only accepts model-authored string messages, use the transport fallback; that path cannot avoid main-context delivery cost. Required host permissions must remain enforced. Leave model and effort to session/host defaults unless explicitly required, and record actual settings when evaluating.
5. Return execution evidence with the worker result, using the host's observed tool records and target versions. Use the return protocol when a host adapter can supply those records. For an already registered shared task, publish the compact graph handoff in one host call: validate records, save the full proof, update the existing graph and return decision inputs instead of also forwarding the full bundle. Skip graph publication for short standalone work. A worker-written report or hash alone is not execution proof. If the host cannot expose records, arrange authorized evidence artifacts before dispatch or report execution as unverified; do not search unrelated folders for missing logs.
6. Reuse guidance the main actually read when its content, task scope and retained context still match. On changed sources/scope/session or lost context, reread the guidance needed for the main's decision. A compact receipt does not prove a body was read; absent receipts do not require loading worker-only procedures into the main. Read those procedures when doing that work or when a concrete review question needs them. Reuse never replaces independent artifact verification, ownership checks or required tests.
7. Check the returned packet identifier, actual edits and evidence against the original brief. Independently review the result when useful using a new worker execution. A matching identifier or integrity check is not proof the instructions were followed or behavior passed. Missing, failed or mismatched evidence remains unverified/failed as appropriate. The main session reconciles the review's per-outcome results with the original requirements before deciding completion and the next playbook step; review completion alone does not verify the requested behavior.

The helper is portable across Claude and Codex and does not spawn an agent or change settings. Only assemble writes the explicitly requested task artifacts; legacy prepare and render remain available. Optional references are not automatically included. Hooks supply repository facts and do not enforce this handoff.