pi-daddy 0.26.1 → 0.27.0

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",

package/src/dashboard-cli.ts

@@ -10,6 +10,8 @@ import { parseDashboardLedger } from "./dashboard-projection.ts";
 import { renderDashboard } from "./dashboard-render.ts";
 import { createDailyViewReader, isDailyViewReader, readDailyView, type DailyViewOptions } from "./daily-view.ts";
 import { renderDailyView } from "./daily-view-render.ts";
+import { renderDailyPanel, panelLines, learningSummary, type PanelAction, type WorkPresentation } from "./daily-panel.ts";
+import { createDashboardMenu } from "./dashboard-menu.ts";
 import { projectWorkLedger, type WorkProjectionContext } from "./work-ledger.ts";
 import { parseRetentionJson } from "./retention-json.ts";
 import { createInterface } from "node:readline";
@@ -49,6 +51,7 @@ export interface DashboardFrameOptions {
   debrief?: DebriefPresenter;
   debriefJson?: boolean;
   connected?: DashboardConnection;
+  actionMenu?: ReturnType<typeof createDashboardMenu>;
 }
 export async function dashboardHostAction(host:DashboardConnection,line:string){
   if(!isDashboardConnection(host)||Buffer.byteLength(line)>60000)throw Error("genuine bounded dashboard connection required");
@@ -60,10 +63,10 @@ export async function dashboardHostAction(host:DashboardConnection,line:string){
 
 /** A fulfilled host call is not necessarily an applied native effect; keep those facts distinct in the UI. */
 export function dashboardActionFeedback(command:string,outcome:unknown):string{
-  const value=outcome&&typeof outcome==="object"?outcome as {state?:unknown;result?:unknown}:{};
+  const value=outcome&&typeof outcome==="object"?outcome as {state?:unknown;result?:unknown;error?:unknown;reason?:unknown}:{};
   const state=typeof value.state==="string"?value.state:"unrecognised host response";
   if(state==="failed-or-unknown"||state==="readback-only")return `NO ACTION CLAIM: ${command} returned ${state}; inspect/reconcile explicitly.`;
-  if(state!=="acknowledged")return `NOT APPLIED: ${command} returned ${state}.`;
+  if(state!=="acknowledged")return `NOT APPLIED: ${command} returned ${state}.${typeof (value.error??value.reason)==="string"?` ${String(value.error??value.reason).slice(0,1024)}`:""}`;
   const result=value.result&&typeof value.result==="object"?value.result as {application?:unknown}:null;
   // A retained records[] snapshot has no outer dashboard request correlation. Never select an old receipt.
   const nativeApplication=typeof result?.application==="string"?result.application:undefined;
@@ -110,15 +113,14 @@ export async function dashboardFrame(options: DashboardFrameOptions): Promise<st
   if(options.connected){
     if(!isDashboardConnection(options.connected))throw Error("original dashboard connection required");
     let view:Awaited<ReturnType<DashboardConnection["frame"]>>;
-    try{view=await options.connected.frame();}catch(error){return `PI-DADDY — CONNECTED HOST ERROR\n${error instanceof Error ? error.message : String(error)}\nNo prior acceptance, presentation or continuity substituted. No action retried.`;}
+    try{view=await options.connected.frame();}catch(error){options.actionMenu?.clear();return panelLines(["PI-DADDY — Disconnected", "The original host is unavailable. No action was retried.", "Return to Pi: /grants host, then /grants dashboard.", ...(options.details?[String(error)]:[])],options.width);}
     if(options.dailyJson||options.debriefJson)return JSON.stringify(view);
     const source=view.source as {daily?:Parameters<typeof renderDailyView>[0]}|null;
-    const actions=(view.actions as {key:string;label:string}[]|undefined)??[];
-    const hostError=typeof view.error==="string"&&view.error?`HOST ERROR — ${view.error}`:null;
-    return ["PI-DADDY — CONNECTED HOST (snapshot; identity/acceptance not authenticated)",hostError,source?.daily?renderDailyView(source.daily,options.width):"Source unavailable; no previous acceptance substituted.",
-      view.debrief?renderDebrief(view.debrief as Parameters<typeof renderDebrief>[0],options.width):"Debrief deferred/closed. No implicit presentation or steering.",
-      `Host control ${view.control}; acknowledgement ${view.acknowledgement}. Attention reserved ${view.attention.attentionUsed}/5 (not proof of delivery). Tip ${view.tip}.`,
-      actions.length?`ACTIONS — type one command and Enter\n${actions.map(action=>`  ${action.key} — ${action.label}`).join("\n")}`:"ACTIONS — none currently authorized; refresh never acts."].filter((line):line is string=>Boolean(line)).join("\n\n");
+    const actions=(view.actions as PanelAction[]|undefined)??[];
+    const menu=(options.actionMenu??createDashboardMenu()).show(view.tip,actions);
+    const learning=view.debrief?["Retained review open below"]:learningSummary(view.learning);
+    const summary=source?.daily?renderDailyPanel(source.daily,options.width,{details:options.details,connected:true,presentation:view.presentation as WorkPresentation|null,error:view.error,controls:view.controls,control:view.control,actions:menu,learning}):panelLines(["PI-DADDY — Needs you","Work observation unavailable. Capture current work or open Details.",...menu.map(a=>`${a.choice}  ${a.label}`)],options.width);
+    return [summary,view.debrief?renderDebrief(view.debrief as Parameters<typeof renderDebrief>[0],options.width):"",options.details?panelLines([`Host control ${view.control}; acknowledgement ${view.acknowledgement}. Attention reserved ${view.attention.attentionUsed}/5. Tip ${view.tip}.`,JSON.stringify(view.controls),JSON.stringify(view.learning),...actions.map(a=>`${a.key} — ${a.label}`)],options.width):""].filter(Boolean).join("\n\n");
   }
   if (options.debrief || options.debriefJson) {
     if (!isDebriefPresenter(options.debrief)) return "PI-DADDY — DEBRIEF UNAVAILABLE: genuine presenter/host missing";
@@ -128,7 +130,7 @@ export async function dashboardFrame(options: DashboardFrameOptions): Promise<st
     try {
       if (options.dailyReader !== undefined && !isDailyViewReader(options.dailyReader)) throw new TypeError("untrusted daily reader callback");
       const view = await (options.dailyReader ?? readDailyView)(options.dailyView);
-      return options.dailyJson ? JSON.stringify(view) : renderDailyView(view, options.width);
+      return options.dailyJson ? JSON.stringify(view) : renderDailyPanel(view, options.width, { details: options.details });
     } catch {
       return "PI-DADDY — DAILY VIEW UNAVAILABLE\nInvalid or unavailable read-only input. No previous acceptance or continuity was substituted.";
     }
@@ -227,6 +229,8 @@ export async function runDashboard(argv = process.argv.slice(2), env: NodeJS.Pro
     if (!host.debrief) await debrief.open({ mode: "manual", userPresent: true }); // Explicit CLI fixture only; never override a host deferral.
   }
   const dailyReader = createDailyViewReader();
+  const actionMenu=createDashboardMenu();
+  let details=cli.details;
   let previous = "";
   let feedback = "";
   let input: ReturnType<typeof createInterface> | null = null;
@@ -237,13 +241,13 @@ export async function runDashboard(argv = process.argv.slice(2), env: NodeJS.Pro
       protocol,
       color: cli.color,
       width: process.stdout.columns || 80,
-      details: cli.details,
+      details, actionMenu,
       dailyView, dailyReader, dailyJson: cli.dailyJson, debrief, debriefJson: cli.debriefJson, connected,
     });
-    const rendered = feedback ? `${frame}\n\n${feedback}` : frame;
+    const rendered = feedback ? `${panelLines([feedback], process.stdout.columns || 80)}\n\n${frame}` : frame;
     if (rendered === previous && !clear) return;
     previous = rendered;
-    const prompt = "COMMAND — type an exact listed key, then Enter (refresh never acts): ";
+    const prompt = "Action number / d Details, then Enter: ";
     const draft = input?.line ?? "";
     process.stdout.write(clear ? `\u001b]0;PI-DADDY\u0007\u001b[2J\u001b[H${rendered}\n\n${input ? prompt + draft : ""}` : `${rendered}\n`);
     if (input) input.setPrompt(prompt);
@@ -253,7 +257,7 @@ export async function runDashboard(argv = process.argv.slice(2), env: NodeJS.Pro
     await draw(false);
     return;
   }
-  input = debrief || connected ? createInterface({ input: process.stdin, output: process.stdout, terminal: true }) : null;
+  input = createInterface({ input: process.stdin, output: process.stdout, terminal: Boolean(process.stdin.isTTY) });
   await draw(true);
   let drawing = false;
   const redraw = (): void => {
@@ -264,10 +268,18 @@ export async function runDashboard(argv = process.argv.slice(2), env: NodeJS.Pro
   let acting = false;
   input?.on("line", line => {
     if (acting) return; // never replay a line typed while the prior exact command is still settling.
+    if(line.trim().toLowerCase()==="d"){details=!details;redraw();return;}
     acting = true;
-    feedback = `COMMAND ${line.trim() || "(empty)"} — applying the displayed exact request…`;
-    void (connected?dashboardHostAction(connected,line):debriefAction(debrief!, line)).then(outcome => {
-      feedback = connected ? dashboardActionFeedback(line.trim() || "command", outcome) : `ACKNOWLEDGED: ${line.trim() || "command"}. Refreshed state is shown below.`;
+    let label=line.trim()||"(empty)";
+    const act=async()=>{
+      if(connected&&/^\d+$/.test(line.trim())){const selected=actionMenu.select(line.trim());label=selected.label;return connected.humanAction(selected.key,{tip:selected.tip,requestDigest:selected.requestDigest});}
+      if(connected)return dashboardHostAction(connected,line);
+      if(debrief)return debriefAction(debrief,line);
+      throw Error("Read-only snapshot; no controls connected");
+    };
+    feedback = `Action ${label} — awaiting acknowledgement…`;
+    void act().then(outcome => {
+      feedback = connected ? dashboardActionFeedback(label, outcome) : `ACKNOWLEDGED: ${label}. Refreshed state is shown below.`;
     }).catch(error => {
       feedback = `REJECTED: ${error instanceof Error ? error.message : String(error)}. No command was retried; inspect the refreshed offered keys.`;
     }).finally(() => { acting = false; redraw(); });

package/src/dashboard-host-contract.ts

@@ -32,6 +32,8 @@ export interface DashboardHostConfig {
   budgetDigest: string; experimentDigest: string | null; harnessArtifactDigest: string;
   ordinaryDigest?: string;
   learningLifecycleId?: string;
+  /** Explicit host journal, while reusing the original trust store/attention across host lifetimes. */
+  journalDirectory?: string;
 }
 export interface DashboardHostRequest { version: "1.0"; requestId: string; hostDigest: string; expectedTip: string; selectionDigest: string; operation: "observe" | "present" | "presented" | "defer" | "debrief" | "dispatch" | "intent" | "cancel" | "dispatch-reconcile" | "intent-reconcile" | "ordinary-cancel"; payload: unknown }
 export interface DashboardHostAuthority {

package/src/dashboard-host-transport.ts

@@ -13,10 +13,13 @@ export async function serveDashboardHost(path:string,host:DashboardHost){
   if(!isDashboardHost(host))throw Error("original dashboard host required");await parent(path);const clients=new Set<Socket>(),tasks=new Set<Promise<void>>();
   const server=createServer(socket=>{if(clients.size>=4){socket.destroy();return;}clients.add(socket);socket.on("close",()=>clients.delete(socket));socket.on("error",()=>{});socket.setTimeout(5000,()=>socket.destroy());let size=0,used=false;const chunks:Buffer[]=[];
     socket.on("data",bytes=>{if(used)return;size+=bytes.length;if(size>65536){socket.destroy();return;}chunks.push(bytes);if(bytes.at(-1)!==10)return;used=true;
-      const task=(async()=>{try{const text=new TextDecoder("utf-8",{fatal:true}).decode(Buffer.concat(chunks));const r=parseRetentionJson(text,65536) as {operation:string;request?:DashboardHostRequest;key?:string};let result:unknown;
+      const task=(async()=>{try{const text=new TextDecoder("utf-8",{fatal:true}).decode(Buffer.concat(chunks));const r=parseRetentionJson(text,65536) as {operation:string;request?:DashboardHostRequest;key?:string;expected?:{tip:string;requestDigest:string}};let result:unknown;
         if(Object.keys(r).join()==="operation"&&r.operation==="frame")result=await host.frame();
         else if(Object.keys(r).sort().join()==="operation,request"&&r.operation==="action")result=await host.action(dashboardHostRequest(r.request!));
-        else if(Object.keys(r).sort().join()==="key,operation"&&r.operation==="human-action"&&typeof r.key==="string")result=await host.humanAction(r.key);
+        else if(["key,operation","expected,key,operation"].includes(Object.keys(r).sort().join())&&r.operation==="human-action"&&typeof r.key==="string"){
+          if(r.expected&&(!/^[a-f0-9]{64}$/.test(r.expected.tip)||!/^[a-f0-9]{64}$/.test(r.expected.requestDigest)||Object.keys(r.expected).sort().join()!=="requestDigest,tip"))throw Error("exact displayed action required");
+          result=await host.humanAction(r.key,r.expected);
+        }
         else throw Error("closed dashboard protocol required");
         const output=JSON.stringify({ok:true,result})+"\n";if(Buffer.byteLength(output)>512*1024)throw Error("dashboard frame bound exceeded");socket.end(output);
       }catch{socket.end(JSON.stringify({ok:false,error:"refused or acknowledgement unknown; explicit readback only"})+"\n");}})();tasks.add(task);void task.finally(()=>tasks.delete(task));
@@ -28,7 +31,7 @@ export async function serveDashboardHost(path:string,host:DashboardHost){
 }
 /** Explicit operator-selected endpoint. Socket ownership is access policy, not module/human authentication. */
 export function connectDashboardHost(path:string):DashboardConnection{
-  const call=async(operation:string,payload:{request?:DashboardHostRequest;key?:string}={})=>{await parent(path);const s=await lstat(path);if(!s.isSocket()||s.mode&0o077||s.uid!==process.getuid?.())throw Error("private original dashboard endpoint unavailable");
+  const call=async(operation:string,payload:{request?:DashboardHostRequest;key?:string;expected?:{tip:string;requestDigest:string}}={})=>{await parent(path);const s=await lstat(path);if(!s.isSocket()||s.mode&0o077||s.uid!==process.getuid?.())throw Error("private original dashboard endpoint unavailable");
     return new Promise<any>((resolve,reject)=>{const socket=createConnection(path);let size=0,done=false;const chunks:Buffer[]=[];const fail=(e:unknown)=>{if(!done){done=true;socket.destroy();reject(e);}};
       socket.setTimeout(5000,()=>fail(Error("dashboard acknowledgement timeout; do not repeat action")));socket.on("error",fail);socket.on("connect",()=>socket.write(JSON.stringify({operation,...payload})+"\n"));
       socket.on("data",b=>{size+=b.length;if(size>512*1024){fail(Error("dashboard frame limit"));return;}chunks.push(b);});
@@ -36,5 +39,5 @@ export function connectDashboardHost(path:string):DashboardConnection{
       socket.on("close",()=>{if(!done)fail(Error("dashboard disconnected; acknowledgement unknown"));});
     });
   };
-  const api={frame:()=>call("frame"),action:(r:DashboardHostRequest)=>call("action",{request:dashboardHostRequest(r)}),humanAction:(key:string)=>call("human-action",{key})};connections.add(api);return Object.freeze(api);
+  const api={frame:()=>call("frame"),action:(r:DashboardHostRequest)=>call("action",{request:dashboardHostRequest(r)}),humanAction:(key:string,expected?:{tip:string;requestDigest:string})=>call("human-action",{key,...(expected?{expected}:{})})};connections.add(api);return Object.freeze(api);
 }

package/src/dashboard-host.ts

@@ -1,3 +1,4 @@
+import type { WorkPresentation } from "./daily-panel.ts";
 import { isOrdinaryChildren, holdOrdinaryDispatch, type OrdinaryChildren, type OrdinaryCancellation } from "./ordinary-children.ts";
 import { loadedDashboardHarnessDigest } from "./dashboard-harness.ts";
 import { join, isAbsolute } from "node:path";
@@ -22,6 +23,11 @@ export type DashboardHost=ReturnType<typeof openDashboardHost>;
 export interface DashboardHostOptions { ordinary?:OrdinaryChildren; harness:DashboardHarness; config:DashboardHostConfig; budget:GovernedBudgetBinding; experiment?:ReturnType<typeof openExperiment>; authority:()=>DashboardHostAuthority|null;
   /** Exact actions constructed and authorized by the owner; the dashboard exposes only human labels/keys. */
   humanActions?:(context:{hostDigest:string;selectionDigest:string;tip:string;observations:readonly {sourceId:string;checkpointId:string}[];preparedPresentationDigest:string|null})=>readonly {key:string;label:string;request:DashboardHostRequest}[]|Promise<readonly {key:string;label:string;request:DashboardHostRequest}[]>;
+  /** Read-only, digest-bound local outcome labels. Never grants acceptance or control. */
+  presentation?: () => WorkPresentation | null | Promise<WorkPresentation | null>;
+  currentWork?: () => Promise<import("./daily-view.ts").DailyView>;
+  learningView?: () => unknown;
+  afterObservation?: (observation: import("./dashboard-observation.ts").DashboardObservation) => void;
   /** Explicit approved observation effect only; refresh/frame never invokes it. */
   beforeObservation?:(sourceId:string)=>Promise<void>;
   /** Owner callback after the exact intent journal reports applied; failure keeps host acknowledgement unknown. */
@@ -30,7 +36,8 @@ export interface DashboardHostOptions { ordinary?:OrdinaryChildren; harness:Dash
   presence?:()=>{present:boolean;closing:boolean;evidenceDigest:string;expiresAt:number}|null;
 }
 function configuration(input:DashboardHostConfig){
-  const c=detached(input);controlShape(c,["version","trustDirectory","trustPolicyId","archiveRoot","scope","author","policyPath","policySha256","sources","selection","cases","blind","budgetDigest","experimentDigest","harnessArtifactDigest",...(Object.hasOwn(c,"ordinaryDigest")?["ordinaryDigest"]:[]),...(Object.hasOwn(c,"learningLifecycleId")?["learningLifecycleId"]:[])]);
+  const c=detached(input);controlShape(c,["version","trustDirectory","trustPolicyId","archiveRoot","scope","author","policyPath","policySha256","sources","selection","cases","blind","budgetDigest","experimentDigest","harnessArtifactDigest",...(Object.hasOwn(c,"ordinaryDigest")?["ordinaryDigest"]:[]),...(Object.hasOwn(c,"learningLifecycleId")?["learningLifecycleId"]:[]),...(Object.hasOwn(c,"journalDirectory")?["journalDirectory"]:[])]);
+  if(c.journalDirectory!==undefined&&(typeof c.journalDirectory!=="string"||!isAbsolute(c.journalDirectory)))throw Error("explicit host journal directory required");
   if(Object.hasOwn(c,"ordinaryDigest")&&!sha(c.ordinaryDigest))throw Error("invalid ordinary binding digest");
   if(Object.hasOwn(c,"learningLifecycleId")&&!sha(c.learningLifecycleId))throw Error("invalid learning lifecycle manifest");
   if(c.version!=="producer-dashboard-host-v1"||![c.trustDirectory,c.archiveRoot,c.policyPath].every(p=>typeof p==="string"&&isAbsolute(p))||![c.trustPolicyId,c.policySha256,c.budgetDigest,c.harnessArtifactDigest].every(sha)||!(c.experimentDigest===null||sha(c.experimentDigest))||typeof c.scope!=="string"||!c.scope||c.scope.length>128||typeof c.author!=="string"||!c.author||c.author.length>256||!Array.isArray(c.sources)||c.sources.length<1||c.sources.length>32||new Set(c.sources.map(s=>s.id)).size!==c.sources.length||c.sources.filter(s=>s.kind==="work").length>1||c.sources.some(s=>!/^[a-zA-Z0-9:_-]{1,128}$/.test(s.id)||!["work","retention","facts"].includes(s.kind)))throw Error("invalid explicit dashboard host binding");
@@ -43,7 +50,7 @@ export function createDashboardHost(options:DashboardHostOptions){
   if(!a?.hostDigests.includes(dashboardHostDigest(c)))throw Error("independent exact host authority required");
   const trust=h.openTrustLifecycle(c.trustDirectory),view=trust.inspect(Date.now());
   if(view.policyId!==c.trustPolicyId)throw Error("trust policy changed");
-  h.learningJournal(join(c.trustDirectory,"producer-host"),{type:"producer-host-initial",config:c});
+  h.learningJournal(c.journalDirectory??join(c.trustDirectory,"producer-host"),{type:"producer-host-initial",config:c});
   return openDashboardHost(options);
 }
 /** Existing native writers + original controllers; no model, launch, authority-file loader or PID recovery. */
@@ -53,7 +60,7 @@ export function openDashboardHost(options:DashboardHostOptions){
   const budget=openResourceBudget(options.budget),experiment=options.experiment,ordinary=options.ordinary;
   if(ordinary&&(!isOrdinaryChildren(ordinary)||ordinary.bindingDigest!==c.ordinaryDigest))throw Error("original ordinary controller binding required");
   if(resourceBindingDigest(budget.binding)!==c.budgetDigest||experiment&&(!isExperimentController(experiment)||experimentBindingDigest(experiment.binding)!==c.experimentDigest))throw Error("original controller binding required");
-  const trust=h.openTrustLifecycle(c.trustDirectory),journal=h.learningJournal(join(c.trustDirectory,"producer-host"));
+  const trust=h.openTrustLifecycle(c.trustDirectory),journal=h.learningJournal(c.journalDirectory??join(c.trustDirectory,"producer-host"));
   const initial=journal.read()[0].value;
   if(initial.type!=="producer-host-initial"||dataDigest(initial.config)!==hostDigest)throw Error("host store binding changed; no new budget");
   const trustInput=trust.history()[0].value.input as {archiveRoot:string;component:unknown;exposure:{attentionRemaining:number}|null};
@@ -62,7 +69,7 @@ export function openDashboardHost(options:DashboardHostOptions){
   const observation=dashboardObservations(h,c,journal.read),history=()=>journal.read();
   const append=(value:Record<string,unknown>)=>journal.append(history().at(-1)!.id,value);
   const saved=():DebriefCheckpoint|null=>{const rows=history().filter(e=>e.value.type==="checkpoint");return rows.length?detached(rows.at(-1)!.value.checkpoint) as DebriefCheckpoint:null;};
-  let presenter:DebriefPresenter|undefined,busy=false,poisoned=false,presentationRevision:number|null=null,presenceDigest:string|null=null,attentionDeferred:string|null=null,presentationAcknowledged=false;
+  let presenter:DebriefPresenter|undefined,busy=false,poisoned=false,stopped=false,presentationRevision:number|null=null,presenceDigest:string|null=null,attentionDeferred:string|null=null,presentationAcknowledged=false;
   const ordinaryDispatchHoldKey=dataDigest({hostDigest,control:"pause-new-ordinary-dispatch"});
   // A host frame is a read-only snapshot: ordinary children may attach or settle without advancing this journal.
   // Within one tip, a key keeps its first exact request; humanAction revalidates it against current native authority.
@@ -88,39 +95,60 @@ export function openDashboardHost(options:DashboardHostOptions){
       return {key:x.key,label:x.label,operation:request.operation,request};});
   };
   const api={hostDigest,selectionDigest,
+    /** Same owner gate as action: checking stop cannot race a newly admitted effect. Never releases a hold. */
+    async stop(){
+      if(stopped)return;if(busy)throw Error("Cannot stop: dashboard operation busy; wait for its acknowledgement first");busy=true;
+      try{
+        const rows=history();
+        if(poisoned||rows.some(e=>e.value.type==="host-failure")||rows.some(e=>e.value.type==="claim"&&!rows.some(r=>r.value.type==="result"&&r.value.requestId===e.value.requestId)))throw Error("Cannot stop: acknowledgement unknown; retain this original host for readback. Do not repeat effects. Ending the whole Pi session does not reconcile or release this hold.");
+        if(c.ordinaryDigest&&!ordinary)throw Error("Cannot stop: original ordinary boundary unavailable; no recovery");
+        const dispatch=await budget.controls(null).inspect();
+        if(dispatch.admission==="blocked-pending")throw Error("Cannot stop: pending original control requires explicit reconciliation, then resume before stopping");
+        if(dispatch.paused||ordinary&&(ordinary.inspect() as {admission:string}).admission!=="open")throw Error("Cannot stop: resume new work in the original dashboard first. Any pending intent also needs its original reconciliation; no hold was released.");
+        stopped=true;presenter?.close();presentationRevision=null;
+      }finally{busy=false;}
+    },
+    /** Final owner-session disposal only, not /grants host stop. Disconnects without resolving/releasing any control. */
+    endSession(){stopped=true;presenter?.close();presentationRevision=null;},
     async frame(){
       const rows=history(),tip=rows.at(-1)!.id,a=authority();let source:unknown=null,error:string|null=null;
       let selection=c.selection,selectionState="current-control-snapshot";
       try{selection=await currentSelection();}catch(e){error=String(e);selectionState="unavailable-host-declaration-only";}
-      try{source=await observation.view(selectionState==="current-control-snapshot"?a:null,selection);}catch(e){error=String(e);}
+      try{source=await observation.view(selectionState==="current-control-snapshot"?a:null,selection);
+        if(options.currentWork)source={...(source as object),daily:await options.currentWork()};
+      }catch(e){error=String(e);}
       let debrief:unknown=null;
       if(a&&presenter&&presentationRevision!==null&&presence()?.evidenceDigest===presenceDigest){try{await paused(presentationRevision);debrief=presenter.view();}catch{debrief=null;}}
       let controls:unknown=null;try{controls=await nativeRead();}catch(e){error=String(e);}
       let learning:unknown=null;if(c.learningLifecycleId)try{learning=h.readLearningLifecycle(c.archiveRoot,c.learningLifecycleId);}catch(e){error=String(e);}
-      const attention=trust.inspect(Date.now());let actions:{key:string;label:string;operation:string}[]=[];
+      let presentation:WorkPresentation|null=null;try{presentation=await options.presentation?.()??null;}catch(e){error=String(e);}
+      if(options.learningView)try{learning=options.learningView();}catch(e){learning={state:"deferred",reason:String(e)};}
+      const attention=trust.inspect(Date.now());let actions:{key:string;label:string;operation:string;requestDigest:string}[]=[];
       try{const available=await availableHumanActions();
         // A frame that completed after its captured tip is stale and cannot replace a newer display generation.
-        if(history().at(-1)!.id===tip){
+        if(!stopped&&history().at(-1)!.id===tip){
           if(!displayedActions||displayedActions.tip!==tip)displayedActions={tip,actions:new Map()};
           const additions=available.filter(action=>!displayedActions!.actions.has(action.key));
           if(displayedActions.actions.size+additions.length>MAX_DISPLAYED_ACTIONS_PER_TIP)throw Error("displayed dashboard action capacity exhausted");
           const shown=available.filter(action=>{const prior=displayedActions!.actions.get(action.key);
             if(prior&&dashboardHostRequestDigest(prior.request)!==dashboardHostRequestDigest(action.request))return false;
             if(!prior)displayedActions!.actions.set(action.key,action);return true;});
-          actions=shown.map(({key,label,operation})=>({key,label,operation}));
+          actions=shown.map(({key,label,operation,request})=>({key,label,operation,requestDigest:dashboardHostRequestDigest(request)}));
         }}catch(e){error=String(e);}
-      return freeze(detached({version:"producer-dashboard-frame-v1",hostDigest,selectionDigest:dashboardSelectionDigest(selection),selectionState,tip,source,controls,learning,debrief,attention,error,actions,
+      return freeze(detached({version:"producer-dashboard-frame-v1",hostDigest,selectionDigest:dashboardSelectionDigest(selection),selectionState,tip,source,controls,learning,debrief,attention,error,actions,presentation,
         requests:rows.filter(e=>["claim","result","presentation","defer","ordinary-intent-pending"].includes(String(e.value.type))).map(e=>e.value),
         control:rows.some(e=>e.value.type==="host-failure")?"failed":rows.some(e=>e.value.type==="claim"&&!rows.some(r=>r.value.type==="result"&&r.value.requestId===e.value.requestId))?"unknown":"not-assessed",
         acknowledgement:poisoned?"unknown":"readback-only",identity:"independently-declared-host; not human/module authentication",activeBranch:null,acceptance:"not-assessed",freshness:"snapshot-unknown",workerInteractions:0}));
     },
     /** Explicit reconciliation is read-only. A retained claim is never replayed as an effect. */
     reconcile:()=>api.frame(),
-    async humanAction(key:string){const tip=history().at(-1)!.id;if(!displayedActions||displayedActions.tip!==tip)throw Error("dashboard actions must be displayed at the current tip");
+    async humanAction(key:string,expected?:{tip:string;requestDigest:string}){const tip=history().at(-1)!.id;if(expected&&expected.tip!==tip)throw Error("displayed action is stale; select again");if(!displayedActions||displayedActions.tip!==tip)throw Error("dashboard actions must be displayed at the current tip");
       const found=displayedActions.actions.get(key);if(!found)throw Error(`unknown dashboard action ${JSON.stringify(key)}`);
+      if(expected&&dashboardHostRequestDigest(found.request)!==expected.requestDigest)throw Error("displayed action identity changed; no effect attempted");
       const current=(await availableHumanActions()).find(action=>action.key===key);if(!current||current.label!==found.label||dashboardHostRequestDigest(current.request)!==dashboardHostRequestDigest(found.request))throw Error("displayed dashboard action changed; no effect attempted");return api.action(found.request);},
     async action(input:DashboardHostRequest){
       const request=dashboardHostRequest(input),digest=dashboardHostRequestDigest(request);
+      if(stopped)throw Error("dashboard host stopped; no effect attempted");
       if(busy||poisoned)throw Error("dashboard operation busy or acknowledgement unknown");busy=true;let attempted=false;
       try{
         const rows=history(),old=rows.find(e=>e.value.type==="claim"&&e.value.requestId===request.requestId);
@@ -135,7 +163,7 @@ export function openDashboardHost(options:DashboardHostOptions){
         try{
           if(request.operation==="observe"){
             const sourceId=(request.payload as {sourceId?:unknown})?.sourceId;if(typeof sourceId!=="string")throw Error("exact observation source required");await options.beforeObservation?.(sourceId);
-            const captured=observation.observe(request.payload,a!,selection);append({type:"observation",observation:captured});result=captured;
+            const captured=observation.observe(request.payload,a!,selection);append({type:"observation",observation:captured});options.afterObservation?.(captured);result=captured;
           }else if(request.operation==="present"){
             const p=detached(request.payload) as {userPresent:boolean;closing:boolean;evidenceDigest:string;dispatchRevision:number};
             if(Object.keys(p).sort().join()!=="closing,dispatchRevision,evidenceDigest,userPresent"||!sha(p.evidenceDigest)||typeof p.userPresent!=="boolean"||typeof p.closing!=="boolean"||!Number.isSafeInteger(p.dispatchRevision))throw Error("explicit presence/boundary evidence required");
@@ -165,8 +193,10 @@ export function openDashboardHost(options:DashboardHostOptions){
               const port=budget.controls(a!.dispatch),ordinaryHold=ordinary&&["pause-dispatch","resume-dispatch"].includes(native.action)?holdOrdinaryDispatch(ordinary,ordinaryDispatchHoldKey):undefined;
               if(request.operation==="dispatch-reconcile"&&(await port.inspect()).records.find(r=>r.request.requestId===native.requestId)?.digest!==dispatchRequestDigest(native))throw Error("exact original dispatch reconciliation required");
               result=request.operation==="dispatch"?await port.request(native):await port.reconcile(native.requestId);
-              const record=(result as {records:{request:{requestId:string};decision:string;application:string}[]}).records.find(r=>r.request.requestId===native.requestId);
-              if(ordinaryHold&&(record?.decision!=="approved"||native.action==="resume-dispatch"&&record.application==="applied"))ordinaryHold.release();
+              const snapshot=result as import("./dispatch-control.ts").DispatchSnapshot,record=snapshot.records.find(r=>r.request.requestId===native.requestId);
+              if(!record)throw Error("native dispatch application acknowledgement unavailable");
+              // A denied resume must not undo an earlier pause/pending control. Release only after final host sync.
+              if(ordinaryHold&&(native.action==="resume-dispatch"&&record.decision==="approved"&&record.application==="applied"||record.application==="not-applied"&&snapshot.admission==="enabled"))releaseOrdinary=ordinaryHold.release;
             }else if(request.operation==="intent"||request.operation==="intent-reconcile"){
               const native=detached(intentRequest(request.payload as IntentRequest)) as IntentRequest,port=budget.intentControls(a!.dispatch),digest=intentRequestDigest(native);
               if(c.ordinaryDigest&&!ordinary)throw Error("original ordinary boundary unavailable; no recovery");
@@ -202,6 +232,11 @@ export function openDashboardHost(options:DashboardHostOptions){
             }else throw Error("unsupported dashboard operation");
           }
         }catch(error){presenter?.close();presentationRevision=null;append({type:"result",requestId:request.requestId,state:"failed-or-unknown",reason:String(error)});throw error;}
+        if(["dispatch","dispatch-reconcile","intent","intent-reconcile"].includes(request.operation)&&result&&typeof result==="object"){
+          const snapshot=result as {records?:{requestId?:string;request?:{requestId:string};application?:string}[]},nativeId=(request.payload as {requestId:string}).requestId;
+          const applied=snapshot.records?.find(r=>(r.requestId??r.request?.requestId)===nativeId);
+          if(applied?.application)result={...result,application:applied.application,nativeRequestId:nativeId};
+        }
         append({type:"result",requestId:request.requestId,state:"acknowledged",resultDigest:dataDigest(result??null)});releaseOrdinary?.();return {state:"acknowledged",result};
       }catch(error){if(attempted){poisoned=true;try{if(history().some(e=>e.value.type==="claim"&&e.value.requestId===request.requestId))append({type:"host-failure",requestId:request.requestId,reason:String(error)});}catch{/* Failure recording also unacknowledged; no claim of no effects. */}}throw error;}finally{busy=false;}
     }