pi-daddy 0.27.4 → 0.32.0

package/extensions/delegate-chain.ts

@@ -7,7 +7,7 @@
  *
  * **Nothing here re-implements a governance rule.** Every step goes through `runOneDelegation`, so the grant, the
  * ceiling, `agent:<name>` authorisation, the depth bound, the ledger and `--tools` enforcement are exactly what a
- * single `delegate` gets. What a chain adds is the handoff (`src/chain.ts`), one gate instead of N, a budget unit
+ * single `delegate` gets. What a chain adds is the handoff (`src/kernel/chain.ts`), one gate instead of N, a budget unit
  * per step, and abort-on-failure.
  *
  * **Why the upfront gate is exact rather than an approximation**, which is the least obvious thing here: an approval
@@ -18,22 +18,30 @@
 
 import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
 import { Type } from "typebox";
-import type { InheritableApproval } from "../src/approval.ts";
-import { DELEGATE_SUBJECT } from "../src/approval.ts";
-import { chainStepSpec, PLACEHOLDER } from "../src/chain.ts";
-import { MAX_CHAIN_STEPS, childSpawnId, splitBudget } from "../src/fanout.ts";
-import { PAINT_INTERVAL_MS, appendTail, emptyTail, renderProgress, replaceTail, throttle, type ChildProgress } from "../src/progress.ts";
+import type { InheritableApproval } from "../src/kernel/approval.ts";
+import { DELEGATE_SUBJECT } from "../src/kernel/approval.ts";
+import { chainStepSpec, PLACEHOLDER } from "../src/kernel/chain.ts";
+import { MAX_CHAIN_STEPS, childSpawnId, splitBudget } from "../src/kernel/fanout.ts";
+import {
+  PAINT_INTERVAL_MS,
+  appendTail,
+  emptyTail,
+  renderProgress,
+  replaceTail,
+  throttle,
+  type ChildProgress,
+} from "../src/kernel/progress.ts";
 import { correlationShape } from "./correlation-shape.ts";
 import { recordChainRefusal } from "./chain-ledger.ts";
 import { obtainApprovals, snapshotOf, type ApprovalOutcome } from "./approvals.ts";
 import { runOneDelegation } from "./run-delegation.ts";
 import { isCriticalAssuranceBlock } from "./execute-child.ts";
 import type { GrantsSession } from "./session.ts";
-import { GovernanceRefusal, refusal, type StructuredRefusal } from "../src/refusals.ts";
+import { GovernanceRefusal, refusal, type StructuredRefusal } from "../src/kernel/refusals.ts";
 import { chainApprovalFacts, newChainApprovalAudit, rememberChainApproval } from "./chain-approval-facts.ts";
-import { newExecutionId } from "../src/execution-id.ts";
+import { newExecutionId } from "../src/kernel/execution-id.ts";
 import { planChain, type GateRequest } from "./chain-plan.ts";
-import { preflightModel } from "../src/model-preflight.ts";
+import { preflightModel } from "../src/kernel/model-preflight.ts";
 import { assertDelegationAuthority } from "./delegation-authority.ts";
 
 /** One chain step is one execution occurrence, however many capability dialogs contributed to its answer. */
@@ -69,15 +77,19 @@ export function registerChainTool(pi: ExtensionAPI, session: GrantsSession): voi
     agent: Type.Optional(Type.String({ description: "Definition to spawn for this step." })),
     tools: Type.Optional(Type.Array(Type.String(), { description: "Capabilities, when no 'agent' fits." })),
     model: Type.Optional(Type.String({ description: "Model as provider/id. Defaults to this session's." })),
-    thinking: Type.Optional(Type.Union(
-      ["off", "minimal", "low", "medium", "high", "xhigh", "max"].map(level => Type.Literal(level)),
-      { description: "Requested Pi thinking level; unsupported model/level combinations fail in the child." },
-    )),
+    thinking: Type.Optional(
+      Type.Union(
+        ["off", "minimal", "low", "medium", "high", "xhigh", "max"].map((level) => Type.Literal(level)),
+        { description: "Requested Pi thinking level; unsupported model/level combinations fail in the child." },
+      ),
+    ),
     correlation: Type.Optional(correlationShape()),
-    workspace: Type.Optional(Type.Object({
-      workspace_id: Type.String(),
-      access: Type.Union([Type.Literal("read"), Type.Literal("write")]),
-    })),
+    workspace: Type.Optional(
+      Type.Object({
+        workspace_id: Type.String(),
+        access: Type.Union([Type.Literal("read"), Type.Literal("write")]),
+      }),
+    ),
   });
 
   const params = Type.Object({
@@ -104,11 +116,12 @@ export function registerChainTool(pi: ExtensionAPI, session: GrantsSession): voi
       const steps = args.steps ?? [];
 
       // **Every cheap refusal happens before any human is asked.** Yesterday's lesson on the `delegate` path: with
-      // `PI_GRANTS_HERDR=1` and herdr down, the gate ran first, an operator approved `bash`, a 30-day entry was
+      // `PI_DADDY_HERDR=1` and herdr down, the gate ran first, an operator approved `bash`, a 30-day entry was
       // written, and the delegation was then refused anyway. `runOneDelegation` checks the executor before its own
       // gate; a chain hoists its gate above `runOneDelegation`, so the check has to be repeated here or that
       // ordering is simply bypassed.
-      if (session.executor.refusal) throw new GovernanceRefusal(refusal("EXECUTOR_UNAVAILABLE", `chain refused: ${session.executor.refusal}`));
+      if (session.executor.refusal)
+        throw new GovernanceRefusal(refusal("EXECUTOR_UNAVAILABLE", `chain refused: ${session.executor.refusal}`));
 
       // Cardinality next, still before the gate. `splitBudget` is reused rather than re-derived, so a chain and a
       // fan-out cannot disagree about what the budget means.
@@ -119,19 +132,22 @@ export function registerChainTool(pi: ExtensionAPI, session: GrantsSession): voi
       // `planChain`.
       const executionIds = steps.map(() => newExecutionId());
       const parentExecutionId = session.ownExecutionId ?? null;
-      const chainPlan = await planChain(
-        session,
-        steps,
-        executionIds,
-        (model) => preflightModel(model, ctx.modelRegistry, session.modelResolutionCache, session.allowUnresolvedModels),
+      const chainPlan = await planChain(session, steps, executionIds, (model) =>
+        preflightModel(model, ctx.modelRegistry, session.modelResolutionCache, session.allowUnresolvedModels),
       );
       if (chainPlan.doomed) {
-        const message = `chain refused at step ${chainPlan.doomed.step}: ${chainPlan.doomed.reason} No step ran, and nobody was ` +
+        const message =
+          `chain refused at step ${chainPlan.doomed.step}: ${chainPlan.doomed.reason} No step ran, and nobody was ` +
           `asked to approve anything — a step that cannot run must not bank authority for a spawn that will never happen.`;
         await recordChainRefusal({
-          session, plan: chainPlan.doomed.plan, stepIndex: chainPlan.doomed.step - 1,
-          executionId: executionIds[chainPlan.doomed.step - 1], parentExecutionId,
-          agent: chainPlan.doomed.agent, reason: message, refusal: chainPlan.doomed.refusal,
+          session,
+          plan: chainPlan.doomed.plan,
+          stepIndex: chainPlan.doomed.step - 1,
+          executionId: executionIds[chainPlan.doomed.step - 1],
+          parentExecutionId,
+          agent: chainPlan.doomed.agent,
+          reason: message,
+          refusal: chainPlan.doomed.refusal,
         });
         if (chainPlan.doomed.refusal) throw new GovernanceRefusal({ ...chainPlan.doomed.refusal, message });
         throw new Error(message);
@@ -141,11 +157,20 @@ export function registerChainTool(pi: ExtensionAPI, session: GrantsSession): voi
       const preApproved: InheritableApproval[] = [];
       const approvalAudit = newChainApprovalAudit();
       const approvalStep = new Map<string, number>();
-      const approvedDecisions: Array<{ request: GateRequest; outcome: Awaited<ReturnType<typeof obtainApprovals>> }> = [];
+      const approvedDecisions: Array<{ request: GateRequest; outcome: Awaited<ReturnType<typeof obtainApprovals>> }> =
+        [];
       let declined: { request: GateRequest; outcome: Awaited<ReturnType<typeof obtainApprovals>> } | undefined;
 
       for (const request of chainPlan.requests) {
-        const outcome = await obtainApprovals(session, [request.capability], request.subject, request.path, ctx, request.task, signal);
+        const outcome = await obtainApprovals(
+          session,
+          [request.capability],
+          request.subject,
+          request.path,
+          ctx,
+          request.task,
+          signal,
+        );
         if (!outcome.approved.includes(request.capability)) {
           // **Stop asking.** The chain's outcome is already fixed, and every further dialog banks authority — a
           // `session` yes into `sessionApprovals` and an `always` yes onto disk for 30 days — for a chain that will
@@ -168,10 +193,14 @@ export function registerChainTool(pi: ExtensionAPI, session: GrantsSession): voi
 
       if (declined) {
         const { request, outcome } = declined;
-        const message = `chain refused: ${request.capability} was not approved for ${request.subject}, so no step ran. A chain ` +
+        const message =
+          `chain refused: ${request.capability} was not approved for ${request.subject}, so no step ran. A chain ` +
           `is gated as a unit — running only its approved steps would return a partial result that reads like a complete one.`;
         const structured = outcome.refusalCode ? refusal(outcome.refusalCode, message) : undefined;
-        const decisions = new Map<number, { request: GateRequest; outcomes: ApprovalOutcome[]; refusal?: typeof structured }>();
+        const decisions = new Map<
+          number,
+          { request: GateRequest; outcomes: ApprovalOutcome[]; refusal?: typeof structured }
+        >();
         for (const approved of approvedDecisions) {
           const decision = decisions.get(approved.request.stepIndex) ?? {
             request: approved.request,
@@ -188,9 +217,14 @@ export function registerChainTool(pi: ExtensionAPI, session: GrantsSession): voi
 
         for (const [stepIndex, decision] of [...decisions].sort(([left], [right]) => left - right)) {
           await recordChainRefusal({
-            session, plan: decision.request.plan, stepIndex,
-            executionId: executionIds[stepIndex], parentExecutionId,
-            agent: steps[stepIndex]?.agent, reason: message, refusal: decision.refusal,
+            session,
+            plan: decision.request.plan,
+            stepIndex,
+            executionId: executionIds[stepIndex],
+            parentExecutionId,
+            agent: steps[stepIndex]?.agent,
+            reason: message,
+            refusal: decision.refusal,
             approval: mergeGateOutcomes(decision.outcomes),
           });
         }
@@ -215,7 +249,12 @@ export function registerChainTool(pi: ExtensionAPI, session: GrantsSession): voi
       }, PAINT_INTERVAL_MS);
 
       const outcomes: Array<{
-        ok: boolean; text: string; reason?: string; refusal?: StructuredRefusal; step: number; agent?: string;
+        ok: boolean;
+        text: string;
+        reason?: string;
+        refusal?: StructuredRefusal;
+        step: number;
+        agent?: string;
       }> = [];
       let previous: string | undefined;
       let aborted = false;
@@ -237,8 +276,7 @@ export function registerChainTool(pi: ExtensionAPI, session: GrantsSession): voi
         const childId = childSpawnId(session.ownSpawnId, index);
         const availableForStep = available.filter((approval) => {
           const key = `${approval.capability}@${approval.subject}`;
-          return chainPlan.uses.get(index)?.has(key) &&
-            (approval.scope !== "once" || approvalStep.get(key) === index);
+          return chainPlan.uses.get(index)?.has(key) && (approval.scope !== "once" || approvalStep.get(key) === index);
         });
         const outcome = await runOneDelegation(
           session,
@@ -277,14 +315,19 @@ export function registerChainTool(pi: ExtensionAPI, session: GrantsSession): voi
         children[index].state = outcome.ok ? "completed" : "failed";
         children[index].settledAt = Date.now();
         outcomes.push({
-          ok: outcome.ok, text: outcome.text, reason: outcome.reason, refusal: outcome.refusal,
-          step: index + 1, agent: step.agent,
+          ok: outcome.ok,
+          text: outcome.text,
+          reason: outcome.reason,
+          refusal: outcome.refusal,
+          step: index + 1,
+          agent: step.agent,
         });
         if (isCriticalAssuranceBlock(outcome)) throw new Error(outcome.text);
 
         // Spend any `once` this step was handed, before the next step sees the list.
-        available = available.filter((approval) =>
-          approval.scope !== "once" || approvalStep.get(`${approval.capability}@${approval.subject}`) !== index,
+        available = available.filter(
+          (approval) =>
+            approval.scope !== "once" || approvalStep.get(`${approval.capability}@${approval.subject}`) !== index,
         );
 
         if (!outcome.ok) {
@@ -301,7 +344,9 @@ export function registerChainTool(pi: ExtensionAPI, session: GrantsSession): voi
       const report = outcomes
         .map((o) => {
           const label = `### step ${o.step}${o.agent ? ` (${o.agent})` : ""}`;
-          return o.ok ? `${label} — completed\n\n${o.text || "(no output)"}` : `${label} — FAILED: ${o.reason}${o.text ? `\n\n${o.text}` : ""}`;
+          return o.ok
+            ? `${label} — completed\n\n${o.text || "(no output)"}`
+            : `${label} — FAILED: ${o.reason}${o.text ? `\n\n${o.text}` : ""}`;
         })
         .join("\n\n---\n\n");
 
@@ -322,8 +367,11 @@ export function registerChainTool(pi: ExtensionAPI, session: GrantsSession): voi
       return {
         content: [{ type: "text", text: `${report}${tail}` }],
         details: {
-          steps: steps.length, completed: outcomes.filter((o) => o.ok).length, aborted,
-          budgetPerStep: split.perChild, refusals: outcomes.map((outcome) => outcome.refusal ?? null),
+          steps: steps.length,
+          completed: outcomes.filter((o) => o.ok).length,
+          aborted,
+          budgetPerStep: split.perChild,
+          refusals: outcomes.map((outcome) => outcome.refusal ?? null),
         },
       };
     },

package/extensions/delegation-authority.ts

@@ -1,12 +1,16 @@
-import { GovernanceRefusal, refusal } from "../src/refusals.ts";
+import { GovernanceRefusal, refusal } from "../src/kernel/refusals.ts";
 import type { GrantsSession } from "./session.ts";
 
 /** Tool definitions may be inspected directly; execution still requires an owner-bound delegation grant. */
 export function assertDelegationAuthority(session: GrantsSession): void {
   if (!session.ownerBound) {
-    throw new GovernanceRefusal(refusal("CAPABILITY_ESCALATION", "delegation refused: session ownership is not bound yet"));
+    throw new GovernanceRefusal(
+      refusal("CAPABILITY_ESCALATION", "delegation refused: session ownership is not bound yet"),
+    );
   }
   if (!session.mayDelegate) {
-    throw new GovernanceRefusal(refusal("CAPABILITY_ESCALATION", "delegation refused: this session does not hold tool:delegate"));
+    throw new GovernanceRefusal(
+      refusal("CAPABILITY_ESCALATION", "delegation refused: this session does not hold tool:delegate"),
+    );
   }
 }

package/extensions/delegation-ledger.ts

@@ -1,5 +1,5 @@
-import type { Delegation } from "../src/delegate.ts";
-import { appendRecord, buildRecord } from "../src/ledger.ts";
+import type { Delegation } from "../src/kernel/delegate.ts";
+import { appendRecord, buildRecord } from "../src/governance/ledger.ts";
 import type { ApprovalOutcome } from "./approvals.ts";
 import type { ExecutionOccurrenceIds } from "./execution-occurrence.ts";
 import type { GrantsSession } from "./session.ts";

package/extensions/delegation-native.ts

@@ -1,12 +1,29 @@
-import { allocateNativeSessionTarget } from "../src/native-session-target.ts";
+import { allocateNativeSessionTarget } from "../src/executors/native-session-target.ts";
 import type { GrantsSession } from "./session.ts";
 import type { ExecutionOccurrenceIds } from "./execution-occurrence.ts";
 /** Shared delegate/all/chain host setup, before planning/audit; no tool-schema destination parameter. */
-export async function nativeDelegationContext(session:GrantsSession,ids:ExecutionOccurrenceIds,budget:number|undefined,refused:boolean){
-  let sessionFile:string|undefined,refusal:string|undefined;
-  if(!refused&&session.nativeSessionRoot!==undefined){
-    try{sessionFile=await allocateNativeSessionTarget(session.nativeSessionRoot,ids.executionId);}
-    catch(error){refusal=`native retention target refused (${String(error)})`;}
+export async function nativeDelegationContext(
+  session: GrantsSession,
+  ids: ExecutionOccurrenceIds,
+  budget: number | undefined,
+  refused: boolean,
+) {
+  let sessionFile: string | undefined, refusal: string | undefined;
+  if (!refused && session.nativeSessionRoot !== undefined) {
+    try {
+      sessionFile = await allocateNativeSessionTarget(session.nativeSessionRoot, ids.executionId);
+    } catch (error) {
+      refusal = `native retention target refused (${String(error)})`;
+    }
   }
-  return {extra:{fanoutBudget:budget,spawnId:ids.parentId,childSpawnId:ids.childId,childExecutionId:ids.executionId,sessionFile},refusal};
+  return {
+    extra: {
+      fanoutBudget: budget,
+      spawnId: ids.parentId,
+      childSpawnId: ids.childId,
+      childExecutionId: ids.executionId,
+      sessionFile,
+    },
+    refusal,
+  };
 }

package/extensions/delegation.ts

@@ -11,13 +11,19 @@
 
 import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
 import { Type } from "typebox";
-import { maySpawnDefinition } from "../src/delegate.ts";
-import { MAX_CHILDREN_PER_CALL, splitBudget } from "../src/fanout.ts";
+import { maySpawnDefinition } from "../src/kernel/delegate.ts";
+import { MAX_CHILDREN_PER_CALL, splitBudget } from "../src/kernel/fanout.ts";
 import {
-  PAINT_INTERVAL_MS, appendTail, emptyTail, renderProgress, replaceTail, throttle, type ChildProgress,
-} from "../src/progress.ts";
+  PAINT_INTERVAL_MS,
+  appendTail,
+  emptyTail,
+  renderProgress,
+  replaceTail,
+  throttle,
+  type ChildProgress,
+} from "../src/kernel/progress.ts";
 import { registerChainTool } from "./delegate-chain.ts";
-import { GovernanceRefusal, refusal } from "../src/refusals.ts";
+import { GovernanceRefusal, refusal } from "../src/kernel/refusals.ts";
 import { runOneDelegation } from "./run-delegation.ts";
 import {
   buildFanoutReport,
@@ -29,7 +35,6 @@ import { isCriticalAssuranceBlock, type DelegationOutcome } from "./execute-chil
 import { type GrantsSession } from "./session.ts";
 import { newDelegationOccurrence } from "./execution-occurrence.ts";
 import { correlationShape as buildCorrelationShape } from "./correlation-shape.ts";
-import { completePrimary } from "./primary-shadow.ts";
 import { assertDelegationAuthority } from "./delegation-authority.ts";
 
 /**
@@ -71,30 +76,32 @@ function progressReporter(
 
   return {
     /** One sink per child index, shaped for `runOneDelegation`'s `onProgress`. */
-    sink: (index: number) => (update: {
-      chunk?: string;
-      snapshot?: string[];
-      paneId?: string;
-      agentName?: string;
-      state?: ChildProgress["state"];
-    }) => {
-      const child = children[index];
-      if (!child) return;
-      if (update.paneId) child.paneId = update.paneId;
-      // **Reported, not derived.** It used to be rebuilt here from the label and the child id, which was true
-      // until `runHerdrPane` began uniquifying the name to stop herdr's `agent_name_taken` — after which the
-      // block named an agent that did not exist, and an operator following it would find nothing. The name is
-      // known only where it is minted, so it travels from there.
-      if (update.agentName) child.agentName = update.agentName;
-      // Two shapes, deliberately distinct, because the two executors are: a subprocess APPENDS bytes, a pane
-      // reports a SNAPSHOT that replaces. Collapsing them into one "output" field is what caused the herdr
-      // path's amplification, so the difference is spelled out in the type rather than remembered.
-      if (update.chunk) child.tail = appendTail(child.tail, update.chunk);
-      if (update.snapshot) child.tail = replaceTail(update.snapshot);
-      if (update.state) child.state = update.state;
-      else if (child.state === "starting") child.state = "running";
-      paint.call();
-    },
+    sink:
+      (index: number) =>
+      (update: {
+        chunk?: string;
+        snapshot?: string[];
+        paneId?: string;
+        agentName?: string;
+        state?: ChildProgress["state"];
+      }) => {
+        const child = children[index];
+        if (!child) return;
+        if (update.paneId) child.paneId = update.paneId;
+        // **Reported, not derived.** It used to be rebuilt here from the label and the child id, which was true
+        // until `runHerdrPane` began uniquifying the name to stop herdr's `agent_name_taken` — after which the
+        // block named an agent that did not exist, and an operator following it would find nothing. The name is
+        // known only where it is minted, so it travels from there.
+        if (update.agentName) child.agentName = update.agentName;
+        // Two shapes, deliberately distinct, because the two executors are: a subprocess APPENDS bytes, a pane
+        // reports a SNAPSHOT that replaces. Collapsing them into one "output" field is what caused the herdr
+        // path's amplification, so the difference is spelled out in the type rather than remembered.
+        if (update.chunk) child.tail = appendTail(child.tail, update.chunk);
+        if (update.snapshot) child.tail = replaceTail(update.snapshot);
+        if (update.state) child.state = update.state;
+        else if (child.state === "starting") child.state = "running";
+        paint.call();
+      },
     /** Record how each child ended and leave the final frame on screen. */
     settle: (outcomes: Array<{ ok: boolean }>) => {
       const at = Date.now();
@@ -120,7 +127,6 @@ export interface DelegationRegistration {
   refreshSpawnable: () => void;
 }
 
-
 /**
  * Register delegation definitions at owner-bound session_start.
  *
@@ -171,10 +177,12 @@ export function registerDelegationTools(pi: ExtensionAPI, session: GrantsSession
     access: Type.Union([Type.Literal("read"), Type.Literal("write")]),
   });
 
-  const thinkingShape = Type.Optional(Type.Union(
-    ["off", "minimal", "low", "medium", "high", "xhigh", "max"].map(level => Type.Literal(level)),
-    { description: "Requested Pi thinking level; unsupported model/level combinations fail in the child." },
-  ));
+  const thinkingShape = Type.Optional(
+    Type.Union(
+      ["off", "minimal", "low", "medium", "high", "xhigh", "max"].map((level) => Type.Literal(level)),
+      { description: "Requested Pi thinking level; unsupported model/level combinations fail in the child." },
+    ),
+  );
   const childShape = Type.Object({
     task: Type.String({ description: "The task for this sub-agent. It receives only this." }),
     agent: Type.Optional(Type.String({ description: describeAgent(spawnable()) })),
@@ -191,32 +199,30 @@ export function registerDelegationTools(pi: ExtensionAPI, session: GrantsSession
       maxItems: MAX_CHILDREN_PER_CALL,
       description: "The sub-agents to run concurrently. Each is independent and unaware of the others.",
     }),
-    completion: Type.Optional(Type.Literal("primary", {description:"Return when the selected primary settles; shadows continue under the original owner."})),
-    primary: Type.Optional(Type.Integer({minimum:1,maximum:MAX_CHILDREN_PER_CALL,description:"1-based primary child; required with completion=primary."})),
   });
 
   const delegateParams = Type.Object({
-      task: Type.String({ description: "The task for the sub-agent. It receives only this." }),
-      agent: Type.Optional(Type.String({ description: describeAgent(spawnable()) })),
-      tools: Type.Optional(
-        Type.Array(Type.String(), {
-          description:
-            "Capabilities to grant when no 'agent' is named, e.g. [\"read\",\"grep\"] or " +
-            "[\"tool:read\",\"ext:pkg/tool\"]. Empty means no tools. Ignored when 'agent' is given.",
-        }),
-      ),
-      model: Type.Optional(
-        Type.String({
-          // A bare id resolves across all known providers and can land on one there is no key for, so the
-          // form is named rather than implied — see the "Verified live" defect in the README.
-          description:
-            "Model for the sub-agent as provider/id, e.g. \"openai-codex/gpt-5.6-sol\". " +
-            "Defaults to this session's model, already provider-qualified.",
-        }),
-      ),
-      thinking: thinkingShape,
-      correlation: Type.Optional(correlationShape),
-      workspace: Type.Optional(workspaceShape),
+    task: Type.String({ description: "The task for the sub-agent. It receives only this." }),
+    agent: Type.Optional(Type.String({ description: describeAgent(spawnable()) })),
+    tools: Type.Optional(
+      Type.Array(Type.String(), {
+        description:
+          'Capabilities to grant when no \'agent\' is named, e.g. ["read","grep"] or ' +
+          '["tool:read","ext:pkg/tool"]. Empty means no tools. Ignored when \'agent\' is given.',
+      }),
+    ),
+    model: Type.Optional(
+      Type.String({
+        // A bare id resolves across all known providers and can land on one there is no key for, so the
+        // form is named rather than implied — see the "Verified live" defect in the README.
+        description:
+          'Model for the sub-agent as provider/id, e.g. "openai-codex/gpt-5.6-sol". ' +
+          "Defaults to this session's model, already provider-qualified.",
+      }),
+    ),
+    thinking: thinkingShape,
+    correlation: Type.Optional(correlationShape),
+    workspace: Type.Optional(workspaceShape),
   });
 
   pi.registerTool({
@@ -231,7 +237,7 @@ export function registerDelegationTools(pi: ExtensionAPI, session: GrantsSession
     async execute(_toolCallId, params, signal, onUpdate, ctx) {
       assertDelegationAuthority(session);
       // ADR-0032: one child, same block. `_onUpdate` was discarded here, so a delegation showed the bare word
-      // `delegate` for up to DEFAULT_TIMEOUT_MS — twenty minutes by default.
+      // `delegate` for up to DEFAULT_TIMEOUT_MS — sixty minutes by default.
       const progress = progressReporter(session, [params.agent ?? "delegate"], onUpdate as never);
       const outcome = await runOneDelegation(
         session,
@@ -269,7 +275,12 @@ export function registerDelegationTools(pi: ExtensionAPI, session: GrantsSession
 
       return {
         content: [{ type: "text", text: outcome.text || "(no output)" }],
-        details: { granted: outcome.granted, depth: outcome.depth, exitCode: outcome.exitCode, retention: outcome.retention },
+        details: {
+          granted: outcome.granted,
+          depth: outcome.depth,
+          exitCode: outcome.exitCode,
+          retention: outcome.retention,
+        },
       };
     },
   });
@@ -298,14 +309,11 @@ export function registerDelegationTools(pi: ExtensionAPI, session: GrantsSession
       `At most ${MAX_CHILDREN_PER_CALL} children per call, and a session-wide budget bounds the total ` +
       "across the whole delegation subtree. Children cannot see each other or share context. Use this " +
       "when independent tasks can proceed in parallel — several reviewers over one diff, say — and read " +
-      "every child's outcome, because one can be refused while the others succeed. For independent variants, " +
-      "completion=primary with a 1-based primary returns that result while shadows remain owned/accounted.",
+      "every child's outcome, because one can be refused while the others succeed.",
     parameters: delegateAllParams,
     async execute(_toolCallId, params, signal, onUpdate, ctx) {
       assertDelegationAuthority(session);
-      const children = params.children ?? [],primaryMode=params.completion==="primary";
-      if(primaryMode!==Number.isInteger(params.primary)||primaryMode&&(params.primary!<1||params.primary!>children.length))throw new GovernanceRefusal(refusal("FANOUT_EXCEEDED","primary fan-out requires one in-range 1-based primary"));
-      if(primaryMode&&session.variantRuns.size>=128)throw new GovernanceRefusal(refusal("FANOUT_EXCEEDED","primary/shadow accounting capacity exhausted"));
+      const children = params.children ?? [];
       const split = splitBudget(session.fanoutBudget, children.length);
       if (!split.ok) {
         // Thrown, not returned: a returned `isError` is discarded by pi, so a refusal that came back as a
@@ -315,7 +323,11 @@ export function registerDelegationTools(pi: ExtensionAPI, session: GrantsSession
 
       // ADR-0032: ONE status block covering every child. `onUpdate` replaces the tool's rendered result, so a
       // painter per child would have each overwriting the others.
-      const progress = progressReporter(session, children.map((c) => c.agent ?? "delegate"), onUpdate as never);
+      const progress = progressReporter(
+        session,
+        children.map((c) => c.agent ?? "delegate"),
+        onUpdate as never,
+      );
 
       // Concurrent by construction. Each child gets its own budget share and its own ledger id, so the
       // records form a tree and two siblings can never be confused for one another.
@@ -324,21 +336,20 @@ export function registerDelegationTools(pi: ExtensionAPI, session: GrantsSession
       // live and its writer lease is deliberately retained" — a resource-retention notice, not a per-child
       // failure. Losing it meant nobody was told a lease is held with no owner until the process exits
       // (R-116).
-      const infrastructureErrors: unknown[] = [],occurrences=children.map((_,index)=>newDelegationOccurrence(session,index));
+      const infrastructureErrors: unknown[] = [],
+        occurrences = children.map((_, index) => newDelegationOccurrence(session, index));
       const pending = children.map(async (child, index): Promise<DelegationOutcome> => {
-          try {
-            return await runOneDelegation(
-              session, child,
-              occurrences[index],
-              split.perChild, ctx, signal, { onProgress: progress.sink(index), toolCallId: _toolCallId },
-            );
-          } catch (error) {
-            infrastructureErrors.push(error);
-            return childFailureOutcome(error, session.depth + 1);
-          }
-        });
-      if(primaryMode){const completed=await completePrimary({session,primaryIndex:params.primary!-1,occurrences,pending,settle:progress.settle}),primary=completed.primary;if(!primary.ok){if(isCriticalAssuranceBlock(primary))throw new Error(primary.text);throw totalFanoutFailure([primary],`primary child failed: ${primary.reason}`);}return {content:[{type:"text",text:primary.text||"(no output)"}],details:{primary:params.primary,shadows:children.length-1,primaryExecutionId:completed.runId,shadowSettlement:"retained-by-original-owner",granted:primary.granted,retention:primary.retention}};}
-      const outcomes=await Promise.all(pending);
+        try {
+          return await runOneDelegation(session, child, occurrences[index], split.perChild, ctx, signal, {
+            onProgress: progress.sink(index),
+            toolCallId: _toolCallId,
+          });
+        } catch (error) {
+          infrastructureErrors.push(error);
+          return childFailureOutcome(error, session.depth + 1);
+        }
+      });
+      const outcomes = await Promise.all(pending);
       progress.settle(outcomes);
       // The upstream controller's verdict outranks our own infrastructure noise — it is the answer the
       // caller is waiting for, and ADR-0034 requires it to pass through unchanged. But an infrastructure