pi-daddy 0.26.0 → 0.27.0

package/extensions/daily-dashboard-session.ts

@@ -7,6 +7,8 @@ import { ENV_DASHBOARD_HOST_SOCKET } from "../src/dashboard-host-transport.ts";
 import { startDailyDashboardHost } from "../src/daily-dashboard-host.ts";
 import type { DeclaredWorkState } from "../src/work-command.ts";
 import type { OrdinaryChildren } from "../src/ordinary-children.ts";
+import { learningHarness, loadLearningConnection } from "../src/learning-connection.ts";
+import { readProductJson } from "../src/product-files.ts";
 
 const BRIDGE=Symbol.for("skill-harness.dashboard-host.v1"),idPattern=/^[A-Za-z0-9][A-Za-z0-9._-]{0,63}$/;
 export function dailyDashboardPaths(cwd:string,id:string,home=homedir(),uid=process.getuid?.()??0){const key=createHash("sha256").update(`${cwd}\0${id}`).digest("hex");return {directory:join(home,".local","state","pi-daddy","hosts",key.slice(0,16)),socketDirectory:join("/tmp",`pi-daddy-${uid}`),socketPath:join("/tmp",`pi-daddy-${uid}`,`host-${key.slice(0,20)}.sock`)};}
@@ -18,22 +20,29 @@ export async function preparePrivateHostRoot(root:string):Promise<void>{
 }
 
 export function createDailyDashboardSession(input:{ordinary:()=>OrdinaryChildren;declared:()=>DeclaredWorkState|undefined;rebind:(state:DeclaredWorkState)=>void;cwd:()=>string;env:Record<string,string|undefined>;author:string;home?:string}){
- let current:null|Awaited<ReturnType<typeof startDailyDashboardHost>>=null,publishedSocket:string|undefined,closing:null|{present:true;closing:true;evidenceDigest:string;expiresAt:number}=null;
+ let ended=false,current:null|Awaited<ReturnType<typeof startDailyDashboardHost>>=null,publishedSocket:string|undefined,closing:null|{present:true;closing:true;evidenceDigest:string;expiresAt:number}=null;
  return Object.freeze({
+  get running(){return current!==null;},
+  async frame(){if(!current)throw Error("Start /grants host first");return current.host.frame();},
+  async choose(key:string,binding?:{tip:string;requestDigest:string}){if(!current)throw Error("Start /grants host first");if(binding)return current.host.humanAction(key,binding);const frame=await current.host.frame(),action=frame.actions.find(a=>a.key===key);if(!action)throw Error("Action unavailable at the current boundary");return current.host.humanAction(key,{tip:frame.tip,requestDigest:action.requestDigest});},
   async run(target:string){
+   if(ended)throw Error("Original Pi session has ended; no host replacement or control recovery");
+   if(!target)target=`daily-${randomUUID().slice(0,8)}`;
    if(target==="stop"){
     if(!current)return "daily host is not running";await current.close();current=null;closing=null;if(publishedSocket&&input.env[ENV_DASHBOARD_HOST_SOCKET]===publishedSocket)delete input.env[ENV_DASHBOARD_HOST_SOCKET];publishedSocket=undefined;return "daily host stopped; no child was cancelled";
    }
-   if(target==="closing"){if(!current)throw Error("daily host is not running");const expiresAt=Date.now()+120_000;closing={present:true,closing:true,evidenceDigest:createHash("sha256").update(`${input.cwd()}\0${expiresAt}\0${randomUUID()}`).digest("hex"),expiresAt};return "explicit closing presence recorded for two minutes; pause new dispatch and finish/cancel active attempts, then choose prepare-case-cards in the dashboard. No card is counted as delivered until visibly acknowledged.";}
+   if(target==="closing"){if(!current)throw Error("daily host is not running");const expiresAt=Date.now()+120_000;closing={present:true,closing:true,evidenceDigest:createHash("sha256").update(`${input.cwd()}\0${expiresAt}\0${randomUUID()}`).digest("hex"),expiresAt};return "explicit closing presence recorded for two minutes; pause new dispatch and finish/cancel active attempts, then choose Prepare retained case cards in the dashboard. No card is counted as delivered until visibly acknowledged.";}
    if(!idPattern.test(target))throw Error("usage — /grants host <fresh-id> | closing | stop");if(current)throw Error("daily host already running in this session; use closing or stop");
-   const declared=input.declared();if(!declared)throw Error("declare current work first with pi-daddy work add, then reload");
+   const declared=input.declared();if(!declared)throw Error("declare current work first with /grants work new");
    const home=input.home??homedir(),paths=dailyDashboardPaths(input.cwd(),target,home),root=join(home,".local","state","pi-daddy","hosts");await preparePrivateHostRoot(root);await mkdir(paths.socketDirectory,{recursive:true,mode:0o700});
    try{await lstat(paths.directory);throw Error(`host ID ${target} already has preserved state; choose a fresh host ID (the existing state was not opened, deleted or reused)`);}catch(error){if((error as NodeJS.ErrnoException).code!=="ENOENT")throw error;}
-   const bridge=(globalThis as Record<PropertyKey,unknown>)[BRIDGE];if(!bridge)throw Error("loaded skill-harness extension bridge unavailable; load the candidate skill-harness extension in this Pi session");
-   try{current=await startDailyDashboardHost({id:target,cwd:input.cwd(),directory:paths.directory,socketPath:paths.socketPath,declared,ordinary:input.ordinary(),harness:adoptDashboardHarnessBridge(bridge) as never,author:input.author,presence:()=>closing,onDeclaredWorkChanged:input.rebind});}catch(error){if((error as NodeJS.ErrnoException).code==="EEXIST")throw Error(`host ID ${target} could not start because state already exists; choose a fresh host ID. Existing state was preserved.`);throw error;}
+   const bridge=(globalThis as Record<PropertyKey,unknown>)[BRIDGE];if(!bridge)throw Error("loaded skill-harness extension bridge unavailable; load the skill-harness extension in this Pi session");
+   const harness=adoptDashboardHarnessBridge(bridge),savedLearning=await readProductJson(join(input.cwd(),".pi","learning-workspace.json")),learning=savedLearning?await loadLearningConnection(input.cwd(),declared,learningHarness(harness),input.author):null;
+   try{current=await startDailyDashboardHost({id:target,cwd:input.cwd(),directory:paths.directory,socketPath:paths.socketPath,declared,ordinary:input.ordinary(),harness,author:input.author,...(learning?{learning:learning.connection}:{}),presence:()=>closing,onDeclaredWorkChanged:input.rebind});}catch(error){if((error as NodeJS.ErrnoException).code==="EEXIST")throw Error(`host ID ${target} could not start because state already exists; choose a fresh host ID. Existing state was preserved.`);throw error;}
    publishedSocket=current.socketPath;input.env[ENV_DASHBOARD_HOST_SOCKET]=publishedSocket;
-   return `daily host started at ${publishedSocket}; current declared work/facts were captured. Run /grants dashboard, then use only its listed pause/resume/refresh/cancel/scope/priority/alternative action keys. Runtime remains unaccepted.`;
+   return `daily host started at ${publishedSocket}; current declared work/facts were captured. Run /grants dashboard for numbered actions or /grants work for work setup. Runtime remains unaccepted.`;
   },
-  async close(){if(current)await current.close();if(publishedSocket&&input.env[ENV_DASHBOARD_HOST_SOCKET]===publishedSocket)delete input.env[ENV_DASHBOARD_HOST_SOCKET];current=null;closing=null;publishedSocket=undefined;}
+  /** Called only when the original Pi session ends; no hold release or effect reconciliation. */
+  async close(){ended=true;if(current)await current.endSession();if(publishedSocket&&input.env[ENV_DASHBOARD_HOST_SOCKET]===publishedSocket)delete input.env[ENV_DASHBOARD_HOST_SOCKET];current=null;closing=null;publishedSocket=undefined;}
  });
 }

package/extensions/execute-child.ts

@@ -94,7 +94,7 @@ async function executeChildBody(input: {
   childId: string;
   executionId: string;
   parentExecutionId: string | null;
-  toolCallId?: string;
+  toolCallId?: string; declaredWork?: GrantsSession["declaredWork"];
   cwd: string;
   preparedWorkspace?: PreparedWorkspace;
   signal?: AbortSignal;
@@ -128,7 +128,7 @@ async function executeChildBody(input: {
     }
   }
   const workAttempt = await beginDeclaredWorkAttempt({
-    session, plan, childId, executionId, parentExecutionId, toolCallId: input.toolCallId,
+    session, plan, childId, executionId, parentExecutionId, toolCallId: input.toolCallId, declaredWork: input.declaredWork,
     preparedWorkspace, configuredTimeoutMs, startedAt,
   });
 

package/extensions/grants-command.ts

@@ -76,12 +76,12 @@ 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", "host", "variants", "dashboard", "ledger", "approvals", "revoke"];
+const KNOWN_SUBCOMMANDS: readonly string[] = ["work", "learning", "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 host <fresh-id>|stop | /grants variants | /grants dashboard | /grants approvals | /grants ledger | /grants revoke <key>|--all",
+    "/grants work (setup/run/results) | /grants learning | /grants host [fresh-id]|stop | /grants dashboard | /grants approvals | /grants ledger",
 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).

package/extensions/grants.ts

@@ -48,6 +48,8 @@ import { defaultDashboardPaths, offerDashboardHandshake, openDashboardCommand }
 import { associateOrdinaryHost, ordinaryChildrenFor } from "../src/ordinary-children.ts";
 import { loadDeclaredWork } from "../src/work-command.ts";
 import { createDailyDashboardSession } from "./daily-dashboard-session.ts";
+import { createWorkSession } from "./work-session.ts";
+import { createLearningSession } from "./learning-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>`.
@@ -70,6 +72,8 @@ export default function (pi: ExtensionAPI) {
   // dispatch surface; afterwards this callback refreshes their model-facing spawnable-definition text.
   const delegation = { refreshSpawnable: () => {} };
   const publishedDailyWork: PublishedDailyWork = {};
+  const workSession=createWorkSession(session,dailyHost,()=>replacePublishedDailyWork(process.env,publishedDailyWork,session.declaredWork));
+  const learningSession=createLearningSession(dailyHost);
 
   pi.on("session_start", async (_event, ctx) => {
     // Real SDK contexts always supply SessionManager. The fallback keeps lightweight wiring fixtures
@@ -253,7 +257,7 @@ export default function (pi: ExtensionAPI) {
    * 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);
+    await workSession.close(); await dailyHost.close().catch(() => undefined);
   });
 
   pi.on("agent_settled", async () => {
@@ -349,7 +353,7 @@ export default function (pi: ExtensionAPI) {
     ...grantsCommand,
     // Built per invocation and spelled out field by field, rather than passing the session whole: what a
     // read-only diagnostic may see is a decision, and `GrantsCommandContext` is where it is recorded.
-    handler: (args, ctx) =>
+    handler: (args, ctx) => /^learning(?:\s|$)/.test(args.trim()) ? learningSession.run(args.trim().slice(8).trim(),ctx).catch(error=>{ctx.ui.notify(String(error),"error");}) : /^work(?:\s|$)/.test(args.trim()) ? workSession.run(args.trim().slice(4).trim(),ctx).catch(error=>{ctx.ui.notify(String(error),"error");}) :
       grantsCommand.handler(args, {
         ...ctx,
         grants: {

package/extensions/learning-outcome-session.ts

@@ -0,0 +1,38 @@
+import { join } from "node:path";
+import { randomUUID } from "node:crypto";
+import type { ExtensionCommandContext } from "@earendil-works/pi-coding-agent";
+import { inspectWorkRun, type WorkRunInitial } from "../src/work-run.ts";
+import type { ControlBinding } from "../src/control-journal.ts";
+import { readProductJson } from "../src/product-files.ts";
+import { readDailySnapshot } from "../src/daily-view-input.ts";
+import { experimentHash } from "../src/experiment-contract.ts";
+import type { LearningHarness, LearningWorkspace } from "../src/learning-connection.ts";
+import type { DeclaredWorkState } from "../src/work-command.ts";
+import type { ProductionObservation } from "../src/vendor/adoption.ts";
+
+/** Link actual later-run bytes/pin; only an explicit independent human supplies outcome labels. */
+export async function linkLatestWorkOutcome(ctx: ExtensionCommandContext, state: DeclaredWorkState, workspace: LearningWorkspace, harness: LearningHarness) {
+  const binding = await readProductJson(join(ctx.cwd, ".pi", "work-last-run.json")) as ControlBinding<WorkRunInitial> | null;
+  if (!binding) throw Error("No retained later bounded order is available");
+  const run = await inspectWorkRun(binding), pin = binding.initial.policyPin;
+  if (!pin?.adoptionId) throw Error("This run was not pinned to an adoption. It cannot establish an adopted outcome.");
+  const comparisons = workspace.inspect(Date.now()).comparisons.filter(c => c.state !== "deferred" && workspace.preparedAdoption(c.name)?.id === pin.adoptionId);
+  if(!comparisons.length)throw Error("No ready learning comparison matches this run's actual adoption pin. Reconnect original evidence before linking outcomes.");
+  const labels = comparisons.map((c, i) => `${i + 1}. ${c.title}`), picked = await ctx.ui.select("Observed adoption", labels), comparison = comparisons[labels.indexOf(picked ?? "")]; if (!comparison) return;
+  const rows = run.tasks.filter(t => t.resultPath && t.resultDigest), tasks = rows.map((t, i) => `${i + 1}. ${t.id}: ${t.state}`), selected = await ctx.ui.select("Actual retained output", tasks), row = rows[tasks.indexOf(selected ?? "")]; if (!row) return;
+  if (row.resultPath !== join(binding.directory, `${row.id}.txt`)) throw Error("retained result path changed");
+  const source = await readDailySnapshot(row.resultPath, 1024 * 1024);
+  if (source.status !== "read" || source.sha256 !== row.resultDigest) throw Error("retained output missing or mismatched");
+  await ctx.ui.editor("Complete retained output (controls escaped; editor edits discarded)", new TextDecoder("utf8", { fatal: true }).decode(source.bytes).replace(/[\p{Cc}\p{Cf}]/gu, c => c === "\n" || c === "\t" ? c : `\\u${c.charCodeAt(0).toString(16).padStart(4,"0")}`));
+  const outcomes = ["Unknown / not independently judged", "Independently confirmed success", "Independently confirmed defect"], outcome = await ctx.ui.select("Observed quality — runtime success is not a label", outcomes); if (!outcome) return;
+  const note = await ctx.ui.editor("Independent observation note / evidence (do not infer acceptance)", ""); if (!note?.trim()) return;
+  if (!await ctx.ui.confirm("Retain this scoped observation?", "This records an explicit human observation of these exact later-work bytes. Acceptance remains absent. It does not calibrate a detector, certify held-out improvement or trigger rollback.")) return;
+  const root = workspace.configuration().archiveRoot;
+  const artifact = harness.retainArchiveSource(root, { sourceId: `later-output-${source.sha256.slice(0,24)}`, parser: { id: "producer-work-output", version: "1" }, retention: "exact", bytes: source.bytes }).manifestId;
+  const evidence = harness.retainArchiveSource(root, { sourceId: `later-observation-${randomUUID()}`, parser: { id: "producer-work-observation", version: "1" }, retention: "exact", bytes: Buffer.from(JSON.stringify({ run: binding.initial, task: row, note, author: workspace.configuration().author })) }).manifestId;
+  const input: ProductionObservation = { id: `work-observation-${experimentHash({run:binding.initial.runId,task:row.id,note,outcome}).slice(0,24)}`, adoptionId: pin.adoptionId, candidateDigest: pin.candidateDigest, scopeDigest: pin.scopeDigest, originalRequirementDigest: binding.initial.selectionDigest, currentRequirementDigest: state.selectedSnapshot.snapshot.digest, outcome: outcomes.indexOf(outcome) === 1 ? "success" : outcomes.indexOf(outcome) === 2 ? "confirmed-defect" : "unknown", acceptanceDigest: null, acceptedArtifactDigest: null, observedArtifactDigest: source.sha256, evidence: [artifact, evidence] };
+  const preview = workspace.previewObservation(comparison.name, input);
+  if (!await ctx.ui.confirm("Confirm classified outcome", JSON.stringify(preview.classification))) return;
+  const retained = workspace.observe(comparison.name, input, [preview.digest]);
+  ctx.ui.notify(`Observed outcome retained (${retained.manifestId.slice(0,12)}). No acceptance, calibration or automatic rollback inferred.`, "info");
+}

package/extensions/learning-session.ts

@@ -0,0 +1,59 @@
+import { randomUUID } from "node:crypto";
+import { homedir } from "node:os";
+import { join } from "node:path";
+import { mkdir } from "node:fs/promises";
+import type { ExtensionCommandContext } from "@earendil-works/pi-coding-agent";
+import { adoptDashboardHarnessBridge } from "../src/dashboard-harness.ts";
+import { learningHarness, bindLearningConnection, loadLearningConnection, learningScopeDigest, type LearningUI } from "../src/learning-connection.ts";
+import { loadDeclaredWork } from "../src/work-command.ts";
+import { privateDirectory } from "../src/product-files.ts";
+import { workPolicyMenu } from "./work-policy-session.ts";
+import { linkLatestWorkOutcome } from "./learning-outcome-session.ts";
+import type { createDailyDashboardSession } from "./daily-dashboard-session.ts";
+
+/** Normal human-only entrypoint: delegates canonical learning decisions to the loaded harness wizard. */
+export function createLearningSession(host: ReturnType<typeof createDailyDashboardSession>) {
+  let busy = false;
+  return { async run(_verb: string, ctx: ExtensionCommandContext) {
+    if (busy) throw Error("A learning dialog is already open");
+    if (!ctx.hasUI) throw Error("Open /grants learning in interactive Pi");
+    busy = true;
+    try {
+      const declared = await loadDeclaredWork(join(ctx.cwd, ".pi", "work-current.json"));
+      if (!declared) throw Error("Declare work with /grants work first so learning has an exact scope");
+      const bridge = (globalThis as Record<PropertyKey, unknown>)[Symbol.for("skill-harness.dashboard-host.v1")];
+      const h = learningHarness(adoptDashboardHarnessBridge(bridge));
+      let connected: Awaited<ReturnType<typeof loadLearningConnection>> = null;
+      try { connected = await loadLearningConnection(ctx.cwd, declared, h, "local-operator"); }
+      catch (error) { ctx.ui.notify(String(error), "warning"); }
+      const menu = ["Open cases, comparisons, trust and outcomes", "Create learning workspace for selected work", "Connect existing learning workspace", "Adoption / rollback for next orders", "Retain current work for learning", "Link observed result from latest adopted order"];
+      const choice = await ctx.ui.select(connected ? "Learning — deliberate review (not earned automatic exposure)" : "Learning not connected", connected ? menu : menu.slice(1, 3));
+      if (!choice) return;
+      if ([menu[1], menu[2]].includes(choice)) {
+        if (host.running && !await ctx.ui.confirm("Reconnect learning after stopping the current host?", "Old host evidence is preserved. No child is cancelled. Start /grants host again after configuration.")) return;
+        if (host.running) await host.run("stop");
+        let directory: string;
+        if (choice === menu[1]) {
+          if (!await ctx.ui.confirm("Enable scoped learning retention?", "Case/comparison/trust decisions and explicitly selected output artifacts will be retained privately. No model is called; no quality, calibration or authority is invented.")) return;
+          const root = join(homedir(), ".local", "state", "pi-daddy", "learning"); await mkdir(root, { recursive: true, mode: 0o700 }); await privateDirectory(root);
+          const instance = join(root, randomUUID()); await privateDirectory(instance);
+          directory = join(instance, "workspace");
+          h.createLearningWorkspace(directory, { archiveRoot: join(instance, "archive"), scopeDigest: learningScopeDigest(declared), population: `work:${learningScopeDigest(declared).slice(0, 32)}`, author: "local-operator" });
+        } else { const path = await ctx.ui.input("Existing learning workspace directory"); if (!path) return; directory = path.trim(); }
+        await bindLearningConnection(ctx.cwd, declared, directory, h, "local-operator");
+        connected = await loadLearningConnection(ctx.cwd, declared, h, "local-operator");
+        ctx.ui.notify("Learning connected to exact work scope. Start /grants host to show it in Herdr.", "info");
+      }
+      if (!connected) throw Error("Connect learning first");
+      if (choice === menu[5]) { await linkLatestWorkOutcome(ctx, declared, connected.workspace, h); return; }
+      if (choice === menu[3]) { await workPolicyMenu(ctx, declared, connected.workspace, h); return; }
+      if (choice === menu[4]) {
+        if (!host.running) throw Error("Start /grants host first; it captures and binds the current work case batch through the existing archive policy");
+        await host.choose("refresh-current-work"); ctx.ui.notify("Current work retained. Open Learning for real case readiness; this is not a defect label.", "info"); return;
+      }
+      const ui: LearningUI = { select: (title, choices) => ctx.ui.select(title, choices), input: (title, initial) => ctx.ui.input(title, initial), editor: (title, text) => ctx.ui.editor(title, text), confirm: (title, detail) => ctx.ui.confirm(title, detail), notify: (text, level) => ctx.ui.notify(text, level ?? "info") };
+      await h.runLearningWizard({ directory: connected.connection.directory, cwd: ctx.cwd, ui });
+      if (host.running) ctx.ui.notify("Learning saved. If you changed trust configuration, stop/start /grants host explicitly to bind it; attention is not reset.", "info");
+    } finally { busy = false; }
+  } };
+}

package/extensions/ordinary-runtime.ts

@@ -5,9 +5,9 @@ import { releaseDelegationWorkspace,type PreparedWorkspace } from "./workspace-r
 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>){
+export async function withOrdinaryChild(input:{session:GrantsSession;executionId:string;parentExecutionId:string|null;childId:string;toolCallId?:string;signal?:AbortSignal;preparedWorkspace?:PreparedWorkspace;declaredWork?:GrantsSession["declaredWork"]},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);}
+ try{if(input.declaredWork&&dataDigest(input.declaredWork.selectedSnapshot)!==dataDigest(input.session.declaredWork?.selectedSnapshot??null))throw Error("declared work changed before original child admission");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/run-delegation.ts

@@ -204,7 +204,7 @@ export async function runOneDelegation(
    */
   options: {
     /** Actual public execute argument, never read from model-authored correlation or output. */
-    toolCallId?: string;
+    toolCallId?: string; declaredWork?: GrantsSession["declaredWork"];
     /** Progress for the parent's status block (ADR-0032). Display only. */
     onProgress?: (update: {
       /** Appended (process executor: a genuine byte stream). */
@@ -389,7 +389,7 @@ export async function runOneDelegation(
     childId: ids.childId,
     executionId: ids.executionId,
     parentExecutionId: ids.parentExecutionId,
-    toolCallId: options.toolCallId,
+    toolCallId: options.toolCallId, declaredWork: options.declaredWork,
     cwd: ctx.cwd,
     preparedWorkspace,
     signal,

package/extensions/work-policy-session.ts

@@ -0,0 +1,139 @@
+import { randomUUID } from "node:crypto";
+import { homedir } from "node:os";
+import { join } from "node:path";
+import { mkdir, readdir } from "node:fs/promises";
+import type { ExtensionCommandContext } from "@earendil-works/pi-coding-agent";
+import { supportedModelEfforts as getSupportedThinkingLevels } from "../src/model-preflight.ts";
+import { createWorkPolicyRegistry, openWorkPolicyRegistry, policyForSetup, workPolicy, workPolicyDigest, workPolicyActivationDigest, type WorkPolicy, type WorkPolicyRegistry, type WorkPolicyActivation } from "../src/work-policy-registry.ts";
+import { loadWorkSetup, type WorkSetup } from "../src/work-setup.ts";
+import { bindLearningAdoption, learningScopeDigest, type LearningHarness, type LearningWorkspace } from "../src/learning-connection.ts";
+import type { DeclaredWorkState } from "../src/work-command.ts";
+import { privateDirectory, readProductJson, writeProductJson } from "../src/product-files.ts";
+import type { AdoptionBinding, AdoptionFacts } from "../src/vendor/adoption.ts";
+import type { FactoryAuthority } from "../src/factory-contract.ts";
+import { experimentHash } from "../src/experiment-contract.ts";
+
+const descriptor = (cwd: string) => join(cwd, ".pi", "work-policy-registry.json");
+const policyPath = (cwd: string, digest: string) => join(cwd, ".pi", "work-policies", `${digest}.json`);
+const registryHistoryPath=(cwd:string,scope:string)=>join(cwd,".pi","work-registry-bindings",`${scope}.json`);
+async function retainRegistryBinding(cwd:string,binding:WorkPolicyRegistry){const path=registryHistoryPath(cwd,binding.initial.scopeDigest),old=await readProductJson(path);if(old&&experimentHash(old)!==experimentHash(binding))throw Error("scoped registry binding history conflict");if(!old)await writeProductJson(path,binding);}
+function authority(id: string, binding?: AdoptionBinding, facts?: AdoptionFacts): FactoryAuthority { return { id, orderDigests: [], decisionDigests: [], activationDigests: [], migrationDigests: [], adoption: { id, adoptions: binding ? [binding.id] : [], rollbacks: [] }, facts: binding && facts ? [{ bindingId: binding.id, facts }] : [] }; }
+async function independentFacts(ctx: ExtensionCommandContext, b: AdoptionBinding): Promise<AdoptionFacts | null> {
+  if (!await ctx.ui.confirm("Independent eligibility attestation — not a quality preference", `Have you independently verified that this exact comparison/candidate meets the scoped assessment policy, and is still eligible?\nExperiment: ${b.experimentDigest}\nCandidate: ${b.candidateDigest}\nScope: ${b.scopeDigest}\nAssessment: ${b.assessmentPolicyDigest}\n\nConfirm only with real independent evidence. Missing/uncertain evidence means No. This does not fabricate calibration or accept any result.`)) return null;
+  return { experimentDigest: b.experimentDigest, candidateDigest: b.candidateDigest, scopeDigest: b.scopeDigest, assessmentPolicyDigest: b.assessmentPolicyDigest, eligible: true };
+}
+export async function loadWorkPolicyRegistry(cwd: string, state: DeclaredWorkState): Promise<WorkPolicyRegistry | null> {
+  const binding = await readProductJson(descriptor(cwd)) as WorkPolicyRegistry | null;
+  if (binding && binding.initial.scopeDigest !== learningScopeDigest(state)) throw Error("Configured adoption registry belongs to different work. Use /grants learning → Adoption / rollback to reconnect or create scoped settings; no adopted setting was carried forward.");
+  if (binding) await openWorkPolicyRegistry(binding).inspect(); return binding;
+}
+async function savePolicy(cwd: string, name: string, policy: WorkPolicy) {
+  if(typeof name!=="string"||!name.trim()||Buffer.byteLength(name)>128||/[\p{Cc}\p{Cf}]/u.test(name))throw Error("bounded plain candidate name required");
+  const path = policyPath(cwd, workPolicyDigest(policy)), old = await readProductJson(path);
+  if(old){await readPolicy(cwd,workPolicyDigest(policy));return;}
+  await writeProductJson(path, { version: "named-work-policy-v1", name, policy });
+}
+async function readPolicy(cwd: string, digest: string) {
+  const saved = await readProductJson(policyPath(cwd, digest)) as { version: string; name: string; policy: WorkPolicy } | null;
+  if (!saved || Object.keys(saved).sort().join()!=="name,policy,version" || typeof saved.name!=="string" || !saved.name.trim() || Buffer.byteLength(saved.name)>128 || /[\p{Cc}\p{Cf}]/u.test(saved.name) || saved.version !== "named-work-policy-v1" || workPolicyDigest(saved.policy) !== digest) throw Error("Exact candidate policy bytes are missing; prepare the candidate profile first");
+  return workPolicy(saved.policy);
+}
+function retain(h: LearningHarness, root: string, parser: string, value: unknown) {
+  return h.retainArchiveSource(root, { sourceId: `${parser}-${experimentHash(value).slice(0, 24)}`, parser: { id: parser, version: "1" }, retention: "exact", bytes: Buffer.from(JSON.stringify(value)) }).manifestId;
+}
+export async function workPolicyMenu(ctx: ExtensionCommandContext, state: DeclaredWorkState, workspace: LearningWorkspace, harness: LearningHarness): Promise<void> {
+  const setup = await loadWorkSetup(state); if (!setup) throw Error("Declare a multi-task work setup before configuring ordinary model/effort adoption");
+  let binding = await readProductJson(descriptor(ctx.cwd)) as WorkPolicyRegistry|null;
+  if(binding)await openWorkPolicyRegistry(binding).inspect();
+  if(binding&&binding.initial.scopeDigest!==learningScopeDigest(state)){
+    if(!await ctx.ui.confirm("Settings belong to different selected work","Connect settings for this exact work scope? Previous registry and active/history-bearing orders remain untouched. No adopted setting carries across scopes."))return;
+    await retainRegistryBinding(ctx.cwd,binding);binding=null;
+  }
+  if(!binding){
+    const saved=await readProductJson(registryHistoryPath(ctx.cwd,learningScopeDigest(state))) as WorkPolicyRegistry|null;
+    if(saved){const view=await openWorkPolicyRegistry(saved).inspect();if(view.scopeDigest!==learningScopeDigest(state))throw Error("saved registry scope mismatch");if(!await ctx.ui.confirm("Reconnect saved settings for this work?",`${view.candidate.profiles.map(p=>`${p.model} / ${p.thinking}`).join(", ")}\nFuture runs still require current eligibility; existing runs do not migrate.`))return;binding=saved;await writeProductJson(descriptor(ctx.cwd),binding,true);}
+  }
+  if (!binding) {
+    const baseline = policyForSetup(setup.setup, learningScopeDigest(state), state.policy.digest);
+    if (!await ctx.ui.confirm("Create a scoped next-order registry?", "Baseline is the selected task models/effort. Future adoption can only change model/effort for these same definitions. No existing or active run changes.")) return;
+    const root = join(homedir(), ".local", "state", "pi-daddy", "work-registries"); await mkdir(root, { recursive: true, mode: 0o700 }); await privateDirectory(root);
+    binding = await createWorkPolicyRegistry({ directory: join(root, randomUUID()), authorityId: "local-operator", baseline });
+    await savePolicy(ctx.cwd, "Baseline", baseline); await retainRegistryBinding(ctx.cwd,binding); await writeProductJson(descriptor(ctx.cwd), binding, true);
+  }
+  const registry = openWorkPolicyRegistry(binding), current = await registry.inspect();
+  const menu = ["Prepare candidate model/effort profile", "Activate adopted comparison for next orders", "Roll back active adoption", "Inspect registry", "Recover learning link (no registry change)"];
+  const choice = await ctx.ui.select("Scoped settings — existing runs stay pinned", menu);
+  if (!choice) return;
+  if (choice === menu[3]) { await ctx.ui.editor("Registry details (read-only; editor changes are discarded)", JSON.stringify(current, null, 2)); return; }
+  if (choice === menu[0]) {
+    const candidate = structuredClone(current.candidate);
+    for (const profile of candidate.profiles) {
+      const models = ctx.scopedModels?.length ? ctx.scopedModels.map(entry => entry.model) : ctx.modelRegistry.getAvailable();
+      if(!models.length)throw Error("No available Pi models. Configure a model in Pi, then reopen settings; no fallback is chosen.");
+      const labels = models.map(m => `${m.provider}/${m.id}`), selected = await ctx.ui.select(`Model for ${setup.setup.tasks.find(t => t.id === profile.taskId)!.outcome}`, labels), model = models[labels.indexOf(selected ?? "")]; if (!model) return;
+      const thinking = await ctx.ui.select("Requested effort", getSupportedThinkingLevels(model)); if (!thinking) return;
+      profile.model = `${model.provider}/${model.id}`; profile.thinking = thinking as typeof profile.thinking;
+    }
+    const name = await ctx.ui.input("Candidate name", "Alternative profile"); if (!name?.trim()) return;
+    await savePolicy(ctx.cwd, name, candidate);
+    ctx.ui.notify(`Candidate retained, not adopted. Comparison must bind configuration digest ${workPolicyDigest(candidate)} to actual outputs. Use Learning to review full artifacts, record quality and choose adopt/reject/defer.`, "info"); return;
+  }
+  const view = workspace.inspect(Date.now()), comparisons = view.comparisons.filter(c => c.state !== "deferred");
+  if(!comparisons.length)throw Error("Adoption deferred: no ready retained comparison. Open Learning to connect/review actual evidence and inspect defer reasons. No setting was activated.");
+  const labels = comparisons.map((c, i) => `${i + 1}. ${c.title}`), picked = await ctx.ui.select("Retained comparison", labels), comparison = comparisons[labels.indexOf(picked ?? "")]; if (!comparison) return;
+  if (choice === menu[1]) {
+    let adoptionBinding = workspace.comparisonContext(comparison.name).adoptionBinding;
+    if (!adoptionBinding) {
+      const files=await readdir(join(ctx.cwd,".pi","work-policies")); if(files.length>128)throw Error("candidate profile bound exceeded");
+      const candidates: {name:string;policy:WorkPolicy}[]=[];
+      for(const file of files.filter(f=>/^[a-f0-9]{64}\.json$/.test(f))){const saved=await readProductJson(join(ctx.cwd,".pi","work-policies",file)) as {name:string;policy:WorkPolicy};const policy=await readPolicy(ctx.cwd,file.slice(0,-5));if(policy.scopeDigest===current.scopeDigest)candidates.push({name:saved.name,policy});}
+      const names=candidates.map((c,i)=>`${i+1}. ${c.name}: ${c.policy.profiles.map(p=>`${p.model}/${p.thinking}`).join(", ")}`),picked=await ctx.ui.select("Candidate already compared in this retained evidence",names),selected=candidates[names.indexOf(picked??"")];if(!selected)return;
+      if(!await ctx.ui.confirm("Bind this scoped adoption proposal?","This requires linked confirmed cases, hypothesis and a durable full-artifact choice of this exact candidate. It does not create eligibility or activate anything."))return;
+      adoptionBinding=bindLearningAdoption(workspace,comparison.name,{candidateDigest:workPolicyDigest(selected.policy),rollbackCandidateDigest:current.candidateDigest,assessmentPolicyDigest:selected.policy.assessmentPolicyDigest,expiresAt:Date.now()+7*86400000});
+    }
+    const candidate = await readPolicy(ctx.cwd, adoptionBinding.candidateDigest), facts = await independentFacts(ctx, adoptionBinding); if (!facts) return;
+    const a = authority(binding.initial.authorityId, adoptionBinding, facts), receipt = workspace.prepareAdoption(comparison.name, a.adoption, facts, Date.now());
+    const request: WorkPolicyActivation = { version: "ordinary-work-activation-v1", requestId: `activate-${randomUUID()}`, expectedRevision: current.revision, expectedCandidateDigest: current.candidateDigest, candidate, binding: adoptionBinding, receipt };
+    if (!await ctx.ui.confirm("Activate for NEXT orders only?", `${comparison.title}\n${candidate.profiles.map(p => `${p.taskId}: ${p.model} / ${p.thinking}`).join("\n")}\nNo active work changes. This is separate from your quality choice.`)) return;
+    a.activationDigests = [workPolicyActivationDigest(request)];
+    const applied = await registry.activate(request, a), archiveRoot = workspace.configuration().archiveRoot;
+    const registryManifestId = retain(harness, archiveRoot, "producer-registry", applied);
+    const wrapper = retain(harness, archiveRoot, "learning-registry-receipt", { version: "learning-registry-receipt-v1", operation: "activate", requestId: request.requestId, adoptionId: receipt.id, scopeDigest: applied.scopeDigest, candidateDigest: applied.candidateDigest, revision: applied.revision, registryManifestId });
+    try { workspace.linkActivation(comparison.name, wrapper, [wrapper]); }
+    catch (error) { throw Error(`Registry activated but learning link failed (${String(error)}). Do not activate again; use Recover learning link. Retained receipt ${wrapper}.`); }
+    ctx.ui.notify("Activated for subsequent bounded work runs. Existing runs remain pinned; later outcomes are still unobserved.", "info"); return;
+  }
+  if(choice===menu[4]){
+    const change=current.lastChange,receipt=workspace.preparedAdoption(comparison.name);
+    if(!change||!receipt||change.adoptionId!==receipt.id)throw Error("Last original registry change does not belong to this comparison");
+    if(!await ctx.ui.confirm("Reconnect actual registry observation?",`The last ${change.operation} is already applied at revision ${current.revision}. This only retains and links that exact original registry observation; no effect is replayed.`))return;
+    const root=workspace.configuration().archiveRoot,registryManifestId=retain(harness,root,"producer-registry",current),wrapper=retain(harness,root,"learning-registry-receipt",{version:"learning-registry-receipt-v1",operation:change.operation,requestId:change.requestId,adoptionId:receipt.id,scopeDigest:current.scopeDigest,candidateDigest:current.candidateDigest,revision:current.revision,registryManifestId});
+    if(change.operation==="activate")workspace.linkActivation(comparison.name,wrapper,[wrapper]);else workspace.linkRollback(comparison.name,wrapper,[wrapper]);
+    ctx.ui.notify("Original registry observation linked. No activation or rollback replayed.","info");return;
+  }
+  if (!current.activation) throw Error("No current adoption to roll back");
+  const receipt = workspace.preparedAdoption(comparison.name);
+  if (!receipt || receipt.id !== current.activation.receipt.id) throw Error("Selected comparison is not the active adoption");
+  const root = workspace.configuration().archiveRoot;
+  const evidence = retain(harness, root, "producer-rollback-request", { reason: "operator-request", adoptionId: receipt.id, observedRevision: current.revision });
+  const request = workspace.previewRollback(comparison.name, "operator-request", [evidence], Date.now() + 120_000);
+  const restore = await registry.previewRollback(request);
+  if (!await ctx.ui.confirm("Roll back NEXT orders?", `Restore candidate: ${restore.restoreCandidateDigest}\n${restore.candidate.profiles.map(p => `${p.taskId}: ${p.model} / ${p.thinking}`).join("\n")}\nNo active run changes; no defect or improvement is inferred.`)) return;
+  const a = authority(binding.initial.authorityId); a.adoption = { id: a.id, adoptions: [], rollbacks: [request.id] };
+  workspace.prepareRollback(comparison.name, request, a.adoption, Date.now(), { adoptionId: receipt.id, candidateDigest: current.candidateDigest, scopeDigest: current.scopeDigest });
+  const applied = await registry.rollback(request, a), registryManifestId = retain(harness, root, "producer-registry", applied);
+  const wrapper = retain(harness, root, "learning-registry-receipt", { version: "learning-registry-receipt-v1", operation: "rollback", requestId: request.id, adoptionId: receipt.id, scopeDigest: applied.scopeDigest, candidateDigest: applied.candidateDigest, revision: applied.revision, registryManifestId });
+  try { workspace.linkRollback(comparison.name, wrapper, [wrapper]); }
+  catch (error) { throw Error(`Rollback applied but learning link failed (${String(error)}). Use Recover learning link; do not repeat the effect. Retained receipt ${wrapper}.`); }
+  ctx.ui.notify("Rollback applied for next orders. Active/history-bearing runs were not changed.", "info");
+}
+/** Fresh human facts at use; a stored lifecycle/receipt is never treated as independent live authority. */
+export async function prepareNextWorkPolicy(ctx: ExtensionCommandContext, state: DeclaredWorkState, setup: WorkSetup) {
+  const binding = await loadWorkPolicyRegistry(ctx.cwd, state); if (!binding) return { setup, pin: async (_id: string) => null };
+  const registry = openWorkPolicyRegistry(binding), current = await registry.inspect();
+  const facts = current.activation ? await independentFacts(ctx, current.activation.binding) : undefined;
+  if (facts === null) throw Error("Next-order adoption deferred; no fallback profile or child launched");
+  const a = authority(binding.initial.authorityId, current.activation?.binding, facts);
+  const configured = { ...setup, tasks: setup.tasks.map(t => { const profile = current.candidate.profiles.find(p => p.taskId === t.id); if (!profile || profile.agent !== t.agent) throw Error("adopted profile no longer matches task definition"); return { ...t, model: profile.model, thinking: profile.thinking }; }) };
+  return { setup: configured, async pin(orderId: string) { const pinned = await registry.pin(orderId, a, { revision: current.revision, candidateDigest: current.candidateDigest }); if (pinned.candidateDigest !== current.candidateDigest || pinned.revision !== current.revision) throw Error("registry changed before order pin; no child launched"); return { orderId, candidateDigest: pinned.candidateDigest, adoptionId: pinned.adoptionId, revision: pinned.revision, scopeDigest: binding.initial.scopeDigest }; } };
+}

package/extensions/work-run-session.ts

@@ -0,0 +1,75 @@
+import { randomUUID } from "node:crypto";
+import { homedir } from "node:os";
+import { join } from "node:path";
+import { mkdir } from "node:fs/promises";
+import { BorderedLoader, type ExtensionCommandContext } from "@earendil-works/pi-coding-agent";
+import { supportedModelEfforts as getSupportedThinkingLevels } from "../src/model-preflight.ts";
+import { splitBudget } from "../src/fanout.ts";
+import { runWorkSetup, type WorkRunResult } from "../src/work-run.ts";
+import { loadWorkSetup, type RecordedWorkSetup } from "../src/work-setup.ts";
+import { privateDirectory, writeProductJson } from "../src/product-files.ts";
+import { loadDeclaredWork } from "../src/work-command.ts";
+import { readDailySnapshot } from "../src/daily-view-input.ts";
+import { ordinaryChildrenFor } from "../src/ordinary-children.ts";
+import { runOneDelegation } from "./run-delegation.ts";
+import { newDelegationOccurrence } from "./execution-occurrence.ts";
+import { assertDelegationAuthority } from "./delegation-authority.ts";
+import type { GrantsSession } from "./session.ts";
+import { prepareNextWorkPolicy } from "./work-policy-session.ts";
+
+export async function runSelectedWork(session: GrantsSession, ctx: ExtensionCommandContext, setup: RecordedWorkSetup, priorities?: string[], lifetime?: { signal: AbortSignal; started: (promise: Promise<WorkRunResult>) => void }): Promise<WorkRunResult | null> {
+  assertDelegationAuthority(session);
+  if (!ctx.isIdle() || !ordinaryChildrenFor(session).quiescent()) throw Error("Wait for original work to settle before starting a bounded run");
+  const loaded = await loadWorkSetup(setup.state);
+  if (!loaded || session.declaredWork?.selectedSnapshot.snapshot.digest !== setup.state.selectedSnapshot.snapshot.digest) throw Error("selected work changed");
+  const available=splitBudget(session.fanoutBudget,setup.setup.tasks.length);if(!available.ok)throw Error(available.reason);
+  const policy = await prepareNextWorkPolicy(ctx, setup.state, setup.setup), configured = policy.setup;
+  // Resolve every profile before any ledger, result store or child. No provider/model/effort fallback.
+  for (const task of configured.tasks) {
+    const slash = task.model.indexOf("/"), model = ctx.modelRegistry.find(task.model.slice(0, slash), task.model.slice(slash + 1));
+    if (!model || !getSupportedThinkingLevels(model).includes(task.thinking)) throw Error(`Unsupported profile for ${task.outcome}: ${task.model} / ${task.thinking}; choose a listed model and effort`);
+  }
+  if (!await ctx.ui.confirm("Run this work?", `${setup.setup.tasks.length} attempts; at most ${setup.setup.maxParallel} parallel. Each child's existing timeout/output/grant bounds apply. Dependencies receive complete bounded predecessor output. No automatic retries; no universal token/cost cap on ordinary children.\n\n${configured.tasks.map(t => `${t.outcome} — ${t.agent ?? "no tools"}, ${t.model}, ${t.thinking}`).join("\n")}`)) return null;
+  const selectedNow=await loadDeclaredWork(setup.state.statePath);
+  if(selectedNow?.selectedSnapshot.snapshot.digest!==setup.state.selectedSnapshot.snapshot.digest||session.declaredWork?.selectedSnapshot.snapshot.digest!==setup.state.selectedSnapshot.snapshot.digest)throw Error("work selection changed during confirmation; no order started");
+  const root = join(homedir(), ".local", "state", "pi-daddy", "work-runs");
+  await mkdir(root, { recursive: true, mode: 0o700 }); await privateDirectory(root);
+  const abort = new AbortController(), signal = lifetime ? AbortSignal.any([abort.signal, lifetime.signal]) : abort.signal;
+  signal.throwIfAborted(); const orderId = randomUUID(), policyPin = await policy.pin(orderId);
+  const run = (update: (text: string) => void) => { const pending = runWorkSetup({ directory: join(root, orderId), orderId, policyPin, selectionDigest: setup.state.selectedSnapshot.snapshot.digest, setup: configured, budget: session.fanoutBudget, priorities, signal, admissionOpen:()=>(ordinaryChildrenFor(session).inspect() as {admission:string}).admission==="open",
+    onUpdate: rows => update(rows.map(row => `${row.state}: ${setup.setup.tasks.find(t => t.id === row.id)!.outcome}`).join("\n")),
+    execute: async (task, prompt, budget, started) => {
+      assertDelegationAuthority(session);
+      if(session.declaredWork?.selectedSnapshot.snapshot.digest!==setup.state.selectedSnapshot.snapshot.digest)throw Error("selected work changed; remaining order attempts were not launched");
+      const ids = newDelegationOccurrence(session, setup.setup.tasks.findIndex(t => t.id === task.id));
+      await started(ids.executionId);
+      const state = { ...setup.state, obligation: setup.tasks.find(t => t.id === task.id)!.obligation };
+      return runOneDelegation(session, { task: prompt, ...(task.agent ? { agent: task.agent } : { tools: [] }), model: task.model, thinking: task.thinking, correlation: { schema_version: "1.0", task_id: task.id, context_id: `work-${setup.setup.id}` } }, ids, budget, ctx, signal, { declaredWork: state, toolCallId: `work-run:${ids.executionId}` });
+    },
+  }); lifetime?.started(pending); return pending; };
+  let result: WorkRunResult;
+  if (ctx.mode === "tui") {
+    result = await ctx.ui.custom<WorkRunResult>((tui, theme, _keys, done) => {
+      const loader = new BorderedLoader(tui, theme, "Running declared work — Esc requests cancellation; awaiting all original children");
+      loader.onAbort = () => abort.abort();
+      void run(text => ctx.ui.setWidget("pi-daddy-work", text.split("\n"))).then(done).catch(error => done({ error } as unknown as WorkRunResult));
+      return loader;
+    });
+    ctx.ui.setWidget("pi-daddy-work", undefined);
+    if ("error" in result) throw (result as unknown as { error: unknown }).error;
+  } else result = await run(text => ctx.ui.notify(text, "info"));
+  // Navigation index only; the original occurrence ledger/control journal remains the result authority.
+  await writeProductJson(join(session.cwd, ".pi", "work-last-run.json"), result.binding, true);
+  return result;
+}
+export async function showWorkResults(ctx: ExtensionCommandContext, result: WorkRunResult): Promise<void> {
+  const choices = result.tasks.map((row, i) => `${i + 1}. ${row.state} — ${result.binding.initial.setup.tasks.find(t => t.id === row.id)?.outcome ?? row.id}`);
+  const choice = await ctx.ui.select("Results — execution is not acceptance", choices);
+  const row = result.tasks[choices.indexOf(choice ?? "")]; if (!row) return;
+  if (!row.resultPath || !row.resultDigest) { ctx.ui.notify(row.reason ?? "No retained output; original acknowledgement unavailable", "warning"); return; }
+  if (row.resultPath !== join(result.binding.directory, `${row.id}.txt`)) throw Error("result path mismatch");
+  const source = await readDailySnapshot(row.resultPath, 1024 * 1024);
+  if (source.status !== "read" || source.sha256 !== row.resultDigest) throw Error("retained output missing or changed");
+  const output = new TextDecoder("utf8", { fatal: true }).decode(source.bytes);
+  await ctx.ui.editor("Retained full output (controls escaped; edits do not alter the artifact)", output.replace(/[\p{Cc}\p{Cf}]/gu, c => c === "\n" || c === "\t" ? c : `\\u${c.charCodeAt(0).toString(16).padStart(4,"0")}`));
+}

package/extensions/work-runtime.ts

@@ -11,12 +11,12 @@ export async function beginDeclaredWorkAttempt(input: {
   childId: string;
   executionId: string;
   parentExecutionId: string | null;
-  toolCallId?: string;
+  toolCallId?: string; declaredWork?: GrantsSession["declaredWork"];
   preparedWorkspace?: PreparedWorkspace;
   configuredTimeoutMs: number;
   startedAt: Date;
 }): Promise<null | { finish(state: Extract<WorkOccurrencePayload["state"], "completed" | "failed">): Promise<void> }> {
-  const state = input.session.declaredWork;
+  const state = input.declaredWork ?? input.session.declaredWork;
   if (!state) return null;
   const argument = (flag: string): string | null => {
     const index = input.plan.args.indexOf(flag);