@zaip-ai/cli 1.0.7 → 1.0.8

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

@@ -1,6 +1,8 @@
+import { readFileSync } from "node:fs";
 import { mkdir, mkdtemp, rm, writeFile } from "node:fs/promises";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
+import { canonicalAllTimeDurationMs } from "@zaip-ai/dashboard-operations/contracts";
 import { describe, expect, it } from "vitest";
 import { createDashboardApp } from "./server.js";
 import { pricedUsageBucket, pricingCatalog } from "./server.test-fixtures.js";
@@ -25,7 +27,7 @@ describe("dashboard backend snapshot", () => {
         "  name: dashboard-fixture",
         "  timezone: UTC",
         "stack:",
-        "  id: typescript-hono-kysely",
+        "  id: zaip-aios-stack",
         "  overrides: {}",
         "clients:",
         "  codex: true",
@@ -43,7 +45,7 @@ describe("dashboard backend snapshot", () => {
       [
         "lock_version: 1",
         "framework:",
-        "  version: 1.0.0",
+        "  version: 1.0.8",
         "  distribution_sha256: null",
         "layout:",
         "  version: 3",
@@ -304,6 +306,55 @@ describe("dashboard backend snapshot", () => {
       `${v2Run("RUN-2026-07-14-00-00-DASHBOARD-FIXTURE-LIFECYCLE", false)}\n`,
       "utf8",
     );
+    // The daily-first API intentionally does not fall back to summary.json.
+    // Materialize the compact overview and empty entity collections that a
+    // normal lifecycle refresh writes alongside the legacy fixture records.
+    const viewsRoot = join(fixtureRoot, ".agents", "records", "lifecycle", "views");
+    await mkdir(viewsRoot, { recursive: true });
+    const overviewPath = ".agents/records/lifecycle/views/overview-fixture.json";
+    await writeFile(
+      join(viewsRoot, "overview-fixture.json"),
+      `${JSON.stringify({
+        schema_version: 1,
+        days: {
+          "2026-07-14": {
+            prds: 0,
+            specs: 0,
+            tasks: 1,
+            validations: 0,
+            evidences: 0,
+            runs: 2,
+            usage: {
+              input_tokens: { known_sum: 10, unknown: 1, complete: false, coverage_ratio: 0.5 },
+              output_tokens: { known_sum: 5, unknown: 1, complete: false, coverage_ratio: 0.5 },
+              total_tokens: { known_sum: 15, unknown: 1, complete: false, coverage_ratio: 0.5 },
+              cost: {
+                known_sum: 6.25,
+                unknown: 1,
+                complete: false,
+                coverage_ratio: 0.5,
+                currency: "BRL",
+              },
+            },
+            duration: { known_sum: 5_000, unknown: 1, complete: false, coverage_ratio: 0.5 },
+            events: { known_sum: 1, unknown: 1, complete: false, coverage_ratio: 0.5 },
+          },
+        },
+      })}\n`,
+      "utf8",
+    );
+    await writeFile(
+      join(viewsRoot, "manifest.json"),
+      `${JSON.stringify({
+        schema_version: 1,
+        snapshot_id: updatedAt,
+        source_latest_at: updatedAt,
+        shard_count: 16,
+        overview_path: overviewPath,
+        collections: { tasks: [], specs: [], prds: [], executions: [], conversations: [] },
+      })}\n`,
+      "utf8",
+    );
 
     try {
       const app = createDashboardApp(fixtureRoot, "test-session");
@@ -326,6 +377,13 @@ describe("dashboard backend snapshot", () => {
       const operations = await app.request("/api/v2/operations", {
         headers: { "x-zaip-session": "test-session" },
       });
+      const quickOperations = await app.request("/api/v2/operations?scope=quick", {
+        headers: { "x-zaip-session": "test-session" },
+      });
+      // Daily summary uses the aggregate cache rather than the old snapshot
+      // cache; absence proves it did not take the snapshot fallback path.
+      expect(allCosts.headers.get("x-zaip-snapshot-cache")).toBeNull();
+      expect(operations.headers.get("x-zaip-snapshot-cache")).toBe("hit");
       const portableServerPath = new URL("../server.mjs", import.meta.url).href;
       const { createDashboardApp: createPortableDashboardApp } = await import(portableServerPath);
       const portableApp = createPortableDashboardApp(fixtureRoot, "test-session");
@@ -337,16 +395,14 @@ describe("dashboard backend snapshot", () => {
         { headers: { "x-zaip-session": "test-session" } },
       );
 
-      expect(monthlyCosts.status, await monthlyCosts.clone().text()).toBe(200);
-      expect(allCosts.status, await allCosts.clone().text()).toBe(200);
-      await expect(monthlyCosts.clone().json()).resolves.toMatchObject({
-        readonly: true,
-        currency: "BRL",
-      });
-      expect(response.status, await response.clone().text()).toBe(200);
-      expect(julySnapshot.status, await julySnapshot.clone().text()).toBe(200);
-      expect(operations.status, await operations.clone().text()).toBe(200);
-      const allOperationsPayload = (await operations.clone().json()) as {
+      expect(monthlyCosts.status).toBe(200);
+      expect(allCosts.status).toBe(200);
+      expect(response.status).toBe(200);
+      expect(julySnapshot.status).toBe(200);
+      expect(operations.status).toBe(200);
+      const allOperationsPayload = (await operations.json()) as {
+        tasks: Array<{ id: string; status: string }>;
+        executions: Array<{ id: string; status: string }>;
         runs: Array<{
           id: string;
           duration_ms: number | null;
@@ -366,95 +422,79 @@ describe("dashboard backend snapshot", () => {
         total_tokens: number | null;
         estimated_brl: number | null;
       };
-      const julyOperationsPayload = (await julyOperations.json()) as { runs: OperationRunMetric[] };
-      const allCostsPayload = (await allCosts.json()) as {
-        runs: Array<{
-          run_id: string;
-          duration_ms: number | null;
-          total_tokens: number | null;
-          estimated_brl: number | null;
-        }>;
-      };
-      const julyCostsPayload = (await monthlyCosts.clone().json()) as { runs: CostRunMetric[] };
-      const portableAllCostsPayload = (await portableAllCosts.json()) as { runs: CostRunMetric[] };
-      const portableJulyCostsPayload = (await portableJulyCosts.json()) as {
+      type CostSummaryPayload = {
         runs: CostRunMetric[];
+        groups: Record<
+          "daily" | "monthly" | "annual",
+          Array<{
+            key: string;
+            duration_ms: number | null;
+            total_tokens: number | null;
+            estimated_brl: number | null;
+          }>
+        >;
       };
-      const julySnapshotPayload = (await julySnapshot.json()) as {
-        operations: { summary: { execution_duration_ms: number } };
-        costs: {
-          groups: Record<"daily" | "monthly" | "annual", Array<{ duration_ms: number | null }>>;
+      type QuickOperationsPayload = {
+        summary: {
+          overview_metrics: { duration_ms: number | null } | null;
+          periods: {
+            daily: Record<
+              string,
+              {
+                duration?: { known_sum: number };
+                usage: { total_tokens: { known_sum: number }; cost: { known_sum: number } };
+              }
+            >;
+          };
         };
       };
+      const julyOperationsPayload = (await julyOperations.json()) as { runs: OperationRunMetric[] };
+      const allCostsPayload = (await allCosts.json()) as CostSummaryPayload;
+      const julyCostsPayload = (await monthlyCosts.json()) as CostSummaryPayload;
+      expect(allCostsPayload).toMatchObject({ readonly: true, aggregate_only: true });
+      expect(julyCostsPayload).toMatchObject({ readonly: true, currency: "BRL" });
+      const portableAllCostsPayload = (await portableAllCosts.json()) as CostSummaryPayload;
+      const portableJulyCostsPayload = (await portableJulyCosts.json()) as CostSummaryPayload;
+      const quickOperationsPayload = (await quickOperations.json()) as QuickOperationsPayload;
       const runIds = (rows: readonly { id: string }[] | readonly { run_id: string }[]) =>
         rows.map((row) => ("id" in row ? row.id : row.run_id)).sort();
-      expect(runIds(allCostsPayload.runs)).toEqual(runIds(allOperationsPayload.runs));
-      expect(runIds(julyCostsPayload.runs)).toEqual(runIds(julyOperationsPayload.runs));
-      expect(runIds(portableAllCostsPayload.runs)).toEqual(runIds(allCostsPayload.runs));
-      expect(runIds(portableJulyCostsPayload.runs)).toEqual(runIds(julyCostsPayload.runs));
-      const expectMetricParity = (
-        costRows: readonly CostRunMetric[],
-        operationRows: readonly OperationRunMetric[],
-      ) => {
-        const operationsById = new Map(operationRows.map((run) => [run.id, run] as const));
-        for (const cost of costRows) {
-          const operation = operationsById.get(cost.run_id);
-          expect(operation).toBeDefined();
-          expect(cost).toMatchObject({
-            duration_ms: operation?.source_duration_ms ?? operation?.duration_ms,
-            total_tokens: operation?.usage.total.tokens.total,
-            estimated_brl: operation?.usage.total.cost.brl,
-          });
-        }
-      };
-      expectMetricParity(allCostsPayload.runs, allOperationsPayload.runs);
-      expectMetricParity(julyCostsPayload.runs, julyOperationsPayload.runs);
-      expect(portableAllCostsPayload.runs).toEqual(allCostsPayload.runs);
-      expect(portableJulyCostsPayload.runs).toEqual(julyCostsPayload.runs);
+      // scope=summary is intentionally aggregate-only: no Run/Sub-Run payload
+      // is loaded or returned.  Detail parity remains covered by Operations.
+      expect(allCostsPayload.runs).toEqual([]);
+      expect(julyCostsPayload.runs).toEqual([]);
+      expect(portableAllCostsPayload.runs).toEqual([]);
+      expect(portableJulyCostsPayload.runs).toEqual([]);
       const groupDuration = (group: readonly { duration_ms: number | null }[]) =>
         group.reduce((sum, row) => sum + (row.duration_ms ?? 0), 0);
-      expect(julySnapshotPayload.operations.summary.execution_duration_ms).toBe(
-        groupDuration(julySnapshotPayload.costs.groups.daily),
-      );
-      expect(julySnapshotPayload.operations.summary.execution_duration_ms).toBe(
-        groupDuration(julySnapshotPayload.costs.groups.monthly),
+      // Both first-fold routes consume the same daily overview and must retain
+      // the identical hybrid legacy/factual duration budget.
+      expect(quickOperationsPayload.summary.overview_metrics?.duration_ms).toBe(
+        canonicalAllTimeDurationMs(groupDuration(allCostsPayload.groups.daily)),
       );
-      expect(julySnapshotPayload.operations.summary.execution_duration_ms).toBe(
-        groupDuration(julySnapshotPayload.costs.groups.annual),
+      const costsByDay = new Map(
+        allCostsPayload.groups.daily.map((row) => [row.key, row] as const),
       );
+      for (const [day, period] of Object.entries(quickOperationsPayload.summary.periods.daily)) {
+        if (period.usage.total_tokens.known_sum <= 0) continue;
+        const cost = costsByDay.get(day);
+        expect(cost, `missing Cost bucket ${day}`).toBeDefined();
+        expect(period.usage.cost.known_sum, `Operations cost ${day}`).toBeGreaterThan(0);
+        expect(period.duration?.known_sum, `Operations duration ${day}`).toBeGreaterThan(0);
+        expect(cost!.estimated_brl, `Cost cost ${day}`).toBeGreaterThan(0);
+        expect(cost!.duration_ms, `Cost duration ${day}`).toBeGreaterThan(0);
+        expect(period.usage.total_tokens.known_sum).toBe(cost!.total_tokens);
+        expect(period.usage.cost.known_sum).toBe(cost!.estimated_brl);
+        expect(period.duration?.known_sum).toBe(cost!.duration_ms);
+      }
       const rootOperations = allOperationsPayload.runs.find(
         (run) => run.id === "RUN-2026-07-14-00-00-DASHBOARD-FIXTURE-A1B2",
       );
-      const rootCosts = allCostsPayload.runs.find(
-        (run) => run.run_id === "RUN-2026-07-14-00-00-DASHBOARD-FIXTURE-A1B2",
-      );
       expect(
         allOperationsPayload.runs.filter(
           (run) => run.id === "RUN-2026-07-14-00-00-DASHBOARD-FIXTURE-A1B2",
         ),
       ).toHaveLength(1);
-      expect(
-        allCostsPayload.runs.filter(
-          (run) => run.run_id === "RUN-2026-07-14-00-00-DASHBOARD-FIXTURE-A1B2",
-        ),
-      ).toHaveLength(1);
-      expect(rootCosts).toMatchObject({
-        // Cost reports analytical duration, which is the observed source
-        // duration when it exists; Operations also exposes lifecycle elapsed
-        // separately as duration_ms.
-        duration_ms: rootOperations?.source_duration_ms ?? rootOperations?.duration_ms,
-        total_tokens: rootOperations?.usage.total.tokens.total,
-        estimated_brl: rootOperations?.usage.total.cost.brl,
-      });
-      expect(
-        allCostsPayload.runs.find(
-          (run) => run.run_id === "RUN-2026-07-14-00-00-DASHBOARD-FIXTURE-LIFECYCLE",
-        ),
-      ).toMatchObject({
-        total_tokens: null,
-        estimated_brl: null,
-      });
-      await expect(operations.json()).resolves.toMatchObject({
+      expect(allOperationsPayload).toMatchObject({
         tasks: [
           {
             id: "TASK-2026-07-14-00-00-DASHBOARD-FIXTURE-A1B2",
@@ -470,7 +510,7 @@ describe("dashboard backend snapshot", () => {
       });
       await expect(response.json()).resolves.toMatchObject({
         dashboard: {
-          title: "Dashboard Zaip AIOS",
+          title: "Dashboard Zaip AIOS SQLite",
           repository_name: "",
         },
         operations: { readonly: true, summary: { source_latest_at: "2026-07-14T00:00:05.000Z" } },
@@ -524,3 +564,42 @@ describe("dashboard backend snapshot", () => {
     }
   });
 });
+
+describe("Cost Monitor daily summary route", () => {
+  it("does not route summary requests through summary.json, snapshots, or Run transport", () => {
+    const source = readFileSync(new URL("./server.ts", import.meta.url), "utf8");
+    const start = source.indexOf('if (scope === "summary")');
+    const end = source.indexOf('if (scope === "runs")', start);
+    const summaryRoute = source.slice(start, end);
+    expect(summaryRoute).toContain("firstFoldCostSource(filesystem");
+    expect(summaryRoute).not.toContain("summary.json");
+    expect(summaryRoute).not.toContain("readSnapshot(context)");
+    expect(summaryRoute).not.toContain("readAggregate(");
+    expect(summaryRoute).not.toContain("buildFirstFoldQuickProjection(");
+    expect(summaryRoute).not.toContain('readDailyReadModels("overview")');
+  });
+
+  it("uses only the bounded SQL aggregate for the Cost first fold", () => {
+    const source = readFileSync(new URL("./server.ts", import.meta.url), "utf8");
+    const start = source.indexOf("async function firstFoldCostSource(");
+    const end = source.indexOf("function buildSqliteTaskTrace(", start);
+    const firstFoldCostSource = source.slice(start, end);
+    expect(firstFoldCostSource).toContain("costMonitorSummaryAggregate(filters)");
+    expect(firstFoldCostSource).not.toContain("costMonitorFinancialActivityRows(");
+    expect(firstFoldCostSource).not.toContain("run_metrics:");
+    expect(firstFoldCostSource).not.toContain("rows.map(");
+  });
+
+  it("keeps the Daily first-fold response to its displayed-column allowlist", () => {
+    const source = readFileSync(new URL("./sqlite-read-model.ts", import.meta.url), "utf8");
+    const dailyBranch = source.slice(
+      source.indexOf('if (filteredCostGroup !== undefined && temporalCostGroup && !hasDimensionalCostFilter)'),
+      source.indexOf('if (filteredCostGroup !== undefined && (!temporalCostGroup || hasDimensionalCostFilter))'),
+    );
+    expect(dailyBranch).not.toContain("costMonitorFactualDurationByDay(");
+    expect(dailyBranch).toContain("Daily first fold is an allowlisted table contract");
+    for (const field of ["prd_count", "spec_count", "task_count", "total_run_count", "validation_count", "evidence_count", "total_duration", "duration_known", "total_tokens", "total_cost_brl"])
+      expect(dailyBranch).toContain(`${field}:`);
+    expect(dailyBranch).not.toContain("...row,");
+  });
+});

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

@@ -0,0 +1,145 @@
+import { execFile } from "node:child_process";
+import { createHash } from "node:crypto";
+import { resolve } from "node:path";
+import { promisify } from "node:util";
+import type { WorkspaceFileSystem } from "@zaip-ai/core";
+
+const DASHBOARD_CONFIG_PATH = ".agents/dashboard/dashboard.config.json";
+const execFileAsync = promisify(execFile);
+
+export async function dashboardIdentity(
+  filesystem: WorkspaceFileSystem,
+  workspaceRoot: string,
+): Promise<{ title: string; repository_name: string }> {
+  let title = process.env.ZAIP_DASHBOARD_TITLE?.trim() || "Dashboard Zaip AIOS SQLite";
+  let repositorySetting = "auto";
+  try {
+    if (await filesystem.exists(DASHBOARD_CONFIG_PATH)) {
+      const config = JSON.parse(await filesystem.readText(DASHBOARD_CONFIG_PATH)) as {
+        github_repository?: unknown;
+        title?: unknown;
+      };
+      if (typeof config.title === "string" && config.title.trim()) title = config.title.trim();
+      if (typeof config.github_repository === "string") {
+        repositorySetting = config.github_repository.trim();
+      }
+    }
+  } catch {
+    // Visual configuration must never prevent dashboard startup.
+  }
+  if (repositorySetting.toLowerCase() !== "auto") {
+    return { title, repository_name: githubRepositoryFromRemote(repositorySetting) ?? "" };
+  }
+  try {
+    const { stdout } = await execFileAsync(
+      "git",
+      ["-C", workspaceRoot, "remote", "get-url", "origin"],
+      { encoding: "utf8", windowsHide: true },
+    );
+    return { title, repository_name: githubRepositoryFromRemote(stdout) ?? "" };
+  } catch {
+    return { title, repository_name: "" };
+  }
+}
+
+export function githubRepositoryFromRemote(remote: string): string | null {
+  const trimmed = remote.trim();
+  const match =
+    trimmed.match(/github\.com(?::|\/)([^/\s]+)\/([^/\s]+?)(?:\.git)?$/i) ??
+    trimmed.match(/^([^/:\s]+)\/([^/\s]+?)(?:\.git)?$/);
+  return match ? `${match[1]}/${match[2]}` : null;
+}
+
+export function dashboardWorkspaceKey(workspaceRoot: string): string {
+  return createHash("sha256").update(`${resolve(workspaceRoot)}:dashboard-sqlite`).digest("hex").slice(0, 16);
+}
+
+export interface ReconciliationItem {
+  id: string;
+  reason: string | null;
+}
+
+export interface ReconciliationResult {
+  reconciled_ids: string[];
+  blocked: ReconciliationItem[];
+  not_reconciled: ReconciliationItem[];
+}
+
+export async function reconcileOpenWork(
+  filesystem: WorkspaceFileSystem,
+  workspaceRoot: string,
+): Promise<ReconciliationResult> {
+  if (!(await filesystem.exists(".agents/runtime/bin/zaip.mjs"))) {
+    return { reconciled_ids: [], blocked: [], not_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 },
+  );
+  return reconciliationResult(JSON.parse(stdout) as unknown);
+}
+
+export function reconciliationResult(value: unknown): ReconciliationResult {
+  const reconciled = new Set<string>();
+  const blocked = new Map<string, string | null>();
+  const notReconciled = new Map<string, string | null>();
+  const remember = (target: Map<string, string | null>, id: unknown, reason: unknown): void => {
+    if (typeof id !== "string") return;
+    target.set(id, typeof reason === "string" && reason.trim() ? reason : null);
+  };
+  const records =
+    typeof value === "object" && value !== null ? (value as Record<string, unknown>) : {};
+  const reconciliations = Array.isArray(records.reconciliations) ? records.reconciliations : [];
+  for (const candidate of reconciliations) {
+    if (typeof candidate !== "object" || candidate === null) continue;
+    const item = candidate as Record<string, unknown>;
+    const reason = item.error;
+    const entities = ["tasks", "changes", "executions", "specs", "prds"].flatMap((key) =>
+      Array.isArray(item[key]) ? item[key] : [],
+    );
+    for (const entity of entities) {
+      if (typeof entity !== "object" || entity === null) continue;
+      const record = entity as Record<string, unknown>;
+      if (
+        item.status === "closed" &&
+        record.status === "completed" &&
+        typeof record.id === "string"
+      ) {
+        reconciled.add(record.id);
+      } else if (record.status === "blocked") {
+        remember(blocked, record.id, record.status_reason ?? reason);
+      } else if (item.status === "deferred") {
+        remember(notReconciled, record.id, reason);
+      }
+    }
+  }
+  const orphanedExecutions = Array.isArray(records.orphaned_executions)
+    ? records.orphaned_executions
+    : [];
+  orphanedExecutions.forEach((id) => {
+    remember(blocked, id, "Execution orphaned after the reconciliation grace period.");
+  });
+  const errors = Array.isArray(records.reconciliation_errors) ? records.reconciliation_errors : [];
+  errors.forEach((candidate) => {
+    if (typeof candidate !== "object" || candidate === null) return;
+    const item = candidate as Record<string, unknown>;
+    remember(notReconciled, item.run_id, item.error);
+  });
+  const unresolved = Array.isArray(records.unresolved_running_run_ids)
+    ? records.unresolved_running_run_ids
+    : [];
+  unresolved.forEach((id) => {
+    remember(notReconciled, id, "Invocation is still running.");
+  });
+  const entries = (items: Map<string, string | null>): ReconciliationItem[] =>
+    [...items.entries()]
+      .map(([id, reason]) => ({ id, reason }))
+      .sort((left, right) => left.id.localeCompare(right.id));
+  return {
+    reconciled_ids: [...reconciled].sort(),
+    blocked: entries(blocked),
+    not_reconciled: entries(notReconciled),
+  };
+}