delegation-layer 0.1.19 → 0.1.21

package/README.md

@@ -20,6 +20,8 @@ already use instead of replacing them.
   and time budget.
 - **Recoverable results** — a later `collect` call can read a finished task
   without launching the provider again.
+- **Clarify while work runs** — answer native questions through Delegate; steer
+  an active Codex turn without restarting it. [Interactive tasks](docs/cli-reference.md#interactive-tasks).
 - **Resumable turns** — a durable timeout can continue the exact provider
   session through a linked successor task.
 - **Runtime compatibility** — the selected provider's executable and advertised
@@ -47,7 +49,9 @@ Delegate to launch another instance of the same CLI.
 
 Skill installation makes this workflow discoverable; it does not force a model
 to choose it over another plugin. Selection depends on the harness, model, and
-loaded instructions. No user rules, settings, or competing plugins are rewritten.
+loaded instructions. The plugin and optional installer routing hooks supply a
+shared preference at session and subagent startup; they do not intercept tools
+or rewrite your persistent instructions.
 If an agent bypasses Delegate, that is a selection failure, not proof the
 integration worked. For a persistent preference, see
 [configure agent routing](docs/agent-routing.md).
@@ -57,7 +61,7 @@ integration worked. For a persistent preference, see
 ### Recommended for Codex and Claude Code
 
 Install the plugin from this repository. It installs the provider-neutral skill
-and runs a trusted session-start bootstrap that reuses the checksum-verified
+and provides collaboration context hooks plus a trusted session-start bootstrap that reuses the checksum-verified
 Delegation Layer release installer when `delegate` is missing. The bootstrap
 installs the CLI and its bundled supervisor; it does not install provider CLIs,
 change provider authentication, or change provider configuration.
@@ -101,8 +105,9 @@ If you want the Delegation Layer guided installer instead, run:
 npx --yes delegation-layer install
 ```
 
-It provides an interactive scope and harness picker, with global installation
-selected by default. For scripts or a choice without prompts:
+It provides interactive scope, harness, and routing choices. Global installation
+and routing hooks for Claude/Codex are selected by default; choose skill-only
+to omit hooks. Codex requires native hook trust before activation. For scripts or a choice without prompts:
 
 ```sh
 npx --yes delegation-layer install \
@@ -111,8 +116,10 @@ npx --yes delegation-layer install \
   --yes
 ```
 
-This path installs guidance only. It does not install the CLI, change provider
-logins, or run a task. Use the plugin path above when you want the skill and
+The commands above do not install the CLI, change provider
+logins, or run a task. Noninteractive installs remain skill-only unless you add
+`--routing default`. See [routing setup and removal](docs/agent-routing.md).
+Use the plugin path above when you want the skill and
 CLI bootstrap together.
 
 ### Install the CLI

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "delegation-layer",
-  "version": "0.1.19",
+  "version": "0.1.21",
   "description": "Multi-provider AI agent delegation CLI and Agent Skill for running bounded coding tasks across provider CLIs.",
   "keywords": [
     "ai-agents",

package/plugins/delegation-layer/.claude-plugin/plugin.json

@@ -1,7 +1,7 @@
 {
   "name": "delegation-layer",
   "displayName": "Delegation Layer",
-  "version": "0.1.19",
+  "version": "0.1.21",
   "description": "Consult external AI harnesses and CCR-configured models for reviews, research, implementation, and debate through the resumable Delegate CLI.",
   "author": {
     "name": "Hesham Karam",

package/plugins/delegation-layer/.codex-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "delegation-layer",
-  "version": "0.1.19",
+  "version": "0.1.21",
   "description": "Consult external AI harnesses and CCR-configured models for reviews, research, implementation, and debate through the resumable Delegate CLI.",
   "author": {
     "name": "Hesham Karam",

package/plugins/delegation-layer/hooks/hooks.json

@@ -8,6 +8,24 @@
             "command": "/bin/sh -c 'plugin_root=\"${CLAUDE_PLUGIN_ROOT:-${PLUGIN_ROOT:?plugin root environment variable is missing}}\"; exec \"$plugin_root/scripts/ensure-delegate.sh\"'"
           }
         ]
+      },
+      {
+        "hooks": [
+          {
+            "type": "command",
+            "command": "/bin/sh -c 'plugin_root=\"${CLAUDE_PLUGIN_ROOT:-${PLUGIN_ROOT:?plugin root environment variable is missing}}\"; exec /bin/sh \"$plugin_root/skills/agent-integration/scripts/delegate-routing-context.sh\" SessionStart'"
+          }
+        ]
+      }
+    ],
+    "SubagentStart": [
+      {
+        "hooks": [
+          {
+            "type": "command",
+            "command": "/bin/sh -c 'plugin_root=\"${CLAUDE_PLUGIN_ROOT:-${PLUGIN_ROOT:?plugin root environment variable is missing}}\"; exec /bin/sh \"$plugin_root/skills/agent-integration/scripts/delegate-routing-context.sh\" SubagentStart'"
+          }
+        ]
       }
     ]
   }

package/plugins/delegation-layer/skills/agent-integration/SKILL.md

@@ -1,6 +1,6 @@
 ---
 name: agent-integration
-description: Delegate external tasks to CCR (Claude Code Router) and other agents. Use for Codex, Claude, AGY, and other external agent or model collaboration for reviews, research, implementation, testing, second opinions, comparisons, and debates, including collaboration you choose during a task. Discover other supported harnesses such as Pi and OpenCode through Delegate. Not for ordinary native subagents, provider setup, or questions merely about a tool.
+description: Coordinate external agent, model, and separate harness tasks through Delegate, including research, implementation, tests, reviews, consultations, comparisons, and debates. Use before choosing an external integration; ordinary native subagents and questions about tools remain local.
 ---
 
 # Delegation Layer
@@ -56,13 +56,27 @@ tasks may proceed; the failed attempt must remain reported as failed or blocked.
    finite budget. Keep the state root outside the workspace. Reuse a supplied
    `DELEGATE_ROOT` for all providers and tasks; do not invent per-provider or
    per-task state roots. Task IDs separate work within that root.
-4. Use `--json` and save the returned `task_id`. Read `admission`, `liveness`,
+4. Use `--json` and save each response separately with its requested destination,
+   model, effort, workspace, and returned `task_id`. Never merge concurrent
+   responses into an unlabeled output stream. Read `admission`, `liveness`,
    `publication`, `status`, `outcome`, `continuation`, `task_record`, `failure`,
    and `error` as separate fields.
    Delegate owns the supervisor lifecycle. Never install, configure, start,
    inspect, or repair Pueue, and never poll a task unless the response says its
    `task_record` is `created`.
-5. Observe with `status` and collect with `collect`. Collection may recover the
+5. Observe tasks only through Delegate `status`, `collect`, or `events`.
+   Do not run `ps`, `pgrep`, process-tree searches, or supervisor commands to
+   monitor delegated work. Pending output is normal startup or work in progress;
+   empty `pending_requests` means keep collecting, not diagnose the environment.
+   Environment diagnostics require a separately requested troubleshooting task.
+   Keep collection in the
+   foreground until all requested tasks reach a terminal result or an explicit
+   blocker. Do not end a headless turn promising a background notification.
+   Pending publication (exit 3) means keep waiting, not success. When the JSON
+   includes an outstanding `interaction.pending_requests` batch, follow
+   [active-task interaction](references/interaction.md) before waiting again. Only detach
+   when the user explicitly requests it, retaining the exact task IDs.
+   Collection may recover the
    saved supervisor only to observe an already-requested budget stop; it never
    launches a provider or retries a task.
 6. If a task is timed out and its JSON says `continuation.resumable: true`, use
@@ -114,7 +128,7 @@ normal task. For an explicitly requested readiness check, see
 [preflight guidance](references/command-reference.md#checking-readiness).
 
 The catalog and `capabilities` response expose supported permission modes,
-request options, continuation, and the read-only mechanism. A read-only
+request options, continuation, native interaction, and the read-only mechanism. A read-only
 capability with `containment: "provider-owned"` selects the provider's native
 behavior but is not an independent delegate-owned sandbox. Static discovery
 does not prove authentication or live acceptance; use the dispatch or live
@@ -129,28 +143,48 @@ name belongs to CCR; clarify only if discovery leaves the destination ambiguous.
 
 Keep provider defaults when no model or effort was requested and neither is required. When an explicit
 choice is needed, read [model and effort guidance](references/command-reference.md#choosing-models-and-effort).
-Pass requested choices through Delegate's public `--model` and `--effort`
-fields; discovery is advisory, never an allowlist.
+Pass exact requested model IDs and effort values unchanged through Delegate's
+public `--model` and `--effort` fields; discovery is advisory, never an allowlist.
+For a natural-language model name, resolve one exact ID through discovery. If
+it remains ambiguous or discovery is unavailable, ask for the exact model ID;
+do not turn a display name into a guessed alias. An explicit ID needs no such
+clarification just because it is absent from discovery.
+
+For planning, consultation, debate, or other external work that may need
+answers or guidance while it runs, read [active-task interaction](references/interaction.md)
+and use `--interactive` when supported. Answer known facts yourself; ask the
+user for missing preferences, authorization, or scope. Keep ordinary native
+subagents available under the same-harness rule above.
 
 ### 3. Prepare separate paths and a finite brief
 
 Use an existing task brief when one is supplied. Otherwise create a bounded
 brief file that contains the requested work and its acceptance criteria. Keep
 the state root outside the workspace and provider-writable trees (which can
-include the system temporary directory). Use `DELEGATE_ROOT` when supplied:
+include the system temporary directory). Use `DELEGATE_ROOT` when supplied.
 
 Run path preparation and dispatch in **one shell/tool invocation**, as shown
 below. Shell variables may disappear between tool calls. For later commands,
 use the actual saved absolute paths or assign them again in that invocation;
 never pass an empty `--root`, `--brief`, or `--cwd`.
 
-Replace the example brief below with the actual user request. Do not place the state
+Write the brief as the **worker’s own assignment**, not a copy of the
+orchestration request. For “consult another agent about X”, tell the worker
+“Investigate X and return your findings; you are the assigned worker, do not
+delegate this assignment.” Keep dispatching, answering questions, and
+collecting results in the lead session unless recursive delegation was
+explicitly requested.
+
+Replace the example brief below with that bounded worker assignment. Do not place the state
 root inside the workspace or place secrets in either path’s task data. Keep it
 outside provider configuration and runtime directories as well. If delegate
 rejects a caller-supplied state root, report the placement error rather than
-silently replacing that root. If no root was supplied, choose one outside the
-workspace and reuse it. Do not change provider settings. Retain the selected
-root for every observation and continuation.
+silently replacing that root. For every task command, use
+`--root "${DELEGATE_ROOT:-$HOME/delegation-state}"` as shown below. This reads the supplied root in each shell call and uses the
+same default when none was supplied; no root setup or new directory choice is
+needed. If the user explicitly requests another root, substitute that exact
+absolute path consistently. Do not change provider settings or switch roots
+when waiting, replying, steering, or continuing.
 
 ### 4. Dispatch one bounded turn
 
@@ -159,19 +193,22 @@ For a named harness or provider resolved in step 2, replace `--auto` with `--pro
 combine the two:
 
 ```sh
-STATE_ROOT="${DELEGATE_ROOT:-$HOME/delegation-state}"
 WORKSPACE="$PWD"
 BRIEF="$(mktemp)"
+RESPONSE="$(mktemp)"
 cat >"$BRIEF" <<'EOF'
 Describe the delegated task, the files or behavior to change, and the checks
 that must pass. Keep the response concise and report validation evidence.
 EOF
-delegate --root "$STATE_ROOT" dispatch --auto \
+delegate --root "${DELEGATE_ROOT:-$HOME/delegation-state}" dispatch --auto \
   --brief "$BRIEF" \
   --cwd "$WORKSPACE" \
   --permission read-only \
   --budget 30m \
-  --json
+  --json >"$RESPONSE"
+dispatch_exit=$?
+cat "$RESPONSE"
+printf '\nDispatch exit: %s; saved response: %s\n' "$dispatch_exit" "$RESPONSE"
 ```
 
 For an authorized code change, use `--permission workspace-write`; this requests
@@ -185,7 +222,16 @@ For independent work, the model may run several complete `dispatch` commands
 concurrently. Keep each task's brief, workspace, permission, and task ID
 independent. Do not configure Pueue or wait for one task before dispatching the
 next solely to serialize ordinary work. Inspect each returned task separately
-with `status` and `collect`.
+with `status` and `collect`. Use independent tool calls or separate response
+files, never background commands writing to the same stdout. Read
+[parallel reviews and debates](references/collaboration.md) when coordinating
+multiple participants or challenge rounds.
+
+Capture the response and exit status in the **original** dispatch invocation,
+as above. Read the saved response if you need it again. Never repeat dispatch
+to obtain its exit code, recover output, or confirm that it worked: each call
+can create new paid work. Once a response says `task_record: created`, save its
+`task_id` and switch to observation. A missing exit code does not undo admission.
 
 Save the exact `task_id` from the JSON response. Apply this decision separately
 for **each attempt**, including requests issued together:
@@ -205,16 +251,20 @@ never retry that uncertain ID or run Pueue commands.
 
 ### 5. Observe and collect
 
-Use the same state root and task ID:
+Use the same state root and task ID. Each command below resolves the root
+in its own shell call, so it does not depend on a previous shell variable:
 
 ```sh
-delegate --root "$STATE_ROOT" status TASK_ID --json
-delegate --root "$STATE_ROOT" collect TASK_ID --watch 5s --json
+delegate --root "${DELEGATE_ROOT:-$HOME/delegation-state}" status TASK_ID --json
+delegate --root "${DELEGATE_ROOT:-$HOME/delegation-state}" collect TASK_ID --watch 5s --json
 ```
 
 Check `status` first: if it is `timed_out`, follow step 6 even when publication
-is pending and no outcome is present. Otherwise, if `collect` exits with code
-`3` because publication is still pending, wait a short interval and run
+is pending and no outcome is present. If `interaction.pending_requests` is
+nonempty and the interaction is not closed, answer the questions using
+[active-task interaction](references/interaction.md) before collecting again.
+Otherwise, if `collect` exits with code `3` because publication is still
+pending, wait a short interval and run
 `collect` again. Do not dispatch again. Continue until
 the response has a terminal `outcome` or a bounded operational error that
 requires the caller’s attention.

package/plugins/delegation-layer/skills/agent-integration/evals/evals.json

@@ -56,6 +56,46 @@
       "name": "write-timeout",
       "prompt": "An authorized write task has status timed_out, publication unknown, no outcome, and continuation.resumable true.",
       "expected": ["delegate continue --task", "same state root", "new task id", "do not wait indefinitely for an outcome", "no fresh unrelated dispatch"]
+    },
+    {
+      "name": "admitted-without-explicit-exit-marker",
+      "prompt": "Dispatch returned task_record created, admission admitted, and a task_id. The shell output did not include a separate EXIT marker. Confirm the task and collect its result.",
+      "expected": ["use status with returned task_id", "read saved dispatch response if needed", "do not dispatch again to print an exit code", "exactly one admitted task for the assignment"]
+    },
+    {
+      "name": "supplied-root-across-shell-calls",
+      "prompt": "DELEGATE_ROOT is already set. Consult a separate external agent and answer its questions; each shell tool call starts a new shell.",
+      "expected": ["use supplied DELEGATE_ROOT on dispatch, status, collect, reply, steer, and continue", "resolve the same root in each shell call", "no invented task-specific root"]
+    },
+    {
+      "name": "pending-without-questions",
+      "prompt": "The admitted task is running. Collect exits 3 with pending publication, empty pending_requests, and no operational error.",
+      "expected": ["keep collecting the same task", "no ps or pgrep or process-tree inspection", "no supervisor commands", "no duplicate dispatch", "answer through delegate reply when a question appears"]
+    },
+    {
+      "name": "interactive-worker-assignment",
+      "prompt": "Consult a separate external agent about a pricing plan and answer its questions from README.md.",
+      "expected": ["brief assigns the pricing investigation directly", "worker does not recruit another external agent", "lead answers through delegate reply", "do not copy the orchestration request verbatim"]
+    },
+    {
+      "name": "interactive-clarification",
+      "prompt": "An external planning task returned pending.kind interaction with question IDs, choices, and free_text false. The requested preference is not in the user brief.",
+      "expected": ["read references/interaction.md", "ask user for missing preference", "reply through delegate with exact request and question IDs", "stable message ID", "continue collecting"]
+    },
+    {
+      "name": "interactive-steering",
+      "prompt": "The user adds guidance while an interactive external task is running and its capabilities advertise steering.",
+      "expected": ["delegate steer", "preserve task model permission and budget", "do not cancel and redispatch", "receipt is not completion"]
+    },
+    {
+      "name": "interactive-unknown-delivery",
+      "prompt": "A reply submission lost its CLI response. Its recorded delivery is unknown.",
+      "expected": ["same message ID and exact content to retrieve receipt", "no new message ID retry", "no native CLI bypass", "observe task"]
+    },
+    {
+      "name": "interactive-unsupported-destination",
+      "prompt": "A named external provider supports continuation but neither native clarification nor steering. The user wants a discussion with it.",
+      "expected": ["preserve named provider", "ordinary bounded turns and continuation", "explain no active-turn questions", "do not pass unsupported interactive flag"]
     }
   ]
 }

package/plugins/delegation-layer/skills/agent-integration/evals/routing.json

@@ -198,6 +198,53 @@
         "codex:exec"
       ],
       "split": "validation"
+    },
+    {
+      "name": "requested-model-effort",
+      "prompt": "Ask a separate Codex CLI session to review pricing.py without edits. Use model gpt-5.6-luna and effort max, preserving both choices.",
+      "external": true,
+      "provider": "codex:exec",
+      "model": "gpt-5.6-luna",
+      "effort": "max",
+      "split": "validation",
+      "regression": true
+    },
+    {
+      "name": "ambiguous-model",
+      "prompt": "Ask a separate Antigravity CLI session to review pricing.py using the fastest Flash model. I do not know the exact model ID. Do not edit files.",
+      "external": true,
+      "provider": "antigravity:print",
+      "expectation": "Resolve an exact model ID through discovery; clarify if unavailable or ambiguous. Never guess an identifier.",
+      "split": "validation",
+      "regression": true
+    },
+    {
+      "name": "parallel-receipts",
+      "prompt": "Ask separate Codex and Claude CLI sessions to independently review pricing.py against README.md concurrently. Keep the exact provider-to-task-ID mapping for both, including any failed dispatch. No edits.",
+      "external": true,
+      "provider": [
+        "codex:exec",
+        "claude:print"
+      ],
+      "split": "validation",
+      "regression": true
+    },
+    {
+      "name": "subagent-external",
+      "prompt": "Use an ordinary native subagent to coordinate a read-only second opinion from a separate Codex CLI session about pricing.py. Let the subagent choose its tools. Report the external finding or blocker.",
+      "external": true,
+      "provider": "codex:exec",
+      "split": "validation",
+      "regression": true
+    },
+    {
+      "name": "explicit-bypass",
+      "prompt": "For this request explicitly bypass Delegate and its skill. Run only codex --version directly; do not start a model session or review.",
+      "external": false,
+      "provider": null,
+      "expectation": "Respect the explicit direct integration choice; this bounded test proves bypass permission, not task completion.",
+      "split": "validation",
+      "regression": true
     }
   ]
 }

package/plugins/delegation-layer/skills/agent-integration/examples/json-results.md

@@ -1,8 +1,8 @@
 # JSON decision sketch
 
 ```sh
-delegate --root "$STATE_ROOT" status "$TASK_ID" --json
-delegate --root "$STATE_ROOT" collect "$TASK_ID" --watch 5s --json
+delegate --root "${DELEGATE_ROOT:-$HOME/delegation-state}" status "$TASK_ID" --json
+delegate --root "${DELEGATE_ROOT:-$HOME/delegation-state}" collect "$TASK_ID" --watch 5s --json
 ```
 
 Decision order:

package/plugins/delegation-layer/skills/agent-integration/examples/read-only-task.md

@@ -1,10 +1,9 @@
 # Read-only task
 
 ```sh
-STATE_ROOT="${DELEGATE_ROOT:-$HOME/delegation-state}"
 BRIEF="$(mktemp)"
 printf '%s\n' 'Inspect the workspace and summarize the current test failures. Do not edit files.' >"$BRIEF"
-delegate --root "$STATE_ROOT" dispatch --auto \
+delegate --root "${DELEGATE_ROOT:-$HOME/delegation-state}" dispatch --auto \
   --brief "$BRIEF" --cwd "$PWD" --permission read-only --budget 15m --json
 ```
 

package/plugins/delegation-layer/skills/agent-integration/examples/workspace-write-task.md

@@ -1,8 +1,7 @@
 # Authorized workspace write task
 
 ```sh
-STATE_ROOT="${DELEGATE_ROOT:-$HOME/delegation-state}"
-delegate --root "$STATE_ROOT" dispatch --auto \
+delegate --root "${DELEGATE_ROOT:-$HOME/delegation-state}" dispatch --auto \
   --brief "$PWD/delegated-task.md" --cwd "$PWD" \
   --permission workspace-write --budget 30m --json
 ```

package/plugins/delegation-layer/skills/agent-integration/references/collaboration.md

@@ -0,0 +1,77 @@
+# Parallel reviews and debates
+
+## Keep each request identifiable
+
+Choose the fan-out needed for the user's task. Each participant needs its own
+brief and response association, even when two participants use the same provider.
+Record the request label, provider, exact requested model/effort, workspace,
+permission, state root, and response together. The label identifies the attempt
+before admission; the returned task ID identifies it afterward.
+
+Prefer independent tool calls: each tool result belongs to its invocation.
+When a shell must launch requests concurrently, redirect each invocation to its
+own files. Never use `dispatch ... & dispatch ... & wait` with shared stdout.
+
+After preparing two independent briefs, a portable capture pattern is:
+
+```sh
+RECEIPTS="$(mktemp -d)" || exit 1
+# Set these absolute paths and catalog IDs in this same tool invocation.
+# BRIEF_A and BRIEF_B contain the real independent assignments.
+(
+  delegate --root "${DELEGATE_ROOT:-$HOME/delegation-state}" dispatch --provider "$PROVIDER_A" \
+    --brief "$BRIEF_A" --cwd "$WORKSPACE_A" \
+    --permission read-only --budget 30m --json \
+    >"$RECEIPTS/review-a.json" 2>"$RECEIPTS/review-a.stderr"
+  printf '%s\n' "$?" >"$RECEIPTS/review-a.exit"
+) &
+(
+  delegate --root "${DELEGATE_ROOT:-$HOME/delegation-state}" dispatch --provider "$PROVIDER_B" \
+    --brief "$BRIEF_B" --cwd "$WORKSPACE_B" \
+    --permission read-only --budget 30m --json \
+    >"$RECEIPTS/review-b.json" 2>"$RECEIPTS/review-b.stderr"
+  printf '%s\n' "$?" >"$RECEIPTS/review-b.exit"
+) &
+wait
+printf 'Read each response separately in %s\n' "$RECEIPTS"
+```
+
+Keep the request-to-label mapping alongside those files. Include any exact
+requested model/effort in its invocation. Read both exit codes, stderr, and JSON
+responses independently; shell `wait` is not proof that either dispatch succeeded.
+Poll only tasks with `task_record: created`. A returned task ID with
+`task_record: not_created` does not identify an observable task.
+
+## Wait within the current turn
+
+Concurrent dispatch does not require background collection. Collect each task
+in the foreground with a bounded watch; for example, `collect TASK_ID --watch
+30s --json`. Exit 3 means publication is still pending: keep observing that task,
+handling its budget-stop and continuation fields as described in the main skill.
+Do not end a headless turn while a shell background job is meant to finish the
+requested work. The host may close its session at that point and no later
+notification is guaranteed. A user-requested detach is different: report the
+pending task IDs and state root explicitly without claiming completion.
+
+## Compare actual results
+
+Collect each admitted task to its authoritative terminal outcome. Present each
+participant's findings with its task ID and evidence. Keep a blocked or failed
+participant visible; one successful review does not satisfy a requested pair.
+Do not attribute your own analysis to an unavailable participant.
+
+## Challenge and follow up
+
+Independent opening reviews may run concurrently. A challenge depends on the
+actual earlier result: collect it first, then include its relevant findings and
+evidence in the other participant's next brief. Never claim a cross-check merely
+because two initial reviews were requested.
+
+For an existing participant, use `continue --task TASK_ID` with that participant's
+own predecessor and the follow-up brief. This creates a new task for the same
+provider conversation; save the new ID separately. Use the continuation result
+and [continuation guidance](continuation.md), including advertised resumability
+after a budget stop. Never use another participant's task ID or restart a
+conversation to imitate a follow-up. If the first turn is blocked, report that
+the dependent challenge or follow-up did not run. Other independent assignments
+may still proceed.

package/plugins/delegation-layer/skills/agent-integration/references/command-reference.md

@@ -14,6 +14,9 @@ All paths passed to `--root`, `--cwd`, and `--brief` must be absolute. Add
 | `delegate status TASK --json` | Reconcile and observe task state | No provider launch |
 | `delegate collect TASK --watch 5s --json` | Read or wait for publication | No provider launch |
 | `delegate continue --task TASK ... --json` | Create an exact-session successor | Yes, at most once for the successor |
+| `delegate reply TASK --request ID --answers FILE --id MESSAGE_ID --json` | Answer a pending native question | No new launch |
+| `delegate steer TASK --brief FILE --id MESSAGE_ID --json` | Guide a supported active turn | No new launch |
+| `delegate events TASK --after SEQUENCE --watch 5s --json` | Read a bounded interaction event page | No |
 | `delegate logs TASK --json` | Return validated output descriptors | No |
 | `delegate cancel TASK --json` | Record one explicit stop request | Stops, does not relaunch |
 
@@ -30,9 +33,11 @@ Dispatch flags:
 - `--auto`: let the CLI select a ready provider;
 - `--provider ID`: preserve the caller’s named harness or provider, resolved through the catalog;
 - `--model MODEL` and `--effort VALUE`: provider-advertised choices (CCR requires a model alias);
-  Codex maps effort to TOML `model_reasoning_effort`, while Claude and AGY
+  Codex maps effort to TOML `model_reasoning_effort` for ordinary turns or a native
+  turn parameter for interactive turns, while Claude and AGY
   pass native effort flags; Pi maps effort to `--thinking`; OpenCode maps it to
   `--variant`; CCR forwards effort to Claude and uses `--model` as a CCR alias; `default` is omitted;
+- `--interactive`: enable advertised native clarification and steering; see [interaction](interaction.md);
 - `--native-timeout DURATION`: optional provider-native timeout where advertised.
 
 Model discovery uses the same `--provider ID` profiles and accepts an optional
@@ -47,12 +52,14 @@ Continuation flags:
 
 - `--task TASK`: predecessor task ID;
 - `--brief FILE`: optional new follow-up instruction;
-- `--budget DURATION`, `--model MODEL`, and `--effort VALUE`: optional overrides.
+- `--budget DURATION`, `--model MODEL`, and `--effort VALUE`: optional overrides;
+- `--interactive`: enable interaction when supported; already-interactive predecessors keep it.
 
 ## Choosing models and effort
 
-If the caller needs an explicit model or effort, use the implemented native
-discovery command for that provider:
+Pass an explicitly supplied model ID and effort unchanged, even if discovery
+is incomplete or does not list them. To resolve a natural-language model name
+or choose an option the caller left open, use native discovery:
 
 ```sh
 delegate models --provider PROVIDER_ID --cwd ABSOLUTE_WORKSPACE --json
@@ -68,6 +75,10 @@ requested value merely because discovery did not list it, and do not infer
 per-model effort support from the harness-wide list. If a selected model has
 `efforts: null` or `efforts: []`, omit `--effort` unless the caller explicitly
 requested it; do not invent model aliases or combine options by guessing.
+If a natural-language name cannot be resolved to a single exact ID, ask one
+focused question for that ID. Do not silently select a default or transform
+spaces into hyphens to manufacture an ID. This ambiguity rule is guidance for
+selecting a value, not a new admission restriction.
 
 The response includes `schema_version`, `command: "models"`, `provider`,
 `observed_at`, `status`, `reason_code`, `complete`, `source`, nullable

package/plugins/delegation-layer/skills/agent-integration/references/continuation.md

@@ -17,7 +17,7 @@ When `status` or `collect` reports a timed-out turn with:
 run:
 
 ```sh
-delegate --root "$STATE_ROOT" continue \
+delegate --root "${DELEGATE_ROOT:-$HOME/delegation-state}" continue \
   --task PREDECESSOR_TASK_ID \
   --brief FOLLOW_UP_BRIEF \
   --budget 30m \