pi-daddy 0.28.0 → 0.32.0

package/src/correlation.ts

@@ -1,320 +0,0 @@
-import { createHash } from "node:crypto";
-import type { DefinitionDigest } from "./definitions.ts";
-import type { Capability } from "./resolve.ts";
-import { GovernanceRefusal, refusal } from "./refusals.ts";
-import { isLedgerCorrelationIdentifier } from "./ledger-identifiers.ts";
-
-export type JsonPrimitive = string | number | boolean | null;
-export type JsonValue = JsonPrimitive | JsonValue[] | { [key: string]: JsonValue };
-
-export interface AssuranceScope {
-  type: "entire-run" | "selectors";
-  selectors: string[];
-}
-
-/**
- * Non-authoritative workflow metadata copied onto runtime and ledger events.
- *
- * pi-daddy interprets only the pinned correlation wire contract: schema version 1.0 and the closed
- * assurance-scope shape. Labels, selector meanings, timestamps and sequence floors remain non-authoritative.
- * In particular, a digest-looking value here never substitutes for a digest computed by the planner. The
- * snake_case names are the wire vocabulary used by external controllers.
- */
-export interface CorrelationMetadata {
-  schema_version?: string;
-  run_id?: string;
-  task_id?: string;
-  workspace_id?: string;
-  context_id?: string;
-  phase?: string;
-  assurance?: string;
-  assurance_effective?: string;
-  policy_label?: string;
-  assurance_source?: string;
-  assurance_scope?: AssuranceScope;
-  activated_at?: string;
-  plan_digest?: string;
-  definition_digest?: string;
-  task_digest?: string;
-  base_sha?: string;
-  head_sha?: string;
-  tree_sha?: string;
-  event_seq?: number;
-  last_change_seq?: number;
-  last_authority_seq?: number;
-  check_receipt_id?: string;
-}
-
-const MAX_CORRELATION_BYTES = 32 * 1024;
-/**
- * Per-field bound on the STRING fields — most are an id, a digest, a label or a timestamp. It does not
- * apply to the three sequence numbers or to `assurance_scope`, which are checked separately; an earlier
- * version of this comment claimed it covered every declared field.
- */
-const MAX_CORRELATION_FIELD_CHARS = 512;
-/** `assurance_scope` is the one structured field, so it gets its own, larger bound. */
-const MAX_CORRELATION_SCOPE_BYTES = 4 * 1024;
-
-/**
- * The exact field set of the pinned schema 1.0 contract. Anything else is refused by name.
- *
- * This is a whitelist rather than a size cap because `correlation` is a MODEL-FACING tool parameter that
- * is copied verbatim onto every append-only ledger event. `src/ledger.ts` states the invariant — capability
- * ids, counts and identifiers only, never prompts, tool arguments or results — and ADR-0034 repeats that the
- * ledger must never carry task text. A 32 KB "bounded JSON object" with no key whitelist and no per-field
- * length bound satisfied neither: `assurance_scope` was declared `Type.Any()`, undeclared keys survived the
- * round trip, and every string was unbounded, so a model could write 32 KB of arbitrary text into the
- * ledger through it (R-111). Refusing an unknown key is also the loud option: if upstream adds a field, the
- * refusal names it, which is an actionable break rather than a silent secrets sink.
- */
-const CORRELATION_FIELDS = new Set<keyof CorrelationMetadata>([
-  "schema_version", "run_id", "task_id", "workspace_id", "context_id", "phase", "assurance",
-  "assurance_effective", "policy_label", "assurance_source", "assurance_scope", "activated_at",
-  "plan_digest", "definition_digest", "task_digest", "base_sha", "head_sha", "tree_sha",
-  "event_seq", "last_change_seq", "last_authority_seq", "check_receipt_id",
-]);
-
-const CORRELATION_NUMERIC = new Set<keyof CorrelationMetadata>([
-  "event_seq", "last_change_seq", "last_authority_seq",
-]);
-
-// These fields are rendered as labels/identities. Treating arbitrary prose as an "id" let a model copy
-// task or output text into the ledger and dashboard through correlation while staying schema-valid.
-const CORRELATION_IDENTIFIERS = new Set<keyof CorrelationMetadata>([
-  "schema_version", "run_id", "task_id", "workspace_id", "context_id", "phase", "assurance",
-  "assurance_effective", "policy_label", "assurance_source",
-]);
-
-function correlationRefusal(message: string, details?: Record<string, string | number>): GovernanceRefusal {
-  return new GovernanceRefusal(refusal("CORRELATION_INVALID", `correlation metadata: ${message}`, details));
-}
-
-/**
- * Size refusals get their own code, because they call for a different response: "you sent too much" is
- * retryable by truncating, "you sent a field we do not recognise" is not. `CORRELATION_TOO_LARGE` was
- * declared in the taxonomy and constructed nowhere, so the union advertised a distinction the code did not
- * make — and the enumeration test kept the dead member green.
- */
-function correlationTooLarge(message: string, details?: Record<string, string | number>): GovernanceRefusal {
-  return new GovernanceRefusal(refusal("CORRELATION_TOO_LARGE", `correlation metadata: ${message}`, details));
-}
-
-function normaliseAssuranceScope(value: unknown): AssuranceScope {
-  if (!value || typeof value !== "object" || Array.isArray(value)) {
-    throw correlationRefusal("assurance_scope must be an object with type and selectors");
-  }
-  const scope = value as Record<string, unknown>;
-  const keys = Object.keys(scope).sort();
-  if (keys.length !== 2 || keys[0] !== "selectors" || keys[1] !== "type") {
-    throw correlationRefusal("assurance_scope must contain only type and selectors");
-  }
-  if (!Array.isArray(scope.selectors) || !scope.selectors.every((selector) => typeof selector === "string" && selector.length > 0)) {
-    throw correlationRefusal("assurance_scope selectors must be non-empty strings");
-  }
-  if (scope.type === "entire-run") {
-    if (scope.selectors.length !== 0) throw correlationRefusal("entire-run assurance_scope requires empty selectors");
-    return { type: "entire-run", selectors: [] };
-  }
-  if (scope.type === "selectors") {
-    if (scope.selectors.length === 0) throw correlationRefusal("selectors scope requires at least one selector");
-    return { type: "selectors", selectors: [...scope.selectors] };
-  }
-  throw correlationRefusal("assurance_scope type must be entire-run or selectors");
-}
-
-/**
- * Snapshot bounded JSON metadata so a caller cannot mutate a record after planning, and so nothing
- * unbounded or undeclared can reach the ledger through it.
- *
- * Refuses with a stable code rather than a bare `Error`: this is reachable from a model-facing tool
- * parameter on all three delegation tools, and it used to throw outside every try, producing a governed
- * refusal with no code and no ledger line at all (R-112).
- */
-export function normaliseCorrelation(input: CorrelationMetadata | undefined): CorrelationMetadata | undefined {
-  if (input === undefined) return undefined;
-  let encoded: string;
-  try {
-    encoded = JSON.stringify(input);
-  } catch (error) {
-    throw correlationRefusal(`must be JSON serializable (${String(error)})`);
-  }
-  if (encoded === undefined) throw correlationRefusal("must be a JSON object");
-  if (Buffer.byteLength(encoded) > MAX_CORRELATION_BYTES) {
-    throw correlationTooLarge(`exceeds ${MAX_CORRELATION_BYTES} bytes`, { limit: MAX_CORRELATION_BYTES });
-  }
-  const parsed = JSON.parse(encoded) as unknown;
-  if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
-    throw correlationRefusal("must be a JSON object");
-  }
-
-  const source = parsed as Record<string, unknown>;
-  const undeclared = Object.keys(source).filter((key) => !CORRELATION_FIELDS.has(key as keyof CorrelationMetadata));
-  if (undeclared.length > 0) {
-    throw correlationRefusal(
-      `carries fields outside the pinned schema 1.0 contract: ${undeclared.sort().join(", ")}`,
-      { undeclared: undeclared.sort().join(",") },
-    );
-  }
-
-  const output: Record<string, unknown> = {};
-  for (const [key, value] of Object.entries(source)) {
-    if (value === undefined || value === null) continue;
-    if (key === "assurance_scope") {
-      const size = Buffer.byteLength(JSON.stringify(value) ?? "");
-      if (size > MAX_CORRELATION_SCOPE_BYTES) {
-        throw correlationTooLarge(
-          `assurance_scope exceeds ${MAX_CORRELATION_SCOPE_BYTES} bytes`,
-          { limit: MAX_CORRELATION_SCOPE_BYTES, actual: size },
-        );
-      }
-      output[key] = normaliseAssuranceScope(value);
-      continue;
-    }
-    if (CORRELATION_NUMERIC.has(key as keyof CorrelationMetadata)) {
-      if (typeof value !== "number" || !Number.isFinite(value)) {
-        throw correlationRefusal(`${key} must be a finite number`, { field: key });
-      }
-      output[key] = value;
-      continue;
-    }
-    if (typeof value !== "string") throw correlationRefusal(`${key} must be a string`, { field: key });
-    if (key === "schema_version" && value !== "1.0") {
-      throw correlationRefusal(`unsupported schema_version ${value}; supported version is 1.0`, {
-        field: key,
-        supported: "1.0",
-      });
-    }
-    if (value.length > MAX_CORRELATION_FIELD_CHARS) {
-      throw correlationTooLarge(
-        `${key} exceeds ${MAX_CORRELATION_FIELD_CHARS} characters`,
-        { field: key, limit: MAX_CORRELATION_FIELD_CHARS, actual: value.length },
-      );
-    }
-    if (CORRELATION_IDENTIFIERS.has(key as keyof CorrelationMetadata) && !isLedgerCorrelationIdentifier(value)) {
-      throw correlationRefusal(`${key} must be an ASCII identifier, not free-form text`, { field: key });
-    }
-    output[key] = value;
-  }
-  return output as CorrelationMetadata;
-}
-
-export function digestTask(task: string): string {
-  return createHash("sha256").update(task, "utf8").digest("hex");
-}
-
-export function digestCapabilities(capabilities: readonly Capability[]): string {
-  const canonical = [...new Set(capabilities)].sort();
-  return createHash("sha256").update(JSON.stringify(canonical), "utf8").digest("hex");
-}
-
-/** Trusted, internally-computed scope of one gated approval. */
-export interface ApprovalBinding {
-  version: "1";
-  task_sha256: string;
-  requested_sha256: string;
-  effective_sha256: string;
-  requested: Capability[];
-  effective: Capability[];
-  definition_sha256?: string;
-  workspace_id?: string;
-  context_id?: string;
-  tree_sha?: string;
-  last_change_seq?: number;
-  parent_id: string;
-}
-
-/**
- * Builds the binding from TRUSTED values only. It deliberately does not take a `CorrelationMetadata`.
- *
- * It used to read `workspace_id` and `context_id` straight out of caller-supplied correlation into what
- * the comment above calls the trusted scope, and a bound approval could then be spent outside the
- * workspace it named (R-110): approve a delegation carrying a real, registry-validated `workspace` spec,
- * then re-issue the identical task with `correlation.workspace_id` set and NO `workspace` field — no
- * registry lookup, no lease, the parent's own cwd, and every digest still matching. The guard that would
- * have caught it can only fire when there is a spec to disagree with.
- *
- * `workspaceId` must therefore be the id of a workspace that was actually resolved and leased.
- * `contextId` is a caller-declared label that nothing validates; it is included because it can only
- * ever NARROW a binding, and a mismatch fails closed.
- */
-export function buildApprovalBinding(input: {
-  task: string;
-  requested: readonly Capability[];
-  effective: readonly Capability[];
-  definitionSha256?: DefinitionDigest["sha256"] | string;
-  parentId: string;
-  /** Id of a workspace this delegation was actually routed to and holds a lease for. */
-  workspaceId?: string;
-  /** Caller-declared label. Narrows only; never a claim that anything was enforced. */
-  contextId?: string;
-  /** Optional upstream tree identity. When supplied, later approval use must match it exactly. */
-  treeSha?: string;
-  /** Optional upstream change floor. When supplied, later approval use must match it exactly. */
-  lastChangeSeq?: number;
-}): ApprovalBinding {
-  const requested = [...new Set(input.requested)].sort();
-  const effective = [...new Set(input.effective)].sort();
-  return {
-    version: "1",
-    task_sha256: digestTask(input.task),
-    requested_sha256: digestCapabilities(requested),
-    effective_sha256: digestCapabilities(effective),
-    requested,
-    effective,
-    ...(input.definitionSha256 ? { definition_sha256: input.definitionSha256 } : {}),
-    ...(input.workspaceId ? { workspace_id: input.workspaceId } : {}),
-    ...(input.contextId ? { context_id: input.contextId } : {}),
-    ...(input.treeSha !== undefined ? { tree_sha: input.treeSha } : {}),
-    ...(input.lastChangeSeq !== undefined ? { last_change_seq: input.lastChangeSeq } : {}),
-    parent_id: input.parentId,
-  };
-}
-
-export function approvalBindingDigest(binding: ApprovalBinding): string {
-  const ordered = {
-    version: binding.version,
-    task_sha256: binding.task_sha256,
-    requested_sha256: binding.requested_sha256,
-    effective_sha256: binding.effective_sha256,
-    requested: binding.requested,
-    effective: binding.effective,
-    definition_sha256: binding.definition_sha256 ?? null,
-    workspace_id: binding.workspace_id ?? null,
-    context_id: binding.context_id ?? null,
-    // Keep the exact pre-ADR-0039 serialization when both additions are absent: persisted approvals store
-    // this digest, so unconditional null placeholders would invalidate every existing bound approval.
-    ...(binding.tree_sha !== undefined ? { tree_sha: binding.tree_sha } : {}),
-    ...(binding.last_change_seq !== undefined ? { last_change_seq: binding.last_change_seq } : {}),
-    parent_id: binding.parent_id,
-  };
-  return createHash("sha256").update(JSON.stringify(ordered), "utf8").digest("hex");
-}
-
-export function isApprovalBinding(value: unknown): value is ApprovalBinding {
-  if (!value || typeof value !== "object" || Array.isArray(value)) return false;
-  const binding = value as Partial<ApprovalBinding>;
-  return binding.version === "1" &&
-    [binding.task_sha256, binding.requested_sha256, binding.effective_sha256].every(
-      (digest) => typeof digest === "string" && /^[a-f0-9]{64}$/i.test(digest),
-    ) &&
-    Array.isArray(binding.requested) && binding.requested.every((item) => typeof item === "string") &&
-    Array.isArray(binding.effective) && binding.effective.every((item) => typeof item === "string") &&
-    typeof binding.parent_id === "string" &&
-    ["definition_sha256", "workspace_id", "context_id", "tree_sha"].every((key) => {
-      const value = (binding as Record<string, unknown>)[key];
-      return value === undefined || typeof value === "string";
-    }) &&
-    (binding.last_change_seq === undefined ||
-      (typeof binding.last_change_seq === "number" && Number.isFinite(binding.last_change_seq))) &&
-    // Self-consistency. This guard's only trust boundary is a binding parsed off DISK
-    // (`approval-store.ts`), so an internally contradictory record — digests that do not match the
-    // capability arrays sitting beside them — must be unrepresentable rather than merely unlikely.
-    binding.requested_sha256 === digestCapabilities(binding.requested as Capability[]) &&
-    binding.effective_sha256 === digestCapabilities(binding.effective as Capability[]);
-}
-
-export function approvalBindingsEqual(a: ApprovalBinding | undefined, b: ApprovalBinding | undefined): boolean {
-  if (a === undefined || b === undefined) return a === b;
-  if (!isApprovalBinding(a) || !isApprovalBinding(b)) return false;
-  return approvalBindingDigest(a) === approvalBindingDigest(b);
-}

package/src/daily-dashboard-host.ts

@@ -1,105 +0,0 @@
-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 { createIntentBudget, openResourceBudget, resourceBindingDigest } from "./resource-budget.ts";
-import { dispatchRequestDigest, type DispatchRequest } from "./dispatch-control.ts";
-import { serveDashboardHost } from "./dashboard-host-transport.ts";
-import { rebindDeclaredWork, type DeclaredWorkState } from "./work-command.ts";
-import { ordinaryCancellation, ordinaryCancellationDigest, type OrdinaryChildren, type OrdinaryTarget } from "./ordinary-children.ts";
-import { dataDigest } from "./debrief-contract.ts";
-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;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)}`;
- const current=resolveWorkSnapshotText(text,selection);if(current.scopeState!=="valid"||!current.scope||!current.snapshot)throw Error("current declared work unavailable");
- const actions:DailyIntentAction[]=[];for(const priority of priorities.slice(1)){
-  const ordered=[priority,...priorities.filter(x=>!same(x.obligation,priority.obligation))].map((x,rank)=>({...x,rank}));
-  actions.push({key:`priority-${hash(intentKey(priority.obligation)).slice(0,12)}`,label:`Put ${label(priority.obligation.id)} first`,action:"reprioritize",fromSelection:selection,events:[],selection,priorities:ordered});
- }
- for(const event of parsed.events){if(event.event!=="work_snapshot")continue;const candidate={snapshot:{id:event.payload.snapshot.snapshotId,digest:event.payload.snapshot.digest},event:{eventId:event.eventId,digest:event.digest}};if(same(candidate,selection))continue;
-  const next=resolveWorkSnapshotText(text,candidate);if(next.scopeState!=="valid"||!next.scope||!next.snapshot||next.snapshot.bindings.length>32)continue;
-  const action=next.scope.digest===current.scope.digest?"select-alternative":next.scope.predecessor&&same(next.scope.predecessor,{kind:current.scope.kind,id:current.scope.id,revision:current.scope.revision,digest:current.scope.digest})?"revise-scope":null;if(!action)continue;
-  actions.push({key:`${action==="revise-scope"?"scope":"alternative"}-${hash(intentKey(candidate)).slice(0,12)}`,label:`Select recorded ${action==="revise-scope"?"scope":"alternative"} ${label(event.payload.snapshot.snapshotId)}`,action,fromSelection:selection,events:[],selection:candidate,priorities:next.snapshot.bindings.map((b,rank)=>({obligation:b.obligation,rank}))});
- }
- return actions.sort((a,b)=>a.key.localeCompare(b.key)).slice(0,8);
-}
-
-/** 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");
- 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: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=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: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??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",...(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});
- 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 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));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((!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:`Stop active agent ${ordinary.children.filter(r=>r.state==="active").indexOf(row)+1}`,request:cancel};
-   });
-   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;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

@@ -1,80 +0,0 @@
-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-input.ts

@@ -1,59 +0,0 @@
-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

@@ -1,45 +0,0 @@
-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 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`,
-    `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");
-}