@zaip-ai/cli 3.2.0 → 3.4.0

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

@@ -1,8 +1,12 @@
 import { describe, expect, it } from "vitest";
 import {
+  aggregateOperationsPageRows,
   executionEntityPageRows,
   executionLifecycleElapsedMs,
+  filterLifecyclePageRows,
+  filterOperationsMetricRows,
   lifecycleElapsedMs,
+  withCanonicalOperationsEntityStatuses,
 } from "./server-operations-pages.js";
 
 describe("executionEntityPageRows", () => {
@@ -120,6 +124,93 @@ describe("executionEntityPageRows", () => {
   });
 });
 
+describe("Operations status filters", () => {
+  it("uses the latest source Run status for an aggregated Execution before filtering", () => {
+    const rows = aggregateOperationsPageRows(
+      [
+        metricRow("RUN-STARTED", "EXEC-1", "running", "2026-09-16T10:00:00.000Z"),
+        metricRow("RUN-FINISHED", "EXEC-1", "completed", "2026-09-16T10:01:00.000Z"),
+      ],
+      "executions",
+    );
+    expect(rows).toMatchObject([{ id: "EXEC-1", status: "completed" }]);
+    expect(
+      filterOperationsMetricRows(rows, { query: "", risk: "", status: "completed" }),
+    ).toHaveLength(1);
+    expect(filterOperationsMetricRows(rows, { query: "", risk: "", status: "running" })).toEqual(
+      [],
+    );
+  });
+
+  it("lets a canonical Execution gate override a completed Run fallback", () => {
+    const execution = metricRow("EXEC-1", "EXEC-1", "completed", "2026-09-16T10:00:00.000Z");
+    const conversation = { ...execution, id: "CONV-1", conversation_id: "CONV-1" };
+    const entities = [
+      { id: "EXEC-1", status: "blocked", data: { origin: { conversation_id: "CONV-1" } } },
+    ];
+    expect(
+      withCanonicalOperationsEntityStatuses([execution], entities, "executions"),
+    ).toMatchObject([{ status: "blocked" }]);
+    expect(
+      withCanonicalOperationsEntityStatuses([conversation], entities, "conversations"),
+    ).toMatchObject([{ status: "blocked" }]);
+  });
+
+  it("keeps an ambiguous Conversation status unavailable unless its own canonical entity exists", () => {
+    const conversation = {
+      ...metricRow("EXEC-1", "EXEC-1", "completed", "2026-09-16T10:00:00.000Z"),
+      id: "CONV-1",
+      conversation_id: "CONV-1",
+    };
+    const executions = [
+      { id: "EXEC-2", status: "completed", data: { origin: { conversation_id: "CONV-1" } } },
+      { id: "EXEC-1", status: "blocked", data: { origin: { conversation_id: "CONV-1" } } },
+    ];
+    expect(
+      withCanonicalOperationsEntityStatuses([conversation], executions, "conversations"),
+    ).toMatchObject([{ status: null }]);
+    expect(
+      withCanonicalOperationsEntityStatuses(
+        [conversation],
+        executions.toReversed(),
+        "conversations",
+        [{ id: "CONV-1", status: "blocked" }],
+      ),
+    ).toMatchObject([{ status: "blocked" }]);
+  });
+
+  it.each([
+    "planned",
+    "running",
+    "verifying",
+    "completed",
+    "blocked",
+    "cancelled",
+    "failed",
+  ])("matches the canonical %s status for Run, Execution and Conversation rows", (status) => {
+    const filters = { query: "", risk: "", status };
+    const run = metricRow("RUN-1", "EXEC-1", status, "2026-09-16T10:00:00.000Z");
+    const execution = { ...run, id: "EXEC-1" };
+    const conversation = { ...run, id: "CONV-1", conversation_id: "CONV-1" };
+    expect(filterOperationsMetricRows([run], filters)).toEqual([run]);
+    expect(filterOperationsMetricRows([execution], filters)).toEqual([execution]);
+    expect(filterOperationsMetricRows([conversation], filters)).toEqual([conversation]);
+  });
+
+  it.each([
+    "planned",
+    "active",
+    "verifying",
+    "delivered",
+    "blocked",
+    "cancelled",
+    "failed",
+  ])("matches the canonical %s Change status without treating it as a Run status", (status) => {
+    const row = { id: `CHG-${status}`, title: "Change", status, risk: "standard" };
+    expect(filterLifecyclePageRows([row], { query: "", risk: "standard", status })).toEqual([row]);
+  });
+});
+
 describe("lifecycleElapsedMs", () => {
   it("is terminal-only and never substitutes source-observed duration", () => {
     expect(
@@ -161,3 +252,23 @@ describe("executionLifecycleElapsedMs", () => {
     expect(executionLifecycleElapsedMs([{ ...rows[0]!, status: "running" }])).toBeNull();
   });
 });
+
+function metricRow(id: string, executionId: string, status: string, startedAt: string) {
+  return {
+    id,
+    started_at: startedAt,
+    finished_at: status === "completed" ? "2026-09-16T10:01:00.000Z" : null,
+    task_id: "TASK-1",
+    execution_id: executionId,
+    conversation_id: null,
+    run_kind: "run" as const,
+    phase: "execution",
+    parent_run_id: null,
+    status,
+    duration_ms: null,
+    total_tokens: null,
+    cost: null,
+    currency: null,
+    events: null,
+  };
+}

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

@@ -1,7 +1,6 @@
 import { posix } from "node:path";
 import type { WorkspaceLayout } from "@zaip-ai/core";
 import type { CostSummarySource } from "@zaip-ai/dashboard-cost-monitor/server";
-import type { Context } from "hono";
 export type OperationsCompactRun = NonNullable<CostSummarySource["run_metrics"]>[number] & {
   execution_id?: string | null;
   conversation_id?: string | null;
@@ -40,6 +39,14 @@ export function aggregateOperationsPageRows(
     if (row.total_tokens !== null)
       current.total_tokens = (current.total_tokens ?? 0) + row.total_tokens;
     if (row.cost !== null) current.cost = (current.cost ?? 0) + row.cost;
+    const currentLatestAt = current.finished_at ?? current.started_at;
+    const rowLatestAt = row.finished_at ?? row.started_at;
+    if (rowLatestAt > currentLatestAt) {
+      // The entity status is a source fact from its latest observed Run.
+      // Filtering happens after aggregation, so keeping the first input row
+      // here made terminal entities match a stale active status.
+      current.status = row.status;
+    }
     if (row.started_at < current.started_at) current.started_at = row.started_at;
     if (
       current.finished_at === null ||
@@ -53,6 +60,46 @@ export function aggregateOperationsPageRows(
   );
 }
 
+/** Canonical Execution state overrides a derived latest-Run fallback. */
+export function withCanonicalOperationsEntityStatuses(
+  rows: readonly OperationsCompactRun[],
+  entities: readonly {
+    id: string;
+    status: string | null;
+    data: Record<string, unknown> | null;
+  }[],
+  kind: "executions" | "conversations",
+  conversations: readonly { id: string; status: string | null }[] = [],
+): OperationsCompactRun[] {
+  const statusById = new Map<string, string | null>();
+  if (kind === "conversations")
+    for (const conversation of conversations) statusById.set(conversation.id, conversation.status);
+  const fallbackConversationStatuses = new Map<string, string | null>();
+  for (const entity of entities) {
+    const conversationId =
+      entity.data?.origin !== null && typeof entity.data?.origin === "object"
+        ? (entity.data.origin as { conversation_id?: unknown }).conversation_id
+        : null;
+    const id =
+      kind === "executions"
+        ? entity.id
+        : typeof conversationId === "string"
+          ? conversationId
+          : null;
+    if (id === null || statusById.has(id)) continue;
+    if (kind === "executions") statusById.set(id, entity.status);
+    else if (!fallbackConversationStatuses.has(id))
+      fallbackConversationStatuses.set(id, entity.status);
+    else fallbackConversationStatuses.set(id, null);
+  }
+  for (const [id, status] of fallbackConversationStatuses) statusById.set(id, status);
+  return rows.map((row) => {
+    const id = kind === "executions" ? row.execution_id : row.conversation_id;
+    if (id === null || id === undefined || !statusById.has(id)) return row;
+    return { ...row, status: statusById.get(id) ?? null };
+  });
+}
+
 export function executionEntityPageRows(
   entities: readonly {
     id: string;
@@ -290,65 +337,8 @@ function stringArray(value: unknown): string[] {
     : [];
 }
 
-interface OperationsPageFilterValues {
-  query: string;
-  status: string;
-  risk: string;
-}
-
-export function operationsPageFilters(context: Context): OperationsPageFilterValues {
-  return {
-    query: (context.req.query("query") ?? "").trim().toLocaleLowerCase(),
-    status: (context.req.query("status") ?? "").trim(),
-    risk: (context.req.query("risk") ?? "").trim(),
-  };
-}
-
-export function filterOperationsMetricRows(
-  rows: readonly OperationsCompactRun[],
-  filters: OperationsPageFilterValues,
-): OperationsCompactRun[] {
-  return rows.filter((row) => {
-    if (filters.status && row.status !== filters.status) return false;
-    if (!filters.query) return true;
-    return [
-      row.id,
-      row.task_id,
-      row.execution_id,
-      row.conversation_id,
-      row.parent_run_id,
-      row.run_kind,
-      row.phase,
-      row.agent,
-    ].some(
-      (value) => typeof value === "string" && value.toLocaleLowerCase().includes(filters.query),
-    );
-  });
-}
-
-export function filterLifecyclePageRows(
-  rows: readonly Record<string, unknown>[],
-  filters: OperationsPageFilterValues,
-): Record<string, unknown>[] {
-  return rows.filter((row) => {
-    if (filters.status && row.status !== filters.status) return false;
-    if (filters.risk && row.risk !== filters.risk) return false;
-    if (!filters.query) return true;
-    return [
-      row.id,
-      row.title,
-      row.status,
-      row.risk,
-      row.source,
-      row.origin,
-      row.scope_type,
-      row.scope_id,
-    ]
-      .flatMap((value) =>
-        typeof value === "object" && value !== null ? Object.values(value) : [value],
-      )
-      .some(
-        (value) => typeof value === "string" && value.toLocaleLowerCase().includes(filters.query),
-      );
-  });
-}
+export {
+  filterLifecyclePageRows,
+  filterOperationsMetricRows,
+  operationsPageFilters,
+} from "./server-operations-page-filters.js";

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

@@ -8,6 +8,7 @@ import {
   aggregateOperationsPageRows,
   filterOperationsMetricRows,
   operationsPageFilters,
+  withCanonicalOperationsEntityStatuses,
 } from "./server-operations-pages.js";
 import { projectionPeriodFilter } from "./server-period.js";
 
@@ -32,7 +33,14 @@ export function registerOperationsRunsRoute(
       Math.max(1, Number.parseInt(context.req.query("limit") ?? "100", 10) || 100),
     );
     const { from, to } = projectionPeriodFilter(context);
-    const kind = context.req.query("kind") ?? "runs";
+    const requestedKind = context.req.query("kind") ?? "runs";
+    if (
+      requestedKind !== "runs" &&
+      requestedKind !== "executions" &&
+      requestedKind !== "conversations"
+    )
+      return respond(context, { error: "Unsupported Operations Run page" }, 400, false);
+    const kind: "runs" | "executions" | "conversations" = requestedKind;
     const filters = operationsPageFilters(context);
     const payload = await readAggregate(
       `operations:runs:${kind}:${from ?? ""}:${to ?? ""}:${offset}:${limit}:${filters.query}:${filters.status}:${filters.risk}`,
@@ -48,9 +56,12 @@ export function registerOperationsRunsRoute(
             );
           }
         }
-        const summary = JSON.parse(
-          await filesystem.readText(".agents/records/lifecycle/summary.json"),
-        ) as CostSummarySource;
+        const manifests = new LifecycleManifestStore(filesystem);
+        const [summaryText, executionEntities] = await Promise.all([
+          filesystem.readText(".agents/records/lifecycle/summary.json"),
+          manifests.readEntities("execution"),
+        ]);
+        const summary = JSON.parse(summaryText) as CostSummarySource;
         const sourceRows = (summary.run_metrics ?? []).filter(
           (run) =>
             (from === null || run.started_at >= from) &&
@@ -61,8 +72,11 @@ export function registerOperationsRunsRoute(
                 run.conversation_id !== null) ||
               (kind === "executions" && run.execution_id !== null)),
         );
+        const aggregated = aggregateOperationsPageRows(sourceRows, kind);
         const rows = filterOperationsMetricRows(
-          aggregateOperationsPageRows(sourceRows, kind),
+          kind === "runs"
+            ? aggregated
+            : withCanonicalOperationsEntityStatuses(aggregated, executionEntities, kind),
           filters,
         );
         return {

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

@@ -41,4 +41,23 @@ describe("periodMacroMetric", () => {
       [expectedStage]: 1,
     });
   });
+
+  it("keeps the canonical Task and rework classification for the filtered macro population", () => {
+    const specs = periodMacroMetric(
+      [
+        { id: "SPEC-STRUCTURED", status: "active", task_count: 2, rework_run_count: 0 },
+        { id: "SPEC-EMPTY", status: "blocked", task_count: 0, rework_run_count: 0 },
+      ],
+      "spec",
+    );
+    const prds = periodMacroMetric(
+      [{ id: "PRD-REWORK", status: "delivered", task_count: 3, rework_run_count: 1 }],
+      "prd",
+    );
+
+    expect(specs.status_counts).toEqual({ executing: 1, blocked: 1 });
+    expect(specs.classification_counts).toEqual({ empty: 1, structured: 1, rework: 0 });
+    expect(prds.status_counts).toEqual({ completed: 1 });
+    expect(prds.classification_counts).toEqual({ empty: 0, structured: 0, rework: 1 });
+  });
 });

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

@@ -41,7 +41,16 @@ export const periodMacroStage = (kind: MacroKind, value: unknown) => {
   if (status === "ready" || status === "planned") return "ready";
   if (status === "active") return "executing";
   if (status === "delivered") return "completed";
-  return ["executing", "verifying", "completed", "blocked", "failed", "cancelled"].includes(status)
+  return [
+    "definition",
+    "planning",
+    "executing",
+    "verifying",
+    "completed",
+    "blocked",
+    "failed",
+    "cancelled",
+  ].includes(status)
     ? status
     : "planning";
 };
@@ -65,7 +74,7 @@ export function periodMacroMetric(
   const statusCounts: Record<string, number> = {};
   const classificationCounts: Record<string, number> = { empty: 0, structured: 0, rework: 0 };
   for (const row of rows) {
-    const status = periodMacroStage(kind, row.status);
+    const status = periodMacroStage(kind, row.stage ?? row.status);
     statusCounts[status] = (statusCounts[status] ?? 0) + 1;
     const classification =
       number(row, "rework_run_count") > 0

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

@@ -119,15 +119,18 @@ export function buildSqliteOperationsProjection(
           run_count: task.run_count,
         }))
       : projectAllTimeTopTasks(allTimeTopTasks);
+  // Compact all-time responses omit entity arrays, but must retain macro aggregates.
+  const allTimeMacroMetrics =
+    allTime === null ? null : (fullAllTime?.macro_metrics ?? filesystem.firstFoldMacroMetrics());
   const macroMetrics =
-    fullAllTime === null
+    allTimeMacroMetrics === null
       ? ({
           specs: periodMacroMetric(specs, "spec"),
           prds: periodMacroMetric(prds, "prd"),
         } satisfies OverviewMacroMetrics)
       : (Object.fromEntries(
           (["specs", "prds"] as const).map((kind) => {
-            const metric = fullAllTime.macro_metrics[kind];
+            const metric = allTimeMacroMetrics[kind];
             return [
               kind,
               {
@@ -249,25 +252,29 @@ export function buildSqliteOperationsProjection(
       created_at: String(row.occurred_at),
       updated_at: String(row.occurred_at),
       kind,
-      parent_id: null,
+      parent_id: kind === "spec" && typeof row.prd_id === "string" ? row.prd_id : null,
       artifact_path: canonicalSource,
       lifecycle_status: String(row.status ?? "draft"),
-      work_status: normalizeMacroStatus(row.status),
+      work_status: normalizeMacroStatus(row.stage ?? row.status),
       execution_ids: [],
-      task_ids: [],
+      task_ids:
+        typeof row.task_ids_json === "string" ? (JSON.parse(row.task_ids_json) as string[]) : [],
       planned_tasks: [],
       canonical_run_ids: [],
       run_ids: [],
       root_execution_run_ids: [],
       execution_count: 0,
-      task_count: 0,
+      task_count: nullableMetric(row.task_count) ?? 0,
       run_count: nullableMetric(row.invocation_count) ?? 0,
       duration_ms: nullableMetric(row.total_duration),
       decisions: { human: 0, agent: 0 },
-      rework_run_count: 0,
+      rework_run_count: nullableMetric(row.rework_run_count) ?? 0,
       quality: {
-        completed_tasks: 0,
-        task_completion_rate: 0,
+        completed_tasks: nullableMetric(row.completed_task_count) ?? 0,
+        task_completion_rate:
+          Number(row.task_count) > 0
+            ? Number(row.completed_task_count ?? 0) / Number(row.task_count)
+            : 0,
         terminal_runs: 0,
         successful_runs: 0,
         terminal_success_rate: 0,
@@ -308,11 +315,11 @@ export function buildSqliteOperationsProjection(
         },
         task_count: taskCount,
         completed_prd_count:
-          allTime?.aggregate.completed_prd_count ??
-          prds.filter((row) => row.status === "completed").length,
+          allTime?.aggregate.completed_prd_count ?? macroMetrics.prds.status_counts.completed ?? 0,
         completed_spec_count:
           allTime?.aggregate.completed_spec_count ??
-          specs.filter((row) => row.status === "completed").length,
+          macroMetrics.specs.status_counts.completed ??
+          0,
         completed_task_count: allTime?.aggregate.completed_task_count ?? statuses.completed ?? 0,
         task_status_counts: statuses,
         task_risk_counts: risks,

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

@@ -1,7 +1,9 @@
 import { EventEmitter } from "node:events";
-import { mkdir, mkdtemp, rm, writeFile } from "node:fs/promises";
+import { copyFile, mkdir, mkdtemp, rm, writeFile } from "node:fs/promises";
+import { execFile } from "node:child_process";
+import { promisify } from "node:util";
 import { tmpdir } from "node:os";
-import { join } from "node:path";
+import { join, resolve } from "node:path";
 import { DatabaseSync } from "node:sqlite";
 import { describe, expect, it, vi } from "vitest";
 import {
@@ -34,6 +36,48 @@ describe("snapshot refresh shutdown", () => {
 });
 
 describe("snapshot worker process boundary", () => {
+  it("refreshes an installed consumer using only the portable bundle and scripts", async () => {
+    const runtimeRoot = resolve(import.meta.dirname, "..");
+    const source = resolve(runtimeRoot, "../../../..");
+    const parent = join(source, ".local/sqlite/tests");
+    await mkdir(parent, { recursive: true });
+    const root = await mkdtemp(join(parent, "portable-worker-"));
+    let filesystem: SqliteReadModelFileSystem | undefined;
+    try {
+      const installed = join(root, ".agents/dashboard/packages/local-runtime");
+      await mkdir(join(installed, "scripts"), { recursive: true });
+      await mkdir(join(root, ".agents/config"), { recursive: true });
+      for (const file of ["project.yaml", "framework.lock.yaml"])
+        await copyFile(join(source, ".agents/config", file), join(root, ".agents/config", file));
+      await copyFile(join(runtimeRoot, "server.mjs"), join(installed, "server.mjs"));
+      for (const name of ["rebuild-sqlite-read-model.mjs", "validate-sqlite-read-model.mjs"])
+        await copyFile(join(runtimeRoot, "scripts", name), join(installed, "scripts", name));
+      const rebuild = join(installed, "scripts/rebuild-sqlite-read-model.mjs");
+      const environment = {
+        ...process.env,
+        ZAIP_WORKSPACE: root,
+        ZAIP_SQLITE_DB_PATH: join(root, ".local/sqlite/zaip-aios-dashboard.sqlite"),
+      };
+      const result = await promisify(execFile)(process.execPath, [rebuild], {
+        cwd: root,
+        env: environment,
+        windowsHide: true,
+      });
+      expect(JSON.parse(result.stdout).schema.schemaVersion).toBe(readModelSchemaVersion);
+      filesystem = new SqliteReadModelFileSystem(root);
+      await mkdir(join(root, ".agents/records/specs"), { recursive: true });
+      const path = ".agents/records/specs/SPEC-PORTABLE.md";
+      await writeFile(
+        join(root, path),
+        "---\nid: SPEC-PORTABLE\ntitle: Portable refresh\nstatus: blocked\ncreated_at: 2026-09-16T00:00:00Z\n---\n",
+      );
+      await refreshSqliteSnapshotInWorker(root, filesystem);
+      expect(await filesystem.readText(path)).toContain("status: blocked");
+    } finally {
+      filesystem?.close();
+      await rm(root, { recursive: true, force: true });
+    }
+  }, 30000);
   it.each([
     "valid",
     "empty",

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

@@ -25,7 +25,13 @@ describe("snapshot source synchronization", () => {
     const onCaptureFailure = vi.fn();
     const onRefreshFailure = vi.fn();
     const onCaptureSuccess = vi.fn();
-    const capture = vi.fn().mockRejectedValueOnce(error).mockResolvedValue(undefined);
+    const capture = vi.fn().mockRejectedValueOnce(error).mockResolvedValue({
+      captured_runs: 0,
+      captured_segments: 0,
+      manifest_state: "initialized",
+      skipped_reason: "no_active_runs",
+      last_capture_at: "2026-09-16T00:00:00.000Z",
+    });
     const refresh = vi.fn(async () => undefined);
     startSnapshotSynchronization({
       workspaceRoot: "C:/workspace",
@@ -42,7 +48,9 @@ describe("snapshot source synchronization", () => {
     expect(onRefreshFailure).not.toHaveBeenCalled();
     expect(refresh).toHaveBeenCalledTimes(1);
     await vi.advanceTimersByTimeAsync(60_000);
-    expect(onCaptureSuccess).toHaveBeenCalledTimes(1);
+    expect(onCaptureSuccess).toHaveBeenCalledWith(
+      expect.objectContaining({ skipped_reason: "no_active_runs" }),
+    );
     expect(refresh).toHaveBeenCalledTimes(2);
   });
   it("watches current data for both creation and alteration refreshes", async () => {

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

@@ -1,5 +1,6 @@
 import { watch } from "node:fs";
 import { join } from "node:path";
+import type { ActiveCodexTelemetryCapture } from "./active-codex-telemetry.js";
 
 export function startSnapshotSynchronization(input: {
   workspaceRoot: string;
@@ -7,9 +8,9 @@ export function startSnapshotSynchronization(input: {
   watchSources: boolean;
   refresh: () => Promise<void>;
   /** Exact active-Codex collection, separate from projection and lifecycle repair. */
-  captureActiveTelemetry?: () => Promise<void>;
+  captureActiveTelemetry?: () => Promise<ActiveCodexTelemetryCapture>;
   onCaptureFailure?: (error: unknown) => void;
-  onCaptureSuccess?: () => void;
+  onCaptureSuccess?: (result: ActiveCodexTelemetryCapture) => void;
   /** Report failed asynchronous refreshes; a stale snapshot must never look healthy. */
   onRefreshFailure?: (input: { trigger: "stale_seed" | "source_change"; error: unknown }) => void;
 }): void {
@@ -42,7 +43,7 @@ export function startSnapshotSynchronization(input: {
     if (input.captureActiveTelemetry === undefined) return scheduleRefresh();
     void input
       .captureActiveTelemetry()
-      .then(() => input.onCaptureSuccess?.())
+      .then((result) => input.onCaptureSuccess?.(result))
       .catch((error: unknown) => input.onCaptureFailure?.(error))
       .finally(scheduleRefresh);
   };

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

@@ -1,6 +1,6 @@
 import { mkdir, mkdtemp, rm, writeFile } from "node:fs/promises";
 import { tmpdir } from "node:os";
-import { join, resolve } from "node:path";
+import { basename, join, resolve } from "node:path";
 import { WorkspaceFileSystem } from "@zaip-ai/core";
 import { describe, expect, it, vi } from "vitest";
 import {
@@ -109,12 +109,54 @@ describe("dashboard backend", () => {
     await expect(response.json()).resolves.toMatchObject({
       kind: "zaip-dashboard-sqlite-runtime",
       workspaceKey: dashboardWorkspaceKey(workspaceRoot),
+      workspace: workspaceRoot,
+      workspace_name: basename(workspaceRoot),
+      server_pid: process.pid,
       api_version: 2,
       read_only: true,
       status: "ok",
       workspace_layout: 3,
     });
   });
+  it("reports a missing canonical lifecycle manifest as degraded without hiding runtime identity", async () => {
+    await withSqliteReadModelFixture("missing-manifest", async ({ root, filesystem }) => {
+      const app = createDashboardApp(root, "test-session", undefined, { filesystem });
+      const health = await app.request("/api/v2/health");
+      expect(health.status).toBe(200);
+      await expect(health.json()).resolves.toMatchObject({
+        status: "degraded",
+        lifecycle_manifest_state: "missing",
+        workspace: root,
+        workspace_name: basename(root),
+        server_pid: process.pid,
+      });
+      const ready = await app.request("/api/v2/ready");
+      expect(ready.status).toBe(200);
+      await expect(ready.json()).resolves.toMatchObject({
+        status: "degraded",
+        lifecycle_manifest_state: "missing",
+        workspace: root,
+      });
+    });
+  });
+  it("rejects a parseable but invalid canonical lifecycle manifest", async () => {
+    await withSqliteReadModelFixture("invalid-manifest", async ({ root, filesystem }) => {
+      await mkdir(join(root, ".agents/records/lifecycle"), { recursive: true });
+      await writeFile(
+        join(root, ".agents/records/lifecycle/manifest.json"),
+        '{"schema_version":1,"offsets":[]}',
+      );
+      await writeFile(join(root, ".agents/records/lifecycle/summary.json"), '{"schema_version":1}');
+      const app = createDashboardApp(root, "test-session", undefined, { filesystem });
+      for (const path of ["/api/v2/health", "/api/v2/ready"]) {
+        const response = await app.request(path);
+        expect(await response.json()).toMatchObject({
+          status: "degraded",
+          lifecycle_manifest_state: "invalid",
+        });
+      }
+    });
+  });
   it("exposes the developer cost endpoint with an account_id filter", async () => {
     await withSqliteReadModelFixture("developer-cost", async ({ root, filesystem }) => {
       const aggregate = vi.spyOn(filesystem, "developerCostAggregate").mockReturnValue({