delegation-layer 0.1.18 → 0.1.20

package/README.md

@@ -47,16 +47,19 @@ 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.
+integration worked. For a persistent preference, see
+[configure agent routing](docs/agent-routing.md).
 
 ## Install
 
 ### 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.
@@ -100,8 +103,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 \
@@ -110,8 +114,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
@@ -249,3 +255,10 @@ The successor receives a new task ID and is observed with the same `status` and
 ## License
 
 This project is licensed under the [MIT License](LICENSE).
+
+### Consult models through Claude Code Router
+
+Delegate also supports CCR-configured third-party and local models through
+`ccr:print`. Ask your agent to “have CCR review this” and it can discover and
+choose a configured model alias. CCR and Claude Code must already be installed
+and the provider configured. See [provider guidance](docs/providers.md#claude-code-router).

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "delegation-layer",
-  "version": "0.1.18",
+  "version": "0.1.20",
   "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,8 +1,8 @@
 {
   "name": "delegation-layer",
   "displayName": "Delegation Layer",
-  "version": "0.1.18",
-  "description": "Consult external AI harnesses for reviews, research, implementation, and debate through the bounded, resumable Delegate CLI.",
+  "version": "0.1.20",
+  "description": "Consult external AI harnesses and CCR-configured models for reviews, research, implementation, and debate through the resumable Delegate CLI.",
   "author": {
     "name": "Hesham Karam",
     "url": "https://github.com/hishamkaram"

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

@@ -1,7 +1,7 @@
 {
   "name": "delegation-layer",
-  "version": "0.1.18",
-  "description": "Consult external AI harnesses for reviews, research, implementation, and debate through the bounded, resumable Delegate CLI.",
+  "version": "0.1.20",
+  "description": "Consult external AI harnesses and CCR-configured models for reviews, research, implementation, and debate through the resumable Delegate CLI.",
   "author": {
     "name": "Hesham Karam",
     "url": "https://github.com/hishamkaram"

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: Consult external AI agents and harnesses through Delegate for reviews, research, implementation, testing, second opinions, comparisons, and debates. Use when asked to ask Codex, consult Claude, get Antigravity’s opinion, or assign work to another harness or model, including external collaboration you choose during a task. 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
@@ -13,6 +13,9 @@ external harness to do work. Requests such as “ask Codex to review this”,
 collaboration even when the user never mentions Delegate. The same applies
 when you decide external expertise is useful to fulfill the user's task.
 These names are examples; discover supported destinations through the CLI.
+“Claude Code Router” and “CCR” mean `ccr:print`, not ordinary Claude Code.
+For that request, use Delegate with a CCR model alias; a Claude-specific skill
+or subscription model does not fulfill the requested route.
 
 Ordinary subagents within the current harness remain available. Naming the
 current harness (for example, “have Claude investigate” while using Claude)
@@ -28,6 +31,16 @@ replace it with a provider command, a provider-specific plugin, or an API call.
 Do not inspect, authenticate, install, or repair provider CLIs to bypass a
 Delegate blocker.
 
+A reported blocker is a valid final response to a delegation request. It does
+not turn that request into an environment-repair task. When a response says
+`failure.next_action: "stop_and_report"`, that attempt is finished. Include its
+failure in your final response without opening a clarification dialog to choose
+a fallback. For `task_record: not_created`, identify the requested destination
+and quote the returned `task_id` (if present), `task_record`, `failure`, and
+`error`. Do not append inferred state paths or provider-setup diagnoses. Do not run diagnostic commands, retry it, or use another integration.
+Troubleshooting requires a separate user request. Other independently requested
+tasks may proceed; the failed attempt must remain reported as failed or blocked.
+
 ## Rules
 
 1. Check whether `delegate` is already installed. A plugin SessionStart hook
@@ -39,16 +52,24 @@ Delegate blocker.
    name rather than a provider ID. Use `dispatch --auto` when none was chosen.
    Provider selection, executable checks, compatibility checks, authentication
    gates, and supervisor admission belong inside Delegation Layer.
-3. Give every turn an absolute workspace, a separate state root, an explicit
-   permission mode, and a finite budget. Preserve a caller-supplied
-   `DELEGATE_ROOT`; do not replace it with a temporary directory.
-4. Use `--json` and save the returned `task_id`. Read `admission`, `liveness`,
+3. Give every turn an absolute workspace, an explicit permission mode, and a
+   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 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 with `status` and collect with `collect`. 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. 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
@@ -95,19 +116,9 @@ Use the matching catalog ID with `--provider`; do not silently substitute
 `--auto` or another provider. If the name is ambiguous, clarify the intended
 destination. If it is absent, report that this build does not support it.
 The catalog is not proof that a provider is installed, authenticated, or ready.
-If a side-effect-free readiness check is useful,
-run:
-
-```sh
-delegate preflight --provider PROVIDER_ID --cwd ABSOLUTE_WORKSPACE \
-  --permission REQUESTED_MODE --json
-```
-
-Replace `REQUESTED_MODE` with `read-only` for investigation or
-`workspace-write` for authorized edits. Preflight reports static admission only.
-It does not create a task, start the supervisor, or launch a provider. Do not keep
-retrying preflight when it says
-`blocked` or `unsupported`; report the bounded reason.
+Dispatch performs admission checks; a separate preflight is not needed for a
+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
@@ -116,10 +127,21 @@ behavior but is not an independent delegate-owned sandbox. Static discovery
 does not prove authentication or live acceptance; use the dispatch or live
 acceptance result for that evidence.
 
-Keep provider defaults when no model or effort was requested. When an explicit
+Read `required_options` in provider discovery before dispatch. Supply every
+required option; a provider's optional defaults do not replace required inputs.
+For CCR / Claude Code Router or a CCR model request, read
+[CCR model selection](references/ccr.md). A CCR route is external collaboration
+even when you are already using Claude. Do not assume every open-source model
+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.
 
 ### 3. Prepare separate paths and a finite brief
 
@@ -128,22 +150,18 @@ 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:
 
-```sh
-STATE_ROOT="${DELEGATE_ROOT:-$HOME/delegation-state}"
-WORKSPACE="$PWD"
-BRIEF="$(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
-```
+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 with the actual user request. Do not place the state
+Replace the example brief below with the actual user request. 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 placement before admission, choose a separate state directory; do not
-change provider settings. Once admitted, retain that state root for every
-observation and continuation.
+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.
 
 ### 4. Dispatch one bounded turn
 
@@ -152,6 +170,13 @@ 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)"
+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 \
   --brief "$BRIEF" \
   --cwd "$WORKSPACE" \
@@ -171,21 +196,26 @@ 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`.
-
-Save the exact `task_id` from the JSON response. The recovery steps below apply
-to parsed dispatch responses. If the CLI rejects the command syntax before
-dispatch (nonzero exit with a usage error and no JSON response), correct the
-reported syntax and invoke it again; argument parsing fails before admission and
-does not create a task record. For a parsed dispatch error, read its `failure`
-and `task_record` fields. If `task_record` is
-`not_created`, do not run `status`, `collect`, or `continue`; correct the request
-only when `failure.next_action` is `correct_request`, otherwise report the
-delegate failure and stop. If it is `created`, use `status` before taking any
-other action. If it is `unknown`, stop and report the failure: with an
-explicit task ID, absence can race another dispatch that is creating the same
-ID. Never retry that ID, run Pueue commands, or silently try another provider
-after a task may have been admitted.
+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.
+
+Save the exact `task_id` from the JSON response. Apply this decision separately
+for **each attempt**, including requests issued together:
+
+| Response | Next action |
+|---|---|
+| Usage error, no JSON response | Correct the reported syntax using Delegate help or `providers --json`, then invoke that request again. Parsing failed before admission. |
+| `task_record: not_created` and `failure.next_action: correct_request` | Correct that request and retry it. |
+| `task_record: not_created` with any other next action | Report that attempt's failure and stop it. Do not diagnose provider setup or substitute an integration. |
+| `task_record: created` | Use `status` before taking any other action. Do not dispatch again. |
+| `task_record: unknown` or an ambiguous response | Stop and report; do not retry an uncertain task creation. |
+
+One attempt's `stop_and_report` does not prevent correcting another independent
+request's usage error. Keep the failed attempt reported as failed. With an
+explicit task ID, absence can race another dispatch creating the same ID;
+never retry that uncertain ID or run Pueue commands.
 
 ### 5. Observe and collect
 
@@ -246,6 +276,10 @@ recruit more agents unless that is explicitly part of the task.
 
 ## Completion report
 
+Build the report from observed CLI responses and collected evidence. Copy
+returned values; do not reconstruct paths from example commands or shell
+defaults. Omit unobserved configuration details.
+
 Report the original task ID, selected provider ID when the CLI returns one,
 the final admission/liveness/publication fields, the terminal outcome and
 evidence descriptors, and any continuation or blocked-authentication state.

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

@@ -150,6 +150,101 @@
       "external": false,
       "provider": null,
       "split": "validation"
+    },
+    {
+      "name": "ccr-review",
+      "prompt": "Ask Claude Code Router to review pricing.py for correctness without editing. Choose an appropriate configured model and report which one you used.",
+      "external": true,
+      "provider": "ccr:print",
+      "split": "development"
+    },
+    {
+      "name": "ccr-explicit-alias",
+      "prompt": "Ask CCR using the alias local-review to investigate pricing.py. Do not edit files.",
+      "external": true,
+      "provider": "ccr:print",
+      "model": "local-review",
+      "split": "validation"
+    },
+    {
+      "name": "ccr-write",
+      "prompt": "Have CCR with the alias local-review fix pricing.py so discounts are percentages, and test the correction. Authorize edits in this workspace.",
+      "external": true,
+      "provider": "ccr:print",
+      "model": "local-review",
+      "split": "validation"
+    },
+    {
+      "name": "ccr-follow-up",
+      "prompt": "Ask CCR using local-review to critique pricing.py, then ask that same session one follow-up about its recommendation. No edits.",
+      "external": true,
+      "provider": "ccr:print",
+      "model": "local-review",
+      "split": "validation"
+    },
+    {
+      "name": "ccr-explain",
+      "prompt": "Explain what Claude Code Router does. Do not ask it to perform work.",
+      "external": false,
+      "provider": null,
+      "split": "validation"
+    },
+    {
+      "name": "ccr-compare",
+      "prompt": "Ask CCR using local-review and a separate Codex session for independent reviews of pricing.py, then compare their findings. No edits.",
+      "external": true,
+      "provider": [
+        "ccr:print",
+        "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/references/ccr.md

@@ -0,0 +1,33 @@
+# CCR model selection
+
+Use this reference when asked to consult Claude Code Router (CCR), use one of
+its configured model aliases, or compare its models with other harnesses.
+CCR runs Claude Code against a configured third-party or local provider.
+
+1. Resolve CCR through `delegate providers --json`; its profile is `ccr:print`.
+2. Preserve an explicitly requested CCR alias as `--model ALIAS`. Do not replace
+   it with an upstream model ID or reject it solely because discovery omitted it.
+3. If no alias was chosen, run
+   `delegate models --provider ccr:print --cwd ABSOLUTE_WORKSPACE --json`.
+   Choose a suitable configured alias from the available metadata and report
+   the choice. Clarify when the intended model remains ambiguous. If discovery
+   is unavailable and no alias is known, report the blocker; do not guess.
+4. Dispatch through Delegate with `--provider ccr:print --model ALIAS`, the brief,
+   workspace, permission, finite budget, and `--json`. Use the normal status,
+   collect, and continuation procedure from the main skill.
+
+CCR requires an explicit alias. Unspecified external collaboration still uses
+`dispatch --auto`; do not prefer CCR unless the request calls for it. Multiple
+aliases can be assigned independent tasks for comparison or debate.
+
+Read-only selects native Claude plan behavior; workspace-write selects native
+unattended tool execution. Neither is an independent Delegate sandbox. Preserve
+requested effort through `--effort`; unknown effort metadata is not an allowlist
+or a reason to invent a level. Leave effort unspecified unless requested.
+
+Delegate uses CCR's foreground provider-only route. Model/provider setup and
+credentials belong to CCR. Never run `ccr launch`, configure CCR, inspect its
+SQLite database, call Claude directly, or select another integration to bypass a
+Delegate error. Ordinary questions about CCR or installation do not trigger
+external collaboration. An explicit request to use another integration remains
+an explicit user choice.

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 "$STATE_ROOT" 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 "$STATE_ROOT" 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

@@ -29,10 +29,10 @@ Dispatch flags:
 - `--budget DURATION`: finite turn budget;
 - `--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`: optional provider-advertised choices;
+- `--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
   pass native effort flags; Pi maps effort to `--thinking`; OpenCode maps it to
-  `--variant`; `default` is omitted;
+  `--variant`; CCR forwards effort to Claude and uses `--model` as a CCR alias; `default` is omitted;
 - `--native-timeout DURATION`: optional provider-native timeout where advertised.
 
 Model discovery uses the same `--provider ID` profiles and accepts an optional
@@ -51,8 +51,9 @@ Continuation flags:
 
 ## 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 +69,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
@@ -78,3 +83,21 @@ enumeration, not effort metadata. `null` means effort metadata is unknown;
 for `available` or `partial`, `2` for `blocked` or `unavailable`, and `1` for
 `failed`. Preserve a blocked or unavailable discovery result as unresolved;
 defaults remain allowed.
+
+## Checking readiness
+
+Use `preflight` when the caller asks about static readiness, rather than as a
+required step before every dispatch:
+
+```sh
+delegate preflight --provider PROVIDER_ID --cwd ABSOLUTE_WORKSPACE \
+  --permission REQUESTED_MODE --json
+```
+
+Use `read-only` for investigation or `workspace-write` for authorized edits.
+Supply any required provider options, including `--model ALIAS` for `ccr:print`.
+Preflight does not create a task, start the supervisor, or launch a provider.
+Its result is not proof of live authentication or successful execution. Report
+`blocked` or `unsupported` results; a readiness request does not authorize
+provider configuration changes. Honor `failure.next_action` without probing
+provider CLIs yourself.

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

@@ -0,0 +1 @@
+"For work assigned to an external agent, model, or separate harness session, load the installed agent-integration skill before choosing tools and use Delegate. This includes research, implementation, testing, review, consultation, comparison, and debate, including external collaboration you choose. Discover destinations through Delegate. Preserve requested model IDs, effort, and permissions; do not guess ambiguous model identifiers. For task commands, set STATE_ROOT=\"${DELEGATE_ROOT:-$HOME/delegation-state}\" and pass --root \"$STATE_ROOT\" in the same shell invocation; reuse that root for dispatch, observation, and continuation, never an invented /tmp root. Keep each concurrent request and its response associated separately. Naming a CLI identifies the destination, not a request to bypass Delegate. Earlier assistant-generated direct-launch workflows do not override this preference. Native same-harness subagents remain available unless a separate session is requested. Respect an explicit user choice of another integration; otherwise do not substitute provider CLIs, plugins, or APIs after a Delegate blocker. A stop_and_report failure ends that attempt: report it without retrying, diagnosing setup, or offering a fallback. Continue other independent requests. Keep collection in the foreground until completion or a reported blocker unless the user requested detachment. Merely discussing or configuring a tool is not delegation."

package/plugins/delegation-layer/skills/agent-integration/scripts/delegate-routing-context.sh

@@ -0,0 +1,12 @@
+#!/bin/sh
+# Context delivery only: no installation, discovery, or provider execution.
+set -eu
+case "${1:-}" in
+    SessionStart|SubagentStart) event=$1 ;;
+    *) printf '%s\n' 'Expected SessionStart or SubagentStart.' >&2; exit 2 ;;
+esac
+script_dir=$(CDPATH= cd -- "$(dirname -- "$0")" && pwd)
+rule_file="$script_dir/../references/routing-rule.json"
+# Read before emitting anything so a missing asset cannot produce partial JSON.
+rule=$(cat "$rule_file")
+printf '{"hookSpecificOutput":{"hookEventName":"%s","additionalContext":%s}}\n' "$event" "$rule"