pi-daddy 0.22.0 → 0.24.0

package/extensions/delegation.ts

@@ -29,6 +29,7 @@ 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";
 
 /**
  * Wire a set of children to pi's partial-result channel — ADR-0032.
@@ -171,11 +172,16 @@ 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 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()) })),
     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: thinkingShape,
     correlation: Type.Optional(correlationShape),
     workspace: Type.Optional(workspaceShape),
   });
@@ -186,6 +192,8 @@ 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({
@@ -207,6 +215,7 @@ export function registerDelegationTools(pi: ExtensionAPI, session: GrantsSession
             "Defaults to this session's model, already provider-qualified.",
         }),
       ),
+      thinking: thinkingShape,
       correlation: Type.Optional(correlationShape),
       workspace: Type.Optional(workspaceShape),
   });
@@ -231,6 +240,7 @@ export function registerDelegationTools(pi: ExtensionAPI, session: GrantsSession
           agent: params.agent,
           tools: params.tools,
           model: params.model,
+          thinking: params.thinking,
           correlation: params.correlation,
           workspace: params.workspace,
         },
@@ -241,7 +251,7 @@ export function registerDelegationTools(pi: ExtensionAPI, session: GrantsSession
         session.fanoutBudget,
         ctx,
         signal,
-        { onProgress: progress.sink(0) },
+        { onProgress: progress.sink(0), toolCallId: _toolCallId },
       );
       progress.settle([outcome]);
 
@@ -259,7 +269,7 @@ 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 },
+        details: { granted: outcome.granted, depth: outcome.depth, exitCode: outcome.exitCode, retention: outcome.retention },
       };
     },
   });
@@ -288,10 +298,13 @@ 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.",
+      "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.",
     parameters: delegateAllParams,
     async execute(_toolCallId, params, signal, onUpdate, ctx) {
-      const children = params.children ?? [];
+      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 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
@@ -310,21 +323,21 @@ 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[] = [];
-      const outcomes = await Promise.all(
-        children.map(async (child, index): Promise<DelegationOutcome> => {
+      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,
-              newDelegationOccurrence(session, index),
-              split.perChild, ctx, signal, { onProgress: progress.sink(index) },
+              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);
       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
@@ -353,6 +366,7 @@ export function registerDelegationTools(pi: ExtensionAPI, session: GrantsSession
           budgetPerChild: split.perChild,
           granted: outcomes.map((o) => o.granted),
           refusals: outcomes.map((o) => o.refusal ?? null),
+          retention: outcomes.map((o) => o.retention ?? null),
         },
       };
     },

package/extensions/execute-child.ts

@@ -1,4 +1,6 @@
+import { withOrdinaryChild } from "./ordinary-runtime.ts";
 import type { Delegation } from "../src/delegate.ts";
+import { beginExecutionRetention, retentionConfigurationDigest, type RetentionStatus } from "../src/execution-retention.ts";
 import { appendLedgerEvent, buildChildLifecycleEvent } from "../src/ledger.ts";
 import { hasFinalizerError } from "../src/finalization.ts";
 import { mergeChildEnv } from "../src/propagation.ts";
@@ -9,6 +11,7 @@ import { HerdrWriterCloseError, runHerdrPane } from "../src/run-herdr.ts";
 import { GovernanceRefusal, refusal, type StructuredRefusal } from "../src/refusals.ts";
 import { ENV_HERDR_KEEP_PANE, type GrantsSession } from "./session.ts";
 import { releaseDelegationWorkspace, type PreparedWorkspace } from "./workspace-runtime.ts";
+import { beginDeclaredWorkAttempt } from "./work-runtime.ts";
 
 export interface DelegationOutcome {
   ok: boolean;
@@ -23,6 +26,9 @@ export interface DelegationOutcome {
   aborted?: boolean;
   truncated?: boolean;
   spawnFailed?: boolean;
+  retention?: RetentionStatus;
+  /** A loud best-effort post-execution observation failure; execution ownership is still settled. */
+  control?: "failed";
 }
 
 /**
@@ -78,13 +84,17 @@ export interface ChildProgressUpdate {
  * has already run, so failing closed there prevents nothing and used to discard completed work while
  * blaming "ledger" (R-99). The failure is reported alongside the outcome instead of replacing it.
  */
-export async function executePlannedChild(input: {
+export function executePlannedChild(input: Parameters<typeof executeChildBody>[0]): Promise<DelegationOutcome> {
+  return withOrdinaryChild(input, signal => executeChildBody({ ...input, signal }));
+}
+async function executeChildBody(input: {
   session: GrantsSession;
   plan: Delegation;
   agent?: string;
   childId: string;
   executionId: string;
   parentExecutionId: string | null;
+  toolCallId?: string;
   cwd: string;
   preparedWorkspace?: PreparedWorkspace;
   signal?: AbortSignal;
@@ -117,6 +127,10 @@ export async function executePlannedChild(input: {
       throw error;
     }
   }
+  const workAttempt = await beginDeclaredWorkAttempt({
+    session, plan, childId, executionId, parentExecutionId, toolCallId: input.toolCallId,
+    preparedWorkspace, configuredTimeoutMs, startedAt,
+  });
 
   // The recorded deadline and executor timer are one fact. Waiting for the strict starting append consumes
   // the budget; handing the child a fresh full timeout would leave it live after the dashboard truthfully
@@ -134,9 +148,16 @@ export async function executePlannedChild(input: {
   const executionSignal = signal
     ? AbortSignal.any([signal, leaseAbort.signal])
     : writerLease ? leaseAbort.signal : undefined;
+  const retention = beginExecutionRetention({ executionId, parentExecutionId, childId,
+    toolCallId: input.toolCallId ?? null, executor: session.executor.kind, taskDigest: plan.taskDigest,
+    definitionDigest: plan.definitionDigest?.sha256 ?? null,
+    configurationDigest: retentionConfigurationDigest({ args: plan.args, effective: plan.effective, timeoutMs: configuredTimeoutMs }),
+    workspaceId: preparedWorkspace?.workspace.workspaceId ?? null });
+  const sessionFlag = plan.args.indexOf("--session");
+  if (sessionFlag >= 0) retention.observeSession({ source: "pi-session-file", value: plan.args[sessionFlag + 1] });
   let releaseReason = "failed";
   let retainWriterLease = false;
-  let terminalAttempted = false;
+  let terminalAttempted = false, workTerminalAttempted = false;
   const teardownFailures: string[] = [];
   let runtimeRecord: Promise<void> | undefined;
   const recordRunning = (executor: "process" | "herdr", pane?: { id: string; agentName: string }): void => {
@@ -171,7 +192,12 @@ export async function executePlannedChild(input: {
           timeoutMs: remainingTimeoutMs,
           keepPane: writerLease ? false : process.env[ENV_HERDR_KEEP_PANE] === "1",
           closeOnSettle: Boolean(writerLease),
-          onPane: (paneId, agentName) => onProgress?.({ paneId, agentName, state: "starting" }),
+          onPane: (paneId, agentName) => {
+            retention.native({ paneId, agentName });
+            onProgress?.({ paneId, agentName, state: "starting" });
+          },
+          onObservation: (bytes) => retention.capture("paneSnapshot", bytes, true),
+          onSessionReference: (reference) => retention.observeSession(reference),
           onRunning: (paneId, agentName) => {
             // Record first: runHerdrPane isolates this display callback, so a renderer exception after the
             // observation cannot suppress the authoritative running event.
@@ -179,6 +205,7 @@ export async function executePlannedChild(input: {
             onProgress?.({ paneId, agentName, state: "running" });
           },
           onTab: preparedWorkspace ? (tabId) => preparedWorkspace.lease.attachHerdrTab(tabId) : undefined,
+          onNativeTab: (tabId) => retention.native({ tabId }),
           onSnapshot: onProgress ? (snapshot) => onProgress({ snapshot }) : undefined,
         })
       : await runChild({
@@ -192,18 +219,26 @@ export async function executePlannedChild(input: {
           timeoutMs: Math.max(1, remainingTimeoutMs - terminationGraceMs),
           hardDeadlineAt: Date.parse(deadlineAt),
           onOutput: onProgress ? (chunk) => onProgress({ chunk }) : undefined,
+          onObservation: (stream, bytes) => retention.capture(stream, bytes),
           onSpawn: (pid) => {
             // Lease attachment is a security hook and may fail the spawn. The shared reporters isolate
             // display exceptions before they reach this callback; runChild deliberately kills on any error
             // here, so presentation must never be added directly without that reporter boundary.
             preparedWorkspace?.lease.attachProcess(pid);
+            retention.native({ pid });
             recordRunning("process");
             onProgress?.({ state: "running" });
           },
         });
 
+    if (sessionFlag >= 0) retention.observeSession({ source: "pi-session-file", value: plan.args[sessionFlag + 1] });
+    retention.capture("result", Buffer.from(output.text), true);
     const childFailed = Boolean(output.spawnError || output.aborted || output.timedOut || output.code !== 0);
+    retention.finish({ code: output.code, signal: output.signal ?? null, timedOut: output.timedOut,
+      aborted: output.aborted, truncated: output.truncated, failed: childFailed });
     releaseReason = output.timedOut ? "timeout" : output.aborted ? "cancelled" : childFailed ? "failed" : "completed";
+    if (workAttempt) try { workTerminalAttempted = true; await workAttempt.finish(childFailed ? "failed" : "completed"); }
+    catch (error) { teardownFailures.push(`declared work terminal record failed: ${String(error)}`); }
     if (ledgerPath) {
       terminalAttempted = true;
       await appendAfterRuntimeRecord(runtimeRecord, () => appendLedgerEvent(
@@ -286,6 +321,9 @@ export async function executePlannedChild(input: {
     await teardown();
     return withTeardownNotes(succeeded);
   } catch (error) {
+    retention.finish({ code: null, signal: null, timedOut: false, aborted: Boolean(signal?.aborted), truncated: false, failed: true });
+    if (workAttempt && !workTerminalAttempted) try { workTerminalAttempted = true; await workAttempt.finish("failed"); }
+    catch (cause) { teardownFailures.push(`declared work terminal record failed: ${String(cause)}`); }
     retainWriterLease = Boolean(writerLease && isHerdrWriterCloseFailure(error));
     if (ledgerPath && !terminalAttempted) {
       // Best-effort: this records the failure, so it must not REPLACE the failure. A strict append that
@@ -338,8 +376,9 @@ function errorWithTeardownNotes(error: unknown, notes: readonly string[]): unkno
 }
 
   function withTeardownNotes(outcome: DelegationOutcome): DelegationOutcome {
-    if (teardownFailures.length === 0) return outcome;
-    return { ...outcome, reason: [outcome.reason, ...teardownFailures].filter(Boolean).join("; ") };
+    const observed = { ...outcome, retention: retention.status() };
+    if (teardownFailures.length === 0) return observed;
+    return { ...observed, control: "failed", reason: [outcome.reason, ...teardownFailures].filter(Boolean).join("; ") };
   }
 
   async function teardown(): Promise<void> {

package/extensions/executor-session.ts

@@ -0,0 +1,9 @@
+import { chooseExecutor, needsProbe, ENV_HERDR } from "../src/executor.ts";
+import { probeHerdr } from "../src/herdr-cli.ts";
+import type { GrantsSession } from "./session.ts";
+
+/** Settle one executor at session start; a later daemon change never relocates siblings. */
+export async function resolveExecutor(session:GrantsSession):Promise<void>{
+ const raw=process.env[ENV_HERDR];
+ session.executor=chooseExecutor(raw,needsProbe(raw)?await probeHerdr():null);
+}

package/extensions/grants-command.ts

@@ -17,6 +17,8 @@ import type { ExecutorChoice } from "../src/executor.ts";
 import type { Catalog } from "../src/catalog.ts";
 import type { SkillDefinition } from "../src/definitions.ts";
 import type { GatedPlan } from "./run-delegation.ts";
+import type { VariantRunAccounting } from "./session.ts";
+import { handleConnectedCommand } from "./grants-connected-command.ts";
 import { loadApprovals, revokeAll, revokeApproval, type SubjectLookup } from "../src/approval-store.ts";
 import { verifyLedger } from "../src/ledger.ts";
 
@@ -62,6 +64,9 @@ export interface GrantsCommandContext {
   runInit: () => Promise<void>;
   /** Open or reuse the read-only Herdr dashboard; injected so this diagnostic never becomes enforcement. */
   openDashboard: () => Promise<{ kind: "opened" | "reused"; paneId: string; visibleBesideCaller: boolean }>;
+  /** Explicit same-process production host lifecycle; owns no model call and never cancels a child on stop. */
+  runHost: (target: string) => Promise<string>;
+  variantRuns: Map<string, VariantRunAccounting>;
 }
 
 /**
@@ -71,18 +76,18 @@ export interface GrantsCommandContext {
 const PREVIEW_LIMIT = 12;
 
 /** The verbs `/grants` answers to. Anything else is refused rather than silently treated as no verb. */
-const KNOWN_SUBCOMMANDS: readonly string[] = ["init", "dashboard", "ledger", "approvals", "revoke"];
+const KNOWN_SUBCOMMANDS: readonly string[] = ["init", "host", "variants", "dashboard", "ledger", "approvals", "revoke"];
 
 export const grantsCommand = {
   description:
     "Show this session's capability grant, delegation depth, and known agent-type ceilings; " +
-    "/grants dashboard | /grants approvals | /grants ledger | /grants revoke <key>|--all",
+    "/grants host <fresh-id>|stop | /grants variants | /grants dashboard | /grants approvals | /grants ledger | /grants revoke <key>|--all",
 handler: async (args: string, ctx: any) => {
     // Everything this command may see, named in one place. Previously these were whatever happened to be in
     // the enclosing closure — which is how a diagnostic came to disagree with the enforcer (R-28).
     const {
       cwd, governed, ownGrant, executor, observed, depth, maxDepth, ledgerPath,
-      catalog, definitions, sessionApprovals, inheritedApprovals, snapshotOf, previewDelegation,
+      catalog, definitions, sessionApprovals, inheritedApprovals, snapshotOf, previewDelegation, variantRuns,
     } = ctx.grants as GrantsCommandContext;
 
     const [sub, target] = args.trim().split(/\s+/).filter(Boolean);
@@ -92,18 +97,12 @@ handler: async (args: string, ctx: any) => {
       return;
     }
 
-    if (sub === "dashboard") {
-      try {
-        const opened = await ctx.grants.openDashboard();
-        ctx.ui.notify(
-          `grants: dashboard ${opened.kind} in Herdr pane ${opened.paneId} without changing focus` +
-            (opened.visibleBesideCaller ? "." : " (the existing pane is in another tab)."),
-          "info",
-        );
-      } catch (error) {
-        ctx.ui.notify(`grants: dashboard unavailable — ${error instanceof Error ? error.message : String(error)}`, "error");
-      }
-      return;
+    if(await handleConnectedCommand(sub,target,{runHost:ctx.grants.runHost,openDashboard:ctx.grants.openDashboard,ui:ctx.ui}))return;
+
+    if (sub === "variants") {
+      const lines=[`grants: ${variantRuns.size} retained primary/shadow run(s)`];
+      for(const run of variantRuns.values())lines.push(`  ${run.runId} ${run.state} — primary ${run.primaryExecutionId}; ${run.shadowExecutionIds.length} shadow(s)`+(!run.outcomes?"":` — ${run.outcomes.map(x=>`${x.role}:${x.ok?"completed":"failed"}`).join(", ")}`));
+      ctx.ui.notify(lines.join("\n"),"info");return;
     }
 
     if (sub === "ledger") {

package/extensions/grants-connected-command.ts

@@ -0,0 +1,19 @@
+export interface GrantsConnectedCommandContext {
+ runHost:(target:string)=>Promise<string>;
+ openDashboard:()=>Promise<{kind:"opened"|"reused";paneId:string;visibleBesideCaller:boolean}>;
+ ui:{notify(message:string,level:"info"|"error"):void};
+}
+/** Host lifecycle and pane placement live together; neither belongs in the capability-report renderer. */
+export async function handleConnectedCommand(sub:string|undefined,target:string|undefined,ctx:GrantsConnectedCommandContext):Promise<boolean>{
+ if(sub==="host"){
+  try{ctx.ui.notify(`grants: ${await ctx.runHost(target??"")}`,"info");}
+  catch(error){ctx.ui.notify(`grants: host unavailable — ${error instanceof Error?error.message:String(error)}`,"error");}
+  return true;
+ }
+ if(sub==="dashboard"){
+  try{const opened=await ctx.openDashboard();ctx.ui.notify(`grants: dashboard ${opened.kind} in Herdr pane ${opened.paneId} without changing focus`+(opened.visibleBesideCaller?".":" (the existing pane is in another tab)."),"info");}
+  catch(error){ctx.ui.notify(`grants: dashboard unavailable — ${error instanceof Error?error.message:String(error)}`,"error");}
+  return true;
+ }
+ return false;
+}

package/extensions/grants.ts

@@ -37,7 +37,8 @@ import { registerDelegationTools } from "./delegation.ts";
 import { grantsCommand } from "./grants-command.ts";
 import { runInit } from "./init-command.ts";
 import { planWithApprovals } from "./run-delegation.ts";
-import { createGrantsSession, loadProjectDefinitions, resolveExecutor, type GrantsSession } from "./session.ts";
+import { createGrantsSession, loadProjectDefinitions, type GrantsSession } from "./session.ts";
+import { resolveExecutor } from "./executor-session.ts";
 import { reportSessionStart } from "./session-report.ts";
 import { SPAWN_TOOLS, tripwireReason } from "./tripwire.ts";
 import { reportGrantStoreRefusal } from "./grant-store-refusal.ts";
@@ -47,6 +48,10 @@ import {
   openDashboardCommand,
 } from "../src/dashboard-handshake.ts";
 
+import { associateOrdinaryHost, ordinaryChildrenFor } from "../src/ordinary-children.ts";
+import { loadDeclaredWork } from "../src/work-command.ts";
+import { createDailyDashboardSession } from "./daily-dashboard-session.ts";
+import { replacePublishedDailyWork, type PublishedDailyWork } from "./daily-work-session.ts";
 export default function (pi: ExtensionAPI) {
   // The path pi loads as the extension, so a child granted `tool:delegate` can be started with `-e <this>`.
   // Only this file can say so about itself, which is why the session takes it rather than deriving it.
@@ -59,6 +64,8 @@ export default function (pi: ExtensionAPI) {
   })();
 
   const session = createGrantsSession(extensionPath);
+  associateOrdinaryHost(pi,session);
+  const dailyHost=createDailyDashboardSession({ordinary:()=>ordinaryChildrenFor(pi),declared:()=>session.declaredWork,cwd:()=>session.cwd,env:process.env,author:"local-operator"});
   const dashboardPluginRoot = fileURLToPath(new URL("../herdr-plugin/", import.meta.url));
   const dashboardPaths = defaultDashboardPaths(
     process.env.PI_CODING_AGENT_DIR?.trim() || join(homedir(), ".pi", "agent"),
@@ -68,6 +75,7 @@ export default function (pi: ExtensionAPI) {
   // because the hooks below have to be registered before the tools and both need to call it — the tool
   // schemas describe which definitions are spawnable, and nothing knows that until a hook has run (R-39).
   const delegation = { refreshSpawnable: () => {} };
+  const publishedDailyWork: PublishedDailyWork = {};
 
   pi.on("session_start", async (_event, ctx) => {
     session.cwd = ctx.cwd;
@@ -75,6 +83,19 @@ export default function (pi: ExtensionAPI) {
     // execution tree across workspaces. Resolve it once at the root's actual pi cwd; descendants inherit
     // this absolute identity verbatim, and resolve(abs) remains abs at every deeper session start.
     if (session.ledgerPath) session.ledgerPath = resolve(ctx.cwd, session.ledgerPath);
+    try {
+      try {
+        replacePublishedDailyWork(process.env, publishedDailyWork, undefined);
+        session.declaredWork = (await loadDeclaredWork(join(ctx.cwd, ".pi", "work-current.json"))) ?? undefined;
+        replacePublishedDailyWork(process.env, publishedDailyWork, session.declaredWork);
+      } catch (error) {
+        session.declaredWork = undefined;
+        ctx.ui.notify(
+          `grants: declared work is invalid (${error instanceof Error ? error.message : String(error)}); ` +
+            `delegations remain unbound and no previous selection was substituted.`,
+          "error",
+        );
+      }
     // The one case the stored-grant lookup can get wrong (ADR-0030). The factory reads the store keyed by
     // `process.cwd()` because it runs before any hook and therefore before `ctx` exists — and S-5 forces
     // that ordering, since whether `delegate` is registered is decided there. Almost always the two agree.
@@ -93,7 +114,6 @@ export default function (pi: ExtensionAPI) {
         "warning",
       );
     }
-    try {
       try {
         await reportGrantStoreRefusal(session, ctx.ui);
       } catch (error) {
@@ -230,6 +250,8 @@ export default function (pi: ExtensionAPI) {
    * `exit` remains the backstop. SIGKILL still orphans panes, exactly as R-62 records, and no signal handler is
    * installed here for the reason R-62 gives: it would turn pi's "interrupt this turn" into "exit pi".
    */
+  pi.on("session_shutdown", async () => { await dailyHost.close().catch(() => undefined); });
+
   pi.on("agent_settled", async () => {
     try {
       if (session.executor.kind !== "herdr" || openPaneCount() === 0) return undefined;
@@ -348,6 +370,7 @@ export default function (pi: ExtensionAPI) {
           definitions: session.definitions,
           sessionApprovals: session.sessionApprovals,
           inheritedApprovals: session.inheritedApprovals,
+          variantRuns: session.variantRuns,
           snapshotOf: (subject: string) => snapshotOf(session, subject),
           // The REAL delegation path, minus the one thing a diagnostic must never do. `ctx: null` is what
           // says so: stored approvals count exactly as they would for a spawn, and no human is asked
@@ -358,6 +381,7 @@ export default function (pi: ExtensionAPI) {
               await loadProjectDefinitions(session, ctx.cwd);
               delegation.refreshSpawnable();
             }),
+          runHost: (target: string) => dailyHost.run(target),
           openDashboard: () => openDashboardCommand({
             env: process.env,
             pid: process.pid,

package/extensions/ordinary-runtime.ts

@@ -0,0 +1,14 @@
+import { retainSessionChild } from "../src/ordinary-children.ts";
+import { dataDigest } from "../src/debrief-contract.ts";
+import { runWithFinalizers } from "../src/finalization.ts";
+import { releaseDelegationWorkspace,type PreparedWorkspace } from "./workspace-runtime.ts";
+import type { GrantsSession } from "./session.ts";
+import type { DelegationOutcome } from "./execute-child.ts";
+/** One wrapper around the original executor. It neither consumes nor replaces the caller's promise. */
+export async function withOrdinaryChild(input:{session:GrantsSession;executionId:string;parentExecutionId:string|null;childId:string;toolCallId?:string;signal?:AbortSignal;preparedWorkspace?:PreparedWorkspace},operation:(signal?:AbortSignal)=>Promise<DelegationOutcome>){
+ let retained:ReturnType<typeof retainSessionChild>;
+ try{retained=retainSessionChild(input.session,{executionId:input.executionId,parentExecutionId:input.parentExecutionId,toolCallId:input.toolCallId??null},input.signal);}
+ catch(error){return runWithFinalizers(async()=>{throw error;},[{label:"ordinary admission workspace release",run:async()=>{await releaseDelegationWorkspace({prepared:input.preparedWorkspace,childId:input.childId,executionId:input.executionId,parentExecutionId:input.parentExecutionId,ledgerPath:input.session.ledgerPath,reason:"refused"});}}]);}
+ try{const outcome=await operation(retained?.signal??input.signal);retained?.settle({ok:outcome.ok,exitCode:outcome.exitCode,aborted:outcome.aborted??false,outputDigest:dataDigest(outcome.text)},outcome.control??"not-assessed",outcome.control==="failed"?"not-assessed":outcome.control??"not-assessed");return outcome;}
+ catch(error){retained?.settle({failure:"original executor threw; inspect original caller"},"unknown");throw error;}
+}

package/extensions/primary-shadow.ts

@@ -0,0 +1,11 @@
+import type { DelegationOutcome } from "./execute-child.ts";
+import type { ExecutionOccurrenceIds } from "./execution-occurrence.ts";
+import type { GrantsSession, VariantRunAccounting } from "./session.ts";
+
+/** Return one primary while the original session retains and settles every shadow outcome. */
+export async function completePrimary(input:{session:GrantsSession;primaryIndex:number;occurrences:ExecutionOccurrenceIds[];pending:Promise<DelegationOutcome>[];settle:(outcomes:{ok:boolean}[])=>void}){
+ const runId=input.occurrences[input.primaryIndex].executionId,record:VariantRunAccounting={runId,primaryExecutionId:runId,shadowExecutionIds:input.occurrences.filter((_,i)=>i!==input.primaryIndex).map(x=>x.executionId),state:"running",outcomes:null};
+ input.session.variantRuns.set(runId,record);
+ void Promise.all(input.pending).then(outcomes=>{record.outcomes=outcomes.map((outcome,index)=>({executionId:input.occurrences[index].executionId,role:index===input.primaryIndex?"primary":"shadow",ok:outcome.ok,reason:outcome.ok?null:outcome.reason??"failed"}));record.state="settled";input.settle(outcomes);});
+ return {runId,primary:await input.pending[input.primaryIndex]};
+}

package/extensions/run-delegation.ts

@@ -11,6 +11,7 @@
  * tool surface is observed.
  */
 
+import { nativeDelegationContext } from "./delegation-native.ts";
 import { DELEGATE_SUBJECT, shouldSeekApproval } from "../src/approval.ts";
 import { planDelegation } from "../src/delegate.ts";
 import {
@@ -43,6 +44,7 @@ interface ChildSpec {
   agent?: string;
   tools?: string[];
   model?: string;
+  thinking?: string;
   correlation?: CorrelationMetadata;
   workspace?: DelegationWorkspaceSpec;
 }
@@ -201,6 +203,8 @@ export async function runOneDelegation(
    * mistake unspellable.
    */
   options: {
+    /** Actual public execute argument, never read from model-authored correlation or output. */
+    toolCallId?: string;
     /** Progress for the parent's status block (ADR-0032). Display only. */
     onProgress?: (update: {
       /** Appended (process executor: a genuine byte stream). */
@@ -245,6 +249,7 @@ export async function runOneDelegation(
     agent: spec.agent,
     tools: spec.tools,
     model: spec.model ?? defaultModel,
+    thinking: spec.thinking,
     correlation: spec.workspace
       ? { ...(spec.correlation ?? {}), workspace_id: spec.workspace.workspace_id }
       : spec.correlation,
@@ -254,12 +259,6 @@ export async function runOneDelegation(
     boundWorkspaceId: spec.workspace?.workspace_id,
     boundContextId: spec.correlation?.context_id,
   };
-  const extra = {
-    fanoutBudget: budget,
-    spawnId: ids.parentId,
-    childSpawnId: ids.childId,
-    childExecutionId: ids.executionId,
-  };
 
   // ADR-0031: herdr was DEMANDED (`PI_GRANTS_HERDR=1`) and is not answering. Refused rather than relocated —
   // the operator chose that over falling back, so the ledger can never name a child that ran somewhere nobody
@@ -275,13 +274,15 @@ export async function runOneDelegation(
   // `ctx: null` rather than skipping the plan entirely: the ledger still gets a full, honest record of what was
   // requested and refused, and stored approvals still count toward it — nothing is *hidden*, only nobody is
   // *asked*. It is the same argument `/grants` uses for its preview.
-  const executorRefusal = session.executor.refusal;
+  let executorRefusal = session.executor.refusal;
   const modelRefusal = preflightModel(
     request.model,
     ctx.modelRegistry,
     session.modelResolutionCache,
     session.allowUnresolvedModels,
   );
+  const {extra,refusal:nativeRefusal}=await nativeDelegationContext(session,ids,budget,Boolean(executorRefusal||modelRefusal));
+  executorRefusal ||= nativeRefusal;
   let preparedWorkspace: PreparedWorkspace | undefined;
   let approvalOutcome: ApprovalOutcome | undefined;
   let plan: ReturnType<typeof planDelegation>;
@@ -388,6 +389,7 @@ export async function runOneDelegation(
     childId: ids.childId,
     executionId: ids.executionId,
     parentExecutionId: ids.parentExecutionId,
+    toolCallId: options.toolCallId,
     cwd: ctx.cwd,
     preparedWorkspace,
     signal,

package/extensions/session.ts

@@ -21,8 +21,7 @@ import { makeCatalog, skillPathsFromCatalog, type Catalog } from "../src/catalog
 import type { SkillDefinition } from "../src/definitions.ts";
 import { DELEGATE_CAPABILITY, type DelegationContext } from "../src/delegate.ts";
 import { budgetFromEnv } from "../src/fanout.ts";
-import { chooseExecutor, needsProbe, ENV_HERDR, type ExecutorChoice } from "../src/executor.ts";
-import { probeHerdr } from "../src/herdr-cli.ts";
+import { chooseExecutor, ENV_HERDR, type ExecutorChoice } from "../src/executor.ts";
 import { WILDCARD } from "../src/pi-tools.ts";
 import {
   childEnv,
@@ -47,8 +46,9 @@ import { ENV_WORKSPACE_REGISTRY } from "../src/workspace.ts";
 import type { GrantStoreRefusalReason } from "../src/grant-store.ts";
 import { republishable } from "./approvals.ts";
 import { storedGrantSessionState } from "./stored-grant-session.ts";
+import { nativeSessionRootFromEnv, type NativeSessionHost } from "../src/native-session-target.ts";
 import { ENV_ALLOW_UNRESOLVED_MODELS } from "../src/model-preflight.ts";
-
+import type { DeclaredWorkState } from "../src/work-command.ts";
 /**
  * Run governed children in herdr panes instead of captured child processes.
  *
@@ -79,7 +79,8 @@ export { ENV_HERDR_WORKSPACE } from "../src/herdr-cli.ts";
 /** Keep each child's pane after it finishes, for inspection. Off by default: fan-out would flood it. */
 export const ENV_HERDR_KEEP_PANE = "PI_GRANTS_HERDR_KEEP_PANE";
 
-export interface GrantsSession {
+export interface VariantRunAccounting {runId:string;primaryExecutionId:string;shadowExecutionIds:string[];state:"running"|"settled";outcomes:null|{executionId:string;role:"primary"|"shadow";ok:boolean;reason:string|null}[]}
+export interface GrantsSession extends NativeSessionHost {
   /**
    * False when neither `PI_GRANTS_GRANT` nor a stored grant applies: the session holds the wildcard and
    * nothing is governed.
@@ -126,6 +127,9 @@ export interface GrantsSession {
   readonly modelResolutionCache: Map<string, boolean>;
   /** Path to this extension, so a child granted `tool:delegate` can delegate in turn. */
   readonly extensionPath?: string;
+  declaredWork?: DeclaredWorkState; // Explicit operator selection; absence leaves execution visibly unbound.
+  /** Primary-return fan-outs retained by this original session; bounded and human-readable via /grants variants. */
+  readonly variantRuns: Map<string, VariantRunAccounting>;
 
   /** Approval keys approved for this session. In memory only — this dies with the process. */
   readonly sessionApprovals: Set<string>;
@@ -234,22 +238,6 @@ export async function loadProjectDefinitions(session: GrantsSession, cwd: string
   session.catalog = await session.catalogReady;
 }
 
-/**
- * Probe for herdr and settle this session's executor — ADR-0031.
- *
- * **Once, at session start, and never per spawn.** A fan-out whose children ran under two executors would put
- * two different things under one call in the ledger, and the two plans differ (`--print` is withheld on the
- * herdr path). A herdr server that dies mid-session therefore surfaces as a failed `tab create`, reported as
- * the spawn error it is, rather than as a silent relocation of the remaining children.
- *
- * `probeHerdr` never throws, so this cannot either — which matters because it runs *before* the line that
- * discloses what it decided (R-60: a throw here would cancel that line and every control after it).
- */
-export async function resolveExecutor(session: GrantsSession): Promise<void> {
-  const raw = process.env[ENV_HERDR];
-  session.executor = chooseExecutor(raw, needsProbe(raw) ? await probeHerdr() : null);
-}
-
 export function createGrantsSession(extensionPath: string | undefined): GrantsSession {
   // Governance is opt-in: with PI_GRANTS_GRANT unset AND no stored grant for this directory, the session
   // holds the wildcard and nothing is blocked. This extension must never silently tighten a normal
@@ -318,8 +306,10 @@ export function createGrantsSession(extensionPath: string | undefined): GrantsSe
      */
     mayDelegate: !governed || inherited.includes(DELEGATE_CAPABILITY) || inherited.includes(WILDCARD),
     allowUnresolvedModels: process.env[ENV_ALLOW_UNRESOLVED_MODELS] === "1",
+    nativeSessionRoot: nativeSessionRootFromEnv(process.env),
     modelResolutionCache: new Map<string, boolean>(),
     extensionPath,
+    variantRuns: new Map(),
 
     sessionApprovals: new Set<string>(),
     sessionApprovalBindings: new Map<string, ApprovalBinding>(),