pi-daddy 0.22.0 → 0.23.0

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/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-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");
+}

package/src/daily-view.ts

@@ -0,0 +1,152 @@
+import { createHash } from "node:crypto";
+import { projectWorkLedger, parseWorkLedgerText, type WorkProjectionContext, type WorkFrozen, type RevisionRef } from "./work-ledger.ts";
+import { canonicalWorkJson, copyWorkJson } from "./work-ledger-json.ts";
+import { readDailySnapshot, parseArchiveProjection, freezeDaily, type ArchiveExecution } from "./daily-view-input.ts";
+
+export const DAILY_VIEW_VERSION = "pi-daddy-daily-view-v1" as const;
+export interface DailyViewOptions {
+  archiveProjectionPath?: string; workLedgerPath?: string;
+  /** Explicit retained adapter bytes; never authority. Mutually exclusive with the corresponding path. */
+  archiveBytes?: Uint8Array; workBytes?: Uint8Array;
+  sourceManifestBytes?: Readonly<Record<string, Uint8Array>>;
+  /** Genuine independently selected host authority only. Never populated from P03 or a context file. */
+  workContext?: WorkFrozen<WorkProjectionContext>;
+  /** Policy-authorized exact paths keyed by expected raw-manifest SHA256. No producer paths followed. */
+  sourceManifestFiles?: Readonly<Record<string, string>>;
+}
+export interface DailyAttempt {
+  executionId: string; logicalChildId: string | null; intentRuntime: string;
+  archive: ArchiveExecution | null; sourceAvailability: Array<{ sha256: string; state: "available" | "missing" | "mismatch" | "error" }>;
+  issues: string[]; activeBranch: null;
+}
+export interface DailyObligation {
+  key: string; intent: RevisionRef; obligation: RevisionRef; policy: RevisionRef;
+  acceptance: "accepted-under-supplied-authority" | "unaccepted" | "unresolved";
+  artifactCoverage: string; evidenceCoverage: string; receiptIds: string[]; claimReferences: string[];
+  attempts: string[]; activity: "unstarted" | "attempts-attached"; obstacles: string[];
+}
+export interface DailyView {
+  version: typeof DAILY_VIEW_VERSION; readOnly: true; freshness: "snapshot-unknown";
+  model: "not-consulted-connectivity-unknown"; continuity: "initial-snapshot" | "resnapshot" | "reconnected-gap";
+  scopeChanged: boolean; scope: RevisionRef | null; selectedSnapshot: WorkProjectionContext["selectedSnapshot"];
+  scopeState: string; progress: { accepted: number; total: number } | null;
+  authority: "supplied-host-context" | "unavailable" | "stale-for-selection"; coverage: "partial";
+  sources: { archive: string; work: string; archiveSha256: string | null; workSha256: string | null };
+  obligations: DailyObligation[]; attempts: DailyAttempt[]; issues: string[]; narrative: string;
+}
+const refKey = (r: WorkFrozen<RevisionRef>) => `${r.kind}:${r.id}:${r.revision}:${r.digest}`;
+const sorted = (values: readonly string[]) => [...new Set(values)].sort();
+function contextCopy(value: DailyViewOptions["workContext"]): WorkProjectionContext {
+  const copied = JSON.parse(canonicalWorkJson(copyWorkJson(value ?? { selectedSnapshot: null, authority: null }))) as WorkProjectionContext;
+  if (projectWorkLedger("", copied).errors.some(e => e.code === "WORK_CONTEXT_INVALID")) throw new TypeError("invalid independent P01 context");
+  return copied;
+}
+const readers = new WeakSet<object>();
+/** Only actual factory readers may carry continuity state through the dashboard; not arbitrary callbacks. */
+export function isDailyViewReader(value: unknown): value is ReturnType<typeof createDailyViewReader> {
+  return typeof value === "function" && readers.has(value);
+}
+/** Each read starts from complete bounded snapshots. The tracker holds only gap/scope metadata, not authority. */
+export function createDailyViewReader() {
+  let seen = false, gap = false, lastSelection = "";
+  const read = async (options: DailyViewOptions): Promise<DailyView> => {
+    try {
+    const archivePath = options.archiveProjectionPath, workPath = options.workLedgerPath;
+    const context = contextCopy(options.workContext);
+    const files = Object.fromEntries(Object.entries(options.sourceManifestFiles ?? {}));
+    if (Object.keys(files).length > 128 || Object.entries(files).some(([key, value]) => !/^[a-f0-9]{64}$/.test(key) || typeof value !== "string")) throw new TypeError("bounded explicit source file map required");
+    const snapshot = (bytes: Uint8Array | undefined, path: string | undefined, limit: number) => {
+      if (bytes === undefined) return readDailySnapshot(path, limit);
+      if (path !== undefined || !(bytes instanceof Uint8Array) || bytes.length > limit) throw new TypeError("bounded exclusive retained snapshot required");
+      const copy=Buffer.from(bytes); return { status: "read" as const, bytes: copy, sha256: createHash("sha256").update(copy).digest("hex") };
+    };
+    const entries=Object.entries(options.sourceManifestBytes??{});if(entries.length>128)throw Error("source byte map bound");
+    const manifestBytes=Object.fromEntries(entries.map(([key,bytes])=>{
+      if(!/^[a-f0-9]{64}$/.test(key)||!(bytes instanceof Uint8Array)||bytes.length>65536)throw Error("bounded source bytes required");return [key,Buffer.from(bytes)];
+    }));
+    const [archiveRead, workRead] = await Promise.all([snapshot(options.archiveBytes,archivePath, 2*1024*1024), snapshot(options.workBytes,workPath, 16 * 1024 * 1024)]);
+    let archiveStatus: string = archiveRead.status, workStatus: string = workRead.status;
+    let archive: ArchiveExecution[] = [], work = projectWorkLedger("", context), workText = "";
+    const issues: string[] = [];
+    if (archiveRead.status === "read") {
+      try { archive = parseArchiveProjection(new TextDecoder("utf-8", { fatal: true }).decode(archiveRead.bytes)).executions; }
+      catch { archiveStatus = "error"; issues.push("archive-invalid-or-unsupported-version"); }
+    }
+    if (workRead.status === "read") {
+      try { workText = new TextDecoder("utf-8", { fatal: true }).decode(workRead.bytes); work = projectWorkLedger(workText, context); }
+      catch { workStatus = "error"; issues.push("work-input-invalid"); }
+      if (work.errors.length) { workStatus = "error"; issues.push("work-projection-errors"); }
+    }
+    const selection = JSON.stringify(context.selectedSnapshot), scopeChanged = seen && selection !== lastSelection;
+    const unavailable = archiveStatus !== "read" || ((Boolean(workPath) || options.workBytes !== undefined) && workStatus !== "read");
+    if (unavailable) gap = true;
+    const continuity = seen ? gap && !unavailable ? "reconnected-gap" : "resnapshot" : "initial-snapshot";
+    seen = true; lastSelection = selection;
+    if (scopeChanged) issues.push("scope-selection-changed; prior acceptance not carried forward");
+    if (gap) issues.push("observation-gap; resnapshot is not continuity");
+    if (archiveStatus !== "read") issues.push(`archive-${archiveStatus}`);
+    if (workStatus !== "read") issues.push(`work-${workStatus}`);
+    // Authority snapshot and selected work snapshot inhabit different identity namespaces.
+    // Applicability comes from P01's exact claim/selection/receipt validation, never ID equality.
+    const stale = !work.claims.some(c => c.matchedReceiptIds.length) && work.claims.some(c =>
+      c.applicability === "superseded" || c.problems.some(p => p.code === "RECEIPT_MISMATCH"));
+    const authority: DailyView["authority"] = !context.authority ? "unavailable" : stale ? "stale-for-selection" : "supplied-host-context";
+    if (authority !== "supplied-host-context") issues.push(`host-authority-${authority}`);
+    const events = workText && work.scopeState === "valid" ? parseWorkLedgerText(workText).events : [];
+    const selected = events.find(e => e.event === "work_snapshot" && e.eventId === context.selectedSnapshot?.event.eventId && e.digest === context.selectedSnapshot.event.digest);
+    const scope = selected?.event === "work_snapshot" ? selected.payload.snapshot.scope : null;
+    const available = new Map<string, DailyAttempt["sourceAvailability"][number]["state"]>();
+    const requested = sorted(archive.flatMap(e => e.sourceReferences));
+    for (const sha256 of requested) {
+      if (manifestBytes[sha256]) { available.set(sha256,createHash("sha256").update(manifestBytes[sha256]).digest("hex")===sha256?"available":"mismatch"); continue; }
+      if (!files[sha256]) { available.set(sha256, "missing"); continue; }
+      const source = await readDailySnapshot(files[sha256], 64 * 1024);
+      available.set(sha256, source.status === "read" ? source.sha256 === sha256 ? "available" : "mismatch" : source.status === "error" ? "error" : "missing");
+    }
+    const attempts = new Map<string, DailyAttempt>();
+    for (const attempt of work.runtime?.attempts ?? []) attempts.set(attempt.executionId, {
+      executionId: attempt.executionId, logicalChildId: attempt.childId, intentRuntime: attempt.state, archive: null,
+      sourceAvailability: [], issues: attempt.problems.map(p => `P01:${p.code}`), activeBranch: null,
+    });
+    for (const entry of archive) {
+      const a = attempts.get(entry.executionId) ?? { executionId: entry.executionId, logicalChildId: null, intentRuntime: "unknown",
+        archive: null, sourceAvailability: [], issues: [], activeBranch: null } as DailyAttempt;
+      a.archive = entry; a.issues.push(...entry.issues.map(i => `P03:${i}`));
+      a.sourceAvailability = entry.sourceReferences.map(sha256 => ({ sha256, state: available.get(sha256) ?? "missing" }));
+      if (!entry.sourceReferences.length) a.issues.push("source-hashes-absent");
+      if (a.sourceAvailability.some(r => r.state !== "available")) a.issues.push("source-bytes-unavailable-or-mismatched");
+      const intent = work.runtime?.attempts.find(r => r.executionId === entry.executionId);
+      if (intent && (entry.parentExecutionIds.length !== 1 || entry.parentExecutionIds[0] !== intent.parentExecutionId)) a.issues.push("P01-P03-parent-disagreement");
+      if (intent && intent.state === "running" && entry.runtime === "terminal") a.issues.push("P01-P03-runtime-disagreement");
+      a.issues = sorted(a.issues); attempts.set(a.executionId, a);
+    }
+    const obligations: DailyObligation[] = work.obligations.map(o => {
+      const attached = (work.runtime?.attempts ?? []).filter(a => a.bindings.some(b => scope && refKey(b.scope) === refKey(scope) && refKey(b.obligation) === refKey(o.binding.obligation)));
+      return {
+        key: canonicalWorkJson(copyWorkJson(o.binding)), intent: o.binding.intent, obligation: o.binding.obligation, policy: o.binding.policy,
+        acceptance: authority === "supplied-host-context" ? o.acceptance : "unresolved", artifactCoverage: o.artifactCoverage.state,
+        evidenceCoverage: o.evidenceCoverage.state,
+        receiptIds: sorted(work.claims.filter(c => o.claims.some(r => r.eventId === c.claim.eventId && r.digest === c.claim.digest)).flatMap(c => [...c.matchedReceiptIds])),
+        claimReferences: o.claims.map(c => `${c.eventId}:${c.digest}`).sort(), attempts: attached.map(a => a.executionId).sort(),
+        activity: attached.length ? "attempts-attached" : "unstarted", obstacles: sorted(o.problems.map(p => `P01:${p.code}`)),
+      };
+    });
+    obligations.sort((a, b) => {
+      const left = `${a.obligation.id}:${a.key}`, right = `${b.obligation.id}:${b.key}`;
+      return left < right ? -1 : left > right ? 1 : 0;
+    });
+    const progress = authority === "supplied-host-context" && workStatus === "read" ? work.progress : null;
+    issues.push(...work.problems.map(p => `P01:${p.code}`));
+    const view: DailyView = { version: DAILY_VIEW_VERSION, readOnly: true, freshness: "snapshot-unknown", model: "not-consulted-connectivity-unknown",
+      continuity, scopeChanged, scope, selectedSnapshot: context.selectedSnapshot, scopeState: work.scopeState,
+      progress, authority, coverage: "partial",
+      sources: { archive: archiveStatus, work: workStatus, archiveSha256: archiveRead.status === "read" ? archiveRead.sha256 : null, workSha256: workRead.status === "read" ? workRead.sha256 : null },
+      obligations, attempts: [...attempts.values()].sort((a, b) => a.executionId < b.executionId ? -1 : a.executionId > b.executionId ? 1 : 0), issues: sorted(issues),
+      narrative: `${obligations.length} scoped obligation(s); ${progress ? `${progress.accepted}/${progress.total} accepted under supplied P01 authority` : "acceptance unresolved"}; ${attempts.size} distinct attempt(s). Runtime exits do not establish acceptance. Snapshot freshness unknown.`,
+    };
+    return freezeDaily(view);
+    } catch (error) { gap = true; seen = true; throw error; }
+  };
+  readers.add(read); return read;
+}
+export const readDailyView = (options: DailyViewOptions): Promise<DailyView> => createDailyViewReader()(options);

package/src/dashboard-cli.ts

@@ -1,10 +1,33 @@
 #!/usr/bin/env node
+import { connectDashboardHost, isDashboardConnection, ENV_DASHBOARD_HOST_SOCKET, type DashboardConnection } from "./dashboard-host-transport.ts";
+import { dashboardHostRequest, type DashboardHostRequest } from "./dashboard-host.ts";
+export { ENV_DASHBOARD_HOST_SOCKET } from "./dashboard-host-transport.ts";
 import { realpathSync } from "node:fs";
 import { readFile } from "node:fs/promises";
 import { resolve } from "node:path";
 import { pathToFileURL } from "node:url";
 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 { projectWorkLedger, type WorkProjectionContext } from "./work-ledger.ts";
+import { parseRetentionJson } from "./retention-json.ts";
+import { createInterface } from "node:readline";
+import { isDebriefPresenter, type DebriefPresenter } from "./debrief.ts";
+import { renderDebrief, debriefAction } from "./debrief-render.ts";
+import { createFixtureDebrief } from "./debrief-fixture.ts";
+export const ENV_DEBRIEF_FIXTURE = "PI_DADDY_DEBRIEF_FIXTURE";
+export { debriefAction as dashboardDebriefAction } from "./debrief-render.ts";
+
+export const ENV_DAILY_ARCHIVE = "PI_DADDY_ARCHIVE_PROJECTION";
+export const ENV_DAILY_WORK = "PI_DADDY_WORK_LEDGER";
+export const ENV_DAILY_SELECTION = "PI_DADDY_WORK_SNAPSHOT";
+function dailySelection(text: string | undefined): WorkProjectionContext["selectedSnapshot"] {
+  if (!text) return null;
+  const selection = parseRetentionJson(text) as WorkProjectionContext["selectedSnapshot"];
+  if (projectWorkLedger("", { selectedSnapshot: selection, authority: null }).errors.some(e => e.code === "WORK_CONTEXT_INVALID")) throw new TypeError("invalid P01 snapshot selection");
+  return selection;
+}
 
 export const DASHBOARD_PROTOCOL_VERSION = 1 as const;
 export const ENV_DASHBOARD_LEDGER = "PI_DADDY_LEDGER";
@@ -20,6 +43,16 @@ export interface DashboardFrameOptions {
   width?: number;
   details?: boolean;
   now?: Date;
+  dailyView?: DailyViewOptions;
+  dailyReader?: ReturnType<typeof createDailyViewReader>;
+  dailyJson?: boolean;
+  debrief?: DebriefPresenter;
+  debriefJson?: boolean;
+  connected?: DashboardConnection;
+}
+export async function dashboardHostAction(host:DashboardConnection,line:string){
+  if(!isDashboardConnection(host)||Buffer.byteLength(line)>60000)throw Error("genuine bounded dashboard connection required");
+  return host.action(dashboardHostRequest(parseRetentionJson(line,60000) as DashboardHostRequest));
 }
 
 function shellQuote(value: string): string {
@@ -57,6 +90,29 @@ export async function dashboardFrame(options: DashboardFrameOptions): Promise<st
   if (options.protocol !== undefined && options.protocol !== DASHBOARD_PROTOCOL_VERSION) {
     return incompatibleFrame(options.protocol);
   }
+  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{return "PI-DADDY — CONNECTED HOST UNAVAILABLE\nNo prior acceptance, presentation or continuity substituted. No action retried.";}
+    if(options.dailyJson||options.debriefJson)return JSON.stringify(view);
+    const source=view.source as {daily?:Parameters<typeof renderDailyView>[0]}|null;
+    return ["PI-DADDY — CONNECTED HOST (snapshot; identity/acceptance not authenticated)",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.",
+      `Attention reserved ${view.attention.attentionUsed}/5 (not proof of delivery). Tip ${view.tip}.`,"Explicit exact approved JSON requests only; refresh never acts."].join("\n\n");
+  }
+  if (options.debrief || options.debriefJson) {
+    if (!isDebriefPresenter(options.debrief)) return "PI-DADDY — DEBRIEF UNAVAILABLE: genuine presenter/host missing";
+    const view = options.debrief.view(); return options.debriefJson ? JSON.stringify(view) : renderDebrief(view, options.width);
+  }
+  if (options.dailyView) {
+    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);
+    } catch {
+      return "PI-DADDY — DAILY VIEW UNAVAILABLE\nInvalid or unavailable read-only input. No previous acceptance or continuity was substituted.";
+    }
+  }
   if (!options.ledgerPath) return setupFrame(options.cwd);
 
   const ledgerPath = resolve(options.cwd, options.ledgerPath);
@@ -90,25 +146,43 @@ interface CliOptions {
   details: boolean;
   color: boolean;
   ledgerPath?: string;
+  archivePath?: string;
+  workPath?: string;
+  selection?: string;
+  dailyJson: boolean;
+  debriefFixture: boolean;
+  debriefJson: boolean;
+  hostSocket?: string;
 }
 
 function parseArgs(argv: string[]): CliOptions {
   let once = false;
   let details = false;
   let color = process.stdout.isTTY;
-  let ledgerPath: string | undefined;
+  let ledgerPath: string | undefined, archivePath: string | undefined, workPath: string | undefined, selection: string | undefined;
+  let dailyJson = false, debriefFixture = false, debriefJson = false;let hostSocket:string|undefined;
   for (let index = 0; index < argv.length; index += 1) {
     const arg = argv[index];
     if (arg === "--once") once = true;
     else if (arg === "--details") details = true;
     else if (arg === "--no-color") color = false;
     else if (arg === "--ledger") ledgerPath = argv[++index];
+    else if (arg === "--daily-json") dailyJson = true;
+    else if (arg === "--debrief-fixture") debriefFixture = true;
+    else if (arg === "--debrief-json") debriefJson = true;
+    else if(arg === "--host-socket"){hostSocket=argv[++index];if(!hostSocket||hostSocket.startsWith("--"))throw Error("explicit host socket required");}
+    else if (["--archive-projection", "--work-ledger", "--work-snapshot"].includes(arg)) {
+      const value = argv[++index]; if (!value || value.startsWith("--")) throw new Error("missing daily view argument");
+      if (arg === "--archive-projection") archivePath = value;
+      else if (arg === "--work-ledger") workPath = value;
+      else selection = value;
+    }
     else throw new Error(`unknown dashboard argument ${JSON.stringify(arg)}`);
   }
-  return { once, details, color, ledgerPath };
+  return { once, details, color, ledgerPath, archivePath, workPath, selection, dailyJson, debriefFixture, debriefJson, hostSocket };
 }
 
-export async function runDashboard(argv = process.argv.slice(2), env: NodeJS.ProcessEnv = process.env): Promise<void> {
+export async function runDashboard(argv = process.argv.slice(2), env: NodeJS.ProcessEnv = process.env, host: { debrief?: DebriefPresenter; connected?:DashboardConnection } = {}): Promise<void> {
   const cli = parseArgs(argv);
   const cwd = process.cwd();
   const ledgerPath = cli.ledgerPath ?? (env[ENV_DASHBOARD_LEDGER]?.trim() || undefined);
@@ -117,6 +191,22 @@ export async function runDashboard(argv = process.argv.slice(2), env: NodeJS.Pro
   const key = env[ENV_DASHBOARD_KEY]?.trim();
   process.title = `pi-daddy-dashboard${key ? `:${key.slice(0, 12)}` : ""}`;
 
+  const archivePath = cli.archivePath ?? env[ENV_DAILY_ARCHIVE];
+  const workPath = cli.workPath ?? env[ENV_DAILY_WORK];
+  const selectedSnapshot = dailySelection(cli.selection ?? env[ENV_DAILY_SELECTION]);
+  const dailyView = archivePath || workPath || selectedSnapshot || cli.dailyJson ? {
+    archiveProjectionPath: archivePath ? resolve(cwd, archivePath) : undefined,
+    workLedgerPath: workPath ? resolve(cwd, workPath) : undefined,
+    workContext: { selectedSnapshot, authority: null },
+  } : undefined;
+  const socket=cli.hostSocket??env[ENV_DASHBOARD_HOST_SOCKET];const connected=host.connected??(socket?connectDashboardHost(socket):undefined);
+  if(connected&&(host.debrief||cli.debriefFixture||env[ENV_DEBRIEF_FIXTURE]==="1"))throw Error("connected host and separate debrief are exclusive");
+  const debrief = host.debrief ?? (cli.debriefFixture || env[ENV_DEBRIEF_FIXTURE] === "1" ? await createFixtureDebrief() : undefined);
+  if (debrief) {
+    if (!isDebriefPresenter(debrief)) throw new Error("invalid debrief presenter");
+    if (!host.debrief) await debrief.open({ mode: "manual", userPresent: true }); // Explicit CLI fixture only; never override a host deferral.
+  }
+  const dailyReader = createDailyViewReader();
   let previous = "";
   const draw = async (clear: boolean): Promise<void> => {
     const frame = await dashboardFrame({
@@ -126,6 +216,7 @@ export async function runDashboard(argv = process.argv.slice(2), env: NodeJS.Pro
       color: cli.color,
       width: process.stdout.columns || 80,
       details: cli.details,
+      dailyView, dailyReader, dailyJson: cli.dailyJson, debrief, debriefJson: cli.debriefJson, connected,
     });
     if (frame === previous && !clear) return;
     previous = frame;
@@ -143,11 +234,19 @@ export async function runDashboard(argv = process.argv.slice(2), env: NodeJS.Pro
     drawing = true;
     void draw(true).finally(() => { drawing = false; });
   };
+  const input = debrief || connected ? createInterface({ input: process.stdin, terminal: false }) : null;
+  let acting = false;
+  input?.on("line", line => {
+    if (acting) return;
+    acting = true;
+    void (connected?dashboardHostAction(connected,line):debriefAction(debrief!, line)).catch(() => { process.stderr.write("Debrief action refused or acknowledgement unknown; inspect/reconcile explicitly.\n"); })
+      .finally(() => { acting = false; redraw(); });
+  });
   const timer = setInterval(redraw, DASHBOARD_REFRESH_MS);
   process.on("SIGWINCH", redraw);
   await new Promise<void>((settle) => {
     const stop = () => {
-      clearInterval(timer);
+      clearInterval(timer); input?.close();
       process.off("SIGWINCH", redraw);
       settle();
     };

package/src/dashboard-harness.ts

@@ -0,0 +1,28 @@
+import { constants } from "node:fs";
+import { lstat,realpath,open,mkdir,mkdtemp,writeFile,symlink } from "node:fs/promises";
+import { dirname,join,isAbsolute } from "node:path";
+import { pathToFileURL } from "node:url";
+import { dataDigest,byteDigest,detached,sha } from "./debrief-contract.ts";
+import { DASHBOARD_HARNESS_PIN,type DashboardHarness } from "./dashboard-host-contract.ts";
+export interface DashboardHarnessArtifact {version:"dashboard-harness-artifact-v1";sourceCommit:typeof DASHBOARD_HARNESS_PIN;files:Record<string,string>;typeboxRoot:string;typeboxPackageSha256:string}
+const loaded=new WeakMap<object,string>();
+export const loadedDashboardHarnessDigest=(h:unknown):string|null=>typeof h==="object"&&h!==null?loaded.get(h)??null:null;
+async function privateDirectory(path:string){const stat=await lstat(path);if(!isAbsolute(path)||await realpath(path)!==path||!stat.isDirectory()||stat.mode&0o077||stat.uid!==process.getuid?.())throw Error("canonical private owned harness directory required");}
+async function bytes(path:string){if(await realpath(path)!==path)throw Error("harness artifact alias");const fd=await open(path,constants.O_RDONLY|constants.O_NOFOLLOW|constants.O_NONBLOCK);try{const stat=await fd.stat();if(!stat.isFile()||stat.nlink!==1||stat.mode&0o022||stat.size>1048576)throw Error("bounded immutable artifact required");const value=Buffer.alloc(stat.size+1),n=await fd.read(value,0,value.length,0),after=await fd.stat();if(n.bytesRead!==stat.size||after.size!==stat.size||after.mtimeMs!==stat.mtimeMs||after.ctimeMs!==stat.ctimeMs)throw Error("artifact changed during read");return value.subarray(0,n.bytesRead);}finally{await fd.close();}}
+/** Load approved real compiled artifacts into an exclusive private tree, avoiding stale module-cache paths.
+ * Byte identity is NOT human/module authentication or hostile-same-UID confinement. No build/install here.
+ * Typebox is the explicit existing peer; its package metadata is bound, not a whole peer-source attestation. */
+export async function loadDashboardHarness(artifactRoot:string,input:DashboardHarnessArtifact,parent:string){
+ const manifest=detached(input);if(manifest.version!=="dashboard-harness-artifact-v1"||manifest.sourceCommit!==DASHBOARD_HARNESS_PIN||!sha(manifest.typeboxPackageSha256))throw Error("exact supported harness artifact required");
+ const files=Object.entries(manifest.files);if(!files.length||files.length>128||files.some(([p,h])=>!sha(h)||!/^([a-zA-Z0-9_-]+\/)*[a-zA-Z0-9_.-]+\.(js|json)$/.test(p)))throw Error("bounded closed artifact inventory required");
+ await privateDirectory(artifactRoot);await privateDirectory(parent);
+ if(await realpath(manifest.typeboxRoot)!==manifest.typeboxRoot||byteDigest(await bytes(join(manifest.typeboxRoot,"package.json")))!==manifest.typeboxPackageSha256)throw Error("retained typebox peer changed");
+ const content=new Map<string,Buffer>();let total=0;for(const[p,digest]of files){const b=await bytes(join(artifactRoot,p));total+=b.length;if(total>8*1024*1024||byteDigest(b)!==digest)throw Error("harness artifact digest mismatch");content.set(p,b);}
+ if(content.get("package.json")?.toString()!=='{"type":"module"}')throw Error("explicit ESM artifact root required");
+ const directory=await mkdtemp(join(parent,"loaded-harness-"));for(const[p,b]of content){await mkdir(dirname(join(directory,p)),{recursive:true,mode:0o700});await writeFile(join(directory,p),b,{flag:"wx",mode:0o400});}
+ await mkdir(join(directory,"node_modules"));await symlink(manifest.typeboxRoot,join(directory,"node_modules/typebox"));
+ const names=["learning-journal","trust-lifecycle","archive-policy","archive-observer","archive-checkpoint","archived-work","execution-retention-archive","work-case-review","blind-intervention","evidence-archive","work-signal-observation","work-signal-cases","work-case-archive"];
+ const api=Object.assign({},...await Promise.all([...names.map(n=>"packages/adapters/src/"+n+".js"),"core.js"].map(p=>{if(!content.has(p))throw Error("missing genuine harness entry");return import(pathToFileURL(join(directory,p)).href);}))) as DashboardHarness;
+ for(const[p,digest]of files)if(byteDigest(await bytes(join(directory,p)))!==digest)throw Error("loaded harness bytes changed");
+ Object.freeze(api);const digest=dataDigest(manifest);loaded.set(api,digest);return Object.freeze({api,artifactDigest:digest,directory,manifest});
+}

package/src/dashboard-herdr.ts

@@ -6,7 +6,7 @@ import {
   ENV_DASHBOARD_KEY,
   ENV_DASHBOARD_LEDGER,
   ENV_DASHBOARD_PROTOCOL,
-  DASHBOARD_PROTOCOL_VERSION,
+  DASHBOARD_PROTOCOL_VERSION, ENV_DAILY_ARCHIVE, ENV_DAILY_WORK, ENV_DAILY_SELECTION, ENV_DEBRIEF_FIXTURE, ENV_DASHBOARD_HOST_SOCKET,
 } from "./dashboard-cli.ts";
 import { parseReply, type HerdrExec } from "./herdr-cli.ts";
 import { withFileLock } from "./file-lock.ts";
@@ -263,8 +263,12 @@ export async function openOrReuseDashboard(input: DashboardOpenInput): Promise<D
   const exec = input.exec ?? dashboardHerdrExec;
   const ledgerPath = input.ledgerPath.trim() ? resolve(input.cwd, input.ledgerPath) : "";
   const cwd = resolve(input.cwd);
+  // Explicit operator inputs/owned host endpoint only, never an authority file or ambient snapshot.
+  // The endpoint keeps original controller handles in its owning process; it is not TUI attachment.
+  const dailyEnv = [ENV_DAILY_ARCHIVE, ENV_DAILY_WORK, ENV_DAILY_SELECTION, ENV_DEBRIEF_FIXTURE, ENV_DASHBOARD_HOST_SOCKET]
+    .flatMap(name => process.env[name] ? ["--env", `${name}=${process.env[name]}`] : []);
   const key = createHash("sha256")
-    .update(`${input.host.workspaceId}\0${input.host.tabId}\0${ledgerPath}`, "utf8")
+    .update(`${input.host.workspaceId}\0${input.host.tabId}\0${ledgerPath}${dailyEnv.length ? JSON.stringify([cwd, ...dailyEnv]) : ""}`, "utf8")
     .digest("hex");
   await mkdir(dirname(input.statePath), { recursive: true });
 
@@ -307,6 +311,7 @@ export async function openOrReuseDashboard(input: DashboardOpenInput): Promise<D
       ...(ledgerPath ? ["--env", `${ENV_DASHBOARD_LEDGER}=${ledgerPath}`] : []),
       "--env", `${ENV_DASHBOARD_PROTOCOL}=${DASHBOARD_PROTOCOL_VERSION}`,
       "--env", `${ENV_DASHBOARD_KEY}=${key}`,
+      ...dailyEnv,
       "--no-focus",
     ];
     const opened = parseReply(await exec(args));