@zaip-ai/cli 1.3.0 → 1.3.1

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

@@ -0,0 +1,91 @@
+import { createHash } from "node:crypto";
+import type { WorkspaceLayout } from "@zaip-ai/core";
+import {
+  buildTraceStageRecords,
+  classifyTraceDocument,
+  timestampsFromContent,
+} from "@zaip-ai/dashboard-traceability/server";
+import type { TaskTrace, TraceDocument } from "../../../modules/traceability/src/contracts.js";
+import type { SqliteReadModelFileSystem } from "./sqlite-read-model.js";
+
+export function buildSqliteTaskTrace(
+  filesystem: SqliteReadModelFileSystem,
+  layout: WorkspaceLayout,
+  taskId: string,
+): TaskTrace {
+  const initial = filesystem.canonicalTraceFiles([taskId]);
+  const taskFile = initial.find(
+    (row) =>
+      row.path.includes("/.agents/records/tasks/") || row.path.includes(".agents/records/tasks/"),
+  );
+  if (taskFile === undefined) throw new Error(`Canonical Task ${taskId} was not found`);
+  const scalar = (key: string): string | null => {
+    const frontMatter = /^---\r?\n([\s\S]*?)\r?\n---/.exec(taskFile.content)?.[1] ?? "";
+    const value = new RegExp(`^${key}:\\s*(.+?)\\s*$`, "m").exec(frontMatter)?.[1]?.trim();
+    if (value === undefined || value === "null") return null;
+    return value.replace(/^['"]|['"]$/g, "");
+  };
+  const relatedId = (key: string, prefix: string): string | null =>
+    scalar(key) ?? new RegExp(`\\b${prefix}[A-Z0-9-]+`).exec(taskFile.content)?.[0] ?? null;
+  const changeId = relatedId("change_id", "CHG-") ?? taskId;
+  const specId = relatedId("spec_id", "SPEC-");
+  const prdId = relatedId("prd_id", "PRD-");
+  const markers = [taskId, changeId, specId, prdId].filter(
+    (value): value is string => value !== null,
+  );
+  const documents = filesystem
+    .canonicalTraceFiles(markers)
+    .filter(
+      (row) => /\.(?:md|json|jsonl|txt|log)$/i.test(row.path) && row.content.length <= 250_000,
+    )
+    .map((row) => {
+      const classification = classifyTraceDocument(row.path);
+      const timestamps = timestampsFromContent(row.content);
+      return {
+        id: createHash("sha256").update(row.path).digest("hex").slice(0, 16),
+        path: row.path,
+        title:
+          row.content.match(/^#\s+(.+)$/m)?.[1]?.trim() ?? row.path.split("/").at(-1) ?? row.path,
+        ...classification,
+        content: row.content,
+        ...timestamps,
+      } satisfies TraceDocument;
+    });
+  const stages = buildTraceStageRecords(documents);
+  const coveredStages = new Set(documents.map((document) => document.stage));
+  const risk = scalar("risk");
+  const status = scalar("status");
+  return {
+    schema_version: 2,
+    layout_version: layout.version as 2 | 3,
+    readonly: true,
+    source: ".agents/records",
+    task_id: taskId,
+    task_title: scalar("title") ?? taskFile.content.match(/^#\s+(.+)$/m)?.[1]?.trim() ?? taskId,
+    task_risk: risk === "lite" || risk === "standard" || risk === "critical" ? risk : null,
+    task_created_at: scalar("created_at"),
+    task_progress:
+      status === "completed"
+        ? 100
+        : status === "verifying"
+          ? 80
+          : status === "executing"
+            ? 50
+            : status === "blocked" || status === "failed" || status === "cancelled"
+              ? 0
+              : 10,
+    spec_id: specId,
+    prd_id: prdId,
+    change_id: changeId,
+    usage: filesystem.taskTraceUsage(taskId),
+    documents,
+    stages,
+    coverage: {
+      stages_with_documents: coveredStages.size,
+      stages_with_timestamps: stages.filter((stage) => stage.status === "recorded").length,
+      total_stages: 6,
+      evidence_count: documents.filter((document) => document.kind === "evidence").length,
+      test_count: documents.filter((document) => document.kind === "test").length,
+    },
+  };
+}

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

@@ -1,4 +1,37 @@
+import { mkdir, mkdtemp, rm, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
 import type { InvocationSummaryV1 } from "@zaip-ai/costs";
+import { rebuildSqliteReadModel, SqliteReadModelFileSystem } from "./sqlite-read-model.js";
+
+export async function withSqliteReadModelFixture<T>(
+  name: string,
+  run: (fixture: { root: string; filesystem: SqliteReadModelFileSystem }) => Promise<T>,
+): Promise<T> {
+  const root = await mkdtemp(join(tmpdir(), `zaip-dashboard-${name}-`));
+  const previousDbPath = process.env.ZAIP_SQLITE_DB_PATH;
+  process.env.ZAIP_SQLITE_DB_PATH = join(root, "read-model.sqlite");
+  let filesystem: SqliteReadModelFileSystem | undefined;
+  try {
+    await mkdir(join(root, ".agents", "config"), { recursive: true });
+    await writeFile(
+      join(root, ".agents", "config", "project.yaml"),
+      `schema_version: 1\nproject:\n  id: ${name}\n  name: ${name}\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(root, ".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",
+    );
+    await rebuildSqliteReadModel(root);
+    filesystem = new SqliteReadModelFileSystem(root);
+    return await run({ root, filesystem });
+  } finally {
+    filesystem?.close();
+    if (previousDbPath === undefined) delete process.env.ZAIP_SQLITE_DB_PATH;
+    else process.env.ZAIP_SQLITE_DB_PATH = previousDbPath;
+    await rm(root, { recursive: true, force: true });
+  }
+}
 
 export function pricingCatalog(inputRate: number) {
   return {
@@ -76,6 +109,9 @@ export function invocationSummary(
     zaip_agent: "zaip-agent-orchestrator",
     phase: "execution",
     purpose: "orchestration",
+    // Legacy fixtures remain valid while current invocation contracts carry a
+    // nullable developer identity.
+    developer_identity: null,
     occurred_at: "2026-07-26T12:00:00.000Z",
     status: "completed",
     coverage: "complete",

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

@@ -14,8 +14,7 @@ import {
   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,
@@ -26,127 +25,6 @@ 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",
@@ -253,6 +131,103 @@ 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"],