@zaip-ai/cli 1.3.7 → 1.4.1

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(

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

@@ -34,6 +34,7 @@ import {
   readProjectOverview,
   readProjectSettings,
 } from "./project-settings.js";
+import { agentPortraitFiles, openWorkIds } from "./server-agent-assets.js";
 import {
   type BoardClassification,
   boardFilters,
@@ -41,6 +42,7 @@ import {
   boardStage,
   classificationPage,
 } from "./server-board.js";
+import { registerBrowserLeaseRoute } from "./server-browser-lease.js";
 import { registerDailyReadModelRoute } from "./server-daily-read-models-route.js";
 import {
   changeEntityPageRows,
@@ -64,11 +66,24 @@ import {
 } from "./server-projections.js";
 import { isAllowedDashboardAuthority } from "./server-request-authority.js";
 import { refreshSqliteSnapshotInWorker } from "./server-snapshot-refresh.js";
+import { readCommittedSnapshotRevision } from "./server-snapshot-revision.js";
+import { startSnapshotSynchronization } from "./server-snapshot-synchronization.js";
 import { buildSqliteTaskTrace } from "./server-sqlite-task-trace.js";
+import { writeReadModelStartup, writeStartupPhase } from "./server-startup.js";
 import { queryValues, selectedCurrency } from "./server-summary-helpers.js";
+import {
+  createWorkReconciliation,
+  reconciliationNeedsRefresh,
+  startHostTerminalReconciliation,
+  waitForWorkReconciliation,
+} from "./server-work-reconciliation.js";
+
+export { reconciliationNeedsRefresh } from "./server-work-reconciliation.js";
+
 import {
   dashboardIdentity,
   dashboardWorkspaceKey,
+  ReconciliationCommandTimeoutError,
   type ReconciliationResult,
   reconcileOpenWork,
 } from "./server-workspace.js";
@@ -79,6 +94,7 @@ import {
 } from "./sqlite-read-model.js";
 
 export { manifestRun, mergeManifestRuns } from "./manifest-runs.js";
+export { openWorkIds } from "./server-agent-assets.js";
 export { projectionPeriodFilter } from "./server-period.js";
 export { projectAllTimeTopTasks } from "./server-period-macro-metric.js";
 export {
@@ -94,10 +110,6 @@ export {
   validateSqliteReadModelSchema,
 } from "./sqlite-read-model.js";
 
-export function reconciliationNeedsRefresh(result: ReconciliationResult): boolean {
-  return result.reconciled_ids.length > 0 || result.blocked.length > 0;
-}
-
 type OverviewMacroMetrics = NonNullable<
   NonNullable<OperationsProjection["summary"]["overview_metrics"]>["macro_metrics"]
 >;
@@ -108,47 +120,6 @@ const RUNTIME_KIND = "zaip-dashboard-sqlite-runtime";
 const SESSION_COOKIE = "zaip-dashboard-sqlite-session";
 const WORK_PRIORITY_PATH = ".agents/dashboard/work-priority.json";
 const SNAPSHOT_CACHE_TTL_MS = 5_000;
-const agentPortraitFiles: Record<string, string> = {
-  "agent-orchestrator": "1 - Dave - Product Owner.png",
-  "agent-builder": "2 - Rafa - Tech Lead.png",
-  "agent-task-executor": "3 - Leo - Software Engineer.png",
-  "agent-analyst": "4 - Bia - Product Manager.png",
-  "agent-finalizer": "5 - Gui - Quality Assurance Lead.png",
-  "agent-reviewer": "6 - Nanda - Principal Engineer.png",
-  "agent-integrator": "7 - Dani - Integration Engineer.png",
-  "agent-auditor": "8 - Ana - Quality Auditor.png",
-  "agent-text-summarizer": "9 - Lia - Technical Writer.png",
-  "agent-data-analyst": "10 - Gabi - Data Analyst.png",
-  "agent-refactoring-specialist": "11 - Tati - Refactoring Specialist.png",
-  "agent-frontend": "12 - Doug - Frontend Developer.png",
-  "agent-backend": "13 - Will - Backend Developer.png",
-  "agent-website-developer": "14 - Jonny - Website Developer.png",
-  "agent-designer": "15 - Manu - Product Designer.png",
-  "agent-cloud-engineer": "16 - Dan - Cloud Engineer.png",
-  "agent-security-auditor": "17 - Luis - Security Auditor.png",
-  "agent-marketing-analyst": "18 - Lucia - Marketing Analyst.png",
-};
-
-interface ActiveWorkItem {
-  kind: string;
-  id: string;
-  status: string | null;
-}
-
-/** Pure lifecycle helper retained for callers; it never reads a runtime projection. */
-export function openWorkIds(items: readonly ActiveWorkItem[]): string[] {
-  const kinds = new Set(["prd", "spec", "change", "task", "execution"]);
-  const statuses = new Set(["active", "executing", "verifying", "running", "paused"]);
-  return items
-    .filter(
-      (item) =>
-        kinds.has(item.kind) &&
-        (statuses.has(item.status ?? "") || (item.kind === "task" && item.status === "planned")),
-    )
-    .map((item) => item.id)
-    .sort();
-}
-
 interface DashboardAppOptions {
   syncAgentAdapters?: () => Promise<AgentAdapterSyncResult>;
   filesystem?: WorkspaceFileSystem;
@@ -158,8 +129,12 @@ interface DashboardAppOptions {
   reconcileOpenWork?: typeof reconcileOpenWork;
   refreshReadModel?: () => Promise<void>;
   snapshotState?: "current" | "updating";
+  /** Enable filesystem and day rollover synchronization for the serving process. */
+  watchSources?: boolean;
   /** Test seam: health and reconciliation only require the asserted V2 layout. */
   layout?: WorkspaceLayout;
+  /** Only the spawned local runtime may self-terminate for a missing browser lease. */
+  launcherOwned?: boolean;
 }
 
 class V2WorkspaceRequiredError extends Error {
@@ -650,14 +625,15 @@ export function createDashboardApp(
   const app = new Hono();
   const filesystem = options.filesystem ?? new WorkspaceFileSystem(workspaceRoot);
   const isSqliteSnapshot = filesystem instanceof SqliteReadModelFileSystem;
-  // A private SQLite generation is immutable for this app instance. Loading
-  // its V2 layout repeatedly costs hundreds of milliseconds per navigation;
-  // canonical filesystems remain deliberately uncached.
-  const sqliteLayout = isSqliteSnapshot ? requireV2Layout(filesystem) : null;
+  // Cache layout within a committed revision and reload after synchronization.
+  let sqliteLayout = isSqliteSnapshot ? requireV2Layout(filesystem) : null;
   const readLayout = async () =>
     options.layout ?? sqliteLayout ?? (await requireV2Layout(filesystem));
   const snapshotReadOnly = options.snapshotReadOnly ?? isSqliteSnapshot;
-  const snapshotState = options.snapshotState ?? "current";
+  // A stale seed is safe to serve only until this process promotes its own
+  // replacement. Keep the state mutable so health/ready stop advertising an
+  // update after the atomic handoff succeeds.
+  let snapshotState = options.snapshotState ?? "current";
   const canonicalFilesystem = options.canonicalFilesystem ?? new WorkspaceFileSystem(workspaceRoot);
   const reconcileOpen = options.reconcileOpenWork ?? reconcileOpenWork;
   const refreshReadModel =
@@ -714,16 +690,48 @@ export function createDashboardApp(
     aggregatePayloads.clear();
     aggregateInFlight.clear();
   };
+  let observedSnapshotRevision: string | null = null;
   let projectionRefreshInFlight: Promise<void> | null = null;
+  let projectionRefreshRequested = false;
   const rebuildProjection = async () => {
-    if (projectionRefreshInFlight !== null) return projectionRefreshInFlight;
-    projectionRefreshInFlight = refreshReadModel()
-      .then(() => clearSnapshotCache())
-      .finally(() => {
-        projectionRefreshInFlight = null;
-      });
+    if (projectionRefreshInFlight !== null) {
+      projectionRefreshRequested = true;
+      return projectionRefreshInFlight;
+    }
+    snapshotState = "updating";
+    projectionRefreshInFlight = (async () => {
+      do {
+        projectionRefreshRequested = false;
+        await refreshReadModel();
+        if (isSqliteSnapshot) sqliteLayout = requireV2Layout(filesystem);
+        clearSnapshotCache();
+      } while (projectionRefreshRequested);
+      snapshotState = "current";
+    })().finally(() => {
+      projectionRefreshInFlight = null;
+    });
     return projectionRefreshInFlight;
   };
+  startSnapshotSynchronization({
+    workspaceRoot,
+    staleSeed: isSqliteSnapshot && snapshotState === "updating",
+    watchSources: isSqliteSnapshot && options.watchSources === true,
+    refresh: rebuildProjection,
+  });
+  const reconcileWork = createWorkReconciliation({
+    reconcile: (mode) =>
+      reconcileOpen(canonicalFilesystem, workspaceRoot, {
+        hostTerminalOnly: mode === "host-terminal",
+      }),
+    refresh: rebuildProjection,
+  });
+  if (
+    isSqliteSnapshot &&
+    options.watchSources === true &&
+    process.env.ZAIP_DASHBOARD_WATCH_SOURCES !== "0"
+  ) {
+    startHostTerminalReconciliation(() => reconcileWork("host-terminal"));
+  }
   const readSnapshot = (context: Context) => {
     const key = snapshotKey(context);
     const cached = cachedSnapshots.get(key);
@@ -785,6 +793,8 @@ export function createDashboardApp(
     // available while the dashboard serves a read-only snapshot.
     const reconcileWrite =
       context.req.method === "POST" && context.req.path === `${API_PREFIX}/reconcile-open-work`;
+    const browserLeaseWrite =
+      context.req.method === "GET" && context.req.path === `${API_PREFIX}/browser-lease`;
     const projectionRefreshWrite =
       context.req.method === "POST" && context.req.path === `${API_PREFIX}/refresh-projection`;
     if (
@@ -792,7 +802,8 @@ export function createDashboardApp(
       context.req.method !== "HEAD" &&
       !settingsWrite &&
       !reconcileWrite &&
-      !projectionRefreshWrite
+      !projectionRefreshWrite &&
+      !browserLeaseWrite
     ) {
       context.header(
         "Allow",
@@ -824,15 +835,23 @@ export function createDashboardApp(
       context.req.path.startsWith(`${API_PREFIX}/agent-catalog-assets/`)
         ? context.req.query("token")
         : undefined;
+    const leaseToken = browserLeaseWrite ? context.req.query("token") : undefined;
+    // EventSource cannot carry the session header and localhost cookies span
+    // ports. Its query capability is therefore intentionally stricter than
+    // ordinary dashboard requests: an old tab must never lease a new runtime.
+    if (browserLeaseWrite && leaseToken !== sessionToken)
+      return context.json({ error: "Invalid local session" }, 401);
     if (
       headerSession !== sessionToken &&
       cookieSession !== sessionToken &&
-      portraitToken !== sessionToken
+      portraitToken !== sessionToken &&
+      leaseToken !== sessionToken
     ) {
       return context.json({ error: "Invalid local session" }, 401);
     }
     return next();
   });
+  registerBrowserLeaseRoute(app, API_PREFIX, options.launcherOwned === true);
 
   app.on(["GET", "HEAD"], `${API_PREFIX}/health`, async (context) => {
     try {
@@ -871,6 +890,15 @@ export function createDashboardApp(
     try {
       const layout = await readLayout();
       if (isSqliteSnapshot) {
+        const revision = readCommittedSnapshotRevision(workspaceRoot);
+        if (observedSnapshotRevision !== null && observedSnapshotRevision !== revision) {
+          // A worker may commit before its completion callback runs. Refresh
+          // the reader and its caches before advertising the new revision.
+          filesystem.refresh();
+          clearSnapshotCache();
+          sqliteLayout = requireV2Layout(filesystem);
+        }
+        observedSnapshotRevision = revision;
         const metadata = filesystem.metadata();
         return headOrJson(context, {
           kind: RUNTIME_KIND,
@@ -884,6 +912,7 @@ export function createDashboardApp(
           // /ready must never start a competing projection in the background.
           day_count: metadata.daily_aggregate_count,
           snapshot_state: snapshotState,
+          snapshot_revision: revision,
         });
       }
       const projection = await buildFirstFoldQuickProjection(filesystem, layout, {
@@ -1220,23 +1249,32 @@ export function createDashboardApp(
   app.post(`${API_PREFIX}/reconcile-open-work`, async (context) => {
     try {
       await readLayout();
-      // The served snapshot is immutable by design. Reconciliation must use
-      // canonical records. When those records changed, atomically rebuild and
-      // reopen the snapshot before the response exposes fresh projections.
-      const reconciledIds = await reconcileOpen(canonicalFilesystem, workspaceRoot);
-      // A clean reconciliation is the normal startup path. It changed no
-      // canonical data, so rebuilding the immutable SQLite snapshot only adds
-      // seconds of redundant work before the dashboard can settle.
-      if (reconciliationNeedsRefresh(reconciledIds)) {
-        await rebuildProjection();
-      }
+      // Share the canonical mutation queue with missed host-stop recovery.
+      // Projection rebuilds run in the background and publish their revision.
+      const reconciledIds = await waitForWorkReconciliation(reconcileWork("manual"), () => {
+        void rebuildProjection().catch(() => undefined);
+      });
       return context.json({
-        ...(await readSnapshot(context)),
         reconciliation: reconciledIds,
-        projection_refresh_completed: reconciliationNeedsRefresh(reconciledIds),
+        snapshot_state: snapshotState,
+        projection_refresh_completed:
+          snapshotState === "current" && projectionRefreshInFlight === null,
       });
     } catch (error) {
       if (error instanceof V2WorkspaceRequiredError) throw error;
+      if (error instanceof ReconciliationCommandTimeoutError) {
+        // SIGTERM can occur after the CLI persisted some records. Start an
+        // atomic refresh without extending the request past the client's
+        // deadline, and make that uncertainty explicit to the caller.
+        return context.json(
+          {
+            error: error.message,
+            reconciliation_may_be_partial: true,
+            projection_refresh_started: true,
+          },
+          408,
+        );
+      }
       return context.json({ error: error instanceof Error ? error.message : String(error) }, 400);
     }
   });
@@ -1314,7 +1352,18 @@ export function createDashboardApp(
         );
         return headOrJson(
           context,
-          await buildManifestCostRunPage(filesystem, layout, context, { from, to }, offset, limit),
+          // The paged Cost adapter reads the lifecycle summary. That canonical
+          // artifact is intentionally not copied into SQLite; use its current
+          // filesystem alongside the immutable SQL facts rather than failing
+          // a filtered page with a synthetic missing-file error.
+          await buildManifestCostRunPage(
+            isSqliteSnapshot ? canonicalFilesystem : filesystem,
+            layout,
+            context,
+            { from, to },
+            offset,
+            limit,
+          ),
           200,
           true,
         );
@@ -1627,42 +1676,23 @@ export const app = new Proxy({} as Hono, {
   },
 });
 
-function startupPhase(phase: string): void {
-  process.stderr.write(
-    `${JSON.stringify({
-      event: "dashboard_sqlite_startup_phase",
-      phase,
-      elapsed_ms: Math.round(performance.now() - moduleStartedAt),
-    })}\n`,
-  );
-}
-
 async function main(): Promise<void> {
   const port = Number.parseInt(process.env.ZAIP_SERVER_PORT ?? "4317", 10);
-  startupPhase("main_entered");
+  writeStartupPhase(moduleStartedAt, "main_entered");
   const startedAt = performance.now();
-  const readModel = await rebuildSqliteReadModel(runtimeWorkspaceRoot);
-  // 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`,
-  );
-  startupPhase("read_model_ready");
+  const startupOptions = { forceCanonical: false, preferExisting: true };
+  const readModel = await rebuildSqliteReadModel(runtimeWorkspaceRoot, startupOptions);
+  writeReadModelStartup(startedAt, readModel);
+  writeStartupPhase(moduleStartedAt, "read_model_ready");
   const runtimeApp = createDashboardApp(runtimeWorkspaceRoot, sessionToken, undefined, {
     filesystem: new SqliteReadModelFileSystem(runtimeWorkspaceRoot),
     snapshotState: readModel.cache === "stale_seed" ? "updating" : "current",
+    watchSources: true,
+    launcherOwned: true,
   });
-  startupPhase("runtime_app_ready");
+  writeStartupPhase(moduleStartedAt, "runtime_app_ready");
   serve({ fetch: runtimeApp.fetch, hostname: HOST, port }, ({ port: boundPort }) => {
-    startupPhase("listening");
+    writeStartupPhase(moduleStartedAt, "listening");
     process.stdout.write(
       `ZAIP-AIOS dashboard API: http://${HOST}:${boundPort}${API_PREFIX}/health\n`,
     );