pi-daddy 0.26.0 → 0.27.0

package/extensions/work-session.ts

@@ -0,0 +1,132 @@
+import { randomUUID, createHash } from "node:crypto";
+import { join } from "node:path";
+import type { ExtensionCommandContext } from "@earendil-works/pi-coding-agent";
+import { supportedModelEfforts as getSupportedThinkingLevels } from "../src/model-preflight.ts";
+import { workSetup, recordWorkSetup, selectRecordedWork, loadWorkSetup, listWorkSetups, type WorkSetup, type WorkTaskSetup } from "../src/work-setup.ts";
+import { loadDeclaredWork } from "../src/work-command.ts";
+import { intentKey } from "../src/intent-control.ts";
+import { ordinaryChildrenFor } from "../src/ordinary-children.ts";
+import { inspectWorkRun, type WorkRunInitial, type WorkRunResult } from "../src/work-run.ts";
+import type { ControlBinding } from "../src/control-journal.ts";
+import { readProductJson } from "../src/product-files.ts";
+import { dashboardActionFeedback } from "../src/dashboard-cli.ts";
+import { runSelectedWork, showWorkResults } from "./work-run-session.ts";
+import type { GrantsSession } from "./session.ts";
+import type { createDailyDashboardSession } from "./daily-dashboard-session.ts";
+
+const cancelled = () => Error("Work setup cancelled; nothing selected or launched");
+async function ask(ctx: ExtensionCommandContext, title: string, initial = ""): Promise<string> {
+  const value = await ctx.ui.editor(title, initial); if (!value?.trim()) throw cancelled(); return value.trim();
+}
+async function profile(ctx: ExtensionCommandContext, session: GrantsSession, previous?: WorkTaskSetup) {
+  const agents = ["No tools (text-only)", ...session.definitions.keys()];
+  const agent = await ctx.ui.select("Agent definition — existing grants still apply", agents);
+  if (!agent) throw cancelled();
+  const available = ctx.scopedModels?.length ? ctx.scopedModels.map(entry => entry.model) : ctx.modelRegistry.getAvailable();
+  if(!available.length)throw Error("No available Pi models. Configure a model in Pi, then reopen work setup; no fallback is chosen.");
+  const labels = available.map(model => `${model.provider}/${model.id}`);
+  const selected = await ctx.ui.select("Model — no silent fallback", labels);
+  const model = available[labels.indexOf(selected ?? "")]; if (!model) throw cancelled();
+  const thinking = await ctx.ui.select("Requested effort (not proof of provider-internal reasoning)", getSupportedThinkingLevels(model));
+  if (!thinking) throw cancelled();
+  return { agent: agent === agents[0] ? null : agent, model: `${model.provider}/${model.id}`, thinking: thinking as WorkTaskSetup["thinking"] };
+}
+async function author(ctx: ExtensionCommandContext, session: GrantsSession): Promise<WorkSetup> {
+  const outcome = await ask(ctx, "What outcome should this work produce?");
+  const tasks: WorkTaskSetup[] = [];
+  do {
+    const outcome = await ask(ctx, `Task ${tasks.length + 1}: outcome / instructions`);
+    const selected = await profile(ctx, session);
+    const dependencies: string[] = [];
+    while (tasks.length) {
+      const candidates = tasks.filter(t => !dependencies.includes(t.id));
+      const labels = ["Dependencies complete", ...candidates.map((t, i) => `${i + 1}. ${t.outcome}`)];
+      const choice = await ctx.ui.select("Wait for which prior tasks? Failed dependencies block only their branch", labels);
+      if (!choice) throw cancelled(); if (choice === labels[0]) break;
+      dependencies.push(candidates[labels.indexOf(choice) - 1].id);
+    }
+    tasks.push({ id: `task${tasks.length + 1}`, outcome, ...selected, dependencies });
+  } while (tasks.length < 8 && await ctx.ui.confirm("Add another task?", "Independent tasks can run in parallel; dependent tasks receive predecessor results."));
+  const width = await ctx.ui.select("Maximum parallel agents", Array.from({ length: tasks.length }, (_, i) => String(i + 1)));
+  if (!width) throw cancelled();
+  return workSetup({ version: "work-setup-v1", id: `work-${randomUUID().slice(0, 8)}`, outcome, tasks, maxParallel: Number(width) });
+}
+async function revise(ctx: ExtensionCommandContext, session: GrantsSession, previous: WorkSetup): Promise<WorkSetup> {
+  const setup = structuredClone(previous);
+  while (true) {
+    const labels = ["Save revision", "Overall outcome", "Parallel limit", ...setup.tasks.map((t,i) => `${i+1}. ${t.outcome}`)];
+    const choice = await ctx.ui.select("Revise scope/configuration (topology and permissions stay fixed)", labels);
+    if (!choice) throw cancelled();
+    const index = labels.indexOf(choice);
+    if (index === 0) return workSetup(setup);
+    if (index === 1) setup.outcome = await ask(ctx, "Revised outcome", setup.outcome);
+    else if (index === 2) { const width = await ctx.ui.select("Parallel limit", Array.from({ length: setup.tasks.length }, (_, i) => String(i + 1))); if (!width) throw cancelled(); setup.maxParallel = Number(width); }
+    else { const task = setup.tasks[index - 3]; task.outcome = await ask(ctx, "Task outcome", task.outcome); Object.assign(task, await profile(ctx, session, task)); }
+  }
+}
+
+export function createWorkSession(session: GrantsSession, host: ReturnType<typeof createDailyDashboardSession>, rebind: () => void) {
+  let pending: Promise<void> | null = null, owned: Promise<WorkRunResult> | null = null;
+  const shutdown = new AbortController();
+  const run = async (verb: string, ctx: ExtensionCommandContext) => {
+    if (!ctx.hasUI) throw Error("Use /grants work in interactive Pi for setup and explicit run confirmation");
+    const current = await loadDeclaredWork(join(ctx.cwd, ".pi", "work-current.json"));
+    if (current) { session.declaredWork = current; rebind(); }
+    const selected = current ? await loadWorkSetup(current) : null;
+    const menu = ["Run selected work", "Declare new work", "Revise scope / configuration", "Record alternative", "Select saved work", "Select task for ordinary delegation", "Change priority", "Inspect results"];
+    const choice = verb ? ({ run: menu[0], new: menu[1], results: menu[7] } as Record<string, string>)[verb] : await ctx.ui.select(current ? selected?.setup.outcome ?? `Declared work: ${current.id}` : "No work selected", menu);
+    if (!choice) { if (verb) throw Error("Use /grants work, work new, work run or work results"); return; }
+    const guard = () => { if (!ctx.isIdle() || !ordinaryChildrenFor(session).quiescent()) throw Error("Wait for the original active work to settle before changing setup"); };
+    if (choice === menu[0]) {
+      if (!selected) throw Error("Declare multi-task work first; existing ordinary delegation remains available");
+      let priorities: string[] | undefined;
+      if (host.running) {
+        const frame = await host.frame(), controls = frame.controls as { intent?: { priorities: { obligation: { digest: string } }[] } };
+        priorities = controls.intent?.priorities.map(p => selected.tasks.find(t => t.obligation.digest === p.obligation.digest)?.id ?? "");
+      }
+      const result = await runSelectedWork(session, ctx, selected, priorities, { signal: shutdown.signal, started: promise => { owned = promise; } });
+      if (shutdown.signal.aborted) return;
+      if (result) { ctx.ui.notify(`${result.tasks.filter(t => t.state === "finished").length} finished; ${result.tasks.filter(t => t.state !== "finished").length} failed/blocked. No acceptance inferred.`, "info"); await showWorkResults(ctx, result); }
+      return;
+    }
+    if (choice === menu[7]) {
+      const binding = await readProductJson(join(ctx.cwd, ".pi", "work-last-run.json")) as ControlBinding<WorkRunInitial> | null;
+      if (!binding) throw Error("No bounded run result is retained for this project yet");
+      await showWorkResults(ctx, await inspectWorkRun(binding)); return;
+    }
+    if (choice === menu[6]) {
+      if (!host.running) throw Error("Start /grants host to change priority through the current dispatch owner");
+      const frame = await host.frame(), actions = frame.actions.filter(a => a.key.startsWith("priority-"));
+      const labels = actions.map((a, i) => `${i + 1}. ${a.label}`), picked = await ctx.ui.select("Next-work priority (does not rearrange active children)", labels);
+      const action = actions[labels.indexOf(picked ?? "")]; if (action) ctx.ui.notify(dashboardActionFeedback(action.label, await host.choose(action.key,{tip:frame.tip,requestDigest:action.requestDigest})), "info"); return;
+    }
+    guard();
+    if (choice === menu[5]) {
+      if (!selected || !current) throw Error("No multi-task setup selected");
+      const labels = selected.setup.tasks.map((t, i) => `${i + 1}. ${t.outcome}`), picked = await ctx.ui.select("Ordinary delegate binds which task?", labels), task = selected.tasks[labels.indexOf(picked ?? "")];
+      if (!task) return;
+      guard(); session.declaredWork = await selectRecordedWork({ ...selected, state: { ...selected.state, obligation: task.obligation } }, current.selectedSnapshot); rebind();
+      ctx.ui.notify("Task selected for subsequent ordinary delegation. Existing attempts were not rebound.", "info"); return;
+    }
+    if (choice === menu[4]) {
+      const setups = await listWorkSetups(ctx.cwd), labels = setups.map((s, i) => `${i + 1}. ${s.setup.outcome}`), picked = await ctx.ui.select("Select saved setup (existing work stays pinned)", labels), target = setups[labels.indexOf(picked ?? "")];
+      if (!target) return;
+      guard();
+      if (host.running) { if (!await ctx.ui.confirm("Stop the current host and select saved work?", "The old host's evidence remains intact. Start /grants host again for the selected setup.")) return; await host.run("stop"); }
+      session.declaredWork = await selectRecordedWork(target, current?.selectedSnapshot ?? null); rebind(); return;
+    }
+    const mode = choice === menu[1] ? "new" : choice === menu[2] ? "revise" : "alternative";
+    if (mode !== "new" && !selected) throw Error("Existing single-task work remains supported; declare a new multi-task setup to use revisions");
+    const draft = mode === "new" ? await author(ctx, session) : await revise(ctx, session, selected!.setup);
+    if (!await ctx.ui.confirm("Save this work setup?", `${draft.outcome}\n${draft.tasks.length} obligations; up to ${draft.maxParallel} parallel. Outcome/instruction text is retained in private project files, not governance ledgers. Nothing runs now.`)) return;
+    guard();
+    if (mode === "new" && host.running) { if (!await ctx.ui.confirm("Stop current host?", "A new topology needs a new host binding. Old evidence is preserved; no running work changes.")) return; await host.run("stop"); }
+    const recorded = await recordWorkSetup(ctx.cwd, draft, mode, current);
+    if (host.running) {
+      const prefix = mode === "revise" ? "scope" : "alternative", digest = createHash("sha256").update(intentKey(recorded.state.selectedSnapshot)).digest("hex").slice(0, 12);
+      ctx.ui.notify(dashboardActionFeedback("Select recorded work", await host.choose(`${prefix}-${digest}`)), "info");
+    } else { session.declaredWork = await selectRecordedWork(recorded, current?.selectedSnapshot ?? null); rebind(); }
+    ctx.ui.notify("Work saved. /grants work run starts it explicitly; /grants host connects the panel.", "info");
+  };
+  return { async close() { shutdown.abort(); if (owned) await owned.catch(() => undefined); }, async run(verb: string, ctx: ExtensionCommandContext) { shutdown.signal.throwIfAborted(); if (pending) throw Error("A work setup/run command is already active"); pending = run(verb, ctx); try { await pending; } finally { pending = null; owned = null; } } };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-daddy",
-  "version": "0.26.0",
+  "version": "0.27.0",
   "description": "Capability governance for pi sub-agents: spawn Agent Skills (SKILL.md) definitions whose allowed-tools becomes a grant that can only narrow going down a delegation tree, enforced by pi's own --tools allowlist, with an append-only ledger.",
   "keywords": [
     "pi-package",
@@ -37,6 +37,12 @@
       "types": "./dist/ledger.d.ts",
       "default": "./dist/ledger.js"
     },
+    "./work-setup": { "types": "./dist/work-setup.d.ts", "default": "./dist/work-setup.js" },
+    "./work-command": { "types": "./dist/work-command.d.ts", "default": "./dist/work-command.js" },
+    "./work-run": { "types": "./dist/work-run.d.ts", "default": "./dist/work-run.js" },
+    "./work-policy-registry": { "types": "./dist/work-policy-registry.d.ts", "default": "./dist/work-policy-registry.js" },
+    "./factory-registry": { "types": "./dist/factory-registry.d.ts", "default": "./dist/factory-registry.js" },
+    "./learning-connection": { "types": "./dist/learning-connection.d.ts", "default": "./dist/learning-connection.js" },
     "./work-ledger": {
       "types": "./dist/work-ledger.d.ts",
       "default": "./dist/work-ledger.js"
@@ -241,6 +247,8 @@
     "THIRD_PARTY_LICENSES",
     "THIRD_PARTY_NOTICES.md",
     "README.md",
+    "PRODUCT-GUIDE.md",
+    "REQUIREMENTS.md",
     "CHANGELOG.md",
     "LICENSE"
   ],

package/src/cli.ts

@@ -1,6 +1,6 @@
 #!/usr/bin/env node
 /**
- * `pi-daddy` — the command line, which today has exactly one subcommand.
+ * `pi-daddy` — scaffolding, read-only work inspection and the installed product guide.
  *
  * Thin on purpose: argv in, `discoverSkillPackages` + `planInit` + `applyInit`, report out. Every decision
  * lives in `./init.ts`, `./grant-env.ts` and `./skill-packages.ts` as functions that touch no argv and print
@@ -21,7 +21,9 @@ import { UnsafeGrantError } from "./grant-env.ts";
 import { applyInit, countDeclaring, planInit, type InitPlan } from "./init.ts";
 import { registeredWorkspaceIds } from "./workspace.ts";
 import { discoverSkillPackages, skillPackageRoots, type RefusedSkill, type SkillPackage } from "./skill-packages.ts";
-import { declareWork } from "./work-command.ts";
+import { declareWork, loadDeclaredWork } from "./work-command.ts";
+import { listWorkSetups, workPresentation } from "./work-setup.ts";
+import { panelText } from "./daily-panel.ts";
 
 const USAGE = `pi-daddy — capability governance for pi sub-agents
 
@@ -30,6 +32,11 @@ Usage:
                                            packages that declare skills (package.json "pi": {"skills": …})
   pi-daddy work add --id <id> --outcome <text> [--dir <path>]
                                            declare one current obligation for ordinary delegation
+  pi-daddy work list | work show [--dir <path>]
+                                           inspect saved setups or selected outcome (no model calls)
+  In Pi: /grants work                     guided multi-task/model/effort/dependency setup and run
+         /grants learning                 retained review, trust, adoption and later outcomes
+  pi-daddy guide | current               installed product guide / current requirement register
   pi-daddy --help | --version
 
 init copies each declared SKILL.md into .pi/skills/ and writes a grant naming exactly what those files
@@ -41,7 +48,7 @@ placeholder and stays unspawnable until you fill it in. Capabilities that can ch
             It never rewrites .pi/grants.env — delete that file if you want it regenerated.`;
 
 export interface ParsedArgs {
-  command: "init" | "work-add" | "help" | "version";
+  command: "init" | "work-add" | "work-list" | "work-show" | "guide" | "current" | "help" | "version";
   dir?: string;
   force: boolean;
   id?: string;
@@ -64,10 +71,12 @@ export function parseArgs(argv: string[]): ParsedArgs {
   if (args.includes("--version") || args.includes("-v")) return { command: "version", force: false, errors: [] };
 
   const [command, ...tail] = args;
+  if(command==="guide"||command==="current")return{command,force:false,errors:tail.length?[`${command} takes no arguments`]:[]};
   if (command !== "init" && command !== "work") return { command: "help", force: false, errors: [`unknown command "${command}"`] };
   const work = command === "work";
-  const rest = work && tail[0] === "add" ? tail.slice(1) : tail;
-  if (work && tail[0] !== "add") return { command: "work-add", force: false, errors: ["work needs subcommand add"] };
+  const workVerb = tail[0];
+  const rest = work ? tail.slice(1) : tail;
+  if (work && !["add", "list", "show"].includes(workVerb)) return { command: "work-add", force: false, errors: ["work needs add, list or show; /grants work opens guided setup in Pi"] };
 
   const errors: string[] = [];
   let dir: string | undefined;
@@ -77,11 +86,11 @@ export function parseArgs(argv: string[]): ParsedArgs {
     const arg = rest[i];
     if (arg === "--force" && !work) {
       force = true;
-    } else if (arg === "--id" && work) {
+    } else if (arg === "--id" && work && workVerb === "add") {
       const value = rest[i + 1];
       if (value === undefined || value.startsWith("-")) errors.push("--id needs a value");
       else { id = value; i += 1; }
-    } else if (arg === "--outcome" && work) {
+    } else if (arg === "--outcome" && work && workVerb === "add") {
       const value = rest[i + 1];
       if (value === undefined || value.startsWith("-")) errors.push("--outcome needs text");
       else { outcome = value; i += 1; }
@@ -104,6 +113,7 @@ export function parseArgs(argv: string[]): ParsedArgs {
     }
   }
 
+  if (work && workVerb !== "add") return { command: workVerb === "list" ? "work-list" : "work-show", force: false, errors, ...(dir ? { dir } : {}) };
   if (work) {
     if (!id && !errors.some(error => error.startsWith("--id"))) errors.push("--id needs a value");
     if (!outcome && !errors.some(error => error.startsWith("--outcome"))) errors.push("--outcome needs text");
@@ -282,6 +292,15 @@ export async function main(argv: string[]): Promise<number> {
     console.log(USAGE);
     return 0;
   }
+  if(parsed.command==="guide"||parsed.command==="current"){
+    console.log(await readFile(new URL(parsed.command==="guide"?"../PRODUCT-GUIDE.md":"../REQUIREMENTS.md",import.meta.url),"utf8"));return 0;
+  }
+  if (parsed.command === "work-list" || parsed.command === "work-show") {
+    const cwd=resolvePath(parsed.dir??process.cwd());
+    if(parsed.command==="work-list") {const setups=await listWorkSetups(cwd);console.log(setups.map((s,i)=>`${i+1}. ${panelText(s.setup.outcome)} — ${s.setup.tasks.length} tasks; up to ${s.setup.maxParallel} parallel`).join("\n")||"No saved multi-task setups. In Pi: /grants work");}
+    else {const state=await loadDeclaredWork(resolvePath(cwd,".pi/work-current.json")),view=state?await workPresentation(state):null;console.log(view?[panelText(view.outcome),...view.obligations.map(o=>`- ${panelText(o.outcome)}`)].join("\n"):state?"Selected legacy work; outcome text unavailable":"No work selected. In Pi: /grants work");}
+    return 0;
+  }
   if (parsed.command === "work-add") {
     const declared = await declareWork({
       cwd: resolvePath(parsed.dir ?? process.cwd()),

package/src/daily-dashboard-host.ts

@@ -14,12 +14,16 @@ import { bindWorkIntent } from "./intent-application.ts";
 import { intentKey, intentRequest, intentRequestDigest, type IntentPriority, type IntentRequest, type IntentSelection } from "./intent-control.ts";
 import { parseWorkLedgerText, type WorkRevisionEvent, type WorkSnapshotEvent } from "./work-ledger.ts";
 import { resolveWorkSnapshotText } from "./work-ledger-snapshot.ts";
+import { workPresentation, workSetupForSelection } from "./work-setup.ts";
+import { createDailyViewReader } from "./daily-view.ts";
+import { learningHarness, learningScopeDigest, type LearningConnection } from "./learning-connection.ts";
 
 export interface DailyIntentAction {key:string;label:string;action:"revise-scope"|"reprioritize"|"select-alternative";fromSelection:IntentSelection;events:(WorkRevisionEvent|WorkSnapshotEvent)[];selection:IntentSelection;priorities:IntentPriority[]}
-export interface DailyDashboardHostInput {id:string;cwd:string;directory:string;socketPath?:string;declared:DeclaredWorkState;ordinary:OrdinaryChildren;harness:DashboardHarness;author:string;priorities?:IntentPriority[];intentActions?:DailyIntentAction[];presence?:()=>{present:boolean;closing:boolean;evidenceDigest:string;expiresAt:number}|null;onDeclaredWorkChanged?:(state:DeclaredWorkState)=>void|Promise<void>}
+export interface DailyDashboardHostInput {id:string;cwd:string;directory:string;socketPath?:string;declared:DeclaredWorkState;ordinary:OrdinaryChildren;harness:DashboardHarness;author:string;learning?:LearningConnection;priorities?:IntentPriority[];intentActions?:DailyIntentAction[];presence?:()=>{present:boolean;closing:boolean;evidenceDigest:string;expiresAt:number}|null;onDeclaredWorkChanged?:(state:DeclaredWorkState)=>void|Promise<void>}
 const idPattern=/^[A-Za-z0-9][A-Za-z0-9._-]{0,63}$/;
 const hash=(value:string)=>createHash("sha256").update(value).digest("hex");
 const same=(a:unknown,b:unknown)=>intentKey(a)===intentKey(b);
+const friendlyLabel=(value:string)=>{let chars=[...value.replace(/[\p{Cc}\p{Cf}]/gu," ")];while(Buffer.byteLength(chars.join(""))>112)chars.pop();return chars.join("")+(chars.length<[...value].length?"...":"");};
 /** Recorded P01 snapshots become labelled proposals; choosing a label still traverses intent validation and exact host/CAS authority. */
 export function discoverDailyIntentActions(text:string,selection:IntentSelection,priorities:readonly IntentPriority[]):DailyIntentAction[]{
  const parsed=parseWorkLedgerText(text);if(!parsed.complete||parsed.events.length>512)throw Error("bounded complete recorded proposal ledger required");const label=(value:string)=>value.length<=80?value:`${value.slice(0,67)}…${hash(value).slice(0,12)}`;
@@ -41,48 +45,61 @@ export async function startDailyDashboardHost(input:DailyDashboardHostInput){
  if(!idPattern.test(input.id)||!isAbsolute(input.cwd)||resolve(input.cwd)!==input.cwd||!isAbsolute(input.directory)||resolve(input.directory)!==input.directory||!input.author.trim()||input.author.length>256)throw Error("explicit bounded daily host configuration required");
  const harnessDigest=loadedDashboardHarnessDigest(input.harness);if(!harnessDigest)throw Error("loaded skill-harness bridge required");
  if(input.declared.ledgerPath!==join(input.cwd,".pi","work.jsonl"))throw Error("current declared work must belong to this host project");
- await mkdir(input.directory,{mode:0o700});const archiveRoot=join(input.directory,"archive");await mkdir(archiveRoot,{mode:0o700});
+ const learning=input.learning?learningHarness(input.harness).openLearningWorkspace(input.learning.directory):null,learningConfig=learning?.configuration();
+ if(input.learning&&(!learningConfig||intentKey(learningConfig)!==intentKey(input.learning.configuration)||learningConfig.scopeDigest!==learningScopeDigest(input.declared)||learningConfig.author!==input.author||intentKey(input.learning.selection)!==intentKey(input.declared.selectedSnapshot)))throw Error("learning scope/archive/population/author mismatch");
+ const learnedTrust=learning?.dashboardBinding();
+ await mkdir(input.directory,{mode:0o700});const archiveRoot=learningConfig?.archiveRoot??join(input.directory,"archive");if(!learningConfig)await mkdir(archiveRoot,{mode:0o700});
  const reference=input.harness.retainArchiveSource(archiveRoot,{sourceId:`host-${input.id}-bootstrap`,parser:{id:"daily-host-bootstrap",version:"1"},retention:"exact",bytes:Buffer.from("explicit daily host bootstrap")});
- const component={kind:"detector",id:"coverage_gap",version:"work-signals-v1:declared-work-v1",population:`daily:${input.id}`};
+ const component={kind:"detector",id:"coverage_gap",version:"work-signals-v1:declared-work-v1",population:learningConfig?.population??`daily:${input.id}`};
  const trustInput={archiveRoot,component,seed:hash(`daily-host\0${input.id}`),maxUnflagged:0,cohort:[{incidentId:"bootstrap",manifestId:reference.manifestId,flagged:true,split:"calibration"}],exposure:null};
- const trustPolicyId=input.harness.trustPolicyDigest(trustInput),trustDirectory=join(input.directory,"trust");input.harness.createTrustLifecycle(trustDirectory,trustInput,[trustPolicyId]);
+ const trustPolicyId=learnedTrust?.trustPolicyId??input.harness.trustPolicyDigest(trustInput),trustDirectory=learnedTrust?.trustDirectory??join(input.directory,"trust");
+ if(Boolean(learnedTrust?.trustDirectory)!==Boolean(learnedTrust?.trustPolicyId))throw Error("incomplete original learning trust binding");
+ if(!learnedTrust?.trustDirectory)input.harness.createTrustLifecycle(trustDirectory,trustInput,[trustPolicyId]);
  const workRelative="work.jsonl",factsRelative="facts.jsonl",workMirror=join(input.directory,workRelative);await writeFile(workMirror,await readFile(input.declared.ledgerPath),{mode:0o600,flag:"wx"});
  const refreshWork=async()=>{const temporary=`${workMirror}.${process.pid}.${randomUUID()}.tmp`;try{await writeFile(temporary,await readFile(input.declared.ledgerPath),{mode:0o600,flag:"wx"});await rename(temporary,workMirror);}finally{await rm(temporary,{force:true});}};
- const facts={scopeDigest:input.declared.selectedSnapshot.snapshot.digest,version:"declared-work-v1",population:`daily:${input.id}`,expectedWaits:[],checkpoints:[],violations:[],priorAccepted:[]};await writeFile(join(input.directory,factsRelative),JSON.stringify(facts)+"\n",{mode:0o600,flag:"wx"});
+ const facts={scopeDigest:input.declared.selectedSnapshot.snapshot.digest,version:"declared-work-v1",population:learningConfig?.population??`daily:${input.id}`,expectedWaits:[],checkpoints:[],violations:[],priorAccepted:[]};await writeFile(join(input.directory,factsRelative),JSON.stringify(facts)+"\n",{mode:0o600,flag:"wx"});
  const policy={version:"archive-policy-v2",id:`daily-${input.id}`,revision:"1",sourceRoot:input.directory,archiveRoot,maxBytes:8*1024*1024,retention:"exact",expiresAt:new Date(Date.now()+24*60*60*1000).toISOString(),sources:[{id:"work",path:workRelative,parser:{id:"pi-daddy-work-ledger",version:"4"},contentPolicy:"manifest-only"},{id:"facts",path:factsRelative,parser:{id:"pi-daddy-work-signal-facts",version:"1"},contentPolicy:"manifest-only"}]};
  const policyPath=join(input.directory,"archive-policy.json"),policyBytes=JSON.stringify(policy);await writeFile(policyPath,policyBytes,{mode:0o600,flag:"wx"});
- const authorityDigest=dataDigest({kind:"daily-dashboard-host",id:input.id,cwd:input.cwd}),initialPriorities=input.priorities??[{obligation:input.declared.obligation,rank:0}];
+ const authorityDigest=dataDigest({kind:"daily-dashboard-host",id:input.id,cwd:input.cwd}),initialPriorities=input.priorities??resolveWorkSnapshotText(await readFile(input.declared.ledgerPath,"utf8"),input.declared.selectedSnapshot).snapshot!.bindings.map((binding,rank)=>({obligation:binding.obligation,rank}));
  const workIntent=await bindWorkIntent({path:input.declared.ledgerPath,grantLedgerPath:input.declared.grantLedgerPath,selection:input.declared.selectedSnapshot,priorities:initialPriorities});
  const budget=await createIntentBudget({directory:join(input.directory,"budget"),authorityDigest,limits:{maxAttempts:6,maxInputBytes:65536,maxConcurrent:3}},workIntent);
- const config:DashboardHostConfig={version:"producer-dashboard-host-v1",trustDirectory,trustPolicyId,archiveRoot,scope:`daily:${input.id}`,author:input.author,policyPath,policySha256:hash(policyBytes),sources:[{id:"work",kind:"work"},{id:"facts",kind:"facts"}],selection:input.declared.selectedSnapshot,cases:null,blind:null,budgetDigest:resourceBindingDigest(budget),experimentDigest:null,harnessArtifactDigest:harnessDigest,ordinaryDigest:input.ordinary.bindingDigest};
+ const config:DashboardHostConfig={version:"producer-dashboard-host-v1",...(learnedTrust?.trustDirectory?{journalDirectory:join(input.directory,"producer-host")} : {}),trustDirectory,trustPolicyId,archiveRoot,scope:`daily:${input.id}`,author:input.author,policyPath,policySha256:hash(policyBytes),sources:[{id:"work",kind:"work"},{id:"facts",kind:"facts"}],selection:input.declared.selectedSnapshot,cases:null,blind:null,budgetDigest:resourceBindingDigest(budget),experimentDigest:null,harnessArtifactDigest:harnessDigest,ordinaryDigest:input.ordinary.bindingDigest};
  const proposals=input.intentActions??[];if(proposals.length>8||new Set(proposals.map(x=>x.key)).size!==proposals.length||proposals.some(x=>!idPattern.test(x.key)||typeof x.label!=="string"||!x.label.trim()||Buffer.byteLength(x.label)>120))throw Error("bounded friendly intent actions required");
  const requestDigests=new Set<string>(),dispatchDigests=new Set<string>(),ordinaryDigests=new Set<string>();let host:ReturnType<typeof createDashboardHost>,factsResultManifest:string|null=null,workSelection:IntentSelection=input.declared.selectedSnapshot,declaredState=input.declared,reboundSnapshotId:string|null=null;
  const authority=():DashboardHostAuthority=>({hostDigests:[dashboardHostDigest(config)],requestDigests:[...requestDigests],workContext:{selectedSnapshot:workSelection,authority:null},dispatch:{authorityDigest,requestDigests:[...dispatchDigests]},experiment:null,ordinary:{bindingDigest:input.ordinary.bindingDigest,requestDigests:[...ordinaryDigests]}});
  const request=(context:{hostDigest:string;selectionDigest:string;tip:string},operation:DashboardHostRequest["operation"],payload:unknown,requestId:string):DashboardHostRequest=>({version:"1.0",requestId,hostDigest:context.hostDigest,selectionDigest:context.selectionDigest,expectedTip:context.tip,operation,payload});
- host=createDashboardHost({harness:input.harness,config,budget,ordinary:input.ordinary,authority,beforeObservation:sourceId=>sourceId==="work"?refreshWork():Promise.resolve(),humanActions:async context=>{
+ const dailyReader=createDailyViewReader();
+ host=createDashboardHost({harness:input.harness,config,budget,ordinary:input.ordinary,authority,learningView:learning?()=>learningScopeDigest(declaredState)===learningConfig!.scopeDigest?learning.inspect(Date.now()):{state:"deferred",reason:"Selected work changed; reconnect learning explicitly"}:undefined,afterObservation:learning?observation=>{if(observation.cases&&learningScopeDigest(declaredState)===learningConfig!.scopeDigest)learning.bindCases({name:`work-${observation.cases.batchId.slice(0,20)}`,title:"Retained daily work",version:3,batchId:observation.cases.batchId});}:undefined,presentation:()=>workPresentation(declaredState),currentWork:()=>dailyReader({workLedgerPath:declaredState.ledgerPath,workContext:{selectedSnapshot:workSelection,authority:null}}),beforeObservation:sourceId=>sourceId==="work"?refreshWork():Promise.resolve(),humanActions:async context=>{
    const state=await openResourceBudget(budget).controls(null).inspect(),action=state.paused?"resume-dispatch":"pause-dispatch",key=state.paused?"resume-dispatch":"pause-new-dispatch";
    const native:DispatchRequest={version:"1.0",requestId:`${action}:${state.revision}`,bindingDigest:config.budgetDigest,expectedRevision:state.revision,action,targetExecutionId:null};dispatchDigests.add(dispatchRequestDigest(native));
    const hostRequest=request(context,"dispatch",native,`host-${action}:${state.revision}`);requestDigests.add(dashboardHostRequestDigest(hostRequest));
    const previous=context.observations.find(x=>x.sourceId==="work")?.checkpointId??null,refresh=request(context,"observe",{sourceId:"work",previousCheckpointId:previous,facts:context.observations.find(x=>x.sourceId==="facts")?.checkpointId?factsResultManifest:null},`refresh-work:${state.revision}:${context.tip.slice(0,12)}`);requestDigests.add(dashboardHostRequestDigest(refresh));
    const intentState=await openResourceBudget(budget).intentControls(null).inspect(),automatic=discoverDailyIntentActions(await readFile(input.declared.ledgerPath,"utf8"),intentState.selection,intentState.priorities);
    const candidates=[...proposals,...automatic].filter((p,index,all)=>all.findIndex(x=>x.key===p.key)===index).filter(p=>p.action==="reprioritize"||Boolean(input.onDeclaredWorkChanged)).slice(0,8);
-   const intents=(input.ordinary.quiescent()?candidates:[]).filter(p=>intentKey(p.fromSelection)===intentKey(intentState.selection)).map(p=>{
+   const labels=await workPresentation(declaredState);
+   const intents=await Promise.all((input.ordinary.quiescent()?candidates:[]).filter(p=>intentKey(p.fromSelection)===intentKey(intentState.selection)).map(async p=>{
     const native=intentRequest({version:"intent-request-v1",requestId:`${p.key}:${intentState.revision}`,bindingDigest:config.budgetDigest,expectedRevision:intentState.revision,expectedSelection:intentState.selection,action:p.action,events:p.events,selection:p.selection,priorities:p.priorities});dispatchDigests.add(intentRequestDigest(native));
-    const proposed=request(context,"intent",native,`host-intent:${p.key}:${intentState.revision}`);requestDigests.add(dashboardHostRequestDigest(proposed));return {key:p.key,label:p.label,request:proposed};
-   });
+    const proposed=request(context,"intent",native,`host-intent:${p.key}:${intentState.revision}`);requestDigests.add(dashboardHostRequestDigest(proposed));const outcome=p.action==="reprioritize"?labels?.obligations.find(o=>o.digest===p.priorities[0]?.obligation.digest)?.outcome:(await workSetupForSelection(input.cwd,p.selection))?.setup.outcome;
+    return {key:p.key,label:outcome?friendlyLabel(p.action==="reprioritize"?`Put ${outcome} first`:`Use ${outcome}`):p.label,request:proposed};
+   }));
    const ordinary=input.ordinary.inspect() as {revision:number;children:{target:OrdinaryTarget;state:string;abortRequested:boolean}[]},accounting=await openResourceBudget(budget).inspect(),presence=input.presence?.();
    const presentation:{key:string;label:string;request:DashboardHostRequest}[]=[];
    if(context.preparedPresentationDigest){const shown=request(context,"presented",{frameDigest:context.preparedPresentationDigest},`host-presented:${state.revision}:${context.tip.slice(0,12)}`);requestDigests.add(dashboardHostRequestDigest(shown));presentation.push({key:"acknowledge-case-cards",label:"Acknowledge these case cards are visible",request:shown});}
-   else if(presence?.present===true&&presence.closing===true&&presence.expiresAt>Date.now()&&state.paused&&accounting.active===0&&!ordinary.children.some(row=>row.state==="active")){const present=request(context,"present",{userPresent:true,closing:true,evidenceDigest:presence.evidenceDigest,dispatchRevision:state.revision},`host-present:${state.revision}:${context.tip.slice(0,12)}`);requestDigests.add(dashboardHostRequestDigest(present));presentation.push({key:"prepare-case-cards",label:"Prepare up to five retained case cards",request:present});}
+   else if((!learningConfig||learningScopeDigest(declaredState)===learningConfig.scopeDigest)&&presence?.present===true&&presence.closing===true&&presence.expiresAt>Date.now()&&state.paused&&accounting.active===0&&!ordinary.children.some(row=>row.state==="active")){const present=request(context,"present",{userPresent:true,closing:true,evidenceDigest:presence.evidenceDigest,dispatchRevision:state.revision},`host-present:${state.revision}:${context.tip.slice(0,12)}`);requestDigests.add(dashboardHostRequestDigest(present));presentation.push({key:"prepare-case-cards",label:"Prepare up to five retained case cards",request:present});}
    const cancellations=ordinary.children.filter(row=>row.state==="active"&&!row.abortRequested).sort((a,b)=>a.target.executionId.localeCompare(b.target.executionId)).slice(0,8).map(row=>{
     const native=ordinaryCancellation({version:"ordinary-cancel-v1",requestId:`cancel:${row.target.executionId.slice(5)}`,bindingDigest:input.ordinary.bindingDigest,expectedRevision:ordinary.revision,target:row.target});ordinaryDigests.add(ordinaryCancellationDigest(native));
     const cancel=request(context,"ordinary-cancel",native,`host-cancel:${row.target.executionId.slice(5)}:${ordinary.revision}`);requestDigests.add(dashboardHostRequestDigest(cancel));
-    return {key:`cancel-${row.target.executionId.replace(":","-")}-${ordinary.revision.toString(36)}`,label:`Cancel running attempt ${row.target.executionId}`,request:cancel};
+    return {key:`cancel-${row.target.executionId.replace(":","-")}-${ordinary.revision.toString(36)}`,label:`Stop active agent ${ordinary.children.filter(r=>r.state==="active").indexOf(row)+1}`,request:cancel};
    });
-   return [{key,label:state.paused?"Resume new governed dispatch":"Pause new governed dispatch; running children continue",request:hostRequest},{key:"refresh-current-work",label:reboundSnapshotId?`Capture rebound declared work; next dispatch uses ${reboundSnapshotId}`:"Capture current declared work and attempts",request:refresh},...intents,...presentation,...cancellations];
+   return [{key,label:state.paused?"Resume new work":"Pause new work (active agents continue)",request:hostRequest},{key:"refresh-current-work",label:reboundSnapshotId?"Retain current work and attempts (new scope)":"Retain current work and attempts",request:refresh},...intents,...presentation,...cancellations];
  },afterIntentApplied:async selection=>{const rebound=await rebindDeclaredWork(declaredState,selection);declaredState=rebound;workSelection=selection;reboundSnapshotId=selection.snapshot.id;await input.onDeclaredWorkChanged?.(rebound);},presence:input.presence});
  const before=await host.frame(),observeFacts=request({hostDigest:host.hostDigest,selectionDigest:before.selectionDigest,tip:before.tip},"observe",{sourceId:"facts",previousCheckpointId:null,facts:null},"observe-current-facts");requestDigests.add(dashboardHostRequestDigest(observeFacts));const factsResult=await host.action(observeFacts) as {result:{sourceManifestId:string}};factsResultManifest=factsResult.result.sourceManifestId;
  const afterFacts=await host.frame(),observeWork=request({hostDigest:host.hostDigest,selectionDigest:afterFacts.selectionDigest,tip:afterFacts.tip},"observe",{sourceId:"work",previousCheckpointId:null,facts:factsResult.result.sourceManifestId},"observe-current-work");requestDigests.add(dashboardHostRequestDigest(observeWork));await host.action(observeWork);
  const socketPath=input.socketPath??join(input.directory,"dashboard.sock"),server=await serveDashboardHost(socketPath,host);
- let closed=false;return Object.freeze({host,socketPath,directory:input.directory,async close(){if(closed)return;closed=true;await server.close();}});
+ let closed=false;const disconnect=async()=>{if(closed)return;closed=true;await server.close();};
+ return Object.freeze({host,socketPath,directory:input.directory,
+  async close(){if(closed)return;await host.stop();await disconnect();},
+  /** Final Pi owner-session disposal, never a manual host replacement or implicit resume. */
+  async endSession(){host.endSession();await disconnect();}
+ });
 }

package/src/daily-panel.ts

@@ -0,0 +1,80 @@
+import type { DailyAttempt, DailyView } from "./daily-view.ts";
+import { renderDailyDetails } from "./daily-view-render.ts";
+
+export interface WorkPresentation {
+  outcome: string;
+  obligations: { digest: string; outcome: string; agent?: string; dependencies?: string[] }[];
+}
+export interface PanelAction { key: string; label: string; operation?: string; requestDigest?: string }
+export interface PanelOptions {
+  details?: boolean;
+  presentation?: WorkPresentation | null;
+  connected?: boolean;
+  error?: string | null;
+  controls?: unknown;
+  control?: string;
+  actions?: readonly { choice: string; label: string }[];
+  learning?: string[];
+}
+export const panelText = (value: unknown): string => String(value ?? "unknown").replace(/[\p{Cc}\p{Cf}]/gu, " ").replace(/\s+/g, " ").trim();
+/** Conservative terminal-cell bound: non-ASCII glyphs take two cells; no ANSI/control bytes survive. */
+export function panelLines(lines: readonly string[], width = 80): string {
+  const columns = Number.isFinite(width) ? Math.max(12, Math.min(240, Math.floor(width))) : 80;
+  return lines.flatMap(line => {
+    let row = "", cells = 0; const rows: string[] = [];
+    for (const char of panelText(line)) {
+      const size = char.codePointAt(0)! > 127 ? 2 : 1;
+      if (cells + size > columns) { rows.push(row); row = ""; cells = 0; }
+      row += char; cells += size;
+    }
+    rows.push(row); return rows;
+  }).join("\n");
+}
+export function learningSummary(value: unknown): string[] {
+  if (!value || typeof value !== "object") return ["Not connected — /grants learning"];
+  const v=value as {state?:string;reason?:string;cases?:unknown[];comparisons?:{state?:string;reason?:string;title?:string}[];trust?:{automaticExposure?:{mode?:string;reason?:string};reason?:string}};
+  if(v.state==="deferred")return [`Deferred: ${v.reason??"evidence unavailable"}`,"/grants learning to reconnect"];
+  if(!v.cases||!v.comparisons)return ["Retained learning linked — /grants learning"];
+  const reasons=v.comparisons.map(c=>`${c.title??"Comparison"}: ${c.reason??c.state??"not ready"}`);
+  return [`${v.cases.length} case batch(es); ${v.comparisons.length} comparison(s)`,...reasons.slice(0,2),`Automatic questions: ${v.trust?.automaticExposure?.mode??"silent"} — ${v.trust?.automaticExposure?.reason??v.trust?.reason??"not configured"}`,"/grants learning opens deliberate review; not earned exposure"];
+}
+const finished = (a: DailyAttempt) => ["completed", "failed"].includes(a.intentRuntime) || a.archive?.runtime === "terminal";
+
+/** Ordinary presentation is not another source of authority. All history remains under Details. */
+export function renderDailyPanel(view: DailyView, width = 80, options: PanelOptions = {}): string {
+  const controls = options.controls as { ordinary?: { admission?: string; children?: { target: { executionId: string }; state: string; abortRequested: boolean }[] }; dispatch?: { paused?: boolean } } | undefined;
+  const live = controls?.ordinary?.children ?? [];
+  const rows = new Map(view.attempts.map(a => [a.executionId, a]));
+  const activeIds = options.connected && controls?.ordinary ? live.filter(r => r.state === "active").map(r => r.target.executionId) : view.attempts.filter(a => !finished(a)).map(a => a.executionId);
+  const complete = view.attempts.filter(finished);
+  const paused = controls?.dispatch?.paused || controls?.ordinary?.admission === "held-by-original-owner";
+  const failed=complete.filter(a=>a.intentRuntime==="failed"||a.archive?.outcome?.failed);
+  const unhealthy = options.error || options.control === "failed" || options.control === "unknown" || live.some(row=>row.state==="unknown");
+  const short=(value:string,rows=1)=>{const limit=Math.max(12,width-4)*rows;return [...panelText(value)].length>limit?[...panelText(value)].slice(0,limit-3).join("")+"...":value;};
+  const status = unhealthy || (!activeIds.length&&failed.length) ? "Needs you" : activeIds.length ? "Running" : paused ? "Waiting" : !view.obligations.length ? "Waiting" : view.obligations.every(o => o.attempts.some(id => rows.get(id) && finished(rows.get(id)!))) ? "Finished" : "Waiting";
+  const lines = ["PI-DADDY", options.presentation?.outcome ? short(options.presentation.outcome,2) : (view.scope ? "Selected work — outcome text unavailable" : "No work selected"), "", status];
+  if (unhealthy) lines.push("Control or observation needs attention. Open Details; no action was retried.");
+  else if (!activeIds.length&&failed.length) lines.push(`${failed.length} attempt(s) failed. Inspect results in /grants work.`);
+  else if (activeIds.length) lines.push(`${activeIds.length} active agent${activeIds.length === 1 ? "" : "s"}${paused ? "; new work paused" : ""}`);
+  else if (paused) lines.push("New work is paused. Running work is not cancelled by pausing.");
+  else if (status === "Finished") lines.push("Attempts finished. Review results; completion is not acceptance.");
+  else lines.push(view.obligations.length ? "Ready for an explicit run in /grants work. No automatic dispatch." : "Declare work with /grants work.");
+  for (const id of activeIds.slice(0, 8)) {
+    const a = rows.get(id), obligation = view.obligations.find(o => o.attempts.includes(id));
+    const label = options.presentation?.obligations.find(o => o.digest === obligation?.obligation.digest);
+    const original = live.find(row => row.target.executionId === id);
+    lines.push(`  ${activeIds.indexOf(id)+1}. ${label?.agent || "Agent"} — ${original?.abortRequested ? "Stopping (awaiting settlement)" : options.connected ? "Running" : "Last observed active; freshness unknown"}`,
+      `    ${short(label?.outcome || "Attempt details pending capture")}`,
+      `    ${a?.modelId || "model unknown"} / effort ${a?.effortId || "unknown"}`);
+  }
+  if (activeIds.length > 8) lines.push(`  ${activeIds.length - 8} more active agents in Details`);
+  if (complete.length) lines.push(`Finished attempts: ${complete.length} (collapsed; Details)`);
+  if (view.obligations.length > 1) lines.push(`Work: ${view.obligations.length} obligations; /grants work to select or change setup`);
+  if (!options.connected) lines.push("Snapshot only — live connection unavailable. /grants host to connect.");
+  if (view.continuity === "reconnected-gap") lines.push("Reconnected — earlier observation gap retained.");
+  if (options.learning?.length) lines.push("", "Learning", ...options.learning);
+  if (options.actions) lines.push("", "Available actions", ...(options.actions.length ? options.actions.map(a => `${a.choice}  ${short(a.label,2)}`) : ["None currently authorized"]));
+  lines.push("", "d  Details / history", "Pi coordinates work; skill-harness retains learning evidence.");
+  const summary = panelLines(lines, width);
+  return options.details ? `${summary}\n\n${panelLines([options.presentation?.outcome??"",...(options.presentation?.obligations.map(o=>o.outcome)??[])],width)}\n${renderDailyDetails(view, width)}${options.error ? `\n${panelLines([options.error], width)}` : ""}` : summary;
+}

package/src/daily-view-render.ts

@@ -1,7 +1,8 @@
 import type { DailyView } from "./daily-view.ts";
+export { renderDailyPanel as renderDailyView } from "./daily-panel.ts";
 const clean = (value: unknown) => String(value ?? "unknown").replace(/[\p{Cc}\p{Cf}]/gu, " ").replace(/\s+/g, " ").trim();
 /** Text-only, accessible labels. No command links, control actions, model calls or terminal input. */
-export function renderDailyView(view: DailyView, width = 100): string {
+export function renderDailyDetails(view: DailyView, width = 100): string {
   const lines = ["PI-DADDY — READ-ONLY DAILY VIEW", view.narrative,
     `Scope: ${view.scope ? `${view.scope.id} revision ${view.scope.revision} digest ${view.scope.digest}` : "UNRESOLVED — select an exact P01 snapshot"}`,
     `Acceptance authority: ${view.authority}; coverage: PARTIAL; freshness: SNAPSHOT / UNKNOWN`,

package/src/daily-view.ts

@@ -18,6 +18,8 @@ export interface DailyAttempt {
   executionId: string; logicalChildId: string | null; intentRuntime: string;
   archive: ArchiveExecution | null; sourceAvailability: Array<{ sha256: string; state: "available" | "missing" | "mismatch" | "error" }>;
   issues: string[]; activeBranch: null;
+  /** Observed launch configuration, not a claim about provider-internal reasoning. */
+  modelId?: string | null; effortId?: string | null;
 }
 export interface DailyObligation {
   key: string; intent: RevisionRef; obligation: RevisionRef; policy: RevisionRef;
@@ -41,6 +43,10 @@ function contextCopy(value: DailyViewOptions["workContext"]): WorkProjectionCont
   if (projectWorkLedger("", copied).errors.some(e => e.code === "WORK_CONTEXT_INVALID")) throw new TypeError("invalid independent P01 context");
   return copied;
 }
+function observedLabel(labels: readonly { modelId: string | null; effortId: string | null }[], key: "modelId" | "effortId"): string | null {
+  const values = [...new Set(labels.map(label => label[key]))];
+  return values.length === 1 ? values[0] : null;
+}
 const readers = new WeakSet<object>();
 /** Only actual factory readers may carry continuity state through the dashboard; not arbitrary callbacks. */
 export function isDailyViewReader(value: unknown): value is ReturnType<typeof createDailyViewReader> {
@@ -107,6 +113,8 @@ export function createDailyViewReader() {
     for (const attempt of work.runtime?.attempts ?? []) attempts.set(attempt.executionId, {
       executionId: attempt.executionId, logicalChildId: attempt.childId, intentRuntime: attempt.state, archive: null,
       sourceAvailability: [], issues: attempt.problems.map(p => `P01:${p.code}`), activeBranch: null,
+      ...(observedLabel(attempt.observedLabels, "modelId")!==null?{modelId:observedLabel(attempt.observedLabels,"modelId")}:{}),
+      ...(observedLabel(attempt.observedLabels, "effortId")!==null?{effortId:observedLabel(attempt.observedLabels,"effortId")}:{}),
     });
     for (const entry of archive) {
       const a = attempts.get(entry.executionId) ?? { executionId: entry.executionId, logicalChildId: null, intentRuntime: "unknown",