delegation-layer 0.3.0 → 0.4.0

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

@@ -7,6 +7,10 @@ or attaches to a managed workspace (`--isolation git-worktree` or
 `--workspace ID`), or creates or removes a [Git checkpoint](#git-checkpoints).
 
 This reference is self-contained guidance for using managed workspaces.
+Commands use the CLI default under the main skill's
+[root rule](../SKILL.md#3-prepare-separate-paths-and-a-finite-brief). For a workspace
+or checkpoint in an explicit custom or recorded historical root, pass that
+exact `--root` on every related command.
 
 Provider-native permissions still apply inside an isolated checkout. A provider
 may edit files but be unable to stage or commit because linked-worktree Git
@@ -41,7 +45,7 @@ row ending or a provider outcome alone is not closure evidence.
 Create a managed workspace from a committed source base:
 
 ```text
-delegate --root ROOT dispatch --isolation git-worktree --cwd ABS \
+delegate dispatch --isolation git-worktree --cwd ABS \
   [--base REV] [--workspace-budget DURATION] ... --json
 ```
 
@@ -55,7 +59,7 @@ removing that source does not block capture, release, or forget. A request that
 workspace uses its recorded checkout and source identity:
 
 ```text
-delegate --root ROOT dispatch --workspace WORKSPACE_ID ... --json
+delegate dispatch --workspace WORKSPACE_ID ... --json
 ```
 
 Public `--workspace` cannot be combined with `--cwd`, `--base`, or
@@ -80,11 +84,11 @@ made no write outside the promised content scope.
 The CLI currently exposes these managed-workspace commands:
 
 ```text
-delegate --root ROOT workspace list [--after ID] [--limit 1..50] --json
-delegate --root ROOT workspace status ID [--operation OP] [--watch DURATION] --json
-delegate --root ROOT workspace exec ID --budget DURATION --json -- ARGV...
-delegate --root ROOT workspace release ID [--discard] [--budget DURATION] --json
-delegate --root ROOT workspace forget ID [--budget DURATION] --json
+delegate workspace list [--after ID] [--limit 1..50] --json
+delegate workspace status ID [--operation OP] [--watch DURATION] --json
+delegate workspace exec ID --budget DURATION --json -- ARGV...
+delegate workspace release ID [--discard] [--budget DURATION] --json
+delegate workspace forget ID [--budget DURATION] --json
 ```
 
 `workspace exec` passes `ARGV...` directly to the supervised helper; the
@@ -110,7 +114,7 @@ must not mutate the predecessor's immutable records. A retained workspace can be
 read-only review by attaching its ID, for example:
 
 ```text
-delegate --root ROOT dispatch --provider codex:review \
+delegate dispatch --provider codex:review \
   --workspace WORKSPACE_ID --review-target TARGET --brief ABS_BRIEF \
   --permission read-only --budget 1h --json
 ```
@@ -183,11 +187,11 @@ fixed Delegate values; trailers carry the checkpoint ID and request digest.
 This is unrelated to a provider continuation `mode: "checkpoint"`.
 
 ```text
-delegate --root ROOT checkpoint create --cwd ABS [--budget DURATION] --json
-delegate --root ROOT checkpoint create --workspace ID [--budget DURATION] --json
-delegate --root ROOT checkpoint status CHECKPOINT_ID [--operation OP] [--watch DURATION] --json
-delegate --root ROOT checkpoint list [--after CHECKPOINT_ID] [--limit 1..50] --json
-delegate --root ROOT checkpoint remove CHECKPOINT_ID [--budget DURATION] --json
+delegate checkpoint create --cwd ABS [--budget DURATION] --json
+delegate checkpoint create --workspace ID [--budget DURATION] --json
+delegate checkpoint status CHECKPOINT_ID [--operation OP] [--watch DURATION] --json
+delegate checkpoint list [--after CHECKPOINT_ID] [--limit 1..50] --json
+delegate checkpoint remove CHECKPOINT_ID [--budget DURATION] --json
 ```
 
 - `create` names exactly one target: `--cwd` for an absolute ordinary Git
@@ -232,7 +236,7 @@ Save every response and exit code once; follow
    the same repository as `--cwd`, normally the source the Lead already uses:
 
    ```text
-   delegate --root ROOT dispatch --auto --brief ABS_BRIEF --cwd ABS_SOURCE \
+   delegate dispatch --auto --brief ABS_BRIEF --cwd ABS_SOURCE \
      --isolation git-worktree --base COMMIT_OID \
      --permission workspace-write --budget 30m --json
    ```

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

@@ -5,11 +5,11 @@ 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)
+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")
-skill_file="$(CDPATH= cd -- "$script_dir/.." && pwd)/SKILL.md"
+skill_file="$(CDPATH='' cd -- "$script_dir/.." && pwd)/SKILL.md"
 DELEGATE_ROUTING_EVENT="$event" DELEGATE_ROUTING_RULE="$rule" DELEGATE_ROUTING_SKILL="$skill_file" awk '
 BEGIN {
     # Paths are task data, not shell code. Escape every JSON control character.

package/scripts/installer/routing-store.mjs

@@ -5,7 +5,7 @@ import { assertNoSymlinkComponents, existingPath } from "./filesystem.mjs";
 import { countRoutingEvents, createRoutingPlan, routingPath, validateHookConfig } from "./routing-rules.mjs";
 import { targetFor } from "./selection.mjs";
 
-export async function prepareRouting(selected, action, { environment, platform, sourceDirectory }) {
+export async function prepareRouting(selected, action, { environment, platform }) {
   const plans = [];
   for (const name of new Set(selected.harnessNames)) {
     const path = routingPath(name, {
@@ -55,85 +55,118 @@ export async function prepareRouting(selected, action, { environment, platform,
   return plans;
 }
 
-async function replaceRoutingConfig(plan, before, after) {
-  await assertNoSymlinkComponents(plan.path);
-  await mkdir(dirname(plan.path), { recursive: true });
+const routingFileOperations = Object.freeze({ open, mkdir, readFile, rename, unlink, existingPath, assertNoSymlinkComponents });
+
+function errorMessage(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+
+function combinedFailure(failures) {
+  if (failures.length === 1) return failures[0];
+  return new AggregateError(failures, failures.map(errorMessage).join("; "), { cause: failures[0] });
+}
+
+async function writeAndClose(file, contents) {
+  const failures = [];
+  try {
+    await file.writeFile(contents);
+    await file.sync();
+  } catch (error) {
+    failures.push(error);
+  }
+  try {
+    await file.close();
+  } catch (error) {
+    failures.push(error);
+  }
+  if (failures.length) throw combinedFailure(failures);
+}
+
+async function cleanupReplacement(lock, temporary, lockPath, operations) {
+  const failures = [];
+  try {
+    await operations.unlink(temporary);
+  } catch (error) {
+    if (!(error && typeof error === "object" && "code" in error && error.code === "ENOENT")) failures.push(error);
+  }
+  try {
+    await lock.close();
+  } catch (error) {
+    failures.push(error);
+  }
+  try {
+    await operations.unlink(lockPath);
+  } catch (error) {
+    failures.push(error);
+  }
+  return failures;
+}
+
+async function replaceRoutingConfig(plan, before, after, operations, onCommitted) {
+  await operations.assertNoSymlinkComponents(plan.path);
+  await operations.mkdir(dirname(plan.path), { recursive: true });
   const lockPath = plan.path + ".delegation-layer.lock";
   let lock;
   try {
-    lock = await open(lockPath, "wx", 0o600);
+    lock = await operations.open(lockPath, "wx", 0o600);
   } catch (error) {
     if (error && typeof error === "object" && "code" in error && error.code === "EEXIST") {
-      throw new Error(`routing configuration is locked: ${lockPath}; verify no other installer is running before removing a stale lock`);
+      throw new Error(`routing configuration is locked: ${lockPath}; verify no other installer is running before removing a stale lock`, { cause: error });
     }
     throw error;
   }
   const suffix = `${process.pid}-${Date.now()}-${Math.random().toString(16).slice(2)}`;
   const temporary = plan.path + `.delegation-layer-stage-${suffix}`;
+  const failures = [];
   try {
-    const stat = await existingPath(plan.path);
+    const stat = await operations.existingPath(plan.path);
     if (stat && (!stat.isFile() || stat.isSymbolicLink())) {
       throw new Error(`routing configuration changed during installation: ${plan.path}`);
     }
-    const current = stat ? await readFile(plan.path, "utf8") : null;
+    const current = stat ? await operations.readFile(plan.path, "utf8") : null;
     if (current !== before) throw new Error(`routing configuration changed during installation; retry: ${plan.path}`);
     if (before !== null) {
-      const backup = await open(plan.path + `.delegation-layer-backup-${suffix}`, "wx", 0o600);
-      try {
-        await backup.writeFile(before);
-        await backup.sync();
-      } finally {
-        await backup.close();
-      }
+      const backup = await operations.open(plan.path + `.delegation-layer-backup-${suffix}`, "wx", 0o600);
+      await writeAndClose(backup, before);
     }
     if (after === null) {
-      await unlink(plan.path);
-      return;
-    }
-    const staged = await open(temporary, "wx", plan.mode);
-    try {
-      await staged.writeFile(after);
-      await staged.sync();
-    } finally {
-      await staged.close();
-    }
-    await rename(temporary, plan.path);
-  } finally {
-    try {
-      try {
-        await unlink(temporary);
-      } catch (error) {
-        if (!(error && typeof error === "object" && "code" in error && error.code === "ENOENT")) throw error;
-      }
-    } finally {
-      try {
-        await lock.close();
-      } finally {
-        await unlink(lockPath);
-      }
+      await operations.unlink(plan.path);
+    } else {
+      const staged = await operations.open(temporary, "wx", plan.mode);
+      await writeAndClose(staged, after);
+      await operations.rename(temporary, plan.path);
     }
+    onCommitted?.();
+  } catch (error) {
+    failures.push(error);
   }
+  failures.push(...await cleanupReplacement(lock, temporary, lockPath, operations));
+  if (failures.length) throw combinedFailure(failures);
 }
 
-export async function applyRouting(plans) {
+export async function applyRouting(plans, fileOperations = {}) {
+  const operations = { ...routingFileOperations, ...fileOperations };
+  // This transaction owns committed mutations, including commits followed by a cleanup failure.
   const applied = [];
   try {
     for (const plan of plans) {
       if (!plan.path || plan.before === plan.after) continue;
-      await replaceRoutingConfig(plan, plan.before, plan.after);
-      applied.push(plan);
+      await replaceRoutingConfig(plan, plan.before, plan.after, operations, () => applied.push(plan));
     }
   } catch (error) {
     const failures = [];
     for (const plan of applied.reverse()) {
       try {
-        await replaceRoutingConfig(plan, plan.after, plan.before);
+        await replaceRoutingConfig(plan, plan.after, plan.before, operations);
       } catch (rollbackError) {
-        failures.push(rollbackError instanceof Error ? rollbackError.message : String(rollbackError));
+        failures.push(rollbackError);
       }
     }
-    const reason = error instanceof Error ? error.message : String(error);
-    throw new Error(`${reason}${failures.length ? `; rollback needs attention: ${failures.join("; ")}` : "; earlier routing changes rolled back"}`);
+    const reason = errorMessage(error);
+    if (failures.length) {
+      throw new AggregateError([error, ...failures], `${reason}; rollback needs attention: ${failures.map(errorMessage).join("; ")}`, { cause: error });
+    }
+    throw new Error(`${reason}; earlier routing changes rolled back`, { cause: error });
   }
 }
 

package/skills/agent-integration/SKILL.md

@@ -87,11 +87,16 @@ Use a supplied brief or write the worker's bounded assignment and acceptance
 criteria to a regular file. Do not copy the orchestration request or ask workers
 to recruit others unless recursive delegation was requested.
 
-Keep the state root outside provider-writable workspaces, provider runtime
-directories, and temporary trees they may write. For every task command pass
-`--root "${DELEGATE_ROOT:-$HOME/delegation-state}"` directly in that shell
-invocation. If the user explicitly requests another root, use that exact path
-consistently. Task IDs separate tasks; do not invent per-task roots.
+For ordinary task, schedule, observation, interaction, and continuation commands,
+omit `--root`; the CLI owns default-root resolution for the user's configuration
+context, independently of the project cwd. Do not assemble a default path, use a
+sample path or shell fallback, or treat ambient `DELEGATE_ROOT` as authority.
+Only pass `--root` when the user explicitly supplies a root or existing work has
+an already recorded custom or historical root; preserve that exact path for
+every command concerning that work. Never search other roots for an old task.
+Task IDs separate tasks; do not invent per-task or per-project roots. The state
+root must remain outside provider-writable workspaces, provider runtime
+directories, and temporary trees they may write.
 
 Prepare paths and dispatch in one tool invocation; shell variables may not
 persist between calls. Use saved absolute paths in later calls. Do not use
@@ -125,13 +130,16 @@ original command and intent.
 ### 5. Observe and collect
 
 Follow [observation decisions](references/result-handling.md#observe-and-collect)
-with the same root and created task ID:
+with the created task ID, using the CLI default for ordinary work:
 
 ```sh
-delegate --root "${DELEGATE_ROOT:-$HOME/delegation-state}" status TASK_ID --json
-delegate --root "${DELEGATE_ROOT:-$HOME/delegation-state}" collect TASK_ID --watch 5s --json
+delegate status TASK_ID --json
+delegate collect TASK_ID --watch 5s --json
 ```
 
+For work bound to an explicit custom or historical root, add its exact
+`--root` to both commands under the [root rule](#3-prepare-separate-paths-and-a-finite-brief).
+
 Apply the owning decision order before waiting: terminal outcomes and concrete
 errors, cancellation/timeout/interruption, interaction, then pending
 observation. Keep collection in the foreground until completion or a reported

package/skills/agent-integration/evals/evals.json

@@ -10,7 +10,7 @@
     {
       "name": "normal-dispatch",
       "prompt": "Run one bounded task through the available agent provider.",
-      "expected": ["dispatch --auto", "--json", "save task_id", "status", "collect"]
+      "expected": ["dispatch --auto", "omit --root on ordinary commands", "--json", "save task_id", "status", "collect"]
     },
     {
       "name": "model-discovery-when-needed",
@@ -68,9 +68,29 @@
       "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",
+      "name": "ambient-root-ignored-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"]
+      "expected": ["omit --root on dispatch, status, collect, reply, steer, and continue", "ambient DELEGATE_ROOT has no root-selection authority", "CLI resolves its default in the same user/configuration context", "no assembled default, shell fallback, sample path, or per-task root"]
+    },
+    {
+      "name": "ordinary-root-from-another-project",
+      "prompt": "DELEGATE_ROOT is unset. An admitted task was dispatched without --root in project A. Observe and continue it from project B in the same user/configuration context.",
+      "expected": ["omit --root on status, collect, and continue", "use the recorded task ID", "CLI default is independent of project cwd", "no path guessed from project A or B", "no search across roots"]
+    },
+    {
+      "name": "explicit-root-across-shell-calls",
+      "prompt": "For this isolated test, I explicitly choose the state root /state/custom with spaces. Consult a separate external agent and answer its questions; each shell tool call starts a new shell.",
+      "expected": ["pass --root with the exact single argument /state/custom with spaces on dispatch, status, collect, reply, steer, and continue", "quote the root in shell commands", "save and reassign absolute brief and response paths in each needed shell invocation", "no ambient variable or fallback overrides the explicit choice"]
+    },
+    {
+      "name": "historical-root-continuation",
+      "prompt": "An eligible predecessor task has recorded historical root /state/legacy with spaces. Continue that exact task and collect its successor. The current CLI default is different.",
+      "expected": ["pass the exact recorded --root argument /state/legacy with spaces on continue, status, and collect", "use the exact predecessor and returned successor IDs", "no fresh dispatch", "do not move or search for the task in the default root"]
+    },
+    {
+      "name": "ordinary-schedule-root",
+      "prompt": "Create a recurring task in this project, then inspect its definition, history, and execution from another project in the same user/configuration context. No custom state root was requested.",
+      "expected": ["omit --root on schedule create, list, show, history, and execution", "keep the definition's own project --cwd", "no per-project root", "do not start a persistent scheduler inside the agent task", "forward any returned scheduler.serve_command argv intact"]
     },
     {
       "name": "pending-without-questions",

package/skills/agent-integration/examples/json-results.md

@@ -1,8 +1,11 @@
 # JSON decision sketch
 
+Use the created task's exact ID as `TASK_ID` and follow the main skill's
+[root rule](../SKILL.md#3-prepare-separate-paths-and-a-finite-brief).
+
 ```sh
-delegate --root "${DELEGATE_ROOT:-$HOME/delegation-state}" status "$TASK_ID" --json
-delegate --root "${DELEGATE_ROOT:-$HOME/delegation-state}" collect "$TASK_ID" --watch 5s --json
+delegate status TASK_ID --json
+delegate collect TASK_ID --watch 5s --json
 ```
 
 Apply [result handling](../references/result-handling.md) to each response and

package/skills/agent-integration/examples/managed-workspace.md

@@ -3,14 +3,18 @@
 Use this example for independent write work that should be isolated in a
 retained Git worktree. The source must be a Git checkout and the state root
 must remain outside provider-writable workspaces.
+Commands use the CLI default under the main skill's
+[root rule](../SKILL.md#3-prepare-separate-paths-and-a-finite-brief); preserve any
+explicit custom or recorded historical root on all related commands.
 
 ```sh
 SOURCE="$PWD"
-BRIEF="$(mktemp)"
-RESPONSE="$(mktemp)"
+BRIEF="$(mktemp)" || exit 1
+RESPONSE="$(mktemp)" || exit 1
 printf '%s\n' 'Implement the requested change and report the files changed.' >"$BRIEF"
+printf 'Saved response: %s\n' "$RESPONSE"
 
-if delegate --root "${DELEGATE_ROOT:-$HOME/delegation-state}" dispatch --auto \
+if delegate dispatch --auto \
   --brief "$BRIEF" --cwd "$SOURCE" \
   --permission workspace-write --isolation git-worktree \
   --base HEAD --workspace-budget 5m --budget 30m --json >"$RESPONSE"; then
@@ -26,9 +30,13 @@ Read the saved JSON before running another command. When
 `task_record: "created"`, use its `task_id` as `TASK_ID` below. When no task
 was created, follow the [result decisions](../references/result-handling.md#managed-workspace-results);
 do not run task status or collection against that nonexistent record.
+Each later block is a separate shell invocation. Replace `ABS_SAVED_RESPONSE`
+with the printed absolute response path and the ID placeholders with the actual
+returned IDs; reassign the path in each invocation.
 
 ```sh
-if delegate --root "${DELEGATE_ROOT:-$HOME/delegation-state}" status TASK_ID --json >"$RESPONSE.status"; then
+RESPONSE="ABS_SAVED_RESPONSE"
+if delegate status TASK_ID --json >"$RESPONSE.status"; then
   status_exit=0
 else
   status_exit=$?
@@ -43,7 +51,8 @@ before running another command. Run the collection below only when that
 guidance calls for it.
 
 ```sh
-if delegate --root "${DELEGATE_ROOT:-$HOME/delegation-state}" collect TASK_ID --watch 5s --json >"$RESPONSE.collect"; then
+RESPONSE="ABS_SAVED_RESPONSE"
+if delegate collect TASK_ID --watch 5s --json >"$RESPONSE.collect"; then
   collect_exit=0
 else
   collect_exit=$?
@@ -64,7 +73,8 @@ Before release, wait for the workspace to return to `state: retained` and inspec
 its final capture. Only after the Lead explicitly chooses release, run:
 
 ```sh
-if delegate --root "${DELEGATE_ROOT:-$HOME/delegation-state}" workspace release WORKSPACE_ID \
+RESPONSE="ABS_SAVED_RESPONSE"
+if delegate workspace release WORKSPACE_ID \
   --budget 5m --json >"$RESPONSE.release"; then
   release_exit=0
 else
@@ -95,8 +105,9 @@ owns every response decision.
 
 ```sh
 SOURCE="$PWD"
-RESPONSE="$(mktemp)"
-if delegate --root "${DELEGATE_ROOT:-$HOME/delegation-state}" checkpoint create \
+RESPONSE="$(mktemp)" || exit 1
+printf 'Saved response: %s\n' "$RESPONSE"
+if delegate checkpoint create \
   --cwd "$SOURCE" --budget 5m --json >"$RESPONSE.checkpoint"; then
   checkpoint_exit=0
 else
@@ -109,9 +120,12 @@ cat "$RESPONSE.checkpoint"
 Exit `3` with `checkpoint.id` and `next_action: "watch_checkpoint"` means the
 request was accepted, not captured. Use that `checkpoint.id` as
 `CHECKPOINT_ID`. Do not run `create` again.
+For the later checkpoint blocks, replace `ABS_SAVED_RESPONSE` with the absolute
+response path printed by this checkpoint invocation.
 
 ```sh
-if delegate --root "${DELEGATE_ROOT:-$HOME/delegation-state}" checkpoint status CHECKPOINT_ID \
+RESPONSE="ABS_SAVED_RESPONSE"
+if delegate checkpoint status CHECKPOINT_ID \
   --watch 30s --json >"$RESPONSE.checkpoint.status"; then
   checkpoint_status_exit=0
 else
@@ -130,7 +144,8 @@ dispatch example, replacing `--base HEAD` with `--base COMMIT_OID`. Report a
 When the Lead no longer needs the checkpoint, remove it explicitly:
 
 ```sh
-if delegate --root "${DELEGATE_ROOT:-$HOME/delegation-state}" checkpoint remove CHECKPOINT_ID \
+RESPONSE="ABS_SAVED_RESPONSE"
+if delegate checkpoint remove CHECKPOINT_ID \
   --budget 5m --json >"$RESPONSE.checkpoint.remove"; then
   checkpoint_remove_exit=0
 else

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

@@ -2,6 +2,8 @@
 
 Run from the intended workspace, outside Delegate's private state root.
 Use a catalog provider ID in place of `--auto` when a destination was named.
+This example uses the CLI default under the main skill's
+[root rule](../SKILL.md#3-prepare-separate-paths-and-a-finite-brief).
 Prepare paths and dispatch in this same shell invocation:
 
 ```sh
@@ -13,7 +15,7 @@ Inspect the workspace and summarize the current test failures. Do not edit files
 You are the assigned worker; perform this task without delegating it.
 EOF
 printf 'Saved response: %s\n' "$RESPONSE"
-if delegate --root "${DELEGATE_ROOT:-$HOME/delegation-state}" dispatch --auto \
+if delegate dispatch --auto \
   --brief "$BRIEF" --cwd "$WORKSPACE" \
   --permission read-only --budget 30m --json >"$RESPONSE"; then
   dispatch_exit=0

package/skills/agent-integration/references/ccr.md

@@ -3,18 +3,19 @@
 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.
-`ROOT` below is the exact absolute state root selected for dispatch; use it
-unchanged for model discovery and dispatch.
+Use the CLI default under the main skill's
+[root rule](../SKILL.md#3-prepare-separate-paths-and-a-finite-brief); preserve any
+explicit custom or recorded historical root for model discovery and dispatch.
 
 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 --root ROOT models --provider ccr:print --cwd ABSOLUTE_WORKSPACE --json`.
+   `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 the same `--root ROOT`,
+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.

package/skills/agent-integration/references/collaboration.md

@@ -45,7 +45,7 @@ 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.
 (
-  if delegate --root "${DELEGATE_ROOT:-$HOME/delegation-state}" dispatch --provider "$PROVIDER_A" \
+  if delegate 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"; then
@@ -56,7 +56,7 @@ RECEIPTS="$(mktemp -d)" || exit 1
   printf '%s\n' "$dispatch_exit" >"$RECEIPTS/review-a.exit"
 ) &
 (
-  if delegate --root "${DELEGATE_ROOT:-$HOME/delegation-state}" dispatch --provider "$PROVIDER_B" \
+  if delegate 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"; then