@zaip-ai/cli 1.0.8 → 1.3.1

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

@@ -12,139 +12,19 @@ import {
   openWorkIds,
   projectionPeriodFilter,
   reconciliationResult,
+  SqliteReadModelFileSystem,
 } from "./server.js";
-import { invocationSummary } from "./server.test-fixtures.js";
-import { classificationPage } from "./server-board.js";
+import { invocationSummary, withSqliteReadModelFixture } from "./server.test-fixtures.js";
 import {
   compactRunProjection,
   mergeKnownManifestRuns,
   mergeLifecycleRunPage,
   runTimestampInRange,
 } from "./server-projections.js";
+import { rebuildSqliteReadModel } from "./sqlite-read-model.js";
 
 const workspaceRoot = resolve(import.meta.dirname, "../../../../..");
 describe("dashboard backend", () => {
-  it.each([
-    ["task", "lite", "TASK-LITE"],
-    ["task", "standard", "TASK-STANDARD"],
-    ["task", "critical", "TASK-CRITICAL"],
-    ["spec", "empty", "SPEC-EMPTY"],
-    ["spec", "structured", "SPEC-STRUCTURED"],
-    ["spec", "rework", "SPEC-REWORK"],
-    ["prd", "empty", "PRD-EMPTY"],
-    ["prd", "structured", "PRD-STRUCTURED"],
-    ["prd", "rework", "PRD-REWORK"],
-  ] as const)("returns only the canonical %s %s classification page", (kind, classification, expectedId) => {
-    const projection = {
-      tasks: [
-        { id: "TASK-LITE", risk: "lite", created_at: "2026-08-21T00:00:00.000Z", updated_at: null },
-        {
-          id: "TASK-STANDARD",
-          risk: "standard",
-          created_at: "2026-08-21T00:00:00.000Z",
-          updated_at: null,
-        },
-        {
-          id: "TASK-CRITICAL",
-          risk: "critical",
-          created_at: "2026-08-21T00:00:00.000Z",
-          updated_at: null,
-        },
-      ],
-      specs: [
-        {
-          id: "SPEC-EMPTY",
-          task_count: 0,
-          rework_run_count: 0,
-          created_at: "2026-08-21T00:00:00.000Z",
-          updated_at: null,
-        },
-        {
-          id: "SPEC-STRUCTURED",
-          task_count: 1,
-          rework_run_count: 0,
-          created_at: "2026-08-21T00:00:00.000Z",
-          updated_at: null,
-        },
-        {
-          id: "SPEC-REWORK",
-          task_count: 1,
-          rework_run_count: 1,
-          created_at: "2026-08-21T00:00:00.000Z",
-          updated_at: null,
-        },
-      ],
-      prds: [
-        {
-          id: "PRD-EMPTY",
-          task_count: 0,
-          rework_run_count: 0,
-          created_at: "2026-08-21T00:00:00.000Z",
-          updated_at: null,
-        },
-        {
-          id: "PRD-STRUCTURED",
-          task_count: 1,
-          rework_run_count: 0,
-          created_at: "2026-08-21T00:00:00.000Z",
-          updated_at: null,
-        },
-        {
-          id: "PRD-REWORK",
-          task_count: 1,
-          rework_run_count: 1,
-          created_at: "2026-08-21T00:00:00.000Z",
-          updated_at: null,
-        },
-      ],
-      changes: [],
-    } as unknown as Parameters<typeof classificationPage>[0];
-
-    const page = classificationPage(projection, kind, classification, 0, 1);
-    const items = kind === "task" ? page.tasks : kind === "spec" ? page.specs : page.prds;
-
-    expect(page).toMatchObject({ offset: 0, total: 1 });
-    expect(items.map((item) => item.id)).toEqual([expectedId]);
-    expect(kind === "task" ? page.specs : page.tasks).toEqual([]);
-    expect(kind === "prd" ? page.specs : page.prds).toEqual([]);
-  });
-
-  it("keeps Runs on the final all-time summary day inside the page-first range", () => {
-    expect(runTimestampInRange("2026-08-07T23:59:59.000Z", "2026-08-01", "2026-08-07")).toBe(true);
-    expect(runTimestampInRange("2026-08-08T00:00:00.000Z", "2026-08-01", "2026-08-07")).toBe(false);
-  });
-  it("keeps a lifecycle Run with no InvocationSummary as a null-telemetry page row", () => {
-    const run = compactRunProjection({
-      id: "RUN-NO-SUMMARY",
-      started_at: "2026-08-07T02:59:59.999Z",
-      finished_at: null,
-      task_id: null,
-      execution_id: null,
-      conversation_id: null,
-      agent: null,
-      agent_name: null,
-      provider: null,
-      model: null,
-      spec_id: null,
-      prd_id: null,
-      change_id: null,
-      phase: "execution",
-      parent_run_id: null,
-      status: "completed",
-      duration_ms: null,
-      total_tokens: null,
-      cost: null,
-      currency: null,
-      events: null,
-    });
-    expect(run).toMatchObject({
-      id: "RUN-NO-SUMMARY",
-      duration_ms: null,
-      source_duration_ms: null,
-    });
-    expect(run.usage.total.tokens.total).toBeNull();
-    expect(run.usage.total.cost.brl).toBeNull();
-  });
   it("projects factual compact Run dimensions without replacing absent data", () => {
     const run = compactRunProjection({
       id: "RUN-FACTUAL-DIMENSIONS",
@@ -251,8 +131,109 @@ describe("dashboard backend", () => {
       workspace_layout: 3,
     });
   });
+  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({
+        data_source: "sqlite_read_model",
+        filters: {
+          from: "2026-08-08T03:00:00.000Z",
+          to: "2026-08-09T02:59:59.999Z",
+          account_ids: ["42"],
+        },
+        rows: [
+          {
+            account_id: "42",
+            login_snapshot: "dev-42",
+            attribution_source: "verified_local_account",
+            qualification: "verified",
+            run_count: 2,
+            total_tokens: 10,
+            total_cost_usd: 0.1,
+            total_cost_brl: 0.5,
+            token_covered_runs: 1,
+            usd_covered_runs: 1,
+            brl_covered_runs: 1,
+            completed_task_count: 1,
+            completed_tasks: [
+              {
+                id: "TASK-42",
+                status: "completed",
+                completed_run_id: "RUN-42",
+                delivered_by: { account_id: "42" },
+                contributors: [{ account_id: "99", login_snapshot: "dev-99" }],
+              },
+            ],
+          },
+        ],
+        totals: { run_count: 2, completed_task_count: 1, total_cost_usd: 0.1, total_cost_brl: 0.5 },
+      } as ReturnType<typeof filesystem.developerCostAggregate>);
+      const app = createDashboardApp(root, "test-session", undefined, { filesystem });
+      const response = await app.request(
+        "/api/v2/developers?account_id=42&from=2026-08-08&to=2026-08-08",
+        {
+          headers: { "x-zaip-session": "test-session" },
+        },
+      );
+      expect(response.status, await response.clone().text()).toBe(200);
+      await expect(response.json()).resolves.toMatchObject({
+        data_source: "sqlite_read_model",
+        filters: { account_ids: ["42"] },
+        rows: [
+          expect.objectContaining({
+            attribution_source: "verified_local_account",
+            qualification: "verified",
+            completed_tasks: [
+              expect.objectContaining({
+                delivered_by: { account_id: "42" },
+                contributors: [{ account_id: "99", login_snapshot: "dev-99" }],
+              }),
+            ],
+          }),
+        ],
+      });
+      expect(aggregate).toHaveBeenCalledWith(expect.objectContaining({ accountIds: ["42"] }));
+    });
+  });
+  it("exposes Operations developer facts without changing the Cost Monitor endpoint", async () => {
+    await withSqliteReadModelFixture("operations-developer", async ({ root, filesystem }) => {
+      const aggregate = vi.spyOn(filesystem, "operationsDeveloperAggregate").mockReturnValue({
+        data_source: "sqlite_read_model",
+        filters: { from: null, to: null, account_ids: ["42"] },
+        rows: [
+          {
+            account_id: "42",
+            login_snapshot: "dev-42",
+            task_count: 2,
+            completed_task_count: 1,
+            status_counts: { completed: 1, executing: 1 },
+            type_counts: { task: 2 },
+            risk_counts: { standard: 2 },
+            total_duration_ms: 10,
+            total_tokens: 20,
+            total_cost_brl: 0.5,
+          },
+        ],
+      } as ReturnType<typeof filesystem.operationsDeveloperAggregate>);
+      const app = createDashboardApp(root, "test-session", undefined, { filesystem });
+      const response = await app.request("/api/v2/operations/developers?account_id=42", {
+        headers: { "x-zaip-session": "test-session" },
+      });
+      expect(response.status, await response.clone().text()).toBe(200);
+      const payload = (await response.json()) as { rows: unknown[] };
+      expect(payload.rows[0]).toMatchObject({
+        task_count: 2,
+        completed_task_count: 1,
+        status_counts: { completed: 1 },
+      });
+      expect(aggregate).toHaveBeenCalledWith(expect.objectContaining({ accountIds: ["42"] }));
+    });
+  });
   it("permits canonical open-work reconciliation while serving a read-only SQLite snapshot", async () => {
-    const reconcile = vi.fn(async () => ({ reconciled_ids: ["TASK-RECONCILED"], blocked: [], not_reconciled: [] }));
+    const reconcile = vi.fn(async () => ({
+      reconciled_ids: ["TASK-RECONCILED"],
+      blocked: [],
+      not_reconciled: [],
+    }));
     const refresh = vi.fn(async () => undefined);
     const canonicalFilesystem = new WorkspaceFileSystem(workspaceRoot);
     const app = createDashboardApp(workspaceRoot, "test-session", undefined, {
@@ -275,6 +256,106 @@ describe("dashboard backend", () => {
     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(
+      fixtureRoot,
+      ".agents",
+      "records",
+      "lifecycle",
+      "indexes",
+      "task.json",
+    );
+    const taskRecordPath = join(
+      fixtureRoot,
+      ".agents",
+      "records",
+      "tasks",
+      "2026",
+      "08",
+      "TASK-STALE-PROJECTION.md",
+    );
+    await mkdir(join(fixtureRoot, ".agents", "config"), { recursive: true });
+    await mkdir(join(fixtureRoot, ".agents", "records", "lifecycle", "indexes"), {
+      recursive: true,
+    });
+    await mkdir(join(fixtureRoot, ".agents", "records", "tasks", "2026", "08"), {
+      recursive: true,
+    });
+    await writeFile(
+      join(fixtureRoot, ".agents", "config", "project.yaml"),
+      "schema_version: 1\nproject:\n  id: stale-projection\n  name: stale-projection\n  timezone: UTC\nstack:\n  id: zaip-aios-stack\n  overrides: {}\nclients:\n  codex: true\n  claude: true\ntracking:\n  enabled: true\n  currency: BRL\n  storage_mode: tracked_sanitized\n",
+    );
+    await writeFile(
+      join(fixtureRoot, ".agents", "config", "framework.lock.yaml"),
+      "lock_version: 1\nframework:\n  version: 1.3.0\n  distribution_sha256: null\nlayout:\n  version: 3\nresolved_profile:\n  id: null\n  sha256: null\nmanaged_files: {}\n",
+    );
+    const task = (status: "executing" | "completed") => ({
+      schema_version: 1,
+      entities: {
+        "TASK-STALE-PROJECTION": {
+          kind: "task",
+          id: "TASK-STALE-PROJECTION",
+          title: "Stale projection",
+          status,
+          risk: "standard",
+          priority: "medium",
+          updated_at: "2026-08-22T12:00:00.000Z",
+          relations: [],
+          usage: null,
+          data: { created_at: "2026-08-22T12:00:00.000Z" },
+        },
+      },
+    });
+    await writeFile(taskIndexPath, `${JSON.stringify(task("executing"))}\n`);
+    const taskRecord = (status: "executing" | "completed") =>
+      `---\nid: TASK-STALE-PROJECTION\ntitle: Stale projection\nstatus: ${status}\nrisk: standard\ncreated_at: 2026-08-22T12:00:00.000Z\n---\n# Stale projection\n`;
+    await writeFile(taskRecordPath, taskRecord("executing"));
+    await rebuildSqliteReadModel(fixtureRoot);
+    const filesystem = new SqliteReadModelFileSystem(fixtureRoot);
+    const reconcile = vi.fn(async () => ({ reconciled_ids: [], blocked: [], not_reconciled: [] }));
+    try {
+      const app = createDashboardApp(fixtureRoot, "test-session", undefined, {
+        canonicalFilesystem: new WorkspaceFileSystem(fixtureRoot),
+        filesystem,
+        reconcileOpenWork: reconcile,
+      });
+      const before = await app.request("/api/v2/operations?scope=quick", {
+        headers: { "x-zaip-session": "test-session" },
+      });
+      const beforePayload = (await before.json()) as {
+        summary: { overview_metrics: { task_status_counts: Record<string, number> } };
+      };
+      expect(beforePayload.summary.overview_metrics.task_status_counts.executing).toBe(1);
+
+      await writeFile(taskIndexPath, `${JSON.stringify(task("completed"))}\n`);
+      await writeFile(taskRecordPath, taskRecord("completed"));
+      const previousSeedPreference = process.env.ZAIP_SQLITE_PREFER_LAST_VALID_SEED;
+      process.env.ZAIP_SQLITE_PREFER_LAST_VALID_SEED = "1";
+      const refreshed = await app.request("/api/v2/refresh-projection", {
+        method: "POST",
+        headers: { "x-zaip-session": "test-session" },
+      });
+      if (previousSeedPreference === undefined)
+        delete process.env.ZAIP_SQLITE_PREFER_LAST_VALID_SEED;
+      else process.env.ZAIP_SQLITE_PREFER_LAST_VALID_SEED = previousSeedPreference;
+
+      expect(refreshed.status, await refreshed.clone().text()).toBe(200);
+      const payload = (await refreshed.json()) as {
+        operations: {
+          summary: { overview_metrics: { task_status_counts: Record<string, number> } };
+        };
+      };
+      expect(payload.operations.summary.overview_metrics.task_status_counts.executing ?? 0).toBe(0);
+      expect(payload.operations.summary.overview_metrics.task_status_counts.completed).toBe(1);
+      expect(reconcile).not.toHaveBeenCalled();
+      const rejected = await app.request("/api/v2/refresh-projection", { method: "POST" });
+      expect(rejected.status).toBe(401);
+    } finally {
+      filesystem.close();
+      await rm(fixtureRoot, { recursive: true, force: true });
+    }
+  }, 130_000);
   it("persists Kanban priority canonically while a SQLite snapshot blocks other settings writes", async () => {
     const canonicalRoot = await mkdtemp(join(tmpdir(), "zaip-dashboard-priority-"));
     try {
@@ -298,11 +379,21 @@ describe("dashboard backend", () => {
       };
       expect(beforeBoard.tasks.length).toBeGreaterThan(1);
       const concurrent = await Promise.all([
-        app.request("/api/v2/operations?scope=board&stage=completed&from=2000-01-01&to=2099-12-31&offset=0&limit=10", { headers: { "x-zaip-session": "test-session" } }),
-        app.request("/api/v2/operations?scope=board&stage=blocked&from=2000-01-01&to=2099-12-31&offset=0&limit=10", { headers: { "x-zaip-session": "test-session" } }),
+        app.request(
+          "/api/v2/operations?scope=board&stage=completed&from=2000-01-01&to=2099-12-31&offset=0&limit=10",
+          { headers: { "x-zaip-session": "test-session" } },
+        ),
+        app.request(
+          "/api/v2/operations?scope=board&stage=blocked&from=2000-01-01&to=2099-12-31&offset=0&limit=10",
+          { headers: { "x-zaip-session": "test-session" } },
+        ),
       ]);
       expect(concurrent.every((response) => response.status === 200)).toBe(true);
-      expect(priorityReads.mock.calls.filter(([path]) => path === ".agents/dashboard/work-priority.json")).toHaveLength(1);
+      expect(
+        priorityReads.mock.calls.filter(
+          ([path]) => path === ".agents/dashboard/work-priority.json",
+        ),
+      ).toHaveLength(1);
       const priority = { item_ids: [beforeBoard.tasks.at(-1)!.id], updated_at: null };
       const persisted = await app.request("/api/v2/work-priority", {
         method: "PUT",
@@ -327,7 +418,10 @@ describe("dashboard backend", () => {
       expect(after.status, await after.clone().text()).toBe(200);
       const afterBoard = (await after.json()) as typeof beforeBoard;
       expect(afterBoard.tasks[0]?.id).toBe(priority.item_ids[0]);
-      expect(priorityReads.mock.calls.filter(([path]) => path === ".agents/dashboard/work-priority.json").length).toBe(readsAfterPut + 1);
+      expect(
+        priorityReads.mock.calls.filter(([path]) => path === ".agents/dashboard/work-priority.json")
+          .length,
+      ).toBe(readsAfterPut + 1);
       const blocked = await app.request("/api/v2/pricing", {
         method: "PUT",
         headers: { "content-type": "application/json", "x-zaip-session": "test-session" },
@@ -414,7 +508,9 @@ describe("dashboard backend", () => {
     };
     expect(payload.tasks).toEqual([]);
     expect(payload.prds).toEqual([]);
-    expect(payload.specs.every((spec) => spec.task_count === 0 && spec.rework_run_count === 0)).toBe(true);
+    expect(
+      payload.specs.every((spec) => spec.task_count === 0 && spec.rework_run_count === 0),
+    ).toBe(true);
   });
   it("serves a compact cost summary and paginated Run metrics from the manifest", async () => {
     const app = createDashboardApp(workspaceRoot, "test-session");
@@ -721,7 +817,7 @@ describe("dashboard backend", () => {
         unresolved_running_run_ids: ["RUN-ACTIVE"],
       }),
     ).toEqual({
-      reconciled_ids: ["CHG-COMPLETED", "TASK-COMPLETED"],
+      reconciled_ids: ["CHG-COMPLETED", "TASK-BLOCKED", "TASK-COMPLETED"],
       blocked: [
         {
           id: "EXEC-ORPHANED",
@@ -830,8 +926,10 @@ describe("dashboard backend", () => {
       source.indexOf("function buildSqliteOperationsProjection"),
       source.indexOf("function nullableMetric"),
     );
-    expect(projection).toContain("options.includePeriods === true ? filesystem.dailyPeriods(filter) : {}");
-    expect(source).toContain("includePeriods: scope === \"detail\" || scope === \"overview\"");
+    expect(projection).toContain(
+      "options.includePeriods === true ? filesystem.dailyPeriods(filter) : {}",
+    );
+    expect(source).toContain('includePeriods: scope === "detail" || scope === "overview"');
   });
   it("rebuilds a fresh aggregate after an in-flight normal read instead of sharing its payload", async () => {
     const source = await import("node:fs/promises").then(({ readFile }) =>