pi-daddy 0.26.1 → 0.27.1

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;}
     }

package/src/dashboard-menu.ts

@@ -0,0 +1,28 @@
+import type { PanelAction } from "./daily-panel.ts";
+/** Numbers never acquire another meaning during repaint, including after a new journal tip. */
+export function createDashboardMenu() {
+  const ids = new Map<string, string>();
+  const choices = new Map<string, { key: string; tip: string; requestDigest: string; label: string }>();
+  let current = new Set<string>();
+  return {
+    show(tip: string, actions: readonly PanelAction[]) {
+      current = new Set();
+      return actions.map(action => {
+        if (!action.requestDigest) return { choice: action.key, label: action.label };
+        const identity = JSON.stringify([tip, action.key, action.requestDigest, action.label]);
+        let choice = ids.get(identity);
+        if (!choice) {
+          if (ids.size >= 32768) throw Error("Action menu capacity reached; reopen the panel. No choice was remapped.");
+          choice = String(ids.size + 1); ids.set(identity, choice);
+          choices.set(choice, { key: action.key, tip, requestDigest: action.requestDigest, label: action.label });
+        }
+        current.add(choice); return { choice, label: action.label };
+      });
+    },
+    select(choice: string) {
+      if (!current.has(choice)) throw Error("That action is no longer displayed; select a current number.");
+      return choices.get(choice)!;
+    },
+    clear() { current.clear(); },
+  };
+}

package/src/definitions.ts

@@ -20,9 +20,8 @@
  */
 
 import { createHash } from "node:crypto";
-import { readFile, readdir } from "node:fs/promises";
-import { join } from "node:path";
-import { skillDirs } from "./catalog.ts";
+import { readFile } from "node:fs/promises";
+import { resolveSkillResources, skillResourceName } from "./skill-resources.ts";
 import { CAPABILITY_NAMESPACE_PREFIXES } from "./capabilities.ts";
 import type { Capability } from "./resolve.ts";
 
@@ -133,6 +132,11 @@ export function parseSkillDefinition(source: string, text: string): SkillDefinit
       continue;
     }
 
+    // A YAML collection/block we cannot parse is not an explicit empty ceiling.
+    if (key === "allowed-tools" && value === "") {
+      const nextValue = lines.slice(i + 1).find(line => line.trim() !== "" && !/^\s*#/.test(line));
+      if (/^\s+\S/.test(nextValue ?? "")) continue;
+    }
     fields.set(key, value);
   }
 
@@ -144,7 +148,7 @@ export function parseSkillDefinition(source: string, text: string): SkillDefinit
     // skills by their directory, so trusting a frontmatter `name` lets our view and the loader's
     // disagree about which file a name refers to. The spec requires `name` to match the parent
     // directory anyway, so a mismatch is the file's defect and not something to honour.
-    name: nameFromPath(source),
+    name: skillResourceName(source),
     description,
     allowedTools: fields.get("allowed-tools"),
     metadata: Object.keys(metadata).length > 0 ? metadata : undefined,
@@ -153,14 +157,6 @@ export function parseSkillDefinition(source: string, text: string): SkillDefinit
   };
 }
 
-/** `/skills/review/SKILL.md` -> `review`; `/skills/triage.md` -> `triage`. */
-function nameFromPath(source: string): string {
-  const parts = source.split("/").filter((p) => p.length > 0);
-  const last = parts.at(-1) ?? "";
-  if (last.toLowerCase() === "skill.md") return parts.at(-2) ?? "";
-  return last.replace(/\.md$/i, "");
-}
-
 /**
  * Turn a definition's `allowed-tools` into a capability ceiling.
  *
@@ -199,41 +195,17 @@ export function ceilingForDefinition(definition: SkillDefinition): DefinitionCei
 }
 
 /**
- * Discover `SKILL.md` definitions under pi's skill roots.
- *
- * Deliberately the SAME roots and the same convention the catalog uses (`skillDirs`): a directory
- * containing `SKILL.md` is one definition named after the directory, and a top-level `.md` is one named
- * after the file. If discovery and the catalog disagreed, a definition could be spawnable but not
- * grantable, or listed but unspawnable.
- *
- * Earlier directories win on a name collision, matching pi's own precedence — project before global.
+ * Read definitions from Pi's enabled resources, including installed packages and local overrides.
+ * Resolver precedence and filters are shared with the capability catalog; unregistered npm packages
+ * are not runtime resources until legacy init explicitly scaffolds them.
  */
 export async function loadDefinitions(cwd: string): Promise<Map<string, SkillDefinition>> {
   const definitions = new Map<string, SkillDefinition>();
-  for (const dir of skillDirs(cwd)) {
-    let names: string[];
-    try {
-      names = await readdir(dir);
-    } catch {
-      continue; // an absent skill root is normal
-    }
-    for (const name of [...names].sort()) {
-      // A directory holding SKILL.md, or a top-level .md — try the former first, exactly as the
-      // catalog does, so the two cannot disagree about what exists.
-      const candidates = [join(dir, name, "SKILL.md"), ...(name.endsWith(".md") ? [join(dir, name)] : [])];
-      for (const path of candidates) {
-        let text: string;
-        try {
-          text = await readFile(path, "utf8");
-        } catch {
-          continue; // not this shape; try the next candidate
-        }
-        const parsed = parseSkillDefinition(path, text);
-        // First writer wins, so project definitions shadow global ones rather than the reverse.
-        if (parsed && !definitions.has(parsed.name)) definitions.set(parsed.name, parsed);
-        break;
-      }
-    }
+  for (const { path } of (await resolveSkillResources(cwd)).skills) {
+    let text: string;
+    try { text = await readFile(path, "utf8"); } catch { continue; }
+    const parsed = parseSkillDefinition(path, text);
+    if (parsed && !definitions.has(parsed.name)) definitions.set(parsed.name, parsed);
   }
   return definitions;
 }

package/src/index.ts

@@ -45,7 +45,8 @@ export { renderDebrief, debriefAction as dashboardDebriefAction } from "./debrie
 export { type ReviewPort, type ReviewRequest, type BlindPort, type BlindChoice } from "./debrief-contract.ts";
 export { readDailyView, createDailyViewReader, DAILY_VIEW_VERSION, type DailyView, type DailyViewOptions,
   type DailyAttempt, type DailyObligation } from "./daily-view.ts";
-export { renderDailyView } from "./daily-view-render.ts";
+export { renderDailyView, renderDailyDetails } from "./daily-view-render.ts";
+export { renderDailyPanel, type PanelOptions, type WorkPresentation } from "./daily-panel.ts";
 export { parseArchiveProjection, ARCHIVE_PROJECTION_VERSION } from "./daily-view-input.ts";
 export { bindWorkIntent } from "./intent-application.ts";
 export { intentRequestDigest, parseIntentRequest, type IntentRequest, type IntentSelection, type IntentPriority,
@@ -154,6 +155,11 @@ export {
 } from "./dashboard-projection.ts";
 
 export { renderDashboard, type DashboardRenderOptions } from "./dashboard-render.ts";
+export { declareWork, loadDeclaredWork, type DeclaredWorkState } from "./work-command.ts";
+export { workSetup, recordWorkSetup, selectRecordedWork, loadWorkSetup, listWorkSetups, workPresentation, type WorkSetup, type WorkTaskSetup, type RecordedWorkSetup } from "./work-setup.ts";
+export { runWorkSetup, inspectWorkRun, type WorkRunResult, type WorkRunInitial, type WorkPolicyPin } from "./work-run.ts";
+export { workPolicy, workPolicyDigest, policyForSetup, createWorkPolicyRegistry, openWorkPolicyRegistry, workPolicyActivationDigest, type WorkPolicy, type WorkPolicyRegistry, type WorkPolicyActivation } from "./work-policy-registry.ts";
+export { learningHarness, bindLearningConnection, loadLearningConnection, bindLearningAdoption, learningScopeDigest, type LearningConnection, type LearningWorkspace } from "./learning-connection.ts";
 
 export {
   runMeasuredAgentSession,

package/src/init.ts

@@ -1,9 +1,9 @@
 /**
  * `pi-daddy init` — scaffold a governed project from the skill packages already installed (B2, P3).
  *
- * Today an operator wanting to govern a package of skills must, per skill: create a directory, copy the
- * body, hand-write frontmatter, choose a capability set with no guidance, and assemble a `PI_GRANTS_GRANT`
- * string by hand. Seven times, for `principal-pi-skills`. This does the mechanical parts.
+ * Legacy unregistered npm packages can be scaffolded per skill: create a directory, copy the
+ * body and declaration copies plus a starting `PI_GRANTS_GRANT`. Configured enabled Pi resources
+ * are referenced where installed instead (ADR-0074); no competing .pi/skills copy is created.
  *
  * **The line it does not cross, and the reason this module exists at all:** `init` writes files an operator
  * then **reviews, edits and commits**. It never chooses a ceiling. A skill that declares `allowed-tools` is
@@ -32,23 +32,9 @@ import { PI_BUILTIN_TOOLS } from "./pi-tools.ts";
 import type { Capability } from "./resolve.ts";
 import type { SkillPackage } from "./skill-packages.ts";
 
-/** Why a discovered skill is not authorised in the generated grant. `null` means it is. */
 /**
- * How many of `from`'s skills actually **declare** a ceiling.
- *
- * Exported because the number is printed to an operator and was wrong: `cli.ts` filtered on
- * `withheld === null`, which is false for all three `WithholdReason`s — so a skill that declares
- * `allowed-tools` perfectly well and merely needs a withheld capability counted as not declaring one.
- * Against `principal-pi-skills` that printed *"7 skill(s), 3 declaring allowed-tools"* while all seven
- * declared. R-28's shape: a diagnostic disagreeing with the thing it describes.
- *
- * **It was invisible until the integration worked.** Before ceilings shipped, none of the seven declared
- * and the line read *"0 declaring"* — correct by coincidence, for the wrong reason. A count that is right
- * only while the interesting case is absent is the kind this project keeps finding.
- *
- * `undeclared` is the only reason that means "did not declare". `pattern` declared something this package
- * refuses to reinterpret, and `needs-withheld` declared something fine that the operator must opt into —
- * both are declarations.
+ * Count declarations, not authorizations (R-73). Both pattern and needs-withheld mean the skill
+ * declared a ceiling; only undeclared means it did not. The CLI must report the same distinction.
  */
 export function countDeclaring(skills: PlannedSkill[], from: string): number {
   return skills.filter((s) => s.from === from && s.withheld !== "undeclared").length;
@@ -62,6 +48,8 @@ export interface PlannedSkill {
   from: string;
   sourcePath: string;
   targetPath: string;
+  /** Configured skills stay at their installed/local source, including when --force is used. */
+  referenced?: boolean;
   /** Exactly what would be written — the file verbatim, or the file plus a commented note. */
   content: string;
   /** The declared ceiling, empty when the declaration is absent or unusable. */
@@ -191,7 +179,8 @@ export function planInit(
         name,
         from: `${pkg.name}@${pkg.version}`,
         sourcePath: skill.path,
-        targetPath: join(cwd, ".pi", "skills", name, "SKILL.md"),
+        targetPath: skill.referenced ? skill.path : join(cwd, ".pi", "skills", name, "SKILL.md"),
+        referenced: skill.referenced,
         content: withPlaceholder(skill.text, withheld === null, note),
         ceiling: ceiling.capabilities,
         withheld,
@@ -391,6 +380,7 @@ export async function applyInit(plan: InitPlan, options: { force?: boolean } = {
   }
   const force = options.force === true;
   for (const skill of plan.skills) {
+    if (skill.referenced) continue;
     if (force) await replace(skill.targetPath, skill.content, outcome);
     else await createUnlessPresent(skill.targetPath, skill.content, outcome);
   }