@zaip-ai/cli 1.3.8 → 1.4.2

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

@@ -163,6 +163,54 @@ describe("project settings persistence", () => {
     expect(architecture).toContain("- TypeScript");
   });
 
+  it("persists observability and on-demand testing components without requiring local detection", async () => {
+    const { filesystem } = await fixtureProject();
+    const current = await readProjectSettings(filesystem);
+    await filesystem.writeTextAtomic(
+      PROJECT_CONFIG_PATH,
+      serializeYaml({
+        ...current,
+        stack: {
+          ...current.stack,
+          overrides: { ...current.stack.overrides, components: { future_tool: { enabled: true } } },
+        },
+      }),
+    );
+    const updated = await persistProjectSettings(filesystem, {
+      ...current,
+      stack: {
+        ...current.stack,
+        overrides: {
+          components: {
+            prometheus: {
+              name: "Prometheus",
+              version: "3.6.0",
+              reference: "docker:prom/prometheus",
+            },
+            grafana: {
+              name: "Grafana",
+              version: "",
+              reference: "docker:grafana/grafana",
+            },
+            k6: { name: "k6", version: "1.1.0", reference: "docker:grafana/k6" },
+            autocannon: { name: "autocannon", version: "", reference: "npm:autocannon" },
+          },
+        },
+      },
+    });
+
+    expect(updated.stack.overrides.components).toMatchObject({
+      prometheus: { name: "Prometheus", version: "3.6.0" },
+      grafana: { name: "Grafana", version: "" },
+      k6: { name: "k6", version: "1.1.0" },
+      autocannon: { name: "autocannon", version: "" },
+      future_tool: { enabled: true },
+    });
+    await expect(filesystem.readText(SOFTWARE_ARCHITECTURE_PATH)).resolves.toContain(
+      "| Coleta de métricas | Prometheus | 3.6.0 | docker:prom/prometheus |",
+    );
+  });
+
   it("rejects invalid settings before touching the project file", async () => {
     const { configPath, filesystem } = await fixtureProject();
     const original = await readFile(configPath, "utf8");
@@ -359,7 +407,7 @@ describe("project settings persistence", () => {
         expect.objectContaining({ id: "skills", value: 2 }),
         expect.objectContaining({ id: "rules", value: 2 }),
         expect.objectContaining({ id: "hooks", value: 3 }),
-        expect.objectContaining({ id: "database", value: "Ativo" }),
+        expect.objectContaining({ id: "database", value: "Inativo" }),
       ],
       stack_components: [
         expect.objectContaining({
@@ -375,6 +423,11 @@ describe("project settings persistence", () => {
         expect.objectContaining({ name: "BullMQ", verification: "unavailable" }),
         expect.objectContaining({ name: "Hono", verification: "unavailable" }),
         expect.objectContaining({ name: "React", verification: "unavailable" }),
+        expect.objectContaining({ name: "Git", configured_version: "latest" }),
+        expect.objectContaining({
+          name: "Terraform",
+          configured_version: "1.16.1",
+        }),
       ],
       areas: expect.arrayContaining([
         expect.objectContaining({
@@ -532,6 +585,7 @@ describe("project settings persistence", () => {
           version: null,
           configured_version: "4.12.34",
           installation: "bundled",
+          verification: "unavailable",
           source: ".agents/dashboard/packages/local-runtime/server.mjs",
         }),
         expect.objectContaining({
@@ -539,12 +593,47 @@ describe("project settings persistence", () => {
           version: null,
           configured_version: "19.2.7",
           installation: "bundled",
+          verification: "unavailable",
           source: ".agents/dashboard/apps/frontend/dist",
         }),
       ]),
     );
   });
 
+  it("reads pnpm workspace manifests and validates their entrypoints", async () => {
+    const { filesystem } = await fixtureProject();
+    for (const [name, version, directory] of [
+      ["hono", "4.12.35", ".agents/dashboard/packages/local-runtime/node_modules/hono"],
+      ["react", "19.2.6", ".agents/dashboard/apps/frontend/node_modules/react"],
+    ]) {
+      await filesystem.writeTextAtomic(
+        `${directory}/package.json`,
+        JSON.stringify({ name, version, main: "index.js" }),
+      );
+      await filesystem.writeTextAtomic(`${directory}/index.js`, "export {};");
+      const overview = await readProjectOverview(filesystem);
+      expect(
+        overview.stack_components.find((item) => item.name.toLowerCase() === name),
+      ).toMatchObject({
+        version,
+        source: `${directory}/package.json`,
+        verification: "exact",
+        installation: "installed",
+      });
+      await filesystem.writeTextAtomic(
+        `${directory}/package.json`,
+        JSON.stringify({ name, version, main: "missing.js" }),
+      );
+      const incomplete = await readProjectOverview(filesystem);
+      expect(
+        incomplete.stack_components.find((item) => item.name.toLowerCase() === name),
+      ).toMatchObject({
+        version: null,
+        verification: "unavailable",
+      });
+    }
+  });
+
   it("does not accept a local package without its matching identity and entrypoint", async () => {
     const { filesystem } = await fixtureProject();
     await mkdir(join(filesystem.root, "node_modules", "hono"), { recursive: true });

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

@@ -1,3 +1,6 @@
+import { execFile } from "node:child_process";
+import { join } from "node:path";
+import { promisify } from "node:util";
 import {
   PROJECT_CONFIG_PATH,
   type ProjectConfig,
@@ -11,8 +14,9 @@ import {
 const AGENT_CATALOG_PATH = ".agents/config/agents/catalog.yaml";
 const CODEX_CONFIG_PATH = ".codex/config.toml";
 const FRAMEWORK_LOCK_PATH = ".agents/config/framework.lock.yaml";
-const SQLITE_READ_MODEL_PATH = ".local/dashboard-sqlite/read-model.sqlite";
+const SQLITE_READ_MODEL_PATH = ".local/sqlite/zaip-aios-dashboard.sqlite";
 const DASHBOARD_STACK_DEPENDENCIES_PATH = ".agents/dashboard/stack-dependencies.json";
+const exec = promisify(execFile);
 export const SOFTWARE_ARCHITECTURE_PATH = ".agents/architecture/software-architecture.md";
 
 export type ProjectOverview = {
@@ -145,11 +149,26 @@ async function countCodexHookEvents(filesystem: WorkspaceFileSystem): Promise<nu
 async function readVerifiedStackComponents(
   filesystem: WorkspaceFileSystem,
 ): Promise<ProjectOverview["stack_components"]> {
-  const [project, fallback, bundledRuntime, bundledFrontend] = await Promise.all([
+  const [project, fallback, bundledRuntime, bundledFrontend, git, terraform] = await Promise.all([
     readProjectSettings(filesystem),
     readDashboardStackDependencies(filesystem),
     hasNonEmptyFile(filesystem, ".agents/dashboard/packages/local-runtime/server.mjs"),
     hasBundledDashboardFrontend(filesystem),
+    executableComponent(
+      filesystem,
+      "Git",
+      ["--version"],
+      "git",
+      (output) => /^git version (.+)$/m.exec(output.trim())?.[1] ?? null,
+    ),
+    executableComponent(filesystem, "Terraform", ["version", "-json"], "terraform", (output) => {
+      try {
+        const version = JSON.parse(output).terraform_version;
+        return typeof version === "string" ? version : null;
+      } catch {
+        return null;
+      }
+    }),
   ]);
   const configured = configuredStackVersions(project, fallback);
   const packages = await Promise.all(
@@ -167,34 +186,41 @@ async function readVerifiedStackComponents(
     packageComponent("BullMQ", "bullmq", configured.get("bullmq"), installed),
     packageComponent("Hono", "hono", configured.get("hono"), installed, bundledRuntime),
     packageComponent("React", "react", configured.get("react"), installed, bundledFrontend),
+    git,
+    terraform,
   ];
 }
 
-type InstalledPackage = { name: string; version: string | null };
+type InstalledPackage = { name: string; version: string | null; source: string | null };
 type DashboardStackDependencies = { node: string | null; packages: Map<string, string> };
 
 async function readInstalledPackageVersion(
   filesystem: WorkspaceFileSystem,
   name: string,
 ): Promise<InstalledPackage> {
-  try {
-    const value = recordValue(
-      JSON.parse(await filesystem.readText(`node_modules/${name}/package.json`)),
-    );
-    const version = stringValue(value.version);
-    const entrypoint = packageEntrypoint(value);
-    if (
-      value.name !== name ||
-      version === null ||
-      !/^\d+\.\d+\.\d+(?:-[\w.-]+)?(?:\+[\w.-]+)?$/.test(version) ||
-      entrypoint === null
-    )
-      return { name, version: null };
-    await filesystem.readText(`node_modules/${name}/${entrypoint}`);
-    return { name, version };
-  } catch {
-    return { name, version: null };
+  const roots = ["node_modules"];
+  if (name === "hono") roots.push(".agents/dashboard/packages/local-runtime/node_modules");
+  if (name === "react") roots.push(".agents/dashboard/apps/frontend/node_modules");
+  for (const root of roots) {
+    try {
+      const source = `${root}/${name}/package.json`;
+      const value = recordValue(JSON.parse(await filesystem.readText(source)));
+      const version = stringValue(value.version);
+      const entrypoint = packageEntrypoint(value);
+      if (
+        value.name !== name ||
+        version === null ||
+        !/^\d+\.\d+\.\d+(?:-[\w.-]+)?(?:\+[\w.-]+)?$/.test(version) ||
+        entrypoint === null
+      )
+        continue;
+      await filesystem.readText(`${root}/${name}/${entrypoint}`);
+      return { name, version, source };
+    } catch {
+      // A pnpm workspace can install dependencies in the owning package only.
+    }
   }
+  return { name, version: null, source: null };
 }
 
 async function readDashboardStackDependencies(
@@ -257,6 +283,55 @@ async function hasNonEmptyFile(filesystem: WorkspaceFileSystem, path: string): P
   }
 }
 
+async function executableComponent(
+  filesystem: WorkspaceFileSystem,
+  name: string,
+  args: string[],
+  command: "git" | "terraform",
+  parse: (output: string) => string | null,
+): Promise<ProjectOverview["stack_components"][number]> {
+  const project = await readProjectSettings(filesystem);
+  const components = recordValue(recordValue(project.stack.overrides).components);
+  const configuredVersion =
+    command === "git"
+      ? "latest"
+      : (stringValue(recordValue(components.backend_infrastructure).version) ?? "1.16.1");
+  const safeTerraformVersion = /^\d+\.\d+\.\d+$/.test(configuredVersion)
+    ? configuredVersion
+    : "1.16.1";
+  const local =
+    command === "git"
+      ? ".local/git/cmd/git.exe"
+      : `.local/terraform/v${safeTerraformVersion}-${process.platform}-${process.arch}/${
+          process.platform === "win32" ? "terraform.exe" : "terraform"
+        }`;
+  const localPath = join(filesystem.root, local);
+  const executable = (await filesystem.exists(local)) ? localPath : command;
+  try {
+    const version = parse(
+      (await exec(executable, args, { timeout: 10_000, windowsHide: true })).stdout,
+    );
+    if (version === null) throw new Error("unsupported version output");
+    return {
+      name,
+      version,
+      configured_version: configuredVersion,
+      source: executable === command ? `Comando do workspace: ${command}` : local,
+      verification: "exact",
+      installation: executable === command ? "runtime" : "installed",
+    };
+  } catch {
+    return {
+      name,
+      version: null,
+      configured_version: configuredVersion,
+      source: null,
+      verification: "unavailable",
+      installation: "missing",
+    };
+  }
+}
+
 function runtimeComponent(
   name: string,
   version: string | null,
@@ -285,7 +360,7 @@ function packageComponent(
       name,
       version: actual,
       configured_version: configuredVersion ?? null,
-      source: `node_modules/${packageName}/package.json`,
+      source: installed.get(packageName)?.source ?? null,
       verification: "exact",
       installation: "installed",
     };
@@ -298,7 +373,7 @@ function packageComponent(
         packageName === "hono"
           ? ".agents/dashboard/packages/local-runtime/server.mjs"
           : ".agents/dashboard/apps/frontend/dist",
-      verification: configuredVersion === undefined ? "unavailable" : "constraint",
+      verification: "unavailable",
       installation: "bundled",
     };
   return {
@@ -332,6 +407,8 @@ export async function persistProjectSettings(
   if (requested.tracking.storage_mode !== "tracked_sanitized") {
     throw new TypeError("This project requires Git-native tracked_sanitized storage.");
   }
+  const currentComponents = recordValue(current.stack.overrides.components);
+  const requestedComponents = recordValue(requested.stack.overrides.components);
   const candidate = parseProjectConfig({
     ...requested,
     clients: current.clients,
@@ -342,6 +419,9 @@ export async function persistProjectSettings(
       overrides: {
         ...current.stack.overrides,
         ...requested.stack.overrides,
+        ...(Object.keys(currentComponents).length > 0 || Object.keys(requestedComponents).length > 0
+          ? { components: { ...currentComponents, ...requestedComponents } }
+          : {}),
       },
     },
   });
@@ -371,6 +451,7 @@ const componentLabels: Record<string, string> = {
   cache_messaging: "Cache e mensageria",
   async_queue: "Filas e processamento assíncrono",
   backend_infrastructure: "Infraestrutura backend",
+  backend_hosting: "Hospedagem do backend",
   web_framework: "Framework do Web App",
   web_language: "Linguagem do Web App",
   web_build: "Build do Web App",
@@ -380,6 +461,14 @@ const componentLabels: Record<string, string> = {
   site_islands: "Componentes interativos",
   site_build: "Build do site",
   site_hosting: "Hospedagem do site",
+  prometheus: "Coleta de métricas",
+  grafana: "Dashboards",
+  uptime_kuma: "Monitoramento de disponibilidade",
+  cadvisor: "Métricas de containers",
+  node_exporter: "Métricas de host",
+  redis_exporter: "Métricas do Redis",
+  k6: "Teste de carga",
+  autocannon: "Teste HTTP de carga",
 };
 
 const architectureLabels: Record<string, string> = {
@@ -387,6 +476,7 @@ const architectureLabels: Record<string, string> = {
   backend_api_and_business_rules: "APIs e regras de negócio",
   backend_async_processing: "Filas e processamento assíncrono",
   backend_infrastructure: "Infraestrutura backend",
+  backend_hosting: "Hospedagem do backend",
 };
 
 export function renderSoftwareArchitecture(config: ProjectConfig): string {

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

@@ -0,0 +1,39 @@
+export 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;
+}
+
+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();
+}

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

@@ -0,0 +1,33 @@
+import type { Hono } from "hono";
+import { streamSSE } from "hono/streaming";
+
+export function registerBrowserLeaseRoute(
+  app: Hono,
+  apiPrefix: string,
+  launcherOwned = false,
+): void {
+  const browserLeases = new Set<object>();
+  let browserLeaseDeadline: NodeJS.Timeout | undefined;
+  if (launcherOwned) {
+    browserLeaseDeadline = setTimeout(() => process.exit(0), 12_000);
+    browserLeaseDeadline.unref();
+  }
+  const releaseBrowserLease = (lease: object) => {
+    browserLeases.delete(lease);
+    if (!launcherOwned || browserLeases.size !== 0) return;
+    if (browserLeaseDeadline !== undefined) clearTimeout(browserLeaseDeadline);
+    browserLeaseDeadline = setTimeout(() => process.exit(0), 12_000);
+    browserLeaseDeadline.unref();
+  };
+  app.get(`${apiPrefix}/browser-lease`, (context) => {
+    const lease = {};
+    if (browserLeaseDeadline !== undefined) clearTimeout(browserLeaseDeadline);
+    browserLeaseDeadline = undefined;
+    browserLeases.add(lease);
+    return streamSSE(context, async (stream) => {
+      stream.onAbort(() => releaseBrowserLease(lease));
+      await stream.writeSSE({ event: "lease", data: "active" });
+      await new Promise(() => {});
+    });
+  });
+}

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

@@ -1,12 +1,96 @@
-import { resolve } from "node:path";
+import { mkdir, mkdtemp, readFile, rm, writeFile } from "node:fs/promises";
+import { join, resolve } from "node:path";
 import { WorkspaceFileSystem, type WorkspaceLayout } from "@zaip-ai/core";
-import { describe, expect, it, vi } from "vitest";
+import { afterEach, describe, expect, it, vi } from "vitest";
 import { createDashboardApp, reconciliationNeedsRefresh } from "./server.js";
+import { ReconciliationCommandTimeoutError, reconciliationResult } from "./server-workspace.js";
+import { rebuildSqliteReadModel, SqliteReadModelFileSystem } from "./sqlite-read-model.js";
 
 const workspaceRoot = resolve(import.meta.dirname, "../../../../..");
 const v2Layout = { version: 3 } as WorkspaceLayout;
+const fixtureRoots: string[] = [];
+const fixtureBase = join(workspaceRoot, ".tmp", "server-reconciliation-refresh-tests");
+
+async function createSqliteFixture(): Promise<string> {
+  await mkdir(fixtureBase, { recursive: true });
+  const root = await mkdtemp(join(fixtureBase, "fixture-"));
+  fixtureRoots.push(root);
+  await mkdir(join(root, ".agents", "config"), { recursive: true });
+  await Promise.all([
+    readFile(join(workspaceRoot, ".agents", "config", "project.yaml"), "utf8").then((content) =>
+      writeFile(join(root, ".agents", "config", "project.yaml"), content),
+    ),
+    readFile(join(workspaceRoot, ".agents", "config", "framework.lock.yaml"), "utf8").then(
+      (content) => writeFile(join(root, ".agents", "config", "framework.lock.yaml"), content),
+    ),
+  ]);
+  await rebuildSqliteReadModel(root);
+  return root;
+}
+
+afterEach(async () => {
+  await Promise.all(
+    fixtureRoots.splice(0).map((root) => rm(root, { recursive: true, force: true })),
+  );
+});
 
 describe("reconciliation snapshot refresh", () => {
+  it("publishes a stable readiness revision and changes it after a status-only snapshot commit", async () => {
+    const fixtureRoot = await createSqliteFixture();
+    const taskPath = join(fixtureRoot, ".agents/records/tasks/TASK-REVISION.md");
+    await mkdir(join(fixtureRoot, ".agents/records/tasks"), { recursive: true });
+    const task = (status: string) => `---
+schema_version: 2
+id: TASK-REVISION
+title: Snapshot status revision
+status: ${status}
+created_at: 2026-09-05T10:00:00.000Z
+---
+# Task
+`;
+    await writeFile(taskPath, task("executing"));
+    await rebuildSqliteReadModel(fixtureRoot);
+    const filesystem = new SqliteReadModelFileSystem(fixtureRoot);
+    const refresh = vi.fn(async () => undefined);
+    const app = createDashboardApp(fixtureRoot, "test-session", undefined, {
+      snapshotReadOnly: true,
+      filesystem,
+      refreshReadModel: refresh,
+      layout: v2Layout,
+    });
+    const ready = async () => {
+      const response = await app.request("/api/v2/ready", {
+        headers: { "x-zaip-session": "test-session" },
+      });
+      expect(response.status).toBe(200);
+      return response.json() as Promise<{
+        snapshot_revision: string;
+        activity_count: number;
+        day_count: number;
+      }>;
+    };
+    try {
+      const before = await ready();
+      expect(before.snapshot_revision).toMatch(/^[a-f0-9]{64}$/);
+      await expect(ready()).resolves.toEqual(before);
+      await writeFile(taskPath, task("completed"));
+      // Canonical edits do not pretend that the opened snapshot was promoted.
+      await expect(ready()).resolves.toEqual(before);
+      // Use the production refresh boundary, which releases Windows readers
+      // before replacing an older snapshot generation.
+      await filesystem.rebuildAndRefresh(() => rebuildSqliteReadModel(fixtureRoot));
+      const after = await ready();
+      expect(after.snapshot_revision).not.toBe(before.snapshot_revision);
+      expect(after.activity_count).toBe(before.activity_count);
+      expect(after.day_count).toBe(before.day_count);
+      await filesystem.rebuildAndRefresh(() => rebuildSqliteReadModel(fixtureRoot));
+      await expect(ready()).resolves.toEqual(after);
+      expect(refresh).not.toHaveBeenCalled();
+    } finally {
+      filesystem.close();
+    }
+  });
+
   it("refreshes only when reconciliation changed canonical work", () => {
     expect(
       reconciliationNeedsRefresh({ reconciled_ids: [], blocked: [], not_reconciled: [] }),
@@ -25,9 +109,35 @@ describe("reconciliation snapshot refresh", () => {
         not_reconciled: [],
       }),
     ).toBe(true);
+    expect(
+      reconciliationNeedsRefresh(
+        reconciliationResult({
+          reconciliations: [
+            {
+              status: "closed",
+              specs: [{ id: "SPEC-DELIVERED", status: "delivered" }],
+              prds: [{ id: "PRD-DELIVERED", status: "delivered" }],
+            },
+          ],
+        }),
+      ),
+    ).toBe(true);
   });
 
-  it("serves health while a changed reconciliation refreshes in a worker", async () => {
+  it("reports a closed Run as a snapshot-changing reconciliation without a Task graph", () => {
+    expect(
+      reconciliationNeedsRefresh(
+        reconciliationResult({
+          runs: [{ run: { run_id: "RUN-CONVERSATION-CLOSED" } }],
+          reconciliations: [],
+        }),
+      ),
+    ).toBe(true);
+  });
+
+  it("returns a compact receipt while a changed reconciliation refreshes in a worker", async () => {
+    const fixtureRoot = await createSqliteFixture();
+    const filesystem = new SqliteReadModelFileSystem(fixtureRoot);
     let rejectRefresh: ((error: Error) => void) | undefined;
     const refresh = vi.fn(
       () =>
@@ -35,9 +145,10 @@ describe("reconciliation snapshot refresh", () => {
           rejectRefresh = reject;
         }),
     );
-    const app = createDashboardApp(workspaceRoot, "test-session", undefined, {
+    const app = createDashboardApp(fixtureRoot, "test-session", undefined, {
       snapshotReadOnly: true,
-      canonicalFilesystem: new WorkspaceFileSystem(workspaceRoot),
+      filesystem,
+      canonicalFilesystem: new WorkspaceFileSystem(fixtureRoot),
       reconcileOpenWork: async () => ({
         reconciled_ids: ["TASK-CHANGED"],
         blocked: [],
@@ -50,17 +161,43 @@ describe("reconciliation snapshot refresh", () => {
       method: "POST",
       headers: { "x-zaip-session": "test-session" },
     });
+    const response = await reconciliation;
+    expect(response.status, await response.clone().text()).toBe(200);
+    await expect(response.json()).resolves.toMatchObject({
+      snapshot_state: "updating",
+      projection_refresh_completed: false,
+      reconciliation: { reconciled_ids: ["TASK-CHANGED"] },
+    });
     await vi.waitFor(() => expect(refresh).toHaveBeenCalledOnce());
     await expect(
       app.request("/api/v2/health", { headers: { "x-zaip-session": "test-session" } }),
-    ).resolves.toMatchObject({
-      status: 200,
-    });
+    ).resolves.toMatchObject({ status: 200 });
     rejectRefresh?.(new Error("simulated worker refresh failure"));
-    const response = await reconciliation;
-    expect(response.status).toBe(400);
+    await vi.waitFor(() => expect(refresh).toHaveBeenCalledOnce());
+    filesystem.close();
+  });
+
+  it("returns a finite partial-reconciliation error and refreshes the projection", async () => {
+    const refresh = vi.fn(async () => undefined);
+    const app = createDashboardApp(workspaceRoot, "test-session", undefined, {
+      snapshotReadOnly: true,
+      canonicalFilesystem: new WorkspaceFileSystem(workspaceRoot),
+      reconcileOpenWork: async () => {
+        throw new ReconciliationCommandTimeoutError();
+      },
+      refreshReadModel: refresh,
+      layout: v2Layout,
+    });
+
+    const response = await app.request("/api/v2/reconcile-open-work", {
+      method: "POST",
+      headers: { "x-zaip-session": "test-session" },
+    });
+    expect(response.status).toBe(408);
     await expect(response.json()).resolves.toMatchObject({
-      error: "simulated worker refresh failure",
+      reconciliation_may_be_partial: true,
+      projection_refresh_started: true,
     });
+    await vi.waitFor(() => expect(refresh).toHaveBeenCalledOnce());
   });
 });