pi-daddy 0.22.0 → 0.24.0

package/extensions/work-runtime.ts

@@ -0,0 +1,44 @@
+import type { Delegation } from "../src/delegate.ts";
+import { retentionConfigurationDigest } from "../src/execution-retention.ts";
+import { appendDeclaredWorkOccurrence } from "../src/work-command.ts";
+import type { WorkOccurrencePayload } from "../src/work-ledger.ts";
+import type { GrantsSession } from "./session.ts";
+import type { PreparedWorkspace } from "./workspace-runtime.ts";
+
+export async function beginDeclaredWorkAttempt(input: {
+  session: GrantsSession;
+  plan: Delegation;
+  childId: string;
+  executionId: string;
+  parentExecutionId: string | null;
+  toolCallId?: string;
+  preparedWorkspace?: PreparedWorkspace;
+  configuredTimeoutMs: number;
+  startedAt: Date;
+}): Promise<null | { finish(state: Extract<WorkOccurrencePayload["state"], "completed" | "failed">): Promise<void> }> {
+  const state = input.session.declaredWork;
+  if (!state) return null;
+  const argument = (flag: string): string | null => {
+    const index = input.plan.args.indexOf(flag);
+    return index >= 0 ? input.plan.args[index + 1] ?? null : null;
+  };
+  const identity = {
+    executionId: input.executionId,
+    parentExecutionId: input.parentExecutionId,
+    childId: input.childId,
+    variantId: input.plan.correlation?.context_id ?? null,
+    toolCallId: input.toolCallId ?? null,
+    taskId: input.plan.correlation?.task_id ?? input.plan.taskDigest,
+    workspaceId: input.preparedWorkspace?.workspace.workspaceId ?? input.plan.correlation?.workspace_id ?? null,
+    definitionDigest: input.plan.definitionDigest?.sha256 ?? null,
+    configurationDigest: retentionConfigurationDigest({
+      args: input.plan.args,
+      effective: input.plan.effective,
+      timeoutMs: input.configuredTimeoutMs,
+    }),
+    modelId: argument("--model"),
+    effortId: argument("--thinking"),
+  };
+  await appendDeclaredWorkOccurrence(state, { ...identity, now: input.startedAt }, "starting");
+  return { finish: (terminal) => appendDeclaredWorkOccurrence(state, { ...identity, now: new Date() }, terminal) };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-daddy",
-  "version": "0.22.0",
+  "version": "0.24.0",
   "description": "Capability governance for pi sub-agents: spawn Agent Skills (SKILL.md) definitions whose allowed-tools becomes a grant that can only narrow going down a delegation tree, enforced by pi's own --tools allowlist, with an append-only ledger.",
   "keywords": [
     "pi-package",
@@ -37,6 +37,67 @@
       "types": "./dist/ledger.d.ts",
       "default": "./dist/ledger.js"
     },
+    "./work-ledger": {
+      "types": "./dist/work-ledger.d.ts",
+      "default": "./dist/work-ledger.js"
+    },
+    "./factory-order": {
+      "types": "./dist/factory-order.d.ts",
+      "default": "./dist/factory-order.js"
+    },
+    "./experiment": {
+      "types": "./dist/experiment.d.ts",
+      "default": "./dist/experiment.js"
+    },
+    "./dashboard-harness": {
+      "types": "./dist/dashboard-harness.d.ts",
+      "default": "./dist/dashboard-harness.js"
+    },
+    "./dashboard-host": {
+      "types": "./dist/dashboard-host.d.ts",
+      "default": "./dist/dashboard-host.js"
+    },
+    "./dashboard-host-transport": {
+      "types": "./dist/dashboard-host-transport.d.ts",
+      "default": "./dist/dashboard-host-transport.js"
+    },
+    "./debrief-host": {
+      "types": "./dist/debrief-host.d.ts",
+      "default": "./dist/debrief-host.js"
+    },
+    "./contracts/debrief/v2/*": "./contracts/debrief/v2/*",
+    "./debrief": {
+      "types": "./dist/debrief.d.ts",
+      "default": "./dist/debrief.js"
+    },
+    "./daily-view": {
+      "types": "./dist/daily-view.d.ts",
+      "default": "./dist/daily-view.js"
+    },
+    "./intent-control": {
+      "types": "./dist/intent-control.d.ts",
+      "default": "./dist/intent-control.js"
+    },
+    "./dispatch-control": {
+      "types": "./dist/dispatch-control.d.ts",
+      "default": "./dist/dispatch-control.js"
+    },
+    "./resource-budget": {
+      "types": "./dist/resource-budget.d.ts",
+      "default": "./dist/resource-budget.js"
+    },
+    "./producer-ipc": {
+      "types": "./dist/producer-ipc.d.ts",
+      "default": "./dist/producer-ipc.js"
+    },
+    "./effect-profile": {
+      "types": "./dist/effect-profile.d.ts",
+      "default": "./dist/effect-profile.js"
+    },
+    "./execution-retention": {
+      "types": "./dist/execution-retention.d.ts",
+      "default": "./dist/execution-retention.js"
+    },
     "./spawn": {
       "types": "./dist/spawn.d.ts",
       "default": "./dist/spawn.js"
@@ -137,6 +198,19 @@
       "types": "./dist/dashboard-render.d.ts",
       "default": "./dist/dashboard-render.js"
     },
+    "./contracts/factory-order/v1/*": "./contracts/factory-order/v1/*",
+    "./contracts/experiment/v1/*": "./contracts/experiment/v1/*",
+    "./contracts/producer-ipc/v1/*": "./contracts/producer-ipc/v1/*",
+    "./contracts/debrief/v1/*": "./contracts/debrief/v1/*",
+    "./contracts/intent-control/v2/request.schema.json": "./contracts/intent-control/v2/request.schema.json",
+    "./contracts/intent-control/v1/request.schema.json": "./contracts/intent-control/v1/request.schema.json",
+    "./contracts/dispatch-control/v1/request.schema.json": "./contracts/dispatch-control/v1/request.schema.json",
+    "./contracts/daily-view/v1/fixtures/*": "./contracts/daily-view/v1/fixtures/*",
+    "./contracts/daily-view/v1/p03/projection.schema.json": "./contracts/daily-view/v1/p03/projection.schema.json",
+    "./contracts/execution-retention/v2/manifest.schema.json": "./contracts/execution-retention/v2/manifest.schema.json",
+    "./contracts/execution-retention/v2/fixtures/*": "./contracts/execution-retention/v2/fixtures/*",
+    "./contracts/ledger/v4/ledger-event.schema.json": "./contracts/ledger/v4/ledger-event.schema.json",
+    "./contracts/ledger/v4/fixtures/*.json": "./contracts/ledger/v4/fixtures/*.json",
     "./contracts/ledger/v3/ledger-event.schema.json": "./contracts/ledger/v3/ledger-event.schema.json",
     "./contracts/ledger/v3/fixtures/*.json": "./contracts/ledger/v3/fixtures/*.json",
     "./contracts/ledger/v2/ledger-event.schema.json": "./contracts/ledger/v2/ledger-event.schema.json",
@@ -159,13 +233,13 @@
   "scripts": {
     "build": "node -e \"require('node:fs').rmSync('dist',{recursive:true,force:true})\" && tsc -p tsconfig.json",
     "typecheck": "tsc -p tsconfig.check.json",
-    "test": "node --test test/*.test.ts",
+    "test": "node scripts/unit-tests.ts",
     "test:integration": "node --test test-integration/*.it.ts",
     "test:integration:ci": "node --test test-integration/approval.it.ts test-integration/governance.it.ts",
     "contracts:generate": "node scripts/generate-ledger-v3-contract.ts",
+    "contracts:generate:v4": "node scripts/generate-ledger-v4-contract.ts contracts/ledger/v4",
     "prepack": "npm run build",
-    "test:smoke": "node scripts/smoke-installed.mjs",
-    "test:mutation": "node scripts/mutation-audit.mjs"
+    "test:smoke": "node scripts/smoke-installed.mjs"
   },
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",

package/src/check-runner.ts

@@ -1,4 +1,5 @@
 import { createHash, randomUUID } from "node:crypto";
+import { beginExecutionRetention, retentionConfigurationDigest, type RetentionStatus } from "./execution-retention.ts";
 import { chmod, mkdtemp, readFile, realpath, rm, stat, writeFile } from "node:fs/promises";
 import { tmpdir } from "node:os";
 import { basename, isAbsolute, join } from "node:path";
@@ -128,11 +129,15 @@ export async function runNamedCheck(input: {
   signal?: AbortSignal;
   leaseDir?: string;
   ledgerPath?: string;
+  /** Explicit host archive boundary; defaults to PI_GRANTS_EXECUTION_ARCHIVE, never correlation. */
+  retentionDirectory?: string;
+  toolCallId?: string;
 }): Promise<{
   output: string;
   exitCode: number | null;
   signal: NodeJS.Signals | null;
   receipt: CheckReceipt;
+  retention: RetentionStatus;
 }> {
   if (input.registry?.version !== 1 || !input.registry.checks || typeof input.registry.checks !== "object") {
     throw new GovernanceRefusal(refusal("CHECK_CONFIGURATION_INVALID", "check registry must contain {version:1, checks:{...}}"));
@@ -159,11 +164,17 @@ export async function runNamedCheck(input: {
   const executionId = newExecutionId();
   const parentExecutionId = null;
   const correlation = normaliseCorrelation(input.correlation);
+  const retention = beginExecutionRetention({ executionId, parentExecutionId, childId: ownerId,
+    toolCallId: input.toolCallId ?? null, executor: "check", taskDigest: null, definitionDigest: null,
+    configurationDigest: retentionConfigurationDigest({ executable, argv: definition.argv, access,
+      timeoutMs: definition.timeout_ms ?? null, maxOutputBytes: definition.max_output_bytes ?? null }),
+    workspaceId: input.workspace.workspaceId }, input.retentionDirectory);
   let lease: Awaited<ReturnType<typeof acquireWorkspaceLease>> | undefined;
   let stagedDir: string | undefined;
   /** Failures of best-effort RECORDS, reported alongside whatever actually happened — never instead of it. */
   const notes: string[] = [];
   let releaseReason = "failed";
+  let observedOutcome = { code: null as number | null, signal: null as string | null, timedOut: false, aborted: false, truncated: false };
   return runWithFinalizers(async () => {
     try {
       try {
@@ -228,8 +239,11 @@ export async function runNamedCheck(input: {
       command: "setpriv", args: ["--pdeathsig", "KILL", "--", stagedExecutable, ...definition.argv],
       env: buildCheckEnvironment(definition, input.inheritedEnv), cwd: input.workspace.root,
       signal: checkSignal, timeoutMs: definition.timeout_ms, maxOutputBytes: definition.max_output_bytes,
-      onSpawn: (pid) => lease!.attachProcess(pid),
+      onSpawn: (pid) => { lease!.attachProcess(pid); retention.native({ pid }); },
+      onObservation: (stream, bytes) => retention.capture(stream, bytes),
     });
+    observedOutcome = { code: result.code, signal: result.signal ?? null, timedOut: result.timedOut, aborted: result.aborted, truncated: result.truncated };
+    retention.capture("result", Buffer.from(result.text), true);
     const ended = new Date();
     releaseReason = input.signal?.aborted ? "cancelled" : result.timedOut ? "timeout" : result.aborted ? "failed" : "completed";
     // Every throw below re-stamps this. Without that, a check refused for CHECK_IDENTITY_MISMATCH still
@@ -285,6 +299,7 @@ export async function runNamedCheck(input: {
       head_sha: before.headSha, tree_sha: before.treeSha, ...(correlation ? { correlation } : {}),
     };
     const receipt: CheckReceipt = { receipt_id: receiptId(body), ...body };
+    retention.capture("checkReceipt", Buffer.from(JSON.stringify(receipt) + "\n"), true);
     if (input.ledgerPath) {
       await appendLedgerEvent(
         { path: input.ledgerPath, strict: true },
@@ -295,8 +310,11 @@ export async function runNamedCheck(input: {
         }),
       );
     }
-    return { output: result.text, exitCode: result.code, signal: result.signal ?? null, receipt };
+    retention.finish({ code: result.code, signal: result.signal ?? null, timedOut: result.timedOut,
+      aborted: result.aborted, truncated: result.truncated, failed: result.code !== 0 });
+    return { output: result.text, exitCode: result.code, signal: result.signal ?? null, receipt, retention: retention.status() };
   } catch (error) {
+    retention.finish({ ...observedOutcome, aborted: observedOutcome.aborted || Boolean(input.signal?.aborted), failed: true });
     // The run did not complete, so the release must not be recorded as if it had. Without this the
     // `finally` wrote `released / completed` as the LAST lease event for a refused check, so the trail
     // still read like a clean run and `verifyLedger` still counted a clean release — the R-114 fix put a

package/src/cli.ts

@@ -21,12 +21,15 @@ import { UnsafeGrantError } from "./grant-env.ts";
 import { applyInit, countDeclaring, planInit, type InitPlan } from "./init.ts";
 import { registeredWorkspaceIds } from "./workspace.ts";
 import { discoverSkillPackages, skillPackageRoots, type RefusedSkill, type SkillPackage } from "./skill-packages.ts";
+import { declareWork } from "./work-command.ts";
 
 const USAGE = `pi-daddy — capability governance for pi sub-agents
 
 Usage:
   pi-daddy init [--force] [--dir <path>]   scaffold .pi/skills/ and .pi/grants.env from installed
                                            packages that declare skills (package.json "pi": {"skills": …})
+  pi-daddy work add --id <id> --outcome <text> [--dir <path>]
+                                           declare one current obligation for ordinary delegation
   pi-daddy --help | --version
 
 init copies each declared SKILL.md into .pi/skills/ and writes a grant naming exactly what those files
@@ -38,9 +41,11 @@ placeholder and stays unspawnable until you fill it in. Capabilities that can ch
             It never rewrites .pi/grants.env — delete that file if you want it regenerated.`;
 
 export interface ParsedArgs {
-  command: "init" | "help" | "version";
+  command: "init" | "work-add" | "help" | "version";
   dir?: string;
   force: boolean;
+  id?: string;
+  outcome?: string;
   /** Non-empty means refuse: argv said something this program does not understand. */
   errors: string[];
 }
@@ -58,16 +63,28 @@ export function parseArgs(argv: string[]): ParsedArgs {
   if (args.includes("--help") || args.includes("-h")) return { command: "help", force: false, errors: [] };
   if (args.includes("--version") || args.includes("-v")) return { command: "version", force: false, errors: [] };
 
-  const [command, ...rest] = args;
-  if (command !== "init") return { command: "help", force: false, errors: [`unknown command "${command}"`] };
+  const [command, ...tail] = args;
+  if (command !== "init" && command !== "work") return { command: "help", force: false, errors: [`unknown command "${command}"`] };
+  const work = command === "work";
+  const rest = work && tail[0] === "add" ? tail.slice(1) : tail;
+  if (work && tail[0] !== "add") return { command: "work-add", force: false, errors: ["work needs subcommand add"] };
 
   const errors: string[] = [];
   let dir: string | undefined;
   let force = false;
+  let id: string | undefined, outcome: string | undefined;
   for (let i = 0; i < rest.length; i += 1) {
     const arg = rest[i];
-    if (arg === "--force") {
+    if (arg === "--force" && !work) {
       force = true;
+    } else if (arg === "--id" && work) {
+      const value = rest[i + 1];
+      if (value === undefined || value.startsWith("-")) errors.push("--id needs a value");
+      else { id = value; i += 1; }
+    } else if (arg === "--outcome" && work) {
+      const value = rest[i + 1];
+      if (value === undefined || value.startsWith("-")) errors.push("--outcome needs text");
+      else { outcome = value; i += 1; }
     } else if (arg === "--dir") {
       const value = rest[i + 1];
       // A flag is not a path. Without this, `--dir --force` consumed the flag as the directory AND left
@@ -87,6 +104,11 @@ export function parseArgs(argv: string[]): ParsedArgs {
     }
   }
 
+  if (work) {
+    if (!id && !errors.some(error => error.startsWith("--id"))) errors.push("--id needs a value");
+    if (!outcome && !errors.some(error => error.startsWith("--outcome"))) errors.push("--outcome needs text");
+    return { command: "work-add", force: false, errors, ...(id ? { id } : {}), ...(outcome ? { outcome } : {}), ...(dir ? { dir } : {}) };
+  }
   return { command: "init", dir, force, errors };
 }
 
@@ -260,6 +282,21 @@ export async function main(argv: string[]): Promise<number> {
     console.log(USAGE);
     return 0;
   }
+  if (parsed.command === "work-add") {
+    const declared = await declareWork({
+      cwd: resolvePath(parsed.dir ?? process.cwd()),
+      id: parsed.id!,
+      outcome: parsed.outcome!,
+    });
+    console.log(
+      `pi-daddy work: declared ${declared.id}\n` +
+      `  ledger    ${declared.ledgerPath}\n` +
+      `  selection ${declared.statePath}\n\n` +
+      `Ordinary governed delegations from this project will record attempts after the Pi extension loads it.\n` +
+      `Run /reload in an existing Pi session, then /grants dashboard. Runtime success is not acceptance.`,
+    );
+    return 0;
+  }
 
   // ABSOLUTE, always. `readSkill` compares a resolved entry against the package directory, and a relative
   // `--dir` made that comparison false for every entry: every declared skill of every package was reported

package/src/control-journal.ts

@@ -0,0 +1,26 @@
+import { constants } from "node:fs";
+import { mkdir, open, lstat } from "node:fs/promises";
+import { dirname, join, resolve } from "node:path";
+import { withFileLock } from "./file-lock.ts";
+import { runWithFinalizers } from "./finalization.ts";
+import { ownedDirectory, readExperimentFile } from "./experiment-store.ts";
+import { cloneExperiment, closed, experimentHash } from "./experiment-contract.ts";
+import { freezeWork, parseWorkJson } from "./work-ledger-json.ts";
+export interface ControlBinding<T> {version:"control-journal-v1";directory:string;device:string;inode:string;journalDevice:string;journalInode:string;initial:T}
+export async function createControlJournal<T>(directory:string,input:T):Promise<ControlBinding<T>>{
+  const initial=cloneExperiment(input);if(typeof directory!=="string"||directory!==resolve(directory)||directory.length>1024||directory.split("/").includes(".pi"))throw new Error("explicit control directory required");
+  await ownedDirectory(dirname(directory));await mkdir(directory,{mode:0o700});const root=await ownedDirectory(directory),f=await open(join(directory,"control.jsonl"),"wx",0o600);
+  const b=await runWithFinalizers(async()=>{const s=await f.stat({bigint:true});const b={version:"control-journal-v1" as const,directory,device:String(root.dev),inode:String(root.ino),journalDevice:String(s.dev),journalInode:String(s.ino),initial};await f.writeFile(JSON.stringify(b)+"\n");await f.sync();return b;},[{label:"control creation close failed",run:()=>f.close()}]);
+  const d=await open(directory,constants.O_RDONLY|constants.O_DIRECTORY);await runWithFinalizers(()=>d.sync(),[{label:"control directory close failed",run:()=>d.close()}]);return freezeWork(b) as unknown as ControlBinding<T>;
+}
+export function controlJournal<T>(input:ControlBinding<T>){
+  const b=freezeWork(cloneExperiment(input)) as unknown as ControlBinding<T>;closed(b,["version","directory","device","inode","journalDevice","journalInode","initial"]);
+  if(b.version!=="control-journal-v1"||b.directory!==resolve(b.directory)||b.directory.split("/").includes(".pi")||[b.device,b.inode,b.journalDevice,b.journalInode].some(v=>!/^\d+$/.test(v)))throw new Error("invalid control binding");
+  const path=join(b.directory,"control.jsonl");
+  const check=async()=>{const root=await ownedDirectory(b.directory),file=await lstat(path,{bigint:true});if(String(root.dev)!==b.device||String(root.ino)!==b.inode||String(file.dev)!==b.journalDevice||String(file.ino)!==b.journalInode)throw new Error("control identity changed");};
+  const read=async()=>{await check();const bytes=await readExperimentFile(path,512*1024);await check();const text=new TextDecoder("utf8",{fatal:true}).decode(bytes);if(!text.endsWith("\n"))throw new Error("torn control journal");const lines=text.slice(0,-1).split("\n");if(lines.length>257||experimentHash(parseWorkJson(lines[0]))!==experimentHash(b))throw new Error("control header/limit mismatch");let previous=experimentHash(b);const events:Record<string,unknown>[]=[];
+    for(const line of lines.slice(1)){const r=parseWorkJson(line) as Record<string,unknown>;closed(r,["sequence","previous","event"]);if(r.sequence!==events.length||r.previous!==previous||!r.event||typeof r.event!=="object"||Array.isArray(r.event))throw new Error("invalid control sequence");previous=experimentHash(r);events.push(r.event as Record<string,unknown>);}return{events,previous,size:bytes.length};};
+  return {binding:b,read,async transaction<R>(fn:(events:Record<string,unknown>[],append:(e:unknown)=>Promise<void>)=>Promise<R>){await check();return withFileLock(path,"factory policy",async()=>{const state=await read();return fn(state.events,async event=>{if(state.events.length>=256)throw new Error("control event budget exhausted");const record={sequence:state.events.length,previous:state.previous,event:cloneExperiment(event)},data=Buffer.from(JSON.stringify(record)+"\n");if(state.size+data.length>512*1024||data.length>65536)throw new Error("control byte budget exhausted");await check();const f=await open(path,constants.O_WRONLY|constants.O_APPEND|constants.O_NOFOLLOW|constants.O_NONBLOCK);
+      await runWithFinalizers(async()=>{const s=await f.stat({bigint:true});if(!s.isFile()||s.nlink!==1n||String(s.dev)!==b.journalDevice||String(s.ino)!==b.journalInode||s.size!==BigInt(state.size)||(s.mode&0o077n)!==0n)throw new Error("control journal changed under lock");await f.writeFile(data);await f.sync();},[{label:"control append close failed",run:()=>f.close()}]);await check();state.size+=data.length;state.previous=experimentHash(record);state.events.push(cloneExperiment(event) as Record<string,unknown>);
+    });},{staleRecovery:"disabled"});}};
+}

package/src/daily-dashboard-host.ts

@@ -0,0 +1,49 @@
+import { createHash, randomUUID } from "node:crypto";
+import { mkdir, readFile, rename, rm, writeFile } from "node:fs/promises";
+import { isAbsolute, resolve, join } from "node:path";
+import { createDashboardHost, dashboardHostDigest, dashboardHostRequestDigest, type DashboardHostAuthority, type DashboardHostConfig, type DashboardHostRequest } from "./dashboard-host.ts";
+import type { DashboardHarness } from "./dashboard-host-contract.ts";
+import { loadedDashboardHarnessDigest } from "./dashboard-harness.ts";
+import { createDispatchBudget, openResourceBudget, resourceBindingDigest } from "./resource-budget.ts";
+import { dispatchRequestDigest, type DispatchRequest } from "./dispatch-control.ts";
+import { serveDashboardHost } from "./dashboard-host-transport.ts";
+import type { DeclaredWorkState } from "./work-command.ts";
+import type { OrdinaryChildren } from "./ordinary-children.ts";
+import { dataDigest } from "./debrief-contract.ts";
+
+export interface DailyDashboardHostInput {id:string;cwd:string;directory:string;socketPath?:string;declared:DeclaredWorkState;ordinary:OrdinaryChildren;harness:DashboardHarness;author:string}
+const idPattern=/^[A-Za-z0-9][A-Za-z0-9._-]{0,63}$/;
+const hash=(value:string)=>createHash("sha256").update(value).digest("hex");
+
+/** One explicitly started, process-owned daily host. No authority, controller or prior host is recovered from disk. */
+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 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:"retained-work",version:"1",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 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 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}),budget=await createDispatchBudget({directory:join(input.directory,"budget"),authorityDigest,limits:{maxAttempts:6,maxInputBytes:65536,maxConcurrent:3}});
+ 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 requestDigests=new Set<string>(),dispatchDigests=new Set<string>();let host:ReturnType<typeof createDashboardHost>,factsResultManifest:string|null=null;
+ const authority=():DashboardHostAuthority=>({hostDigests:[dashboardHostDigest(config)],requestDigests:[...requestDigests],workContext:{selectedSnapshot:config.selection,authority:null},dispatch:{authorityDigest,requestDigests:[...dispatchDigests]},experiment:null});
+ 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 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));
+   return [{key,label:state.paused?"Resume new governed dispatch":"Pause new governed dispatch; running children continue",request:hostRequest},{key:"refresh-current-work",label:"Capture current declared work and attempts",request:refresh}];
+ }});
+ 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();}});
+}

package/src/daily-view-input.ts

@@ -0,0 +1,59 @@
+import { constants } from "node:fs";
+import { open, lstat } from "node:fs/promises";
+import { createRequire } from "node:module";
+import { createHash } from "node:crypto";
+import { Compile } from "typebox/compile";
+import { parseRetentionJson } from "./retention-json.ts";
+import { runWithFinalizers } from "./finalization.ts";
+
+export const ARCHIVE_PROJECTION_VERSION = "execution-archive-projection-v1" as const;
+export const DAILY_INPUT_LIMIT = 4 * 1024 * 1024;
+export interface ArchiveExecution {
+  executionId: string; parentExecutionIds: (string | null)[]; retainedSessionIds: string[]; activeBranch: null;
+  toolCallIds: (string | null)[]; archiveIds: string[]; runtime: "running" | "terminal" | "conflict";
+  outcome: { code: number | null; signal: string | null; timedOut: boolean; aborted: boolean; truncated: boolean; failed: boolean } | null;
+  sourceReferences: string[]; issues: string[]; coverage: "partial"; acceptance: "not-assessed";
+}
+export interface ArchiveProjection { version: typeof ARCHIVE_PROJECTION_VERSION; executions: ArchiveExecution[]; acceptance: "not-assessed" }
+const schema = createRequire(import.meta.url)("../contracts/daily-view/v1/p03/projection.schema.json");
+const validator = Compile(schema);
+export const byteHash = (bytes: Uint8Array | string): string => createHash("sha256").update(bytes).digest("hex");
+export function freezeDaily<T>(value: T): T {
+  if (value && typeof value === "object") { Object.values(value).forEach(freezeDaily); Object.freeze(value); }
+  return value;
+}
+/** Exact vendored P03 shape, plus no duplicate execution identity or contradictory terminal shape.
+ * Only the producer's emitted integer-token subset is supported; no lossy fractional rounding. */
+export function parseArchiveProjection(text: string): ArchiveProjection {
+  const value = parseRetentionJson(text, DAILY_INPUT_LIMIT);
+  for (const match of text.matchAll(/"(?:[^"\\]|\\[\s\S])*"|[^\s{}\[\],:]+/g)) {
+    if (/^-?\d/.test(match[0]) && !/^-?(0|[1-9]\d*)$/.test(match[0])) throw new TypeError("unsupported archive numeric token");
+  }
+  if (!validator.Check(value)) throw new TypeError("unsupported archive projection shape/version");
+  const projection = value as ArchiveProjection, ids = new Set<string>();
+  for (const e of projection.executions) {
+    if (ids.has(e.executionId) || (e.runtime !== "terminal" && e.outcome !== null)) throw new TypeError("ambiguous archive execution");
+    ids.add(e.executionId);
+  }
+  projection.executions.sort((a, b) => a.executionId < b.executionId ? -1 : a.executionId > b.executionId ? 1 : 0);
+  return freezeDaily(projection);
+}
+export type SnapshotRead = { status: "read"; bytes: Buffer; sha256: string } | { status: "missing" | "error" | "unconfigured"; reason: string };
+/** Caller-authorized exact file only. No directories, symlink following, watching or mtime freshness claim. */
+export async function readDailySnapshot(path: string | undefined, limit = DAILY_INPUT_LIMIT): Promise<SnapshotRead> {
+  if (!path) return { status: "unconfigured", reason: "not-configured" };
+  try {
+    const file = await open(path, constants.O_RDONLY | constants.O_NOFOLLOW | constants.O_NONBLOCK);
+    return await runWithFinalizers(async (): Promise<SnapshotRead> => {
+      const before = await file.stat({ bigint: true });
+      if (!before.isFile() || before.size > BigInt(limit)) return { status: "error", reason: "not-regular-or-over-limit" };
+      const bytes = Buffer.alloc(Number(before.size)); let offset = 0;
+      while (offset < bytes.length) { const n = (await file.read(bytes, offset, bytes.length - offset, offset)).bytesRead;
+        if (!n) return { status: "error", reason: "changed-during-read" }; offset += n; }
+      const after = await file.stat({ bigint: true }), located = await lstat(path, { bigint: true });
+      if (before.size !== after.size || before.mtimeNs !== after.mtimeNs || before.ctimeNs !== after.ctimeNs ||
+        after.dev !== located.dev || after.ino !== located.ino) return { status: "error", reason: "changed-during-read" };
+      return { status: "read", bytes, sha256: byteHash(bytes) };
+    }, [{ label: "snapshot close failed", run: () => file.close() }]);
+  } catch (error) { return { status: (error as { code?: string }).code === "ENOENT" ? "missing" : "error", reason: "snapshot-unavailable" }; }
+}

package/src/daily-view-render.ts

@@ -0,0 +1,44 @@
+import type { DailyView } from "./daily-view.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 {
+  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`,
+    `Models: NOT CONSULTED; connectivity UNKNOWN. Continuity: ${view.continuity}${view.scopeChanged ? "; SCOPE CHANGED" : ""}`,
+    `Inputs: work ${view.sources.work}; archive ${view.sources.archive}`, "", "INTENDED OBLIGATIONS"];
+  if (!view.obligations.length) lines.push("EMPTY / UNRESOLVED: no scoped obligations available; not proof of no intended work.");
+  const attempts = new Map(view.attempts.map(a => [a.executionId, a]));
+  for (const o of view.obligations) {
+    lines.push(`${o.obligation.id}@${o.obligation.revision} | ${o.acceptance.toUpperCase()} | ${o.activity.toUpperCase()}`,
+      `  intent ${o.intent.id}@${o.intent.revision}; policy ${o.policy.id}@${o.policy.revision}`,
+      `  artifact ${o.artifactCoverage}; evidence ${o.evidenceCoverage}; P01 matched receipts: ${o.receiptIds.join(", ") || "none"}`,
+      `  obstacle: ${o.obstacles.join(", ") || (o.acceptance === "accepted-under-supplied-authority" ? "none under supplied snapshot authority" : "acceptance not established")}`);
+    for (const id of o.attempts) {
+      const a = attempts.get(id)!;
+      lines.push(`  attempt ${id} (logical ${a.logicalChildId ?? "unknown"}) | P01 runtime ${a.intentRuntime} | P03 ${a.archive?.runtime ?? "unavailable"}`);
+    }
+    for (const ref of o.claimReferences) lines.push(`  claim source ${ref}`);
+  }
+  lines.push("", "EXECUTION SNAPSHOTS — NOT ACCEPTANCE");
+  if (!view.attempts.length) lines.push("EMPTY: no execution attempts in these snapshots.");
+  for (const a of view.attempts) {
+    const e = a.archive;
+    lines.push(`${a.executionId} | logical ${a.logicalChildId ?? "unknown"} | P01 ${a.intentRuntime} | P03 ${e?.runtime ?? "unavailable"}`);
+    if (e) {
+      lines.push(`  producer-reported exit ${e.outcome?.code ?? "unknown"}; failed control/runtime ${e.outcome?.failed ?? "unknown"}; aborted ${e.outcome?.aborted ?? "unknown"}`,
+        `  parents ${e.parentExecutionIds.map(clean).join(", ") || "unknown"}; calls ${e.toolCallIds.map(clean).join(", ") || "unknown"}`,
+        `  reported retained sessions ${e.retainedSessionIds.join(", ") || "none"}; ACTIVE BRANCH UNKNOWN`,
+        "  check receipt detail/bytes not supplied by P03 v1; never inferred from exit status");
+    }
+    lines.push(`  obstacle/coverage: ${a.issues.join(", ") || "partial snapshot; freshness unknown"}`);
+    for (const r of a.sourceAvailability) lines.push(`  source ${r.sha256} | ${r.state}`);
+  }
+  lines.push("", `Coverage gaps: ${view.issues.join("; ") || "partial snapshots; live freshness unavailable"}`,
+    `Work source SHA256: ${view.sources.workSha256 ?? "missing"}`, `Archive projection SHA256: ${view.sources.archiveSha256 ?? "missing"}`,
+    "P06: fixed digest profile only; arbitrary shell/model effects and aggregate CPU/memory/PID/money caps unsupported.",
+    "No steering, dispatch, acceptance, session edit or recovery action is performed by this view.");
+  const bounded = lines.slice(0, 300); if (lines.length > 300) bounded.push(`${lines.length - 300} additional lines omitted; full rows remain in the read-model.`);
+  const columns = Number.isFinite(width) ? Math.max(20, Math.min(240, Math.floor(width))) : 100;
+  return bounded.map(line => { const text = [...clean(line)]; return text.length > columns ? text.slice(0, columns - 3).join("") + "..." : text.join(""); }).join("\n");
+}