[{"data":1,"prerenderedAt":-1},["ShallowReactive",2],{"skill:01M7DBQVVAV65GGN7VMPXJ5GDR":3,"skill-same:01M7DBQVVAV65GGN7VMPXJ5GDR":48},{"skillNo":4,"name":5,"nameZh":6,"description":7,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":12,"repositoryNo":13,"starsCount":14,"licenseSpdxId":15,"licenseFileUrl":6,"sourceHtmlUrl":16,"categories":17,"keywords":18,"publishedAt":19,"linkOnly":20,"markdownContent":21,"markdownBody":22,"frontMatter":23,"refName":26,"commitSha":27,"skillDirectory":28,"forksCount":14,"repositoryHtmlUrl":29,"repositoryHomepageUrl":6,"ownerHtmlUrl":30,"ownerBlogUrl":31,"ownerDescription":32,"updatedAt":33,"install":34,"resources":47},"01M7DBQVVAV65GGN7VMPXJ5GDR","pi-delegate",null,"Load when dispatching work to subagents as `runs: [{agent, task, …}]`: each\nentry is one run with its own worker session, and each collapses to a single\ntool result. A `mode: \"supervised\"` run additionally forks the main agent into\na private multi-turn conversation with its worker. Prefer this over the\nfire-and-forget `subagent` tool whenever the worker is likely to need review,\nclarification, redirection, or iterative refinement (advisory review,\nimplementation handoffs, parallel exploration, long-running QA). Also covers\nsteering and cancelling running work, background vs awaited execution, and\ngit-worktree isolation for parallel work.","CenterForAgenticAI\u002Ftools","CenterForAgenticAI","https:\u002F\u002Favatars.githubusercontent.com\u002Fu\u002F250424195?v=4","01M7DBNBBRNZ6NT6WYSEPYK811","CAAIR","01M7DBNBCBH3B7HHWP0ACQW3F7",0,"MIT","https:\u002F\u002Fgithub.com\u002FCenterForAgenticAI\u002Ftools\u002Fblob\u002Fmain\u002Fpackages\u002Fpi-delegate\u002Fskills\u002Fpi-delegate\u002FSKILL.md",[],[],"2026-11-15 14:19:17",false,"---\nname: pi-delegate\ndescription: |\n  Load when dispatching work to subagents as `runs: [{agent, task, …}]`: each\n  entry is one run with its own worker session, and each collapses to a single\n  tool result. A `mode: \"supervised\"` run additionally forks the main agent into\n  a private multi-turn conversation with its worker. Prefer this over the\n  fire-and-forget `subagent` tool whenever the worker is likely to need review,\n  clarification, redirection, or iterative refinement (advisory review,\n  implementation handoffs, parallel exploration, long-running QA). Also covers\n  steering and cancelling running work, background vs awaited execution, and\n  git-worktree isolation for parallel work.\nload: recognition\n---\n\n# pi-delegate\n\nUse this skill when you need a subagent to do real work. One `delegate` call\ndispatches a list of runs; each run gets its own worker session and collapses to\none result in the main thread.\n\nThe ordinary in-process modes are:\n\n- **`solo`** (the default) — send the task to one worker, return its answer.\n- **`supervised`** — insert a **fork of the main agent** (same model, same\n  system prompt) between you and the worker. It chats privately with the worker\n  for up to `rounds` turns, then collapses. Use it when you might want to push\n  back on the first answer.\nSolo and supervised worker conversations **never enter the main thread's\nhistory**; only their collapsed result does.\n\n## Empty harvests fail loudly\n\nA run that finishes with no substantive output is now a loud failure offering\nrecovery, not a silent success. Do not treat a resolved worker turn or lifecycle\nchatter as proof that the run completed. The solo runner and supervised\nworker channel share one harvest classifier:\n\n- substantive assistant text is a deliverable;\n- an explicit provider or assistant failure is a terminal failure; and\n- no assistant output, empty output, or cancellation-only output is a terminal\n  `failed` result with `No substantive assistant output recovered`.\n\nWhen recovery is available, the existing `delegate:fork-failed` wake offers it.\nIf an earlier substantive response was genuinely recovered, the harvest method\nis recorded as `salvage`; a terminal substantive response uses `terminal`.\nOrdered-run output, progress, and `{previous}` propagation happen only after a\nvalidated substantive completion. This shared classifier closes the independent\nblind spots that solo and supervised paths previously had.\n\n## Slash syntax\n\npi-delegate registers exactly `\u002Fdelegate`, `\u002Fdelegate-cancel`,\n`\u002Fdelegate-inspector`, and `\u002Fdelegate-help`. The dispatch grammar is:\n\n```text\n\u002Fdelegate TASK [--direct | --fork | --supervised | --chain NAME] [--agent NAME] [--foreground | --fg] [--worktree] [--model MODEL] [--thinking LEVEL] [--skill NAME ...] [--cwd PATH]\n```\n\n```text\n\u002Fdelegate-cancel [RUN_ID [ENTRY]]\n```\n\nFor operator cancellation, omit both values to pick one live target. Supply\n`RUN_ID ENTRY` to cancel one canonical entry immediately. Supply only `RUN_ID`\nto confirm whole-batch cancellation. Completion lists unique live run IDs, then\ncanonical entry names for the chosen run. Picker dismissal leaves work running.\n\nThe task comes first. `\u002Fdelegate TASK` runs the built-in `delegate` worker\ndirectly in the background. `--direct` is the explicit default. `--fork` and\n`--supervised` select supervised execution. `--foreground` and `--fg` wait for\nthe result. `\u002Fdelegate TASK --chain NAME` runs a saved chain and permits only the\ntask, `--cwd`, and foreground control.\n\nQuote task tokens whose text looks like an option. A quote starts a structural\nregion only at the beginning of a token, so contractions and possessives such\nas `don't` and `module's` remain ordinary task text. Backslash escapes the next\ncharacter. Unclosed quotes, unknown options, missing values, conflicting\nselectors, invalid thinking levels, unknown workers or chains, and incompatible\nchain options are rejected before dispatch.\n\n```text\n\u002Fdelegate Review the authentication changes\n\u002Fdelegate \"Review text ending in --foreground\"\n\u002Fdelegate Review the change --fork --agent reviewer --thinking high --skill code-review\n\u002Fdelegate Summarize the repository --chain discovery-report --cwd \u002Frepo --fg\n\u002Fdelegate-cancel\n\u002Fdelegate-cancel RUN_ID ENTRY\n```\n\nUse management forms alone: `\u002Fdelegate --agents`, `\u002Fdelegate --chains`,\n`\u002Fdelegate --health`, and `\u002Fdelegate --help`. Bare `\u002Fdelegate` and\n`\u002Fdelegate-help` show the same help. Use `\u002Fdelegate-inspector` for status and\ntranscripts. Inline chains and parallel workers remain available through the\n`delegate` tool API, not the slash interface.\n\n## Composing saved chains\n\nA saved chain can reference another saved chain with this exact canonical\nheading; do not insert whitespace after the colon:\n\n```md\n## chain:reusable-review\n\nReview {task} after {previous}.\n```\n\nThe management equivalent is `{ chain: \"reusable-review\", task?: \"...\" }`.\nIt is a distinct step variant and cannot carry `agent` or worker-only options.\nThe parser accepts legacy whitespace after `chain:` for compatibility, but the\nserializer always writes `## chain:\u003Cname>`. The `chain:` heading prefix is\nreserved: a worker agent used in a saved chain must not have a name beginning\nwith `chain:` because that spelling is parsed as a saved-chain reference.\n\nA deterministic command stage uses `## run:\u003Clabel>` followed by required\n`command` and optional `cwd`, `env`, and `timeoutMs` lines. Its management shape\nis `{ run, command, cwd?, env?, timeoutMs? }`; it cannot carry a task or worker\nfields. It starts no LLM. A successful command leaves scoped `{previous}`\nunchanged. Any failure stops the chain. Project-scoped commands require project\ntrust, and all command stages are preflighted before the first worker starts. A\nconfined nested caller cannot invoke a command stage because its separate shell\nprocess cannot inherit the caller's write guard.\n\nEvery reference creates a local template scope. The reference task is evaluated\nonce against the parent's scoped `{task}` and current `{previous}`. That result\nis frozen as `{task}` for the referenced chain, including its first worker and\nall deeper references. `{previous}` is different: it starts empty inside each\nreferenced chain, advances after each local worker or completed child reference,\nstays unchanged across a successful command stage, and returns the referenced\nchain's final output to its parent.\n\nResolution is recursive and eager. Every referenced name uses normal saved-chain\ndiscovery precedence. The complete reference graph resolves and every command\nstage validates before any worker starts. A missing reference, cycle, or invalid\ncommand stage rejects the whole invocation before side effects begin.\n\nNested-delegation policy applies to the resolved worker leaves, not to\nsaved-chain names. `nestedDelegateAgents` must allow every resolved leaf agent. The\ncaller's write-confinement authority also bounds every resolved leaf: inherited\nworker directories must remain within the caller's roots, and a leaf cannot\nwaive confinement or add an outside root. Allow-list or confinement rejection\nhappens before worker construction.\n\nComposition expands in place. All workers and command stages belong to one\nchain run and share its single `chainDir`; a referenced chain never creates a\nsecond artifact directory.\nExpansion makes no nested `delegate` call, so each reference adds zero delegation\ndepth.\n\n## When to prefer `delegate` over `subagent`\n\n| Situation | Tool |\n| --- | --- |\n| Likely to need review \u002F clarify \u002F redirect with the worker | **`delegate`** |\n| Parallel specialists where each may iterate independently | **`delegate`** (up to 6 runs) |\n| Long-running review\u002FQA you can dispatch and forget | **`delegate`** (background is the default) |\n| Git-isolated parallel implementation work | **`delegate`** with `worktree: true` |\n| Truly fire-and-forget single-shot question | `subagent` (simpler) |\n| You specifically need pi-subagents' chain\u002Fparallel orchestration DSL | `subagent` |\n\nDefault to `delegate` unless the task is clearly one-shot.\n\n## Tool surface\n\n- `delegate` — dispatch 1..6 parallel runs. The main call.\n- `delegate_control` — inspect and control ordinary runs:\n  - `status` — list active\u002Fcompleted dispatched runs.\n  - `result` — replay a dispatched run's authoritative output by `runId`.\n  - `steer` — guide an explicit supervised run's copied supervisor `fork`.\n    Direct workers, chain steps, and unknown in-process shapes reject steering;\n    use sparingly.\n  - `cancel` — abort one run or the whole dispatch.\n  - `recover` — relaunch a single failed worker entry. Foreground-only: a\n    delegated worker is refused this action.\n- `delegate_escalation` — one tool, three actions:\n  - `list` — list canonical pending escalation requests and their holders.\n  - `resolve` — resolve a root-held request within root authority, or a\n    user-held request only after the operator actually chose and\n    `onBehalfOfUser: true` is supplied.\n  - `pass_up` — pass a root-held request upward, normally to the user.\n\nBoth appear only once there is something to control, so they are absent from an\nidle session. The eleven names they replace still work in a `tools:` allowlist.\n\n## Minimum viable call\n\n```ts\ndelegate({\n  runs: [\n    { agent: \"reviewer\", task: \"Review packages\u002Fapi\u002Fsrc\u002Fsession-store.ts for race conditions\" }\n  ]\n})\n```\n\nSolo and supervised background runs return immediately with a `runId`; when they\nfinish, the main agent gets a `custom_message` wake-up containing the collapsed\noutput.\n\n## Key parameters per run entry\n\n```ts\ndelegate({ runs: [{\n  agent: \"reviewer\",                \u002F\u002F agent definition name (required)\n  task: \"...\",                      \u002F\u002F initial framing (required unless `after`-gated)\n  name?: \"reviewer-a\",              \u002F\u002F the key you steer\u002Fcancel\u002Frecover this run by\n  mode?: \"solo\",                    \u002F\u002F \"solo\" (default) | \"supervised\"\n\n  \u002F\u002F solo only — reject on a supervised entry\n  after?: [\"scout\"] | \"previous\",   \u002F\u002F order this run behind a whole earlier layer\n  count?: 3,                        \u002F\u002F fan out N copies of this entry\n  artifact?: \"notes.md\",            \u002F\u002F private returned file; basename only, never a workspace path\n  check?: \"validate-notes notes.md\", \u002F\u002F validate that artifact; independent solo runs only\n  reads?: [\"spec.md\"],              \u002F\u002F seed the worker with file contents\n  progress?: true,                  \u002F\u002F direct\u002Fchain progress file; supervised ignores and warns once\n\n  \u002F\u002F supervision. `rounds` REJECTS on a solo entry; `clone_mode` and\n  \u002F\u002F `collapse_mode` are accepted there and silently do nothing (#286).\n  rounds?: 5,                       \u002F\u002F total worker-message budget; exact first turn consumes one\n  clone_mode?: \"full\" | \"snippet\" | \"task_only\",   \u002F\u002F history seeding, default \"full\"\n  task_delivery?: \"direct-first-turn\" | \"supervisor-mediated\", \u002F\u002F exact caller task first by default\n  snippet_last_n?: 10,              \u002F\u002F for \"snippet\" mode\n  collapse_mode?: \"final_output\" | \"summary\",\n  \u002F\u002F Omit for no provider call; pin provider\u002Fmodel, or use \"auto\" for built-in Haiku 4.5.\n  summary_model?: \"anthropic\u002Fclaude-haiku-4-5\" | \"auto\",\n  supervisor_instructions?: \"be strict about error handling\",\n  heartbeat_interval_ms?: 180_000,  \u002F\u002F supervisor wait: heartbeat after this much worker silence\n  max_consecutive_heartbeats?: 5,   \u002F\u002F silent heartbeats before a wind-down steer, then abort\n\n  \u002F\u002F solo and supervised\n  thinking?: \"high\" | false,        \u002F\u002F worker-only initial level override\n  thinkingMin?: \"medium\" | false,   \u002F\u002F worker-local adaptive lower bound\n  thinkingMax?: \"high\" | false,     \u002F\u002F worker-local adaptive upper bound\n  skills?: \"code-review\" | [\"code-review\"] | false,\n  cwd?: \"packages\u002Fapi\",             \u002F\u002F per-run cwd (rejected when worktree:true)\n  interactive?: false,              \u002F\u002F route worker UI prompts to overlay\n  worktree?: false,                 \u002F\u002F one fresh git worktree for this run\n  escalation?: \"off\" | \"local\" | object, \u002F\u002F per-entry structured escalation policy\n  fabric?: false,                   \u002F\u002F keep native tools, no fabric_exec; only narrows\n\n  model?: \"openai\u002Fgpt-5\",           \u002F\u002F worker model override\n  fallbackModels?: [\"openai\u002Fgpt-5-mini\"], \u002F\u002F ordered worker fallback models\n  depth?: 1,                        \u002F\u002F nested-delegation cap\n  env?: { GRAFT_MAIN_REF?: string | null }, \u002F\u002F per-worker env patch\n  handoff?: { tasks: [...] },       \u002F\u002F seed the durable task list\n}] })\n```\n\nFor a supervised run, omission of `task_delivery` means `direct-first-turn`: the\nruntime sends the caller's exact `task` to the worker, then seeds the supervisor\nwith that completed exchange. The exchange consumes round 1. Use explicit\n`task_delivery: \"supervisor-mediated\"` only when the supervisor should compose\nthe first worker instruction.\n\n`progress?: boolean` is accepted on a supervised entry for compatibility, but it\nis ignored and warns once per dispatch because the supervisor controls the\nmessage stream. The supervised `artifact` and `reads` fields remain\nrejected. Direct and chain runs retain their existing `progress.md` behavior.\n\n`env` merges over the inherited process environment on direct and chain worker\nsurfaces; `null` explicitly unsets a non-delegate-owned variable. Delegate\nlineage, routing, authentication, and child-control variables cannot be replaced\nor removed. Saved agent defaults may declare the same field and invocation\nvalues take precedence. Workers use the already-loaded extension code from the\nparent session; rebuilding an extension while a session is running does not\nupdate existing runs.\nDurable agent\u002Fchain\u002Fconfig definitions store `env` values in plaintext.\n\nWhen the worker loads pi-fabric, it gets `fabric_exec` unless it is\n`readOnly`, has an explicit `tools` list, or sets `fabric: false` (agent, run\nentry, or top level). A `readOnly` worker stays on native `read`, `bash`,\n`write` and `edit` until pi-fabric supports a worker write policy, so it can\nstill write its scratch files and artifact; its result reports\n`surfaceReason: readonly-worker`. A run entry's `fabric: true` never undoes an\nagent's `fabric: false`. Each result reports `surface` (`fabric` or `native`) and\n`surfaceReason`, its text has a line such as `surface: native (fabric-opt-out)`,\nand status details count them in `workerSurfaces`. See\n[`docs\u002Ffabric-mode.md`](..\u002F..\u002Fdocs\u002Ffabric-mode.md#fabric-inside-a-worker).\nName-only operational displays are redaction, not encryption of those files.\nNever save API keys, tokens, passwords, or other secrets in these definitions;\nuse the process environment or a secret manager instead.\nStart\u002Freload a fresh Pi session when a task depends on newly built extension\ncode.\n\n**`clone_mode` cheat sheet.** It seeds a supervisor, so it only means something\nwith `mode: \"supervised\"`. A solo entry accepts it and drops it — inert, not\ninvalid — so it never fails a dispatch, and never does anything either:\n- `full` — the supervisor fork sees the entire main thread (highest fidelity,\n  costs the most). Default. Watch token cost on long sessions.\n- `snippet` — the fork sees only the last N main-thread messages. Cheap\n  mid-session delegations.\n- `task_only` — the fork sees just the task framing. Cheapest; use for\n  self-contained questions.\n\n### Seed and read a worker checklist\n\nWhen a delegated worker has several steps worth tracking and a `session_tasks`\nclaimant is loaded, request a durable checklist in that entry's namespaced handoff:\n\n```ts\ndelegate({\n  runs: [{\n    name: \"worker-lane\",\n    agent: \"worker\",\n    task: \"Implement the requested change.\",\n    handoff: { tasks: [{ title: \"Read the spec\" }, { title: \"Implement and test\" }] },\n  }],\n})\n```\n\nWhen a `session_tasks` claimant is loaded, the runtime stores the seed as a\n`context-aware.tasks.v1` session entry and supplies the worker's list-maintenance\ninstruction; do not duplicate that runtime instruction here. Without a claimant,\nthe worker receives a prompt checklist instead; it is not durable and has no subtree\nor progress rows to read. With a claimant, progress rows ride the\nexisting `updated` bus event; read the worker's subtree with `session_tasks action=subtree`\nrather than waiting for a prose update. Worker task IDs belong to its own address space\nand are marked `id-kind=\"local\"`; never reconcile them against the dispatcher's own `t1`\u002F`t2` ids.\n\nThe receiver bounds come from `src\u002Ftask-seam.ts`: `MAX_SEED_TASKS` tasks,\none-level subtasks via the `parseSlotTask` depth guard and `MAX_SEED_SUBTASKS`,\nand notes capped by `MAX_SEED_NOTE_CHARS`. Keep these names in documentation and\ncode references so the limits cannot drift silently.\n\n### Name your runs\n\n`name:` is the addressing key. Every later `delegate_control` call takes it, the completion envelope reports it as\n`forkNames`, and the widget shows it. Set it on every entry of a multi-run\ndispatch, and name it after the **work** — an issue reference, a lane, a\ncomponent — never after the agent.\n\nOmitted, it falls back to the agent's name, with `#2`, `#3` appended for\nduplicates. The runtime then derives a display label from the task so the row\nstill says something, but it can only work from the text you sent: three entries\nbriefed from the same file are indistinguishable to it and come back as\n`worker 1\u002F3`, `worker 2\u002F3`, `worker 3\u002F3`. Naming them costs one field and makes\nthe whole run legible.\n\n```ts\nruns: [\n  { name: \"#128-widget\", agent: \"implementer\", task: \"…\" },\n  { name: \"#128-overlay\", agent: \"implementer\", task: \"…\" },\n]\n```\n\n### Bounded adaptive thinking\n\nAgent frontmatter can declare `thinking`, `thinkingMin`, and `thinkingMax` from\n`off|minimal|low|medium|high|xhigh`. A bounded worker begins at `thinking`, then\na compatible adaptive-thinking extension may adjust only inside the session's\nrange. Bounds are isolated per worker and never rewrite global adaptive-thinking\nconfiguration. Invocation and chain-slot overrides use the same fields; `false`\nclears one field for that invocation.\n\nFor least privilege, load the extension explicitly and select only its adaptive\ntool, for example:\n\n```yaml\nthinking: high\nthinkingMin: medium\nthinkingMax: high\nextensions: \u002Fpath\u002Fto\u002Fadaptive-thinking\u002Findex.ts\ntools: read, bash, ext:adaptive-thinking\u002Fset_thinking_effort\n```\n\n`ext:\u003Cextension>\u002F\u003Ctool>` resolves after worker extension loading. If the provider is\nmissing, the selector is skipped with a diagnostic; it never activates sibling\nextension tools. A configured provider that fails to load or is removed by explicit policy\nremains a setup error. Ambiguous or malformed selectors still fail closed. Explicit\nallowlists that select no usable tools also fail closed instead of widening to\nPi defaults. Bounds remain dormant if adaptive-thinking is absent. A loaded\n`set_thinking_effort` provider must acknowledge pi-delegate's session-local\npolicy protocol v1 or the worker fails before model work.\n\nNested delegation uses a separate depth policy. Its conservative default is 3,\nbut a fresh root agent may set `maxSubagentDepth` to 3, 4, 5, or another\ndeliberate value up to the global hard ceiling of 16. Ordinary descendants can\ntighten that inherited root cap but cannot raise it. This keeps ordinary calls\nshallow without rejecting valid multi-stage orchestrator trees.\n\n## Detached driver mode\n\n`mode: \"driver\"` hosts exactly one durable `pi-daemon` session that survives\ncaller exit. Launch returns after prompt acceptance; use `delegate_control`\n`prompt_status` and `result` to retrieve completion after caller or daemon\nrestart. Pi-daemon's session file is authoritative; pi-delegate stores only its\nlocator.\n\nDriver entries accept `model`, `env`, and task handoff, but reject `cwd`,\n`interactive`, `worktree`, and `escalation`; `thinking` and `skills` are inert.\nTask handoff reaches a usable session-tasks claimant before the first model\nrequest, otherwise it is delivered once as Markdown. The child rechecks\nadaptive-thinking policy and keeps the established minimum nested-delegation\ndepth of 3. Foreground write confinement does not cover the detached child.\n\nDriver control uses the authenticated daemon route:\n\n- `prompt_status` queries the durable prompt outcome without a lease.\n- `steer`, `follow_up`, and `ui_answer` deliver guidance or a correlated answer.\n- `cancel` acquires the lease and calls `abort`; live contention returns\n  `lease_held`.\n- `recover` resumes an interrupted driver.\n\nThe overlay shows drivers in a status-only section with elapsed time, last\nactivity, PID, phase, and terminal reason. `status` returns that projection;\n`health` reports the active-detached count; raw errors remain result-only. A\nrunner that exits before publishing a result is persisted as `runner-exited` and\ndelivered through the normal pending-wake path.\n\nDriver runs cannot use `retryOf`; recover them through the control route.\n\n## Top-level parameters\n\n```ts\n{\n  runs: [...],                      \u002F\u002F 1..6 entries, required\n  task?: \"shared task\",             \u002F\u002F used by entries that omit their own\n  concurrency?: 4,                  \u002F\u002F max simultaneous workers\n  failFast?: false,                 \u002F\u002F stop an ordered dispatch at the first failed layer\n  chain?: \"saved-chain-name\",       \u002F\u002F invoke a saved `.chain.md` template\n  agent_scope?: \"user\" | \"project\" | \"both\",  \u002F\u002F default \"both\"\n  worktree?: false,                 \u002F\u002F one fresh git worktree per run\n  await?: false,                    \u002F\u002F true only when the next action requires the result\n  sync?: false,                     \u002F\u002F deprecated compatibility alias for await\n  notifyOnFailure?: true,            \u002F\u002F default true; set false to opt out of early failure wakes\n  fabric?: false,                   \u002F\u002F native tools for every run; a run's true cannot undo it\n}\n```\n\n## Background (default) vs awaited completion\n\n- **Background** (default for every ordinary dispatch): the tool returns immediately\n  with `runId` + run names; runs execute in the background; the main agent keeps\n  working. Combined output arrives later as a `custom_message` that wakes you\n  when you would otherwise stop. Do NOT poll or sleep; one status check at a\n  natural checkpoint is fine. Otherwise continue with other work or let your\n  turn end.\n- **`await: true`**: the tool blocks until all runs finish and returns the\n  combined output as the current tool result. Use this explicit dependency\n  barrier only when the next action requires the answer and blocking the normal\n  conversational path for run-control instructions is acceptable. `sync: true` is\n  a deprecated compatibility alias.\n\n### Early failure wakes and recovery (default-on)\n\nA bounded `delegate:fork-failed` wake is emitted immediately when a background\nrun reaches terminal failure. This is **on by default** (`notifyOnFailure: true`).\nSet `notifyOnFailure: false` to opt out to aggregate-only behavior. The wake is\nbounded to `runId`, run identity, categorical reason, sibling statuses, and\nrecovery availability; it contains no free-form error\u002Ftask\u002Fprompt\u002Ftranscript,\npath, URL, environment, or worker-output data.\nHealthy siblings continue and the normal aggregate `delegate:complete` wake still\narrives once.\n\nWhen the wake says `recoveryAvailable: true`, call\n`delegate_control({action: \"recover\", runId, forkName, strategy: \"auto\"})` only for that failed\nrun. Recovery dispatches an **independent child run** with its own `runId` and\ncompletion wake — the original dispatch is never delayed or mutated. `auto` tries\n`resume` (new child seeded only with a categorical failure kind, whether partial\noutput existed, and bounded categorical tool-activity facts) if available,\notherwise falls back to `fresh` (exact original config, no prior context).\n`strategy: \"resume\"` fails closed when no safe context exists. Recovery preserves\nthe exact applicable original invocation configuration (including explicit\nfalse\u002Fzero values), is idempotent per run, never cancels healthy siblings,\nand is also available after the original aggregate completes while the same live\nprocess and dispatching foreground session own the descriptor. Hydrated,\nreplacement-session, and pending-wake paths fail closed. A halted chain step is\nintentionally not recoverable. See [`docs\u002Fearly-failure-recovery.md`](..\u002F..\u002Fdocs\u002Fearly-failure-recovery.md).\n\nOmitting both `await` and deprecated `sync` always dispatches in the background.\n\n## Structured escalation (strict opt-in, resolved per slot)\n\nEnable escalation when safe progress may require a bounded decision outside the\nworker's authority, the worker may be unable to proceed, or the task, plan,\nspec, or model may need amendment. Workers should still decide reversible\nimplementation-local details supported by task and repository evidence. Do not\nguess material scope\u002Fproduct changes, conflicting requirements, security or\npermission questions, compatibility or migration risk, destructive or\nirreversible actions, external side effects, meaningful cost, or anything the\ntask explicitly requires to be escalated.\n\nEscalation is **strictly opt-in**, and every slot resolves its effective mode\nindependently. Only a resolved `mode: \"local\"` enables a slot. Use\n`escalation: \"local\"` or an object with `mode: \"local\"` to opt in an individual\nrun entry or saved chain step.\nAn agent or global policy may also supply the opt-in mode for a slot, while a\nhigher-precedence layer can opt it back out; authority alone does not enable\nescalation. Enabled workers receive:\n\n- `escalate_decision` for a bounded choice with 2–5 explicit options; include the required `category`: `implementation` for reversible implementation-local choices, `scope-product` for material scope\u002Fproduct\u002FUX changes, or `security-permission` for security or permission questions;\n- `escalate_blocker` when progress is impossible, including the cause and what\n  would unblock it; and\n- `escalate_amendment` when the task\u002Fplan\u002Fspec\u002Fmodel needs an exact proposed\n  change and rationale.\n\nA generic extension `ask` never reaches the operator from a worker dispatch. In an\nescalation-enabled slot it is safely routed to `escalate_decision` only when\nquestion, 2–5 options, zero-based recommendation, explicit category, and\nmultiselect semantics are representable; otherwise the adapter fails closed.\nTranslated decisions do not apply a timeout default. In an escalation-disabled\nslot, `ask` returns an actionable error telling the worker to stop and report the\nunresolved question upward; no escalation tool exists there to call. Do not\nself-answer, infer `implementation` for scope\u002Fproduct or security\u002Fpermission\nquestions, or treat cancellation as an answer. Foreground interactive `ask`\nremains unchanged.\n\nIn supervised mode, the fork supervisor uses `resolve_escalation` only when its\ndeclared authority covers the request and it can choose safely. Otherwise it\nuses `escalate` to pass the request upward with useful context and a\nrecommendation. At the root, first call `delegate_escalation(action=\"list\")` to re-read\ncanonical state. Resolve root-held requests only inside root authority; use\naction `pass_up` for “not mine; pass up.” A user-held request may be resolved\nwith `delegate_escalation(action=\"resolve\", ..., onBehalfOfUser: true)` **only after the\noperator actually chose**. Never infer or manufacture the operator's answer.\n\nA pending request durably suspends **only the raiser's tool call**, without\nmodel-token burn. Supervisors and root hops wake briefly to resolve or pass;\nthey must not poll, sleep, or busy-wait. Escalation relies on background\ndelivery, so preflight rejects `await: true` (and `sync: true`) whenever any\nslot resolves to enabled. Let the current turn end while an operator-held\nrequest remains pending; a later resolution wakes and resumes the raiser.\n\nSee [`docs\u002Fescalation.md`](..\u002F..\u002Fdocs\u002Fescalation.md) for the complete schemas,\nauthority matrix, routing, timeout defaults, and cleanup semantics.\n\n## Parallel work with git worktrees\n\n```ts\ndelegate({\n  worktree: true,\n  runs: [\n    { agent: \"worker\", task: \"Implement feature A on branch a\" },\n    { agent: \"worker\", task: \"Implement feature B on branch b\" },\n  ]\n})\n```\n\nEach run gets a fresh worktree under the OS tmpdir, branched from current\nHEAD. Diffs are summarised in the combined output and the worktree is cleaned\nup automatically. Requires a clean git tree in the main cwd. Per-run `cwd`\nis rejected when `worktree: true` (worktree owns cwd assignment).\n\nAll delegate-owned in-process workers enforce writable-root confinement by\ndefault and receive a unique per-worker scratch directory. `write`\u002F`edit` paths\nare checked lexically, case-aware per filesystem root, and through existing\nsymlinks. Use `readOnly: true` on the run entry to restrict primary-root\n`write`\u002F`edit` paths; scratch and separate artifact roots remain writable, while\nthe primary root and its ancestors are excluded. It also refuses mutating git\nunless git runs (tool cwd or `-C`) and targets only inside scratch or the\nartifact workspace, so a read-only reviewer cannot commit or switch branches in\nthe shared checkout; read-only git forms such as `git status`, `git log`, and\n`git diff` run anywhere. `readOnly` guards against accidental writes through\n`write`, `edit`, and git. It is not isolation: other `bash` commands are not\nclassified and run on the host with the worker's own permissions, so they can\nwrite anywhere the OS allows. Prose and a tool list do not enforce read-only\nbehavior. To isolate a worker from your checkout, use `worktree: true`.\nThe repository-pollution guard rejects reserved or declared artifact names and\nthe protected `.pi\u002Fpi-delegate.json` config for `write`\u002F`edit` and common shell\nwrites in Git worktrees. It detects the effective (last) static `dd of=` operand\nand awk output redirection whose complete target expression is one string-literal\npath. Projects can use that config's `artifactNameExceptions` list for legitimate\nrepository paths. The bash name\nguard is best effort against deliberate command-form evasion, not a sandbox.\nDynamic or computed target construction, unmodelled interpreter file-open APIs\nsuch as `os.open`, `fs.openSync`, `sysopen`, and `File.binwrite`, nested shells,\nunparsed mutators, and arbitrary custom tools remain accepted residuals. The\nauthoritative guarantee that reserved files never reach Git is the delivery\u002FCI\ngate, whose git-level staged\u002Ftracked check catches files however they were\ncreated. Direct\nworkers and supervised forks report git-only mutation attribution. Configure\n`writableRoots` or `confineWrites: false` per slot; see\n[`docs\u002Fwrite-confinement.md`](..\u002F..\u002Fdocs\u002Fwrite-confinement.md).\n\nA worker may write only inside its cwd, its own scratch directory, its artifact\npath, and roots granted with `writableRoots`; a `readOnly` worker loses its cwd.\nOther absolute paths, including the rest of `\u002Ftmp`, are refused, so \"write the\nreport to `\u002Ftmp\u002Ffoo.md`\" fails however it is phrased. Scratch is removed when\nthe run ends.\n\n### Pick the worker by what the task returns\n\n- **Findings, a review or an answer:** `readOnly: true`. The worker returns its\n  findings in its final message, and you read them from the result. It can\n  still orient itself: `git status`, `git log`, `git branch --show-current` and\n  `git remote -v` run without a refusal, so a rule to name the repository and\n  branch is satisfiable.\n- **A file you want back:** `artifact: \"\u003Cname>.\u003Cext>\"` (one basename; works with\n  `readOnly`). The runtime gives the worker one absolute path inside that\n  worker's own attempt directory, then validates the file and returns it with\n  the result. That path is never the worker cwd or a shared `output\u002F`\n  directory under pi-delegate's data root. Its root defaults to the OS\n  temporary directory, so it can be under `\u002Ftmp`; use the exact path given.\n- **A file in the workspace:** a writable worker (no `readOnly`) that writes at\n  a workspace-relative path. Grant `writableRoots` for a path outside its cwd.\n\n```ts\ndelegate({ runs: [{ agent: \"reviewer\", readOnly: true, task: \"Review src\u002Fauth.ts for token leaks. Report findings in your final message.\" }] })\ndelegate({ runs: [{ agent: \"worker\", readOnly: true, artifact: \"audit.md\", task: \"Write the audit as Markdown to your artifact path.\" }] })\ndelegate({ runs: [{ agent: \"worker\", task: \"Write docs\u002Fauth.md describing the token flow.\" }] })\n```\n\n`readOnly: true` does not combine with `writableRoots`. A read-only worker may\nwrite only its scratch directory and its artifact workspace, so a granted root\nnever takes effect -- including one outside the worker's own root. A grant at,\ninside, or containing the primary root is now rejected at dispatch rather than\nsilently ignored; before that, the worker did its whole task and the write\nfailed at the end, after which the scratch directory was removed and the work\nwas unrecoverable.\n\nThe worker is told its own write scope automatically, so the task text does not need\nto name a scratch path — and must not hard-code an out-of-scope one.\n\n## Steering a supervised fork\n\nSteering is supported for an explicit supervised run. It targets the `fork`,\nthe copied main-agent supervisor context; guidance reaches that supervisor,\nwhich guides the delegated `worker`. Direct workers, chain steps, and unknown\nin-process shapes reject steering rather than assuming a supervisor.\n\nUse it sparingly — frequent interruptions defeat the purpose of delegation.\nPrefer letting the supervised session finish unless it's clearly off-track.\n\n```ts\ndelegate_control({\n  action: \"steer\",\n  runId: \"...\",\n  forkName: \"reviewer-a\",     \u002F\u002F the compatibility field for this run's address\n  message: \"Focus only on the locking logic; skip naming nits.\",\n  deliverAs: \"steer\"          \u002F\u002F or \"followUp\" or \"queue\"; default = best-effort ladder\n})\n```\n\n`forkName` also accepts the display label the widget shows, when exactly one\nlive supervised entry owns it; the result then tells you which supervised entry it resolved to. A name\nthat matches nothing, or a label that matches two supervised entries, is an error that\nchanges nothing — it never falls back to the broadcast. The run name is the generic\naddressing key used by control actions across direct workers, supervised forks,\nand chain steps; `forkName` remains the control API's compatibility spelling.\n\nThe user can also steer interactively from the overlay (`Option-O` \u002F `Alt+O`,\nor `Ctrl+Alt+D` → select entry → `Tab` → type → `Enter`).\n\n## Cancelling\n\nThe operator-facing command is `\u002Fdelegate-cancel [RUN_ID [ENTRY]]`. With no\narguments it lists live targets. `RUN_ID ENTRY` cancels one exact entry without\nconfirmation. Bare `RUN_ID` confirms whole-batch cancellation.\n\n`Esc` keeps its local context: foreground-turn interruption, inspector ascent or\nclose, and confirmation dismissal. Use `\u002Fdelegate-cancel` for an explicit target.\n\nThe agent-facing equivalent is:\n\n```ts\ndelegate_control({ action: \"cancel\", runId, forkName?, reason? })\n```\n\nCancellation addresses any ordinary delegated run entry: a direct `worker`, a\nsupervised `fork` plus its delegated `worker`, or a chain `step`. Existing\nauthorization rules still apply. Omit `forkName` to abort the whole batch. Any\nblocking worker UI prompts resolve to their default. Completion still wakes the\nmain agent.\n\nRun-entry timeout policy is opt-in by default: global `perForkMaxDurationMs`\n(`0` by default) is an absolute operator ceiling. Agent definitions and\nrun entries can set `max_duration_ms` and\n`wind_down_grace_ms`; precedence is invocation > agent > global, with explicit\n`0` disabling a layer unless a positive global ceiling clamps it. Solo runs\nresolve the same budget at the dispatch boundary through the same precedence\n(#287). They arm it when the first worker session becomes steerable, before\nextension binding and prompt delivery. `max_duration_ms` is the\nexplicit worker execution limit; it is not a promise that the\nouter `delegate` call returns at that exact wall-clock instant. On timeout,\nthe supervisor\u002Ffork-clone still has to wind down, cancel its worker, persist\nthe terminal result, and collapse the fork. That shutdown overhead can make\nobserved wall-clock duration exceed `max_duration_ms`, while the result still\ncorrectly reports `cancelReason: \"timeout\"`. A refusal fallback shares that first\ndeadline; changing models does not restart the clock.\n\nFor a long solo run that writes incremental findings, set one `artifact` file.\nThe worker must write it at the absolute artifact-workspace path the runtime injects. On clean\ncompletion, the runtime reads its non-empty contents and uses them as the\nworker's deliverable. Missing or invalid artifacts fail the step; the runtime\nnever substitutes the final assistant message.\n\n`check` is an optional shell command beside `artifact` on an independent solo run.\nThe runtime runs it after the producer finishes. A failed check retries that producer\nexactly once with the checker's bounded output, and a second failure fails the run.\nA successful artifact writes `manifest.json`: `check.status` is `pending` without a\nchecker and records the checker result otherwise.\n\nPer-run `check` does not compile into ordered runs. A dispatch with any `after` entry\nrejects a per-run `check` instead of dropping it. For an ordered or saved-chain\nproducer, declare both `artifact` and `check` in that producer's agent frontmatter;\nthe agent-level checker applies to its chain step.\n\nTimeouts do not inspect or publish a declared artifact. The run remains\ntruthfully `aborted`\u002F`timeout`, and any final message remains a handoff.\n\n### Choosing and retrying timeout budgets\n\nBudget for the work the worker must do, not just the model's next response:\n\n- Start bounded inspections and code reviews at 5–10 minutes. Use 15–30 minutes for\n  builds, integration tests, or work that may wait on tools.\n- Add a `wind_down_grace_ms` large enough for the supervisor to collect a useful\n  result. A 60–120 second grace window is a practical starting point when the\n  worker may finish near the limit.\n- If a timeout is otherwise healthy, retry once with roughly 2× the worker budget\n  and a matching grace window before changing the task or model.\n- If a second timeout occurs, inspect `delegate_control(action=\"result\")` and the\n  run activity. Then narrow the task, split the work, or stop retrying. Do not\n  treat a longer outer wall-clock wait as proof that the worker received more\n  execution time.\n\n## Discovering available agents\n\nBundled builtin agents (always available): `delegate` and `worker`. Companion\ndevelopment-tool packages can ship the `scout`, `planner`, `reviewer`,\n`implementer`, and `integrator` workflow agents. Plus anything in\n`~\u002F.pi\u002Fagent\u002Fagents\u002F`, `~\u002F.agents\u002F`, or project-local `.agents\u002F` \u002F `.pi\u002Fagents\u002F`\ndirectories.\n\n`implementer` is the language-agnostic implementation worker (it loads\n`implement` plus the matching `implement-\u003Clanguage>` orientation).\n`integrator` is the narrow merge helper for putting finished parallel work onto\none branch (it loads `merge-coordinate`). For planning and dispatching that\nparallel work in the first place, load `orchestrate-work`.\n\nUse `\u002Fdelegate --agents` (humans) or read the relevant `.md` definition\n(agents) to see what each one does.\n\n## Picking a collapse mode\n\n- **`final_output`** (default) — return whatever the supervisor passes to\n  `finish_delegation({ final_output })`. Use this when the supervisor itself\n  has produced the answer you want.\n- **`summary`** — ask the supervisor for a concise closing note. With no\n  `summary_model`, that note is returned verbatim with zero summarizer provider\n  calls. Pin `provider\u002Fmodel` to refine the full transcript, or use literal\n  `\"auto\"` to select only `anthropic\u002Fclaude-haiku-4-5`. If Haiku is unavailable,\n  collapse retains the supervisor hint and does not select another model. Before\n  any worktree or fork is created, the dispatch preflight emits at most one\n  diagnostic warning when configured summary references are unavailable in the\n  active registry or session scope. For a narrow registry, set per-run\n  `summary_model`, agent frontmatter `summary_model`, or\n  `delegateConfig.agentOverrides.\u003Cagent>.summaryModel` to an available model.\n  The per-run value wins over the effective agent default. The warning is\n  advisory and never selects a fallback. For reviews, prefer `final_output`\n  unless a separate transcript-collapse pass is genuinely needed.\n\n## Common patterns\n\n**Advisory review of staged work** (supervised, so `clone_mode` is valid):\n```ts\ndelegate({ runs: [{ agent: \"reviewer\", task: \"Review the diff for bugs\",\n                    mode: \"supervised\", clone_mode: \"snippet\", snippet_last_n: 20 }] })\n```\n\n**Two specialists in parallel:**\n```ts\ndelegate({ runs: [\n  { name: \"callsites\", agent: \"scout\",   task: \"Find every call site of foo()\" },\n  { name: \"refactor\",  agent: \"planner\", task: \"Plan a refactor that renames foo to bar\" },\n]})\n```\n\n**Cheap self-contained research** (solo — no `clone_mode`, there is no supervisor):\n```ts\ndelegate({ runs: [{ agent: \"worker\", task: \"Summarise the OAuth2 PKCE flow\" }] })\n```\n\nFor web research, see the README guidance on host-specific search\u002Ffetch tools.\n\n**Ordered pipeline** — each layer waits for the whole one before it:\n```ts\ndelegate({ runs: [\n  { name: \"scout\",  agent: \"scout\",   task: \"Inventory the session store\" },\n  { name: \"plan\",   agent: \"planner\", task: \"{previous}\", after: \"previous\" },\n  { name: \"review\", agent: \"reviewer\", task: \"{previous}\", after: \"previous\" },\n]})\n```\n\n**Implementation handoff with git isolation:**\n```ts\ndelegate({ worktree: true, runs: [\n  { agent: \"worker\", task: \"Implement plan in scratch\u002Fplan.md\", mode: \"supervised\", rounds: 8 },\n]})\n```\n\n## Watching delegated work live\n\n- **Status widget** below the editor — one line per active run. Wide rows show\n  each run's current deterministic or opt-in semantic ticker headline and\n  update immediately when it changes; a ~10 s refresh advances elapsed time.\n  Each row also shows a compact rolling chip such as `12k tok\u002F$0.084`, summed\n  across the supervisor clone (when present), worker, caches, and that run's\n  activity-ticker usage. Message counts use the compact `8msg` form. The narrow\n  `◆N` row aggregates usage over the visible runs.\n- **Footer ticker** — aggregate live and briefly retained terminal counts for\n  every run count; per-run identities and headlines stay in the widget.\n- **Transcript inspector** — `Option-O` \u002F `Alt+O`, `Ctrl+Alt+D`, or `\u002Fdelegate-inspector`.\n  - The header keeps a persistent `live N:` summary; `N live elsewhere` explains historical selection.\n  - `←\u002F→` switch run entry, `{\u002F}` switch run, `[\u002F]` jump message, `l` jumps to\u002Fcycles live runs.\n  - `↑\u002F↓` scroll, `End` resumes auto-follow, `t` cycles thinking detail, and `g` cycles tool detail.\n  - `s` → compose → `Enter` to steer the selected supervised fork.\n  - `x` then `y` to cancel the selected run entry.\n\n## Gotchas\n\n- **Never poll or sleep after dispatching.** Results wake you when you would\n  otherwise stop. A single `delegate_control(action=\"status\")` check at a natural\n  checkpoint is fine; a status loop or `bash sleep` wastes tokens and time.\n- `clone_mode: \"full\"` copies the entire main-thread history into the fork.\n  Cheap mid-session delegations should use `snippet` or `task_only`.\n- Fork-clone needs the main agent's model configured in `ModelRegistry` —\n  if your main model lacks auth, fork creation fails.\n- Worker sessions are saved under `~\u002F.pi\u002Fagent\u002Fsessions\u002Fforks\u002F` — a\n  discoverable subdir of the main sessions dir, kept out of `\u002Fresume`'s\n  per-cwd picker. Open with `pi --session \u003Cpath>`.\n- Outside the opt-in escalation native prompt and existing overlay controls,\n  there is no general mid-fork user-driven supervisor UI. The main agent still\n  drives the fork; a `supervisor: \"user\"` mode is not implemented.\n\n## Reference\n\n- Use `pi list` to locate the active package source; editable package checkouts\n  should not live under `~\u002F.pi\u002Fagent\u002Fextensions\u002F`.\n- Full package docs: `README.md` and `docs\u002Fescalation.md` relative to the active\n  package root (parameters, config, builtin agents, testing, and security notes).\n\n## Retrying a failed attempt\n\nUse `retryOf: { runId, forkName }` on an ordinary supervised run entry, direct\nrun entry, or single direct run. Copy the exact stored `forkName`, provide a corrected\n`task` and any needed `cwd` or worktree settings, and expect a new `attempt`.\nOnly failed and aborted predecessors qualify; `count > 1`, live\u002Fcompleted\u002F\npaused predecessors, duplicate or already-replaced references, chains, and\nsaved chains are rejected. A valid unresolved lane is retained as one component within the 25-run durable\ncompleted-record budget; malformed hydrated relationships are quarantined and fail\nclosed without hiding their rows. `retryOf` hides only the valid predecessor\nrow in the owner-scoped ambient widget. Public retry metadata is capped at 32\nentries separately from the 24-attempt retention-safe lineage bound and reports explicit\nincomplete\u002Ftruncated flags consistently across status, result, synchronous\nreturns, live wakes, and durable redelivery. Cumulative presentation may carry\nprior usage for a zero-usage attempt, while accounting stays attempt-local. It\nis not `delegate_recover`, which has separate recovery\u002Fresumption authority.\n\n## Nested coordinator synthesis\n\nFor a nested coordinator, `delegate:complete` starts a fresh result window. Its\nnext answer must be one self-contained synthesis of the completed children;\npre-wake progress is not concatenated into that result. While owned children\nremain live, pi-delegate keeps the coordinator session available through\n`agent_end` until a child wake, queued input, cancellation, or provider failure\nadvances the lifecycle. Coordinator shutdown aborts its unfinished children.\n","# pi-delegate\n\nUse this skill when you need a subagent to do real work. One `delegate` call\ndispatches a list of runs; each run gets its own worker session and collapses to\none result in the main thread.\n\nThe ordinary in-process modes are:\n\n- **`solo`** (the default) — send the task to one worker, return its answer.\n- **`supervised`** — insert a **fork of the main agent** (same model, same\n  system prompt) between you and the worker. It chats privately with the worker\n  for up to `rounds` turns, then collapses. Use it when you might want to push\n  back on the first answer.\nSolo and supervised worker conversations **never enter the main thread's\nhistory**; only their collapsed result does.\n\n## Empty harvests fail loudly\n\nA run that finishes with no substantive output is now a loud failure offering\nrecovery, not a silent success. Do not treat a resolved worker turn or lifecycle\nchatter as proof that the run completed. The solo runner and supervised\nworker channel share one harvest classifier:\n\n- substantive assistant text is a deliverable;\n- an explicit provider or assistant failure is a terminal failure; and\n- no assistant output, empty output, or cancellation-only output is a terminal\n  `failed` result with `No substantive assistant output recovered`.\n\nWhen recovery is available, the existing `delegate:fork-failed` wake offers it.\nIf an earlier substantive response was genuinely recovered, the harvest method\nis recorded as `salvage`; a terminal substantive response uses `terminal`.\nOrdered-run output, progress, and `{previous}` propagation happen only after a\nvalidated substantive completion. This shared classifier closes the independent\nblind spots that solo and supervised paths previously had.\n\n## Slash syntax\n\npi-delegate registers exactly `\u002Fdelegate`, `\u002Fdelegate-cancel`,\n`\u002Fdelegate-inspector`, and `\u002Fdelegate-help`. The dispatch grammar is:\n\n```text\n\u002Fdelegate TASK [--direct | --fork | --supervised | --chain NAME] [--agent NAME] [--foreground | --fg] [--worktree] [--model MODEL] [--thinking LEVEL] [--skill NAME ...] [--cwd PATH]\n```\n\n```text\n\u002Fdelegate-cancel [RUN_ID [ENTRY]]\n```\n\nFor operator cancellation, omit both values to pick one live target. Supply\n`RUN_ID ENTRY` to cancel one canonical entry immediately. Supply only `RUN_ID`\nto confirm whole-batch cancellation. Completion lists unique live run IDs, then\ncanonical entry names for the chosen run. Picker dismissal leaves work running.\n\nThe task comes first. `\u002Fdelegate TASK` runs the built-in `delegate` worker\ndirectly in the background. `--direct` is the explicit default. `--fork` and\n`--supervised` select supervised execution. `--foreground` and `--fg` wait for\nthe result. `\u002Fdelegate TASK --chain NAME` runs a saved chain and permits only the\ntask, `--cwd`, and foreground control.\n\nQuote task tokens whose text looks like an option. A quote starts a structural\nregion only at the beginning of a token, so contractions and possessives such\nas `don't` and `module's` remain ordinary task text. Backslash escapes the next\ncharacter. Unclosed quotes, unknown options, missing values, conflicting\nselectors, invalid thinking levels, unknown workers or chains, and incompatible\nchain options are rejected before dispatch.\n\n```text\n\u002Fdelegate Review the authentication changes\n\u002Fdelegate \"Review text ending in --foreground\"\n\u002Fdelegate Review the change --fork --agent reviewer --thinking high --skill code-review\n\u002Fdelegate Summarize the repository --chain discovery-report --cwd \u002Frepo --fg\n\u002Fdelegate-cancel\n\u002Fdelegate-cancel RUN_ID ENTRY\n```\n\nUse management forms alone: `\u002Fdelegate --agents`, `\u002Fdelegate --chains`,\n`\u002Fdelegate --health`, and `\u002Fdelegate --help`. Bare `\u002Fdelegate` and\n`\u002Fdelegate-help` show the same help. Use `\u002Fdelegate-inspector` for status and\ntranscripts. Inline chains and parallel workers remain available through the\n`delegate` tool API, not the slash interface.\n\n## Composing saved chains\n\nA saved chain can reference another saved chain with this exact canonical\nheading; do not insert whitespace after the colon:\n\n```md\n## chain:reusable-review\n\nReview {task} after {previous}.\n```\n\nThe management equivalent is `{ chain: \"reusable-review\", task?: \"...\" }`.\nIt is a distinct step variant and cannot carry `agent` or worker-only options.\nThe parser accepts legacy whitespace after `chain:` for compatibility, but the\nserializer always writes `## chain:\u003Cname>`. The `chain:` heading prefix is\nreserved: a worker agent used in a saved chain must not have a name beginning\nwith `chain:` because that spelling is parsed as a saved-chain reference.\n\nA deterministic command stage uses `## run:\u003Clabel>` followed by required\n`command` and optional `cwd`, `env`, and `timeoutMs` lines. Its management shape\nis `{ run, command, cwd?, env?, timeoutMs? }`; it cannot carry a task or worker\nfields. It starts no LLM. A successful command leaves scoped `{previous}`\nunchanged. Any failure stops the chain. Project-scoped commands require project\ntrust, and all command stages are preflighted before the first worker starts. A\nconfined nested caller cannot invoke a command stage because its separate shell\nprocess cannot inherit the caller's write guard.\n\nEvery reference creates a local template scope. The reference task is evaluated\nonce against the parent's scoped `{task}` and current `{previous}`. That result\nis frozen as `{task}` for the referenced chain, including its first worker and\nall deeper references. `{previous}` is different: it starts empty inside each\nreferenced chain, advances after each local worker or completed child reference,\nstays unchanged across a successful command stage, and returns the referenced\nchain's final output to its parent.\n\nResolution is recursive and eager. Every referenced name uses normal saved-chain\ndiscovery precedence. The complete reference graph resolves and every command\nstage validates before any worker starts. A missing reference, cycle, or invalid\ncommand stage rejects the whole invocation before side effects begin.\n\nNested-delegation policy applies to the resolved worker leaves, not to\nsaved-chain names. `nestedDelegateAgents` must allow every resolved leaf agent. The\ncaller's write-confinement authority also bounds every resolved leaf: inherited\nworker directories must remain within the caller's roots, and a leaf cannot\nwaive confinement or add an outside root. Allow-list or confinement rejection\nhappens before worker construction.\n\nComposition expands in place. All workers and command stages belong to one\nchain run and share its single `chainDir`; a referenced chain never creates a\nsecond artifact directory.\nExpansion makes no nested `delegate` call, so each reference adds zero delegation\ndepth.\n\n## When to prefer `delegate` over `subagent`\n\n| Situation | Tool |\n| --- | --- |\n| Likely to need review \u002F clarify \u002F redirect with the worker | **`delegate`** |\n| Parallel specialists where each may iterate independently | **`delegate`** (up to 6 runs) |\n| Long-running review\u002FQA you can dispatch and forget | **`delegate`** (background is the default) |\n| Git-isolated parallel implementation work | **`delegate`** with `worktree: true` |\n| Truly fire-and-forget single-shot question | `subagent` (simpler) |\n| You specifically need pi-subagents' chain\u002Fparallel orchestration DSL | `subagent` |\n\nDefault to `delegate` unless the task is clearly one-shot.\n\n## Tool surface\n\n- `delegate` — dispatch 1..6 parallel runs. The main call.\n- `delegate_control` — inspect and control ordinary runs:\n  - `status` — list active\u002Fcompleted dispatched runs.\n  - `result` — replay a dispatched run's authoritative output by `runId`.\n  - `steer` — guide an explicit supervised run's copied supervisor `fork`.\n    Direct workers, chain steps, and unknown in-process shapes reject steering;\n    use sparingly.\n  - `cancel` — abort one run or the whole dispatch.\n  - `recover` — relaunch a single failed worker entry. Foreground-only: a\n    delegated worker is refused this action.\n- `delegate_escalation` — one tool, three actions:\n  - `list` — list canonical pending escalation requests and their holders.\n  - `resolve` — resolve a root-held request within root authority, or a\n    user-held request only after the operator actually chose and\n    `onBehalfOfUser: true` is supplied.\n  - `pass_up` — pass a root-held request upward, normally to the user.\n\nBoth appear only once there is something to control, so they are absent from an\nidle session. The eleven names they replace still work in a `tools:` allowlist.\n\n## Minimum viable call\n\n```ts\ndelegate({\n  runs: [\n    { agent: \"reviewer\", task: \"Review packages\u002Fapi\u002Fsrc\u002Fsession-store.ts for race conditions\" }\n  ]\n})\n```\n\nSolo and supervised background runs return immediately with a `runId`; when they\nfinish, the main agent gets a `custom_message` wake-up containing the collapsed\noutput.\n\n## Key parameters per run entry\n\n```ts\ndelegate({ runs: [{\n  agent: \"reviewer\",                \u002F\u002F agent definition name (required)\n  task: \"...\",                      \u002F\u002F initial framing (required unless `after`-gated)\n  name?: \"reviewer-a\",              \u002F\u002F the key you steer\u002Fcancel\u002Frecover this run by\n  mode?: \"solo\",                    \u002F\u002F \"solo\" (default) | \"supervised\"\n\n  \u002F\u002F solo only — reject on a supervised entry\n  after?: [\"scout\"] | \"previous\",   \u002F\u002F order this run behind a whole earlier layer\n  count?: 3,                        \u002F\u002F fan out N copies of this entry\n  artifact?: \"notes.md\",            \u002F\u002F private returned file; basename only, never a workspace path\n  check?: \"validate-notes notes.md\", \u002F\u002F validate that artifact; independent solo runs only\n  reads?: [\"spec.md\"],              \u002F\u002F seed the worker with file contents\n  progress?: true,                  \u002F\u002F direct\u002Fchain progress file; supervised ignores and warns once\n\n  \u002F\u002F supervision. `rounds` REJECTS on a solo entry; `clone_mode` and\n  \u002F\u002F `collapse_mode` are accepted there and silently do nothing (#286).\n  rounds?: 5,                       \u002F\u002F total worker-message budget; exact first turn consumes one\n  clone_mode?: \"full\" | \"snippet\" | \"task_only\",   \u002F\u002F history seeding, default \"full\"\n  task_delivery?: \"direct-first-turn\" | \"supervisor-mediated\", \u002F\u002F exact caller task first by default\n  snippet_last_n?: 10,              \u002F\u002F for \"snippet\" mode\n  collapse_mode?: \"final_output\" | \"summary\",\n  \u002F\u002F Omit for no provider call; pin provider\u002Fmodel, or use \"auto\" for built-in Haiku 4.5.\n  summary_model?: \"anthropic\u002Fclaude-haiku-4-5\" | \"auto\",\n  supervisor_instructions?: \"be strict about error handling\",\n  heartbeat_interval_ms?: 180_000,  \u002F\u002F supervisor wait: heartbeat after this much worker silence\n  max_consecutive_heartbeats?: 5,   \u002F\u002F silent heartbeats before a wind-down steer, then abort\n\n  \u002F\u002F solo and supervised\n  thinking?: \"high\" | false,        \u002F\u002F worker-only initial level override\n  thinkingMin?: \"medium\" | false,   \u002F\u002F worker-local adaptive lower bound\n  thinkingMax?: \"high\" | false,     \u002F\u002F worker-local adaptive upper bound\n  skills?: \"code-review\" | [\"code-review\"] | false,\n  cwd?: \"packages\u002Fapi\",             \u002F\u002F per-run cwd (rejected when worktree:true)\n  interactive?: false,              \u002F\u002F route worker UI prompts to overlay\n  worktree?: false,                 \u002F\u002F one fresh git worktree for this run\n  escalation?: \"off\" | \"local\" | object, \u002F\u002F per-entry structured escalation policy\n  fabric?: false,                   \u002F\u002F keep native tools, no fabric_exec; only narrows\n\n  model?: \"openai\u002Fgpt-5\",           \u002F\u002F worker model override\n  fallbackModels?: [\"openai\u002Fgpt-5-mini\"], \u002F\u002F ordered worker fallback models\n  depth?: 1,                        \u002F\u002F nested-delegation cap\n  env?: { GRAFT_MAIN_REF?: string | null }, \u002F\u002F per-worker env patch\n  handoff?: { tasks: [...] },       \u002F\u002F seed the durable task list\n}] })\n```\n\nFor a supervised run, omission of `task_delivery` means `direct-first-turn`: the\nruntime sends the caller's exact `task` to the worker, then seeds the supervisor\nwith that completed exchange. The exchange consumes round 1. Use explicit\n`task_delivery: \"supervisor-mediated\"` only when the supervisor should compose\nthe first worker instruction.\n\n`progress?: boolean` is accepted on a supervised entry for compatibility, but it\nis ignored and warns once per dispatch because the supervisor controls the\nmessage stream. The supervised `artifact` and `reads` fields remain\nrejected. Direct and chain runs retain their existing `progress.md` behavior.\n\n`env` merges over the inherited process environment on direct and chain worker\nsurfaces; `null` explicitly unsets a non-delegate-owned variable. Delegate\nlineage, routing, authentication, and child-control variables cannot be replaced\nor removed. Saved agent defaults may declare the same field and invocation\nvalues take precedence. Workers use the already-loaded extension code from the\nparent session; rebuilding an extension while a session is running does not\nupdate existing runs.\nDurable agent\u002Fchain\u002Fconfig definitions store `env` values in plaintext.\n\nWhen the worker loads pi-fabric, it gets `fabric_exec` unless it is\n`readOnly`, has an explicit `tools` list, or sets `fabric: false` (agent, run\nentry, or top level). A `readOnly` worker stays on native `read`, `bash`,\n`write` and `edit` until pi-fabric supports a worker write policy, so it can\nstill write its scratch files and artifact; its result reports\n`surfaceReason: readonly-worker`. A run entry's `fabric: true` never undoes an\nagent's `fabric: false`. Each result reports `surface` (`fabric` or `native`) and\n`surfaceReason`, its text has a line such as `surface: native (fabric-opt-out)`,\nand status details count them in `workerSurfaces`. See\n[`docs\u002Ffabric-mode.md`](..\u002F..\u002Fdocs\u002Ffabric-mode.md#fabric-inside-a-worker).\nName-only operational displays are redaction, not encryption of those files.\nNever save API keys, tokens, passwords, or other secrets in these definitions;\nuse the process environment or a secret manager instead.\nStart\u002Freload a fresh Pi session when a task depends on newly built extension\ncode.\n\n**`clone_mode` cheat sheet.** It seeds a supervisor, so it only means something\nwith `mode: \"supervised\"`. A solo entry accepts it and drops it — inert, not\ninvalid — so it never fails a dispatch, and never does anything either:\n- `full` — the supervisor fork sees the entire main thread (highest fidelity,\n  costs the most). Default. Watch token cost on long sessions.\n- `snippet` — the fork sees only the last N main-thread messages. Cheap\n  mid-session delegations.\n- `task_only` — the fork sees just the task framing. Cheapest; use for\n  self-contained questions.\n\n### Seed and read a worker checklist\n\nWhen a delegated worker has several steps worth tracking and a `session_tasks`\nclaimant is loaded, request a durable checklist in that entry's namespaced handoff:\n\n```ts\ndelegate({\n  runs: [{\n    name: \"worker-lane\",\n    agent: \"worker\",\n    task: \"Implement the requested change.\",\n    handoff: { tasks: [{ title: \"Read the spec\" }, { title: \"Implement and test\" }] },\n  }],\n})\n```\n\nWhen a `session_tasks` claimant is loaded, the runtime stores the seed as a\n`context-aware.tasks.v1` session entry and supplies the worker's list-maintenance\ninstruction; do not duplicate that runtime instruction here. Without a claimant,\nthe worker receives a prompt checklist instead; it is not durable and has no subtree\nor progress rows to read. With a claimant, progress rows ride the\nexisting `updated` bus event; read the worker's subtree with `session_tasks action=subtree`\nrather than waiting for a prose update. Worker task IDs belong to its own address space\nand are marked `id-kind=\"local\"`; never reconcile them against the dispatcher's own `t1`\u002F`t2` ids.\n\nThe receiver bounds come from `src\u002Ftask-seam.ts`: `MAX_SEED_TASKS` tasks,\none-level subtasks via the `parseSlotTask` depth guard and `MAX_SEED_SUBTASKS`,\nand notes capped by `MAX_SEED_NOTE_CHARS`. Keep these names in documentation and\ncode references so the limits cannot drift silently.\n\n### Name your runs\n\n`name:` is the addressing key. Every later `delegate_control` call takes it, the completion envelope reports it as\n`forkNames`, and the widget shows it. Set it on every entry of a multi-run\ndispatch, and name it after the **work** — an issue reference, a lane, a\ncomponent — never after the agent.\n\nOmitted, it falls back to the agent's name, with `#2`, `#3` appended for\nduplicates. The runtime then derives a display label from the task so the row\nstill says something, but it can only work from the text you sent: three entries\nbriefed from the same file are indistinguishable to it and come back as\n`worker 1\u002F3`, `worker 2\u002F3`, `worker 3\u002F3`. Naming them costs one field and makes\nthe whole run legible.\n\n```ts\nruns: [\n  { name: \"#128-widget\", agent: \"implementer\", task: \"…\" },\n  { name: \"#128-overlay\", agent: \"implementer\", task: \"…\" },\n]\n```\n\n### Bounded adaptive thinking\n\nAgent frontmatter can declare `thinking`, `thinkingMin`, and `thinkingMax` from\n`off|minimal|low|medium|high|xhigh`. A bounded worker begins at `thinking`, then\na compatible adaptive-thinking extension may adjust only inside the session's\nrange. Bounds are isolated per worker and never rewrite global adaptive-thinking\nconfiguration. Invocation and chain-slot overrides use the same fields; `false`\nclears one field for that invocation.\n\nFor least privilege, load the extension explicitly and select only its adaptive\ntool, for example:\n\n```yaml\nthinking: high\nthinkingMin: medium\nthinkingMax: high\nextensions: \u002Fpath\u002Fto\u002Fadaptive-thinking\u002Findex.ts\ntools: read, bash, ext:adaptive-thinking\u002Fset_thinking_effort\n```\n\n`ext:\u003Cextension>\u002F\u003Ctool>` resolves after worker extension loading. If the provider is\nmissing, the selector is skipped with a diagnostic; it never activates sibling\nextension tools. A configured provider that fails to load or is removed by explicit policy\nremains a setup error. Ambiguous or malformed selectors still fail closed. Explicit\nallowlists that select no usable tools also fail closed instead of widening to\nPi defaults. Bounds remain dormant if adaptive-thinking is absent. A loaded\n`set_thinking_effort` provider must acknowledge pi-delegate's session-local\npolicy protocol v1 or the worker fails before model work.\n\nNested delegation uses a separate depth policy. Its conservative default is 3,\nbut a fresh root agent may set `maxSubagentDepth` to 3, 4, 5, or another\ndeliberate value up to the global hard ceiling of 16. Ordinary descendants can\ntighten that inherited root cap but cannot raise it. This keeps ordinary calls\nshallow without rejecting valid multi-stage orchestrator trees.\n\n## Detached driver mode\n\n`mode: \"driver\"` hosts exactly one durable `pi-daemon` session that survives\ncaller exit. Launch returns after prompt acceptance; use `delegate_control`\n`prompt_status` and `result` to retrieve completion after caller or daemon\nrestart. Pi-daemon's session file is authoritative; pi-delegate stores only its\nlocator.\n\nDriver entries accept `model`, `env`, and task handoff, but reject `cwd`,\n`interactive`, `worktree`, and `escalation`; `thinking` and `skills` are inert.\nTask handoff reaches a usable session-tasks claimant before the first model\nrequest, otherwise it is delivered once as Markdown. The child rechecks\nadaptive-thinking policy and keeps the established minimum nested-delegation\ndepth of 3. Foreground write confinement does not cover the detached child.\n\nDriver control uses the authenticated daemon route:\n\n- `prompt_status` queries the durable prompt outcome without a lease.\n- `steer`, `follow_up`, and `ui_answer` deliver guidance or a correlated answer.\n- `cancel` acquires the lease and calls `abort`; live contention returns\n  `lease_held`.\n- `recover` resumes an interrupted driver.\n\nThe overlay shows drivers in a status-only section with elapsed time, last\nactivity, PID, phase, and terminal reason. `status` returns that projection;\n`health` reports the active-detached count; raw errors remain result-only. A\nrunner that exits before publishing a result is persisted as `runner-exited` and\ndelivered through the normal pending-wake path.\n\nDriver runs cannot use `retryOf`; recover them through the control route.\n\n## Top-level parameters\n\n```ts\n{\n  runs: [...],                      \u002F\u002F 1..6 entries, required\n  task?: \"shared task\",             \u002F\u002F used by entries that omit their own\n  concurrency?: 4,                  \u002F\u002F max simultaneous workers\n  failFast?: false,                 \u002F\u002F stop an ordered dispatch at the first failed layer\n  chain?: \"saved-chain-name\",       \u002F\u002F invoke a saved `.chain.md` template\n  agent_scope?: \"user\" | \"project\" | \"both\",  \u002F\u002F default \"both\"\n  worktree?: false,                 \u002F\u002F one fresh git worktree per run\n  await?: false,                    \u002F\u002F true only when the next action requires the result\n  sync?: false,                     \u002F\u002F deprecated compatibility alias for await\n  notifyOnFailure?: true,            \u002F\u002F default true; set false to opt out of early failure wakes\n  fabric?: false,                   \u002F\u002F native tools for every run; a run's true cannot undo it\n}\n```\n\n## Background (default) vs awaited completion\n\n- **Background** (default for every ordinary dispatch): the tool returns immediately\n  with `runId` + run names; runs execute in the background; the main agent keeps\n  working. Combined output arrives later as a `custom_message` that wakes you\n  when you would otherwise stop. Do NOT poll or sleep; one status check at a\n  natural checkpoint is fine. Otherwise continue with other work or let your\n  turn end.\n- **`await: true`**: the tool blocks until all runs finish and returns the\n  combined output as the current tool result. Use this explicit dependency\n  barrier only when the next action requires the answer and blocking the normal\n  conversational path for run-control instructions is acceptable. `sync: true` is\n  a deprecated compatibility alias.\n\n### Early failure wakes and recovery (default-on)\n\nA bounded `delegate:fork-failed` wake is emitted immediately when a background\nrun reaches terminal failure. This is **on by default** (`notifyOnFailure: true`).\nSet `notifyOnFailure: false` to opt out to aggregate-only behavior. The wake is\nbounded to `runId`, run identity, categorical reason, sibling statuses, and\nrecovery availability; it contains no free-form error\u002Ftask\u002Fprompt\u002Ftranscript,\npath, URL, environment, or worker-output data.\nHealthy siblings continue and the normal aggregate `delegate:complete` wake still\narrives once.\n\nWhen the wake says `recoveryAvailable: true`, call\n`delegate_control({action: \"recover\", runId, forkName, strategy: \"auto\"})` only for that failed\nrun. Recovery dispatches an **independent child run** with its own `runId` and\ncompletion wake — the original dispatch is never delayed or mutated. `auto` tries\n`resume` (new child seeded only with a categorical failure kind, whether partial\noutput existed, and bounded categorical tool-activity facts) if available,\notherwise falls back to `fresh` (exact original config, no prior context).\n`strategy: \"resume\"` fails closed when no safe context exists. Recovery preserves\nthe exact applicable original invocation configuration (including explicit\nfalse\u002Fzero values), is idempotent per run, never cancels healthy siblings,\nand is also available after the original aggregate completes while the same live\nprocess and dispatching foreground session own the descriptor. Hydrated,\nreplacement-session, and pending-wake paths fail closed. A halted chain step is\nintentionally not recoverable. See [`docs\u002Fearly-failure-recovery.md`](..\u002F..\u002Fdocs\u002Fearly-failure-recovery.md).\n\nOmitting both `await` and deprecated `sync` always dispatches in the background.\n\n## Structured escalation (strict opt-in, resolved per slot)\n\nEnable escalation when safe progress may require a bounded decision outside the\nworker's authority, the worker may be unable to proceed, or the task, plan,\nspec, or model may need amendment. Workers should still decide reversible\nimplementation-local details supported by task and repository evidence. Do not\nguess material scope\u002Fproduct changes, conflicting requirements, security or\npermission questions, compatibility or migration risk, destructive or\nirreversible actions, external side effects, meaningful cost, or anything the\ntask explicitly requires to be escalated.\n\nEscalation is **strictly opt-in**, and every slot resolves its effective mode\nindependently. Only a resolved `mode: \"local\"` enables a slot. Use\n`escalation: \"local\"` or an object with `mode: \"local\"` to opt in an individual\nrun entry or saved chain step.\nAn agent or global policy may also supply the opt-in mode for a slot, while a\nhigher-precedence layer can opt it back out; authority alone does not enable\nescalation. Enabled workers receive:\n\n- `escalate_decision` for a bounded choice with 2–5 explicit options; include the required `category`: `implementation` for reversible implementation-local choices, `scope-product` for material scope\u002Fproduct\u002FUX changes, or `security-permission` for security or permission questions;\n- `escalate_blocker` when progress is impossible, including the cause and what\n  would unblock it; and\n- `escalate_amendment` when the task\u002Fplan\u002Fspec\u002Fmodel needs an exact proposed\n  change and rationale.\n\nA generic extension `ask` never reaches the operator from a worker dispatch. In an\nescalation-enabled slot it is safely routed to `escalate_decision` only when\nquestion, 2–5 options, zero-based recommendation, explicit category, and\nmultiselect semantics are representable; otherwise the adapter fails closed.\nTranslated decisions do not apply a timeout default. In an escalation-disabled\nslot, `ask` returns an actionable error telling the worker to stop and report the\nunresolved question upward; no escalation tool exists there to call. Do not\nself-answer, infer `implementation` for scope\u002Fproduct or security\u002Fpermission\nquestions, or treat cancellation as an answer. Foreground interactive `ask`\nremains unchanged.\n\nIn supervised mode, the fork supervisor uses `resolve_escalation` only when its\ndeclared authority covers the request and it can choose safely. Otherwise it\nuses `escalate` to pass the request upward with useful context and a\nrecommendation. At the root, first call `delegate_escalation(action=\"list\")` to re-read\ncanonical state. Resolve root-held requests only inside root authority; use\naction `pass_up` for “not mine; pass up.” A user-held request may be resolved\nwith `delegate_escalation(action=\"resolve\", ..., onBehalfOfUser: true)` **only after the\noperator actually chose**. Never infer or manufacture the operator's answer.\n\nA pending request durably suspends **only the raiser's tool call**, without\nmodel-token burn. Supervisors and root hops wake briefly to resolve or pass;\nthey must not poll, sleep, or busy-wait. Escalation relies on background\ndelivery, so preflight rejects `await: true` (and `sync: true`) whenever any\nslot resolves to enabled. Let the current turn end while an operator-held\nrequest remains pending; a later resolution wakes and resumes the raiser.\n\nSee [`docs\u002Fescalation.md`](..\u002F..\u002Fdocs\u002Fescalation.md) for the complete schemas,\nauthority matrix, routing, timeout defaults, and cleanup semantics.\n\n## Parallel work with git worktrees\n\n```ts\ndelegate({\n  worktree: true,\n  runs: [\n    { agent: \"worker\", task: \"Implement feature A on branch a\" },\n    { agent: \"worker\", task: \"Implement feature B on branch b\" },\n  ]\n})\n```\n\nEach run gets a fresh worktree under the OS tmpdir, branched from current\nHEAD. Diffs are summarised in the combined output and the worktree is cleaned\nup automatically. Requires a clean git tree in the main cwd. Per-run `cwd`\nis rejected when `worktree: true` (worktree owns cwd assignment).\n\nAll delegate-owned in-process workers enforce writable-root confinement by\ndefault and receive a unique per-worker scratch directory. `write`\u002F`edit` paths\nare checked lexically, case-aware per filesystem root, and through existing\nsymlinks. Use `readOnly: true` on the run entry to restrict primary-root\n`write`\u002F`edit` paths; scratch and separate artifact roots remain writable, while\nthe primary root and its ancestors are excluded. It also refuses mutating git\nunless git runs (tool cwd or `-C`) and targets only inside scratch or the\nartifact workspace, so a read-only reviewer cannot commit or switch branches in\nthe shared checkout; read-only git forms such as `git status`, `git log`, and\n`git diff` run anywhere. `readOnly` guards against accidental writes through\n`write`, `edit`, and git. It is not isolation: other `bash` commands are not\nclassified and run on the host with the worker's own permissions, so they can\nwrite anywhere the OS allows. Prose and a tool list do not enforce read-only\nbehavior. To isolate a worker from your checkout, use `worktree: true`.\nThe repository-pollution guard rejects reserved or declared artifact names and\nthe protected `.pi\u002Fpi-delegate.json` config for `write`\u002F`edit` and common shell\nwrites in Git worktrees. It detects the effective (last) static `dd of=` operand\nand awk output redirection whose complete target expression is one string-literal\npath. Projects can use that config's `artifactNameExceptions` list for legitimate\nrepository paths. The bash name\nguard is best effort against deliberate command-form evasion, not a sandbox.\nDynamic or computed target construction, unmodelled interpreter file-open APIs\nsuch as `os.open`, `fs.openSync`, `sysopen`, and `File.binwrite`, nested shells,\nunparsed mutators, and arbitrary custom tools remain accepted residuals. The\nauthoritative guarantee that reserved files never reach Git is the delivery\u002FCI\ngate, whose git-level staged\u002Ftracked check catches files however they were\ncreated. Direct\nworkers and supervised forks report git-only mutation attribution. Configure\n`writableRoots` or `confineWrites: false` per slot; see\n[`docs\u002Fwrite-confinement.md`](..\u002F..\u002Fdocs\u002Fwrite-confinement.md).\n\nA worker may write only inside its cwd, its own scratch directory, its artifact\npath, and roots granted with `writableRoots`; a `readOnly` worker loses its cwd.\nOther absolute paths, including the rest of `\u002Ftmp`, are refused, so \"write the\nreport to `\u002Ftmp\u002Ffoo.md`\" fails however it is phrased. Scratch is removed when\nthe run ends.\n\n### Pick the worker by what the task returns\n\n- **Findings, a review or an answer:** `readOnly: true`. The worker returns its\n  findings in its final message, and you read them from the result. It can\n  still orient itself: `git status`, `git log`, `git branch --show-current` and\n  `git remote -v` run without a refusal, so a rule to name the repository and\n  branch is satisfiable.\n- **A file you want back:** `artifact: \"\u003Cname>.\u003Cext>\"` (one basename; works with\n  `readOnly`). The runtime gives the worker one absolute path inside that\n  worker's own attempt directory, then validates the file and returns it with\n  the result. That path is never the worker cwd or a shared `output\u002F`\n  directory under pi-delegate's data root. Its root defaults to the OS\n  temporary directory, so it can be under `\u002Ftmp`; use the exact path given.\n- **A file in the workspace:** a writable worker (no `readOnly`) that writes at\n  a workspace-relative path. Grant `writableRoots` for a path outside its cwd.\n\n```ts\ndelegate({ runs: [{ agent: \"reviewer\", readOnly: true, task: \"Review src\u002Fauth.ts for token leaks. Report findings in your final message.\" }] })\ndelegate({ runs: [{ agent: \"worker\", readOnly: true, artifact: \"audit.md\", task: \"Write the audit as Markdown to your artifact path.\" }] })\ndelegate({ runs: [{ agent: \"worker\", task: \"Write docs\u002Fauth.md describing the token flow.\" }] })\n```\n\n`readOnly: true` does not combine with `writableRoots`. A read-only worker may\nwrite only its scratch directory and its artifact workspace, so a granted root\nnever takes effect -- including one outside the worker's own root. A grant at,\ninside, or containing the primary root is now rejected at dispatch rather than\nsilently ignored; before that, the worker did its whole task and the write\nfailed at the end, after which the scratch directory was removed and the work\nwas unrecoverable.\n\nThe worker is told its own write scope automatically, so the task text does not need\nto name a scratch path — and must not hard-code an out-of-scope one.\n\n## Steering a supervised fork\n\nSteering is supported for an explicit supervised run. It targets the `fork`,\nthe copied main-agent supervisor context; guidance reaches that supervisor,\nwhich guides the delegated `worker`. Direct workers, chain steps, and unknown\nin-process shapes reject steering rather than assuming a supervisor.\n\nUse it sparingly — frequent interruptions defeat the purpose of delegation.\nPrefer letting the supervised session finish unless it's clearly off-track.\n\n```ts\ndelegate_control({\n  action: \"steer\",\n  runId: \"...\",\n  forkName: \"reviewer-a\",     \u002F\u002F the compatibility field for this run's address\n  message: \"Focus only on the locking logic; skip naming nits.\",\n  deliverAs: \"steer\"          \u002F\u002F or \"followUp\" or \"queue\"; default = best-effort ladder\n})\n```\n\n`forkName` also accepts the display label the widget shows, when exactly one\nlive supervised entry owns it; the result then tells you which supervised entry it resolved to. A name\nthat matches nothing, or a label that matches two supervised entries, is an error that\nchanges nothing — it never falls back to the broadcast. The run name is the generic\naddressing key used by control actions across direct workers, supervised forks,\nand chain steps; `forkName` remains the control API's compatibility spelling.\n\nThe user can also steer interactively from the overlay (`Option-O` \u002F `Alt+O`,\nor `Ctrl+Alt+D` → select entry → `Tab` → type → `Enter`).\n\n## Cancelling\n\nThe operator-facing command is `\u002Fdelegate-cancel [RUN_ID [ENTRY]]`. With no\narguments it lists live targets. `RUN_ID ENTRY` cancels one exact entry without\nconfirmation. Bare `RUN_ID` confirms whole-batch cancellation.\n\n`Esc` keeps its local context: foreground-turn interruption, inspector ascent or\nclose, and confirmation dismissal. Use `\u002Fdelegate-cancel` for an explicit target.\n\nThe agent-facing equivalent is:\n\n```ts\ndelegate_control({ action: \"cancel\", runId, forkName?, reason? })\n```\n\nCancellation addresses any ordinary delegated run entry: a direct `worker`, a\nsupervised `fork` plus its delegated `worker`, or a chain `step`. Existing\nauthorization rules still apply. Omit `forkName` to abort the whole batch. Any\nblocking worker UI prompts resolve to their default. Completion still wakes the\nmain agent.\n\nRun-entry timeout policy is opt-in by default: global `perForkMaxDurationMs`\n(`0` by default) is an absolute operator ceiling. Agent definitions and\nrun entries can set `max_duration_ms` and\n`wind_down_grace_ms`; precedence is invocation > agent > global, with explicit\n`0` disabling a layer unless a positive global ceiling clamps it. Solo runs\nresolve the same budget at the dispatch boundary through the same precedence\n(#287). They arm it when the first worker session becomes steerable, before\nextension binding and prompt delivery. `max_duration_ms` is the\nexplicit worker execution limit; it is not a promise that the\nouter `delegate` call returns at that exact wall-clock instant. On timeout,\nthe supervisor\u002Ffork-clone still has to wind down, cancel its worker, persist\nthe terminal result, and collapse the fork. That shutdown overhead can make\nobserved wall-clock duration exceed `max_duration_ms`, while the result still\ncorrectly reports `cancelReason: \"timeout\"`. A refusal fallback shares that first\ndeadline; changing models does not restart the clock.\n\nFor a long solo run that writes incremental findings, set one `artifact` file.\nThe worker must write it at the absolute artifact-workspace path the runtime injects. On clean\ncompletion, the runtime reads its non-empty contents and uses them as the\nworker's deliverable. Missing or invalid artifacts fail the step; the runtime\nnever substitutes the final assistant message.\n\n`check` is an optional shell command beside `artifact` on an independent solo run.\nThe runtime runs it after the producer finishes. A failed check retries that producer\nexactly once with the checker's bounded output, and a second failure fails the run.\nA successful artifact writes `manifest.json`: `check.status` is `pending` without a\nchecker and records the checker result otherwise.\n\nPer-run `check` does not compile into ordered runs. A dispatch with any `after` entry\nrejects a per-run `check` instead of dropping it. For an ordered or saved-chain\nproducer, declare both `artifact` and `check` in that producer's agent frontmatter;\nthe agent-level checker applies to its chain step.\n\nTimeouts do not inspect or publish a declared artifact. The run remains\ntruthfully `aborted`\u002F`timeout`, and any final message remains a handoff.\n\n### Choosing and retrying timeout budgets\n\nBudget for the work the worker must do, not just the model's next response:\n\n- Start bounded inspections and code reviews at 5–10 minutes. Use 15–30 minutes for\n  builds, integration tests, or work that may wait on tools.\n- Add a `wind_down_grace_ms` large enough for the supervisor to collect a useful\n  result. A 60–120 second grace window is a practical starting point when the\n  worker may finish near the limit.\n- If a timeout is otherwise healthy, retry once with roughly 2× the worker budget\n  and a matching grace window before changing the task or model.\n- If a second timeout occurs, inspect `delegate_control(action=\"result\")` and the\n  run activity. Then narrow the task, split the work, or stop retrying. Do not\n  treat a longer outer wall-clock wait as proof that the worker received more\n  execution time.\n\n## Discovering available agents\n\nBundled builtin agents (always available): `delegate` and `worker`. Companion\ndevelopment-tool packages can ship the `scout`, `planner`, `reviewer`,\n`implementer`, and `integrator` workflow agents. Plus anything in\n`~\u002F.pi\u002Fagent\u002Fagents\u002F`, `~\u002F.agents\u002F`, or project-local `.agents\u002F` \u002F `.pi\u002Fagents\u002F`\ndirectories.\n\n`implementer` is the language-agnostic implementation worker (it loads\n`implement` plus the matching `implement-\u003Clanguage>` orientation).\n`integrator` is the narrow merge helper for putting finished parallel work onto\none branch (it loads `merge-coordinate`). For planning and dispatching that\nparallel work in the first place, load `orchestrate-work`.\n\nUse `\u002Fdelegate --agents` (humans) or read the relevant `.md` definition\n(agents) to see what each one does.\n\n## Picking a collapse mode\n\n- **`final_output`** (default) — return whatever the supervisor passes to\n  `finish_delegation({ final_output })`. Use this when the supervisor itself\n  has produced the answer you want.\n- **`summary`** — ask the supervisor for a concise closing note. With no\n  `summary_model`, that note is returned verbatim with zero summarizer provider\n  calls. Pin `provider\u002Fmodel` to refine the full transcript, or use literal\n  `\"auto\"` to select only `anthropic\u002Fclaude-haiku-4-5`. If Haiku is unavailable,\n  collapse retains the supervisor hint and does not select another model. Before\n  any worktree or fork is created, the dispatch preflight emits at most one\n  diagnostic warning when configured summary references are unavailable in the\n  active registry or session scope. For a narrow registry, set per-run\n  `summary_model`, agent frontmatter `summary_model`, or\n  `delegateConfig.agentOverrides.\u003Cagent>.summaryModel` to an available model.\n  The per-run value wins over the effective agent default. The warning is\n  advisory and never selects a fallback. For reviews, prefer `final_output`\n  unless a separate transcript-collapse pass is genuinely needed.\n\n## Common patterns\n\n**Advisory review of staged work** (supervised, so `clone_mode` is valid):\n```ts\ndelegate({ runs: [{ agent: \"reviewer\", task: \"Review the diff for bugs\",\n                    mode: \"supervised\", clone_mode: \"snippet\", snippet_last_n: 20 }] })\n```\n\n**Two specialists in parallel:**\n```ts\ndelegate({ runs: [\n  { name: \"callsites\", agent: \"scout\",   task: \"Find every call site of foo()\" },\n  { name: \"refactor\",  agent: \"planner\", task: \"Plan a refactor that renames foo to bar\" },\n]})\n```\n\n**Cheap self-contained research** (solo — no `clone_mode`, there is no supervisor):\n```ts\ndelegate({ runs: [{ agent: \"worker\", task: \"Summarise the OAuth2 PKCE flow\" }] })\n```\n\nFor web research, see the README guidance on host-specific search\u002Ffetch tools.\n\n**Ordered pipeline** — each layer waits for the whole one before it:\n```ts\ndelegate({ runs: [\n  { name: \"scout\",  agent: \"scout\",   task: \"Inventory the session store\" },\n  { name: \"plan\",   agent: \"planner\", task: \"{previous}\", after: \"previous\" },\n  { name: \"review\", agent: \"reviewer\", task: \"{previous}\", after: \"previous\" },\n]})\n```\n\n**Implementation handoff with git isolation:**\n```ts\ndelegate({ worktree: true, runs: [\n  { agent: \"worker\", task: \"Implement plan in scratch\u002Fplan.md\", mode: \"supervised\", rounds: 8 },\n]})\n```\n\n## Watching delegated work live\n\n- **Status widget** below the editor — one line per active run. Wide rows show\n  each run's current deterministic or opt-in semantic ticker headline and\n  update immediately when it changes; a ~10 s refresh advances elapsed time.\n  Each row also shows a compact rolling chip such as `12k tok\u002F$0.084`, summed\n  across the supervisor clone (when present), worker, caches, and that run's\n  activity-ticker usage. Message counts use the compact `8msg` form. The narrow\n  `◆N` row aggregates usage over the visible runs.\n- **Footer ticker** — aggregate live and briefly retained terminal counts for\n  every run count; per-run identities and headlines stay in the widget.\n- **Transcript inspector** — `Option-O` \u002F `Alt+O`, `Ctrl+Alt+D`, or `\u002Fdelegate-inspector`.\n  - The header keeps a persistent `live N:` summary; `N live elsewhere` explains historical selection.\n  - `←\u002F→` switch run entry, `{\u002F}` switch run, `[\u002F]` jump message, `l` jumps to\u002Fcycles live runs.\n  - `↑\u002F↓` scroll, `End` resumes auto-follow, `t` cycles thinking detail, and `g` cycles tool detail.\n  - `s` → compose → `Enter` to steer the selected supervised fork.\n  - `x` then `y` to cancel the selected run entry.\n\n## Gotchas\n\n- **Never poll or sleep after dispatching.** Results wake you when you would\n  otherwise stop. A single `delegate_control(action=\"status\")` check at a natural\n  checkpoint is fine; a status loop or `bash sleep` wastes tokens and time.\n- `clone_mode: \"full\"` copies the entire main-thread history into the fork.\n  Cheap mid-session delegations should use `snippet` or `task_only`.\n- Fork-clone needs the main agent's model configured in `ModelRegistry` —\n  if your main model lacks auth, fork creation fails.\n- Worker sessions are saved under `~\u002F.pi\u002Fagent\u002Fsessions\u002Fforks\u002F` — a\n  discoverable subdir of the main sessions dir, kept out of `\u002Fresume`'s\n  per-cwd picker. Open with `pi --session \u003Cpath>`.\n- Outside the opt-in escalation native prompt and existing overlay controls,\n  there is no general mid-fork user-driven supervisor UI. The main agent still\n  drives the fork; a `supervisor: \"user\"` mode is not implemented.\n\n## Reference\n\n- Use `pi list` to locate the active package source; editable package checkouts\n  should not live under `~\u002F.pi\u002Fagent\u002Fextensions\u002F`.\n- Full package docs: `README.md` and `docs\u002Fescalation.md` relative to the active\n  package root (parameters, config, builtin agents, testing, and security notes).\n\n## Retrying a failed attempt\n\nUse `retryOf: { runId, forkName }` on an ordinary supervised run entry, direct\nrun entry, or single direct run. Copy the exact stored `forkName`, provide a corrected\n`task` and any needed `cwd` or worktree settings, and expect a new `attempt`.\nOnly failed and aborted predecessors qualify; `count > 1`, live\u002Fcompleted\u002F\npaused predecessors, duplicate or already-replaced references, chains, and\nsaved chains are rejected. A valid unresolved lane is retained as one component within the 25-run durable\ncompleted-record budget; malformed hydrated relationships are quarantined and fail\nclosed without hiding their rows. `retryOf` hides only the valid predecessor\nrow in the owner-scoped ambient widget. Public retry metadata is capped at 32\nentries separately from the 24-attempt retention-safe lineage bound and reports explicit\nincomplete\u002Ftruncated flags consistently across status, result, synchronous\nreturns, live wakes, and durable redelivery. Cumulative presentation may carry\nprior usage for a zero-usage attempt, while accounting stays attempt-local. It\nis not `delegate_recover`, which has separate recovery\u002Fresumption authority.\n\n## Nested coordinator synthesis\n\nFor a nested coordinator, `delegate:complete` starts a fresh result window. Its\nnext answer must be one self-contained synthesis of the completed children;\npre-wake progress is not concatenated into that result. While owned children\nremain live, pi-delegate keeps the coordinator session available through\n`agent_end` until a child wake, queued input, cancellation, or provider failure\nadvances the lifecycle. Coordinator shutdown aborts its unfinished children.\n",{"load":24,"name":5,"description":25},"recognition","Load when dispatching work to subagents as `runs: [{agent, task, …}]`: each\nentry is one run with its own worker session, and each collapses to a single\ntool result. A `mode: \"supervised\"` run additionally forks the main agent into\na private multi-turn conversation with its worker. Prefer this over the\nfire-and-forget `subagent` tool whenever the worker is likely to need review,\nclarification, redirection, or iterative refinement (advisory review,\nimplementation handoffs, parallel exploration, long-running QA). Also covers\nsteering and cancelling running work, background vs awaited execution, and\ngit-worktree isolation for parallel work.\n","main","a341ec69437d028e71ea1de51b7f6d9c1238048b","packages\u002Fpi-delegate\u002Fskills\u002Fpi-delegate","https:\u002F\u002Fgithub.com\u002FCenterForAgenticAI\u002Ftools","https:\u002F\u002Fgithub.com\u002FCenterForAgenticAI","https:\u002F\u002Fwww.centerforairesearch.org\u002F","CAAIR develops applied AI systems that support civil society, public accountability, and democratic infrastructure.","2026-11-12 02:15:25",{"source":8,"skillName":5,"commands":35,"prompt":45,"zipAvailable":46},[36,39,42],{"tool":37,"command":38},"npx","npx skills add CenterForAgenticAI\u002Ftools --skill pi-delegate",{"tool":40,"command":41},"bunx","bunx skills add CenterForAgenticAI\u002Ftools --skill pi-delegate",{"tool":43,"command":44},"pnpm","pnpm dlx skills add CenterForAgenticAI\u002Ftools --skill pi-delegate","安装技能，技能地址：https:\u002F\u002Fgithub.com\u002FCenterForAgenticAI\u002Ftools\u002Fblob\u002Fmain\u002Fpackages\u002Fpi-delegate\u002Fskills\u002Fpi-delegate\u002FSKILL.md",true,[],[49,56,63,70,77,84],{"skillNo":50,"name":51,"nameZh":6,"description":52,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":12,"repositoryNo":13,"starsCount":14,"licenseSpdxId":15,"licenseFileUrl":6,"sourceHtmlUrl":53,"categories":54,"keywords":55,"publishedAt":19},"01M7DBS96C51VE1KHCM1N0SR47","work-execution","Execute a validated pi-work node or wave when you need the ready-set, by-reference work_plan brief, Fabric default, pi-delegate fallback, explicit tree-bound verification, remediation, scope amendments, or a post-integration refactor pass. Use after decomposition and before claiming any node is done.","https:\u002F\u002Fgithub.com\u002FCenterForAgenticAI\u002Ftools\u002Fblob\u002Fmain\u002Fpackages\u002Fpi-work\u002Fskills\u002Fwork-execution\u002FSKILL.md",[],[],{"skillNo":57,"name":58,"nameZh":6,"description":59,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":12,"repositoryNo":13,"starsCount":14,"licenseSpdxId":15,"licenseFileUrl":6,"sourceHtmlUrl":60,"categories":61,"keywords":62,"publishedAt":19},"01M7DBS2SJ4ZND4SG77JX66BWK","work-decomposition","Turn a validated pi-work intent into a strict workspec work graph when the work is too large for one bounded worker. Use when assigning criterion homes, dependencies, honest write scopes, open decisions, or optional model-change nodes before planning execution.","https:\u002F\u002Fgithub.com\u002FCenterForAgenticAI\u002Ftools\u002Fblob\u002Fmain\u002Fpackages\u002Fpi-work\u002Fskills\u002Fwork-decomposition\u002FSKILL.md",[],[],{"skillNo":64,"name":65,"nameZh":6,"description":66,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":12,"repositoryNo":13,"starsCount":14,"licenseSpdxId":15,"licenseFileUrl":6,"sourceHtmlUrl":67,"categories":68,"keywords":69,"publishedAt":19},"01M7DBRXT98J0Q84K38FCFQ9VT","work-authoring","Draft a pi-work workspec when an outcome, scope, or proof obligation is still unclear. Use this before turning a conversation, issue, or design into a markdown draft, especially when acceptance criteria need to survive lossless promotion into strict YAML.","https:\u002F\u002Fgithub.com\u002FCenterForAgenticAI\u002Ftools\u002Fblob\u002Fmain\u002Fpackages\u002Fpi-work\u002Fskills\u002Fwork-authoring\u002FSKILL.md",[],[],{"skillNo":71,"name":72,"nameZh":6,"description":73,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":12,"repositoryNo":13,"starsCount":14,"licenseSpdxId":15,"licenseFileUrl":6,"sourceHtmlUrl":74,"categories":75,"keywords":76,"publishedAt":19},"01M7DBRST29F8J729DHGCM55WJ","intent-records","Draft or approve an intent record when a person asks for a change, or describe existing behaviour before retrofitting compiled intent. Use before turning intent into a pi-work workspec.","https:\u002F\u002Fgithub.com\u002FCenterForAgenticAI\u002Ftools\u002Fblob\u002Fmain\u002Fpackages\u002Fpi-intent\u002Fskills\u002Fintent-records\u002FSKILL.md",[],[],{"skillNo":78,"name":79,"nameZh":6,"description":80,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":12,"repositoryNo":13,"starsCount":14,"licenseSpdxId":15,"licenseFileUrl":6,"sourceHtmlUrl":81,"categories":82,"keywords":83,"publishedAt":19},"01M7DBRNVNYBW7K25Y7W7CYVEA","intent-conformance","Connect an approved finite Bend model to actual application code with a language-neutral conformance manifest, app-language oracles and a broken-model control. Load when proving implementation parity or diagnosing decision drift.","https:\u002F\u002Fgithub.com\u002FCenterForAgenticAI\u002Ftools\u002Fblob\u002Fmain\u002Fpackages\u002Fpi-intent\u002Fskills\u002Fintent-conformance\u002FSKILL.md",[],[],{"skillNo":85,"name":86,"nameZh":6,"description":87,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":12,"repositoryNo":13,"starsCount":14,"licenseSpdxId":15,"licenseFileUrl":6,"sourceHtmlUrl":88,"categories":89,"keywords":90,"publishedAt":19},"01M7DBRH9KT2DMXVT16P1JCHQK","compiled-intent-model","Author or change a finite Bend model from an approved intent record, review its meaning, obtain human law approval, and produce an offline-verifiable Jev receipt. Load for model-change nodes, not for emergent runtime behaviour.","https:\u002F\u002Fgithub.com\u002FCenterForAgenticAI\u002Ftools\u002Fblob\u002Fmain\u002Fpackages\u002Fpi-intent\u002Fskills\u002Fcompiled-intent-model\u002FSKILL.md",[],[]]