@zaip-ai/cli 1.3.8 → 1.4.2

package/templates/.agents/dashboard/packages/local-runtime/src/server-reconciliation-result.test.ts

@@ -0,0 +1,68 @@
+import type { WorkspaceFileSystem } from "@zaip-ai/core";
+import { describe, expect, it, vi } from "vitest";
+import { reconcileOpenWork, reconciliationResult } from "./server-workspace.js";
+
+describe("manual reconciliation report", () => {
+  it("reports delivered SPECs and PRDs even when no Task or Run changed", () => {
+    expect(
+      reconciliationResult({
+        reconciliations: [
+          {
+            status: "closed",
+            specs: [{ id: "SPEC-DONE", status: "delivered" }],
+            prds: [{ id: "PRD-DONE", status: "delivered" }],
+          },
+        ],
+      }),
+    ).toEqual({ reconciled_ids: ["PRD-DONE", "SPEC-DONE"], blocked: [], not_reconciled: [] });
+  });
+
+  it("reports the canonical owners of an orphan with their persisted blocking reasons", () => {
+    expect(
+      reconciliationResult({
+        orphaned_executions: ["EXEC-ORPHAN"],
+        orphaned_execution_entities: [
+          {
+            id: "EXEC-ORPHAN",
+            status: "blocked",
+            status_reason: "Host terminated without delivery evidence.",
+          },
+        ],
+        orphaned_owner_entities: [
+          { id: "TASK-ORPHAN", status: "blocked", status_reason: "Host interrupted." },
+          { id: "SPEC-ORPHAN", status: "blocked", status_reason: "Child attempt stopped." },
+          { id: "PRD-ORPHAN", status: "blocked", status_reason: "Child attempt stopped." },
+        ],
+        unresolved_running_run_ids: ["RUN-LIVE"],
+      }),
+    ).toEqual({
+      reconciled_ids: ["EXEC-ORPHAN", "PRD-ORPHAN", "SPEC-ORPHAN", "TASK-ORPHAN"],
+      blocked: [
+        { id: "EXEC-ORPHAN", reason: "Host terminated without delivery evidence." },
+        { id: "PRD-ORPHAN", reason: "Child attempt stopped." },
+        { id: "SPEC-ORPHAN", reason: "Child attempt stopped." },
+        { id: "TASK-ORPHAN", reason: "Host interrupted." },
+      ],
+      not_reconciled: [{ id: "RUN-LIVE", reason: "Invocation is still running." }],
+    });
+  });
+
+  it("does not advertise untouched draft, ready or active entities as reconciled", () => {
+    expect(
+      reconciliationResult({
+        orphaned_owner_entities: [
+          { id: "PRD-DRAFT", status: "draft" },
+          { id: "SPEC-READY", status: "ready" },
+          { id: "TASK-LIVE", status: "executing" },
+        ],
+      }),
+    ).toEqual({ reconciled_ids: [], blocked: [], not_reconciled: [] });
+  });
+
+  it("reports unavailable reconciliation instead of returning a successful empty result", async () => {
+    const filesystem = { exists: vi.fn(async () => false) } as unknown as WorkspaceFileSystem;
+    await expect(reconcileOpenWork(filesystem, "test-workspace")).rejects.toThrow(
+      "could not be reconciled",
+    );
+  });
+});

package/templates/.agents/dashboard/packages/local-runtime/src/server-snapshot-refresh.test.ts

@@ -0,0 +1,19 @@
+import { EventEmitter } from "node:events";
+import { describe, expect, it } from "vitest";
+import { attachRefreshWorkerCleanup } from "./server-snapshot-refresh.js";
+
+describe("snapshot refresh shutdown", () => {
+  it("terminates an active refresh worker on runtime shutdown and removes its listener on completion", () => {
+    const processRef = new EventEmitter();
+    const calls: string[] = [];
+    const cleanup = attachRefreshWorkerCleanup(
+      { kill: (signal) => (calls.push(String(signal)), true) },
+      processRef,
+    );
+    processRef.emit("exit");
+    expect(calls).toEqual(["SIGTERM"]);
+    cleanup();
+    processRef.emit("exit");
+    expect(calls).toEqual(["SIGTERM"]);
+  });
+});

package/templates/.agents/dashboard/packages/local-runtime/src/server-snapshot-refresh.ts

@@ -1,25 +1,13 @@
 import { spawn } from "node:child_process";
-import { randomBytes } from "node:crypto";
 import { existsSync } from "node:fs";
-import { rm } from "node:fs/promises";
-import { dirname, resolve } from "node:path";
+import { resolve } from "node:path";
 import {
   type SqliteReadModelFileSystem,
   sqliteReadModelPath,
   validateSqliteReadModelSchema,
 } from "./sqlite-read-model.js";
-import { activateStagedSqliteSnapshot, stageSqliteSnapshot } from "./sqlite-snapshot-install.js";
 
-/** Rebuilds an isolated SQLite generation so the serving event loop stays available. */
-export async function rebuildSnapshotInWorker(workspaceRoot: string, currentPath: string) {
-  const target = resolve(
-    dirname(currentPath),
-    `refresh-server-${process.pid}-${randomBytes(4).toString("hex")}.sqlite`,
-  );
-  // A temporary/canonical workspace contains data, not necessarily a second
-  // dashboard runtime checkout. The explicit candidates work for a launcher
-  // opened at the workspace root and for fixture tests launched from the
-  // runtime's source checkout, without relying on import.meta in the CJS build.
+async function rebuildPersistentDatabaseInWorker(workspaceRoot: string, destination: string) {
   const scriptCandidates = [
     resolve(
       workspaceRoot,
@@ -40,58 +28,66 @@ export async function rebuildSnapshotInWorker(workspaceRoot: string, currentPath
       cwd: workspaceRoot,
       env: {
         ...process.env,
-        // The script prioritizes ZAIP_WORKSPACE over cwd. Do not inherit a
-        // launcher's root when this refresh was requested for another
-        // canonical workspace (notably an isolated test fixture).
         ZAIP_WORKSPACE: workspaceRoot,
-        ZAIP_SQLITE_DB_PATH: target,
+        ZAIP_SQLITE_DB_PATH: destination,
         ZAIP_SQLITE_PREFER_LAST_VALID_SEED: "0",
         ZAIP_DASHBOARD_LAUNCH_PROGRESS: "0",
       },
       stdio: ["ignore", "ignore", "pipe"],
       windowsHide: true,
     });
+    // Lease shutdown may end the serving parent while a slow snapshot rebuild
+    // is still writing. Terminate the direct child synchronously during parent
+    // exit so the next launcher cannot overlap the persistent SQLite writer.
+    const cleanupWorker = attachRefreshWorkerCleanup(worker);
     worker.stderr?.setEncoding("utf8");
     worker.stderr?.on("data", (chunk: string) => {
-      stderr += chunk;
+      stderr = `${stderr}${chunk}`.slice(-8_000);
     });
-    worker.once("error", rejectWorker);
-    worker.once("exit", (code) =>
-      code === 0
+    worker.once("error", (error) => {
+      cleanupWorker();
+      rejectWorker(error);
+    });
+    worker.once("exit", (code) => {
+      cleanupWorker();
+      return code === 0
         ? resolveWorker()
         : rejectWorker(
             new Error(`SQLite refresh worker failed (${code}): ${stderr.trim() || "no stderr"}`),
-          ),
-    );
+          );
+    });
   });
-  return target;
 }
 
-export async function removeRefreshSnapshot(path: string) {
-  await rm(path, { force: true }).catch(() => {});
+export function attachRefreshWorkerCleanup(
+  worker: { kill(signal?: NodeJS.Signals): boolean },
+  processRef: {
+    once(event: string, listener: () => void): unknown;
+    removeListener(event: string, listener: () => void): unknown;
+  } = process,
+): () => void {
+  const stopWorkerOnParentExit = () => {
+    try {
+      worker.kill("SIGTERM");
+    } catch {
+      /* already terminal */
+    }
+  };
+  processRef.once("exit", stopWorkerOnParentExit);
+  return () => processRef.removeListener("exit", stopWorkerOnParentExit);
 }
 
 /**
- * Builds and validates a replacement outside the serving process, then asks
- * the read-model filesystem to perform only the short close/rename/reopen
- * handoff. The current immutable generation remains readable while staging.
+ * The child process writes the single persistent database in place. WAL keeps
+ * the server reader usable until the worker commits; no staged SQLite file is
+ * created. On an error the worker rolls back and this reader stays untouched.
  */
 export async function refreshSqliteSnapshotInWorker(
   workspaceRoot: string,
   filesystem: SqliteReadModelFileSystem,
 ) {
   const destination = sqliteReadModelPath(workspaceRoot);
-  const refreshedPath = await rebuildSnapshotInWorker(workspaceRoot, destination);
-  try {
-    const stagedPath = await stageSqliteSnapshot(
-      refreshedPath,
-      destination,
-      validateSqliteReadModelSchema,
-    );
-    await filesystem.rebuildAndRefresh(async () => {
-      activateStagedSqliteSnapshot(stagedPath, destination);
-    });
-  } finally {
-    await removeRefreshSnapshot(refreshedPath);
-  }
+  await rebuildPersistentDatabaseInWorker(workspaceRoot, destination);
+  validateSqliteReadModelSchema(destination);
+  filesystem.refresh();
 }

package/templates/.agents/dashboard/packages/local-runtime/src/server-snapshot-revision.test.ts

@@ -0,0 +1,42 @@
+import { mkdir, mkdtemp, rm } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { dirname, join, resolve, sep } from "node:path";
+import { DatabaseSync } from "node:sqlite";
+import { expect, it } from "vitest";
+import { readCommittedSnapshotRevision } from "./server-snapshot-revision.js";
+import { sqliteReadModelPath } from "./sqlite-read-model.js";
+
+it("publishes only committed metadata, preserving the revision through a rolled-back write", async () => {
+  const base = resolve(tmpdir());
+  const root = await mkdtemp(join(base, "zaip-revision-"));
+  if (!resolve(root).startsWith(base + sep))
+    throw new Error("Fixture cleanup outside temporary directory");
+  const databasePath = sqliteReadModelPath(root);
+  await mkdir(dirname(databasePath), { recursive: true });
+  const writer = new DatabaseSync(databasePath);
+  try {
+    writer.exec(`
+      PRAGMA journal_mode=WAL;
+      CREATE TABLE read_model_metadata (key TEXT PRIMARY KEY, value TEXT);
+      CREATE VIEW zaip_vw_read_model_metadata AS SELECT * FROM read_model_metadata;
+      INSERT INTO read_model_metadata VALUES ('schema_version', '1'), ('source_fingerprint', 'first');
+    `);
+    const original = readCommittedSnapshotRevision(root);
+    expect(original).toMatch(/^[a-f0-9]{64}$/);
+    writer.exec(
+      "BEGIN IMMEDIATE; UPDATE read_model_metadata SET value='second' WHERE key='source_fingerprint';",
+    );
+    expect(readCommittedSnapshotRevision(root)).toBe(original);
+    writer.exec("ROLLBACK;");
+    expect(readCommittedSnapshotRevision(root)).toBe(original);
+    writer.exec(
+      "BEGIN IMMEDIATE; UPDATE read_model_metadata SET value='second' WHERE key='source_fingerprint'; COMMIT;",
+    );
+    const committed = readCommittedSnapshotRevision(root);
+    expect(committed).not.toBe(original);
+    expect(readCommittedSnapshotRevision(root)).toBe(committed);
+  } finally {
+    writer.close();
+    await rm(root, { recursive: true, force: true });
+  }
+});

package/templates/.agents/dashboard/packages/local-runtime/src/server-snapshot-revision.ts

@@ -0,0 +1,26 @@
+import { createHash } from "node:crypto";
+import { DatabaseSync } from "node:sqlite";
+import { sqliteReadModelPath } from "./sqlite-read-model.js";
+
+/** Read committed inputs only. Canonical edits and rolled-back writes cannot advance the revision. */
+export function readCommittedSnapshotRevision(workspaceRoot: string): string {
+  const database = new DatabaseSync(sqliteReadModelPath(workspaceRoot), { readOnly: true });
+  try {
+    const rows = database
+      .prepare(
+        "SELECT key, value FROM zaip_vw_read_model_metadata WHERE key IN ('schema_version', 'source_fingerprint')",
+      )
+      .all() as Array<{ key: string; value: string }>;
+    const metadata = new Map(rows.map((row) => [row.key, row.value]));
+    if (!metadata.has("schema_version") || !metadata.has("source_fingerprint")) {
+      throw new Error("Committed SQLite snapshot metadata is incomplete");
+    }
+    return createHash("sha256")
+      .update(metadata.get("schema_version") as string)
+      .update(":")
+      .update(metadata.get("source_fingerprint") as string)
+      .digest("hex");
+  } finally {
+    database.close();
+  }
+}

package/templates/.agents/dashboard/packages/local-runtime/src/server-snapshot-synchronization.ts

@@ -0,0 +1,34 @@
+import { watch } from "node:fs";
+import { join } from "node:path";
+
+export function startSnapshotSynchronization(input: {
+  workspaceRoot: string;
+  staleSeed: boolean;
+  watchSources: boolean;
+  refresh: () => Promise<void>;
+}): void {
+  if (input.staleSeed) void input.refresh().catch(() => undefined);
+  if (!input.watchSources || process.env.ZAIP_DASHBOARD_WATCH_SOURCES === "0") return;
+  let pendingRefresh: NodeJS.Timeout | undefined;
+  const scheduleRefresh = () => {
+    if (pendingRefresh !== undefined) clearTimeout(pendingRefresh);
+    pendingRefresh = setTimeout(() => {
+      pendingRefresh = undefined;
+      void input.refresh().catch(() => undefined);
+    }, 300);
+    pendingRefresh.unref();
+  };
+  for (const sourceRoot of [
+    join(input.workspaceRoot, ".agents", "records"),
+    join(input.workspaceRoot, ".agents", "config"),
+  ]) {
+    try {
+      const watcher = watch(sourceRoot, { recursive: true }, scheduleRefresh);
+      watcher.unref();
+    } catch {
+      // Reuse-triggered refresh remains the portable fallback.
+    }
+  }
+  const freshnessTimer = setInterval(scheduleRefresh, 60_000);
+  freshnessTimer.unref();
+}

package/templates/.agents/dashboard/packages/local-runtime/src/server-startup.ts

@@ -0,0 +1,30 @@
+import type { rebuildSqliteReadModel } from "./sqlite-read-model.js";
+
+export function writeStartupPhase(startedAt: number, phase: string): void {
+  process.stderr.write(
+    `${JSON.stringify({
+      event: "dashboard_sqlite_startup_phase",
+      phase,
+      elapsed_ms: Math.round(performance.now() - startedAt),
+    })}\n`,
+  );
+}
+
+export function writeReadModelStartup(
+  startedAt: number,
+  readModel: Awaited<ReturnType<typeof rebuildSqliteReadModel>>,
+): void {
+  // The parent launcher captures stderr even when stdout is intentionally
+  // hidden. This makes seed hit/miss and private-copy cost observable without
+  // exposing a shared handle or workspace payload.
+  process.stderr.write(
+    `${JSON.stringify({
+      event: "dashboard_sqlite_read_model",
+      elapsed_ms: Math.round(performance.now() - startedAt),
+      cache: readModel.cache,
+      fingerprint_ms: readModel.fingerprint_ms,
+      materialize_ms: readModel.materialize_ms,
+      source_files: readModel.files,
+    })}\n`,
+  );
+}

package/templates/.agents/dashboard/packages/local-runtime/src/server-work-reconciliation.test.ts

@@ -0,0 +1,89 @@
+import { afterEach, describe, expect, it, vi } from "vitest";
+import {
+  createWorkReconciliation,
+  startHostTerminalReconciliation,
+  waitForWorkReconciliation,
+} from "./server-work-reconciliation.js";
+import { type ReconciliationResult, reconciliationCommandTimeoutMs } from "./server-workspace.js";
+
+const clean: ReconciliationResult = { reconciled_ids: [], blocked: [], not_reconciled: [] };
+const changed: ReconciliationResult = {
+  ...clean,
+  reconciled_ids: ["TASK-TERMINAL", "SPEC-DELIVERED", "PRD-DELIVERED"],
+};
+afterEach(() => vi.useRealTimers());
+
+describe("canonical host recovery", () => {
+  it("serializes manual recovery after host-only work and deduplicates concurrent clicks", async () => {
+    let release!: (value: ReconciliationResult) => void;
+    const first = new Promise<ReconciliationResult>((resolve) => {
+      release = resolve;
+    });
+    const reconcile = vi.fn().mockReturnValueOnce(first).mockResolvedValue(changed);
+    const refresh = vi.fn().mockResolvedValue(undefined);
+    const run = createWorkReconciliation({ reconcile, refresh });
+    const automatic = run("host-terminal");
+    await Promise.resolve();
+    const manual = run("manual");
+    expect(run("manual")).toBe(manual);
+    expect(run("host-terminal")).toBe(manual);
+    expect(reconcile.mock.calls).toEqual([["host-terminal"]]);
+    release(clean);
+    await automatic;
+    await expect(manual).resolves.toEqual(changed);
+    expect(reconcile.mock.calls).toEqual([["host-terminal"], ["manual"]]);
+    expect(refresh).toHaveBeenCalledOnce();
+  });
+
+  it("promotes partial changes after a failure and allows the next attempt", async () => {
+    const reconcile = vi
+      .fn()
+      .mockRejectedValueOnce(new Error("writer interrupted"))
+      .mockResolvedValue(clean);
+    const refresh = vi.fn().mockResolvedValue(undefined);
+    const run = createWorkReconciliation({ reconcile, refresh });
+    await expect(run("manual")).rejects.toThrow("writer interrupted");
+    await expect(run("manual")).resolves.toEqual(clean);
+    expect(refresh).toHaveBeenCalledOnce();
+  });
+
+  it("recovers at startup and retries after failure without overlapping work", async () => {
+    vi.useFakeTimers();
+    let release!: () => void;
+    const reconcile = vi
+      .fn()
+      .mockImplementationOnce(
+        () =>
+          new Promise<void>((resolve) => {
+            release = resolve;
+          }),
+      )
+      .mockRejectedValueOnce(new Error("busy"))
+      .mockResolvedValue(undefined);
+    const stop = startHostTerminalReconciliation(reconcile);
+    await vi.advanceTimersByTimeAsync(1_000);
+    await vi.advanceTimersByTimeAsync(90_000);
+    expect(reconcile).toHaveBeenCalledOnce();
+    release();
+    await vi.advanceTimersByTimeAsync(30_000);
+    expect(reconcile).toHaveBeenCalledTimes(2);
+    await vi.advanceTimersByTimeAsync(30_000);
+    expect(reconcile).toHaveBeenCalledTimes(3);
+    stop();
+    await vi.advanceTimersByTimeAsync(60_000);
+    expect(reconcile).toHaveBeenCalledTimes(3);
+  });
+
+  it("bounds total request time even while the canonical writer is queued", async () => {
+    vi.useFakeTimers();
+    let release!: (value: ReconciliationResult) => void;
+    const pending = new Promise<ReconciliationResult>((resolve) => {
+      release = resolve;
+    });
+    const bounded = expect(waitForWorkReconciliation(pending)).rejects.toThrow("exceeded");
+    await vi.advanceTimersByTimeAsync(reconciliationCommandTimeoutMs);
+    await bounded;
+    release(changed);
+    await expect(pending).resolves.toEqual(changed);
+  });
+});

package/templates/.agents/dashboard/packages/local-runtime/src/server-work-reconciliation.ts

@@ -0,0 +1,88 @@
+import {
+  ReconciliationCommandTimeoutError,
+  type ReconciliationResult,
+  reconciliationCommandTimeoutMs,
+} from "./server-workspace.js";
+
+export function reconciliationNeedsRefresh(result: ReconciliationResult): boolean {
+  return result.reconciled_ids.length > 0 || result.blocked.length > 0;
+}
+
+export type ReconciliationMode = "manual" | "host-terminal";
+
+/** Include queue time in the HTTP deadline; the serialized job remains retryable. */
+export async function waitForWorkReconciliation(
+  work: Promise<ReconciliationResult>,
+  onDeadline: () => void = () => undefined,
+): Promise<ReconciliationResult> {
+  let timer: ReturnType<typeof setTimeout> | undefined;
+  try {
+    return await Promise.race([
+      work,
+      new Promise<never>((_resolve, reject) => {
+        timer = setTimeout(() => {
+          onDeadline();
+          reject(new ReconciliationCommandTimeoutError());
+        }, reconciliationCommandTimeoutMs);
+        timer.unref();
+      }),
+    ]);
+  } finally {
+    if (timer !== undefined) clearTimeout(timer);
+  }
+}
+
+/** Serialize canonical mutations from the button and the host recovery timer. */
+export function createWorkReconciliation(input: {
+  reconcile: (mode: ReconciliationMode) => Promise<ReconciliationResult>;
+  refresh: () => Promise<void>;
+}) {
+  let tail = Promise.resolve();
+  const pending = new Map<ReconciliationMode, Promise<ReconciliationResult>>();
+  const refresh = () => void input.refresh().catch(() => undefined);
+  return (mode: ReconciliationMode): Promise<ReconciliationResult> => {
+    const current = pending.get("manual") ?? pending.get(mode);
+    if (current !== undefined) return current;
+    const job = tail
+      .then(() => input.reconcile(mode))
+      .then(
+        (result) => {
+          if (result.reconciled_ids.length > 0 || result.blocked.length > 0) refresh();
+          return result;
+        },
+        (error: unknown) => {
+          // A failed command may already have persisted part of the graph.
+          refresh();
+          throw error;
+        },
+      )
+      .finally(() => pending.delete(mode));
+    pending.set(mode, job);
+    tail = job.then(
+      () => undefined,
+      () => undefined,
+    );
+    return job;
+  };
+}
+
+/** Recover missed host-stop callbacks without relying on an open browser tab. */
+export function startHostTerminalReconciliation(reconcile: () => Promise<unknown>): () => void {
+  let stopped = false;
+  let timer: ReturnType<typeof setTimeout>;
+  const schedule = (delay: number) => {
+    timer = setTimeout(() => {
+      void reconcile()
+        .catch(() => undefined)
+        .finally(() => {
+          if (!stopped) schedule(30_000);
+        });
+    }, delay);
+    timer.unref();
+  };
+  schedule(1_000);
+  return () => {
+    stopped = true;
+    clearTimeout(timer);
+  };
+}

package/templates/.agents/dashboard/packages/local-runtime/src/server-workspace.ts

@@ -68,19 +68,52 @@ export interface ReconciliationResult {
   not_reconciled: ReconciliationItem[];
 }
 
+export const reconciliationCommandTimeoutMs = 170_000;
+
+export class ReconciliationCommandTimeoutError extends Error {
+  constructor() {
+    super(
+      `Open-work reconciliation exceeded ${reconciliationCommandTimeoutMs}ms. Canonical records may contain partial changes; the dashboard projection is being refreshed.`,
+    );
+    this.name = "ReconciliationCommandTimeoutError";
+  }
+}
+
 export async function reconcileOpenWork(
   filesystem: WorkspaceFileSystem,
   workspaceRoot: string,
+  options: { hostTerminalOnly?: boolean } = {},
 ): Promise<ReconciliationResult> {
   if (!(await filesystem.exists(".agents/runtime/bin/zaip.mjs"))) {
-    return { reconciled_ids: [], blocked: [], not_reconciled: [] };
+    throw new Error("ZAIP runtime is unavailable; open work could not be reconciled.");
   }
   const cliPath = resolve(workspaceRoot, ".agents", "runtime", "bin", "zaip.mjs");
-  const { stdout } = await execFileAsync(
-    process.execPath,
-    [cliPath, "run", "reconcile", "--open", "--json"],
-    { cwd: workspaceRoot, windowsHide: true, timeout: 120_000, maxBuffer: 10 * 1_024 * 1_024 },
-  );
+  let stdout: string;
+  try {
+    ({ stdout } = await execFileAsync(
+      process.execPath,
+      [
+        cliPath,
+        "run",
+        "reconcile",
+        "--open",
+        "--json",
+        ...(options.hostTerminalOnly ? ["--host-terminal-only"] : []),
+      ],
+      {
+        cwd: workspaceRoot,
+        windowsHide: true,
+        maxBuffer: 10 * 1_024 * 1_024,
+        timeout: reconciliationCommandTimeoutMs,
+        killSignal: "SIGTERM",
+      },
+    ));
+  } catch (error) {
+    if (typeof error === "object" && error !== null && "killed" in error && error.killed === true) {
+      throw new ReconciliationCommandTimeoutError();
+    }
+    throw error;
+  }
   return reconciliationResult(JSON.parse(stdout) as unknown);
 }
 
@@ -94,6 +127,7 @@ export function reconciliationResult(value: unknown): ReconciliationResult {
   };
   const records =
     typeof value === "object" && value !== null ? (value as Record<string, unknown>) : {};
+  const terminalStatuses = new Set(["completed", "delivered", "blocked", "cancelled", "failed"]);
   const reconciliations = Array.isArray(records.reconciliations) ? records.reconciliations : [];
   for (const candidate of reconciliations) {
     if (typeof candidate !== "object" || candidate === null) continue;
@@ -107,7 +141,7 @@ export function reconciliationResult(value: unknown): ReconciliationResult {
       const record = entity as Record<string, unknown>;
       if (
         item.status === "closed" &&
-        ["completed", "blocked", "cancelled", "failed"].includes(record.status as string) &&
+        terminalStatuses.has(record.status as string) &&
         typeof record.id === "string"
       ) {
         reconciled.add(record.id);
@@ -119,12 +153,39 @@ export function reconciliationResult(value: unknown): ReconciliationResult {
       }
     }
   }
+  // A terminal conversation/root can change canonical telemetry without a
+  // Task graph. It still requires a snapshot promotion so Cost Monitor does
+  // not keep serving the generation that preceded its Run closure.
+  const closedRuns = Array.isArray(records.runs) ? records.runs : [];
+  closedRuns.forEach((candidate) => {
+    if (typeof candidate !== "object" || candidate === null) return;
+    const runId = (candidate as { run?: { run_id?: unknown } }).run?.run_id;
+    if (typeof runId === "string") reconciled.add(runId);
+  });
   const orphanedExecutions = Array.isArray(records.orphaned_executions)
     ? records.orphaned_executions
     : [];
   orphanedExecutions.forEach((id) => {
     remember(blocked, id, "Execution orphaned after the reconciliation grace period.");
   });
+  const orphanedInteractionExecutions = Array.isArray(records.orphaned_interaction_executions)
+    ? records.orphaned_interaction_executions
+    : [];
+  orphanedInteractionExecutions.forEach((id) => {
+    remember(blocked, id, "Interaction Execution orphaned after the reconciliation grace period.");
+  });
+  // Orphan recovery can settle owners without returning a Run reconciliation.
+  // Surface every persisted owner, including macro-only `delivered` outcomes,
+  // so the button reports the changed entities and refreshes their snapshot.
+  for (const key of ["orphaned_owner_entities", "orphaned_execution_entities"]) {
+    for (const candidate of Array.isArray(records[key]) ? records[key] : []) {
+      if (typeof candidate !== "object" || candidate === null) continue;
+      const entity = candidate as Record<string, unknown>;
+      if (typeof entity.id !== "string" || !terminalStatuses.has(entity.status as string)) continue;
+      reconciled.add(entity.id);
+      if (entity.status === "blocked") remember(blocked, entity.id, entity.status_reason);
+    }
+  }
   const errors = Array.isArray(records.reconciliation_errors) ? records.reconciliation_errors : [];
   errors.forEach((candidate) => {
     if (typeof candidate !== "object" || candidate === null) return;

package/templates/.agents/dashboard/packages/local-runtime/src/server.test.ts

@@ -247,15 +247,21 @@ describe("dashboard backend", () => {
       headers: { "x-zaip-session": "test-session" },
     });
     expect(response.status, await response.clone().text()).toBe(200);
-    await expect(response.json()).resolves.toMatchObject({
-      reconciliation: { reconciled_ids: ["TASK-RECONCILED"] },
-    });
+    const receipt = (await response.json()) as Record<string, unknown>;
+    expect(receipt).toMatchObject({ reconciliation: { reconciled_ids: ["TASK-RECONCILED"] } });
+    expect(Object.keys(receipt).sort()).toEqual([
+      "projection_refresh_completed",
+      "reconciliation",
+      "snapshot_state",
+    ]);
     expect(reconcile).toHaveBeenCalledOnce();
-    expect(reconcile).toHaveBeenCalledWith(canonicalFilesystem, workspaceRoot);
+    expect(reconcile).toHaveBeenCalledWith(canonicalFilesystem, workspaceRoot, {
+      hostTerminalOnly: false,
+    });
     expect(refresh).toHaveBeenCalledOnce();
     const rejected = await app.request("/api/v2/reconcile-open-work", { method: "POST" });
     expect(rejected.status).toBe(401);
-  }, 130_000);
+  });
   it("rebuilds a stale immutable projection without reconciling lifecycle work", async () => {
     const fixtureRoot = await mkdtemp(join(tmpdir(), "zaip-dashboard-stale-projection-"));
     const taskIndexPath = join(