@zaip-ai/cli 2.6.0 → 3.1.0

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

@@ -1,11 +1,44 @@
 import { spawn } from "node:child_process";
 import { existsSync } from "node:fs";
 import { resolve } from "node:path";
+import { type SqliteReadModelFileSystem, sqliteReadModelPath } from "./sqlite-read-model.js";
 import {
-  type SqliteReadModelFileSystem,
-  sqliteReadModelPath,
-  validateSqliteReadModelSchema,
-} from "./sqlite-read-model.js";
+  readModelSchemaVersion,
+  requiredIndexes,
+  requiredPersistedTables,
+  requiredViews,
+} from "./sqlite-read-model-schema.js";
+
+/** The worker validates integrity and schema before emitting this receipt. */
+export function validateSnapshotWorkerReceipt(stdout: string, destination: string): void {
+  const result = JSON.parse(stdout) as {
+    storage_mode?: unknown;
+    path?: unknown;
+    schema?: {
+      schemaVersion?: unknown;
+      tableCount?: unknown;
+      viewCount?: unknown;
+      indexCount?: unknown;
+    };
+  } | null;
+  const schema = result?.schema;
+  if (
+    result?.storage_mode !== "sqlite_read_model" ||
+    typeof result.path !== "string" ||
+    resolve(result.path) !== resolve(destination) ||
+    schema?.schemaVersion !== readModelSchemaVersion ||
+    schema.tableCount !== requiredPersistedTables.length ||
+    typeof schema.viewCount !== "number" ||
+    !Number.isSafeInteger(schema.viewCount) ||
+    schema.viewCount < requiredViews.length ||
+    typeof schema.indexCount !== "number" ||
+    !Number.isSafeInteger(schema.indexCount) ||
+    schema.indexCount < requiredIndexes.length
+  )
+    throw new Error(
+      "SQLite refresh worker did not return a valid schema receipt for this destination",
+    );
+}
 
 async function rebuildPersistentDatabaseInWorker(workspaceRoot: string, destination: string) {
   const scriptCandidates = [
@@ -24,6 +57,8 @@ async function rebuildPersistentDatabaseInWorker(workspaceRoot: string, destinat
     throw new Error("SQLite refresh worker script is unavailable from this runtime checkout");
   await new Promise<void>((resolveWorker, rejectWorker) => {
     let stderr = "";
+    let stdout = "";
+    let oversizedReceipt = false;
     const worker = spawn(process.execPath, [script], {
       cwd: workspaceRoot,
       env: {
@@ -33,13 +68,18 @@ async function rebuildPersistentDatabaseInWorker(workspaceRoot: string, destinat
         ZAIP_SQLITE_PREFER_LAST_VALID_SEED: "0",
         ZAIP_DASHBOARD_LAUNCH_PROGRESS: "0",
       },
-      stdio: ["ignore", "ignore", "pipe"],
+      stdio: ["ignore", "pipe", "pipe"],
       windowsHide: true,
     });
     // Lease shutdown may end the serving parent while a slow snapshot rebuild
     // is still writing. Terminate the direct child synchronously during parent
     // exit so the next launcher cannot overlap the persistent SQLite writer.
     const cleanupWorker = attachRefreshWorkerCleanup(worker);
+    worker.stdout?.setEncoding("utf8");
+    worker.stdout?.on("data", (chunk: string) => {
+      if (stdout.length + chunk.length > 64_000) oversizedReceipt = true;
+      if (!oversizedReceipt) stdout += chunk;
+    });
     worker.stderr?.setEncoding("utf8");
     worker.stderr?.on("data", (chunk: string) => {
       stderr = `${stderr}${chunk}`.slice(-8_000);
@@ -48,13 +88,22 @@ async function rebuildPersistentDatabaseInWorker(workspaceRoot: string, destinat
       cleanupWorker();
       rejectWorker(error);
     });
-    worker.once("exit", (code) => {
+    // close follows stdout drain; exit alone may precede the receipt bytes.
+    worker.once("close", (code) => {
       cleanupWorker();
-      return code === 0
-        ? resolveWorker()
-        : rejectWorker(
-            new Error(`SQLite refresh worker failed (${code}): ${stderr.trim() || "no stderr"}`),
-          );
+      if (code !== 0) {
+        rejectWorker(
+          new Error(`SQLite refresh worker failed (${code}): ${stderr.trim() || "no stderr"}`),
+        );
+        return;
+      }
+      try {
+        if (oversizedReceipt) throw new Error("SQLite refresh worker receipt exceeds size limit");
+        validateSnapshotWorkerReceipt(stdout, destination);
+        resolveWorker();
+      } catch (error) {
+        rejectWorker(error);
+      }
     });
   });
 }
@@ -88,6 +137,7 @@ export async function refreshSqliteSnapshotInWorker(
 ) {
   const destination = sqliteReadModelPath(workspaceRoot);
   await rebuildPersistentDatabaseInWorker(workspaceRoot, destination);
-  validateSqliteReadModelSchema(destination);
+  // Integrity/schema checking belongs to the worker, not the HTTP event loop.
+  // Zero exit alone is insufficient: its exact-destination receipt is mandatory.
   filesystem.refresh();
 }

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

@@ -19,6 +19,32 @@ afterEach(() => {
 });
 
 describe("snapshot source synchronization", () => {
+  it("reports capture failure separately while refreshing canonical data", async () => {
+    vi.useFakeTimers();
+    const error = new Error("capture timed out");
+    const onCaptureFailure = vi.fn();
+    const onRefreshFailure = vi.fn();
+    const onCaptureSuccess = vi.fn();
+    const capture = vi.fn().mockRejectedValueOnce(error).mockResolvedValue(undefined);
+    const refresh = vi.fn(async () => undefined);
+    startSnapshotSynchronization({
+      workspaceRoot: "C:/workspace",
+      staleSeed: false,
+      watchSources: true,
+      refresh,
+      captureActiveTelemetry: capture,
+      onCaptureFailure,
+      onCaptureSuccess,
+      onRefreshFailure,
+    });
+    await vi.advanceTimersByTimeAsync(301);
+    expect(onCaptureFailure).toHaveBeenCalledWith(error);
+    expect(onRefreshFailure).not.toHaveBeenCalled();
+    expect(refresh).toHaveBeenCalledTimes(1);
+    await vi.advanceTimersByTimeAsync(60_000);
+    expect(onCaptureSuccess).toHaveBeenCalledTimes(1);
+    expect(refresh).toHaveBeenCalledTimes(2);
+  });
   it("watches current data for both creation and alteration refreshes", async () => {
     vi.useFakeTimers();
     const refresh = vi.fn(async () => undefined);

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

@@ -8,6 +8,8 @@ export function startSnapshotSynchronization(input: {
   refresh: () => Promise<void>;
   /** Exact active-Codex collection, separate from projection and lifecycle repair. */
   captureActiveTelemetry?: () => Promise<void>;
+  onCaptureFailure?: (error: unknown) => void;
+  onCaptureSuccess?: () => void;
   /** Report failed asynchronous refreshes; a stale snapshot must never look healthy. */
   onRefreshFailure?: (input: { trigger: "stale_seed" | "source_change"; error: unknown }) => void;
 }): void {
@@ -40,7 +42,8 @@ export function startSnapshotSynchronization(input: {
     if (input.captureActiveTelemetry === undefined) return scheduleRefresh();
     void input
       .captureActiveTelemetry()
-      .catch((error: unknown) => input.onRefreshFailure?.({ trigger: "source_change", error }))
+      .then(() => input.onCaptureSuccess?.())
+      .catch((error: unknown) => input.onCaptureFailure?.(error))
       .finally(scheduleRefresh);
   };
   // Run at most once a minute. File watchers only project canonical changes;

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

@@ -0,0 +1,97 @@
+import { mkdir, mkdtemp, rm, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { dirname, join } from "node:path";
+import { createV2WorkspaceLayout } from "@zaip-ai/core";
+import { afterEach, expect, it, vi } from "vitest";
+import { buildSqliteTaskTrace } from "./server-sqlite-task-trace.js";
+import { rebuildSqliteReadModel, SqliteReadModelFileSystem } from "./sqlite-read-model.js";
+import { prepareMultiProviderFixture } from "./sqlite-read-model-multi-provider-fixture.js";
+
+const roots: string[] = [];
+const readers: SqliteReadModelFileSystem[] = [];
+afterEach(async () => {
+  vi.restoreAllMocks();
+  for (const reader of readers.splice(0)) reader.close();
+  await Promise.all(roots.splice(0).map((root) => rm(root, { recursive: true, force: true })));
+});
+const taskId = "TASK-2026-09-10-12-00-TRACE-AAAA";
+const layout = createV2WorkspaceLayout(
+  {
+    schema_version: 1,
+    project: { id: "trace", name: "Trace", timezone: "America/Sao_Paulo" },
+    stack: { id: "zaip-aios-stack", overrides: {} },
+    clients: { codex: true, claude: false },
+    tracking: { enabled: true, currency: "BRL", storage_mode: "tracked_sanitized" },
+  },
+  {
+    lock_version: 2,
+    framework: { version: "3.0.0", distribution_sha256: null },
+    layout: { version: 3 },
+    resolved_profile: { id: null, sha256: null },
+    managed_files: {},
+  },
+);
+const taskContent = (id: string, title: string) =>
+  `---\nid: ${id}\ntitle: ${title}\nstatus: completed\nrisk: standard\ncreated_at: 2026-09-10T15:00:00.000Z\n---\n# ${title}\n`;
+async function fixture(files: Record<string, string>) {
+  const root = await mkdtemp(join(tmpdir(), "zaip-trace-bounded-"));
+  roots.push(root);
+  await prepareMultiProviderFixture(root);
+  for (const [path, content] of Object.entries(files)) {
+    const target = join(root, path);
+    await mkdir(dirname(target), { recursive: true });
+    await writeFile(target, content);
+  }
+  await rebuildSqliteReadModel(root);
+  const filesystem = new SqliteReadModelFileSystem(root);
+  readers.push(filesystem);
+  return filesystem;
+}
+
+it("resolves the exact Task and filters oversized history before transport without losing documents", async () => {
+  const path = layout.activePath("task", taskId);
+  const small = ".agents/records/changes/trace/artifacts/tests/notes.md";
+  const large = ".agents/records/changes/trace/artifacts/tests/oversized.md";
+  const astral = ".agents/records/changes/trace/artifacts/tests/astral.md";
+  const shadowId = "TASK-2026-09-10-11-00-SHADOW-AAAA";
+  const filesystem = await fixture({
+    [path]: taskContent(taskId, "Requested Task"),
+    [layout.activePath("task", shadowId)]: taskContent(shadowId, `References ${taskId}`),
+    [small]: `# ${taskId}\n${"x".repeat(250_000 - taskId.length - 3)}`,
+    [large]: `${taskId}\n${"x".repeat(250_001)}`,
+    [astral]: `${taskId}\n${"😀".repeat(130_000)}`,
+  });
+  const expected = filesystem
+    .canonicalTraceFiles([taskId])
+    .filter((row) => row.content.length <= 250_000)
+    .map((row) => row.path);
+  expect(expected).toContain(small);
+  expect(expected).not.toContain(large);
+  expect(expected).not.toContain(astral);
+  const scan = vi.spyOn(filesystem, "canonicalTraceFiles");
+  const trace = await buildSqliteTaskTrace(filesystem, layout, taskId);
+  expect(trace.task_title).toBe("Requested Task");
+  expect(trace.task_id).toBe(taskId);
+  expect(trace.documents.map((row) => row.path)).toEqual(expected);
+  expect(scan).toHaveBeenCalledOnce();
+  expect(scan.mock.calls[0]?.[1]).toBe(250_000);
+  expect(scan.mock.results[0]?.value.map((row: { path: string }) => row.path)).not.toContain(large);
+});
+
+it("rejects a mismatched Task identity instead of tracing a document that mentions it", async () => {
+  const filesystem = await fixture({
+    [layout.activePath("task", taskId)]: taskContent("TASK-2026-09-10-11-00-WRONG-AAAA", taskId),
+  });
+  await expect(buildSqliteTaskTrace(filesystem, layout, taskId)).rejects.toThrow(
+    /identity mismatch/,
+  );
+});
+
+it("retains the canonical divergent-layout guard and rejects invalid bounds", async () => {
+  const filesystem = await fixture({
+    [layout.activePath("task", taskId)]: taskContent(taskId, "Active"),
+    [`.agents/data/tasks/2026/09/10/${taskId}.md`]: taskContent(taskId, "Divergent"),
+  });
+  await expect(buildSqliteTaskTrace(filesystem, layout, taskId)).rejects.toThrow(/Divergent/);
+  expect(() => filesystem.canonicalTraceFiles([taskId], -1)).toThrow(/Invalid trace content bound/);
+});

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

@@ -1,5 +1,5 @@
 import { createHash } from "node:crypto";
-import type { WorkspaceLayout } from "@zaip-ai/core";
+import { resolveArtifactReadPath, type WorkspaceLayout } from "@zaip-ai/core";
 import type { TaskTrace, TraceDocument } from "@zaip-ai/dashboard-traceability/contracts";
 import {
   buildTraceStageRecords,
@@ -8,26 +8,23 @@ import {
 } from "@zaip-ai/dashboard-traceability/server";
 import type { SqliteReadModelFileSystem } from "./sqlite-read-model.js";
 
-export function buildSqliteTaskTrace(
+export async function buildSqliteTaskTrace(
   filesystem: SqliteReadModelFileSystem,
   layout: WorkspaceLayout,
   taskId: string,
-): TaskTrace {
-  const initial = filesystem.canonicalTraceFiles([taskId]);
-  const taskFile = initial.find(
-    (row) =>
-      row.path.includes("/.agents/data/tasks/") ||
-      row.path.includes(".agents/data/tasks/") ||
-      row.path.includes("/.agents/records/tasks/") ||
-      row.path.includes(".agents/records/tasks/"),
-  );
-  if (taskFile === undefined) throw new Error(`Canonical Task ${taskId} was not found`);
+): Promise<TaskTrace> {
+  // Resolve the exact canonical identity, not the first Task mentioning it.
+  // This also avoids scanning all historical contents just to locate one Task.
+  const taskPath = await resolveArtifactReadPath(filesystem, layout, "task", taskId);
+  if (taskPath === null) throw new Error(`Canonical Task ${taskId} was not found`);
+  const taskFile = { path: taskPath, content: await filesystem.readText(taskPath) };
   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, "");
   };
+  if (scalar("id") !== taskId) throw new Error(`Canonical Task identity mismatch: ${taskId}`);
   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;
@@ -37,7 +34,7 @@ export function buildSqliteTaskTrace(
     (value): value is string => value !== null,
   );
   const documents = filesystem
-    .canonicalTraceFiles(markers)
+    .canonicalTraceFiles(markers, 250_000)
     .filter(
       (row) => /\.(?:md|json|jsonl|txt|log)$/i.test(row.path) && row.content.length <= 250_000,
     )

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

@@ -10,15 +10,7 @@ import type { DashboardRouteContext } from "./server-route-context.js";
 import { buildSqliteTaskTrace } from "./server-sqlite-task-trace.js";
 import { SqliteReadModelFileSystem } from "./sqlite-read-model.js";
 export function registerTraceRoutes(app: Hono, dependencies: DashboardRouteContext) {
-  const {
-    filesystem,
-    canonicalFilesystem,
-    isSqliteSnapshot,
-    readLayout,
-    readSnapshot,
-    readAggregate,
-    clearSnapshotCache,
-  } = dependencies;
+  const { filesystem, readLayout } = dependencies;
   app.on(["GET", "HEAD"], `${API_PREFIX}/tasks/:id`, async (context) => {
     try {
       const layout = await readLayout();
@@ -53,7 +45,7 @@ export function registerTraceRoutes(app: Hono, dependencies: DashboardRouteConte
       return headOrJson(
         context,
         filesystem instanceof SqliteReadModelFileSystem
-          ? buildSqliteTaskTrace(filesystem, layout, taskId)
+          ? await buildSqliteTaskTrace(filesystem, layout, taskId)
           : await buildTaskTrace(filesystem, layout, taskId),
       );
     } catch (error) {

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

@@ -0,0 +1,84 @@
+import { serializeMarkdown, WorkspaceFileSystem } from "@zaip-ai/core";
+import { expect, it } from "vitest";
+import { createDashboardApp } from "./server.js";
+import { withSqliteReadModelFixture } from "./server.test-fixtures.js";
+import { rebuildSqliteReadModel, SqliteReadModelFileSystem } from "./sqlite-read-model.js";
+
+it("indexes draft and terminal Tasks in SQLite without adding drafts to Kanban", async () => {
+  await withSqliteReadModelFixture("trace-index", async ({ root }) => {
+    const at = "2026-09-11T10:00:00.000Z";
+    const canonical = new WorkspaceFileSystem(root);
+    for (const [i, status] of ["draft", "cancelled", "blocked"].entries()) {
+      await canonical.writeTextAtomic(
+        `.agents/records/tasks/2026/09/task-${i}.md`,
+        serializeMarkdown({
+          metadata: {
+            schema_version: 2,
+            id: `TASK-INDEX-${i}`,
+            title: `Task ${status}`,
+            status,
+            revision: 1,
+            change_id: `CHG-INDEX-${i}`,
+            short_name: `index-${i}`,
+            objective: "Identity fixture",
+            risk: "standard",
+            priority: "medium",
+            owner: null,
+            requirement_ids: ["REQ-WORK-001"],
+            acceptance_ids: ["AC-WORK-001-09"],
+            depends_on: [],
+            write_scopes: ["proof"],
+            plan_revision: null,
+            plan_hash: null,
+            created_at: at,
+            updated_at: at,
+            started_at: null,
+            finished_at: null,
+            result: null,
+          },
+          body: "# Identity fixture\n",
+        }),
+      );
+    }
+    await rebuildSqliteReadModel(root);
+    const sqlite = new SqliteReadModelFileSystem(root);
+    try {
+      const app = createDashboardApp(root, "fixture", undefined, { filesystem: sqlite });
+      const request = async (query: string) => {
+        const response = await app.request(`/api/v2/operations?${query}`, {
+          headers: { "x-zaip-session": "fixture" },
+        });
+        expect(response.status).toBe(200);
+        return response.json() as Promise<{
+          total: number;
+          tasks: { id: string; status: string }[];
+        }>;
+      };
+      const first = await request("scope=traceability&offset=0&limit=2");
+      const second = await request("scope=traceability&offset=2&limit=2");
+      expect(first.total).toBe(3);
+      expect(first.tasks).toHaveLength(2);
+      expect(second.tasks).toHaveLength(1);
+      expect([...first.tasks, ...second.tasks].map((task) => task.id)).toEqual([
+        "TASK-INDEX-2",
+        "TASK-INDEX-1",
+        "TASK-INDEX-0",
+      ]);
+      expect(second.tasks[0]?.status).toBe("draft");
+      for (const stage of [
+        "definition",
+        "planning",
+        "ready",
+        "executing",
+        "completed",
+        "blocked",
+      ]) {
+        const board = await request(`scope=board&stage=${stage}&kind=all-tasks`);
+        expect(board.tasks.map((task: { id: string }) => task.id)).not.toContain("TASK-INDEX-0");
+      }
+      expect((await request("scope=traceability&offset=3&limit=2")).tasks).toEqual([]);
+    } finally {
+      sqlite.close();
+    }
+  });
+});

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

@@ -212,6 +212,7 @@ export function createDashboardApp(
   };
   let observedSnapshotRevision: string | null = null;
   const projectionRefreshDiagnostics = createProjectionRefreshDiagnostics();
+  let activeCaptureFailure: { code: string; occurred_at: string; cause: string } | null = null;
   let projectionRefreshInFlight: Promise<void> | null = null;
   let projectionRefreshRequested = false;
   const rebuildProjection = async () => {
@@ -262,6 +263,16 @@ export function createDashboardApp(
       ? { captureActiveTelemetry: () => captureActiveCodexTelemetry(workspaceRoot) }
       : {}),
     onRefreshFailure: projectionRefreshDiagnostics.record,
+    onCaptureSuccess: () => {
+      activeCaptureFailure = null;
+    },
+    onCaptureFailure: (error) => {
+      activeCaptureFailure = {
+        code: "active_telemetry_capture_failed",
+        occurred_at: new Date().toISOString(),
+        cause: error instanceof Error ? error.name : "unknown_error",
+      };
+    },
   });
   const reconcileWork = createWorkReconciliation({
     reconcile: (mode) =>
@@ -397,13 +408,15 @@ export function createDashboardApp(
         kind: RUNTIME_KIND,
         workspaceKey,
         service: "zaip-aios-dashboard",
-        status: projectionRefreshDiagnostics.healthStatus,
+        status:
+          activeCaptureFailure === null ? projectionRefreshDiagnostics.healthStatus : "degraded",
         api_version: 2,
         workspace_layout: layout.version,
         read_only: true,
         storage: isSqliteSnapshot ? filesystem.metadata() : { storage_mode: "filesystem" },
         snapshot_state: snapshotState,
         projection_refresh_failure: projectionRefreshDiagnostics.failure,
+        active_capture_failure: activeCaptureFailure,
       });
     } catch (error) {
       return headOrJson(
@@ -450,6 +463,7 @@ export function createDashboardApp(
           day_count: metadata.daily_aggregate_count,
           snapshot_state: snapshotState,
           projection_refresh_failure: projectionRefreshDiagnostics.failure,
+          active_capture_failure: activeCaptureFailure,
           snapshot_revision: revision,
         });
       }

package/templates/.agents/dashboard/packages/local-runtime/src/sqlite-calendar.ts

@@ -0,0 +1,17 @@
+// Intl's immutable formatter is reusable; timestamps and results are never cached.
+const dateFormatter = new Intl.DateTimeFormat("en", {
+  timeZone: "America/Sao_Paulo",
+  year: "numeric",
+  month: "2-digit",
+  day: "2-digit",
+});
+
+export function saoPauloDay(timestamp: string): string {
+  const values = Object.fromEntries(
+    dateFormatter
+      .formatToParts(new Date(timestamp))
+      .filter((part) => part.type !== "literal")
+      .map((part) => [part.type, part.value]),
+  ) as { year: string; month: string; day: string };
+  return `${values.year}-${values.month}-${values.day}`;
+}

package/templates/.agents/dashboard/packages/local-runtime/src/sqlite-cold-parse.test.ts

@@ -0,0 +1,78 @@
+import { expect, it, vi } from "vitest";
+import { saoPauloDay } from "./sqlite-calendar.js";
+import { readCanonicalLifecycleRecords } from "./sqlite-read-model-canonical.js";
+import { isCanonicalLifecyclePath } from "./sqlite-read-model-canonical-parsing.js";
+
+it("reuses only the immutable formatter and preserves calendar, DST and invalid input behavior", () => {
+  const cases = [
+    ["2024-03-01T02:59:59Z", "2024-02-29"],
+    ["2026-01-01T02:59:59Z", "2025-12-31"],
+    ["2026-01-01T03:00:00Z", "2026-01-01"],
+    ["2018-11-04T02:59:59Z", "2018-11-03"],
+    ["2018-11-04T03:00:00Z", "2018-11-04"],
+    ["2019-02-17T02:00:00Z", "2019-02-16"],
+  ] as const;
+  const formatterConstructor = vi.spyOn(Intl, "DateTimeFormat");
+  try {
+    for (let index = 0; index < 100; index++)
+      for (const [timestamp, expected] of cases) expect(saoPauloDay(timestamp)).toBe(expected);
+    expect(() => saoPauloDay("invalid")).toThrow(RangeError);
+    expect(formatterConstructor).not.toHaveBeenCalled();
+  } finally {
+    formatterConstructor.mockRestore();
+  }
+});
+
+it("ignores irrelevant source content before YAML parsing and keeps both lifecycle layouts", () => {
+  const ignored = [
+    ".agents/records/tasks/2026/09/task.md",
+    ".agents/records/changes/2026/09/C/artifacts/tests/test.md",
+    ".agents/records/runs/run.jsonl",
+    ".agents/records/executions/E/other.md",
+    ".agents/records/changes/C/decisions/other.txt",
+    "elsewhere/executions/E/execution.md",
+  ].map((path) => ({
+    path,
+    get content(): string {
+      throw new Error("Irrelevant content must never be inspected");
+    },
+  }));
+  expect(readCanonicalLifecycleRecords(ignored)).toEqual({
+    executions: [],
+    changes: [],
+    decisions: [],
+  });
+  for (const layout of ["data", "records"]) {
+    const rows = [
+      {
+        path: `.agents/${layout}/executions/2026/09/E/execution.md`,
+        content:
+          "---\nid: E\ncreated_at: 2026-09-15T00:00:00Z\nstatus: blocked\norigin:\n  type: interaction\n  conversation_id: C\n---\n",
+      },
+      {
+        path: `.agents/${layout}/changes/2026/09/H/change.md`,
+        content:
+          "---\nid: H\ncreated_at: 2026-09-15T00:00:00Z\nsource:\n  type: task\n  task_id: T\n---\n",
+      },
+      ...["changes", "executions"].map((kind) => ({
+        path: `.agents/${layout}/${kind}/E/artifacts/decisions/D.md`,
+        content: `---\nid: D-${kind}\ncreated_at: 2026-09-15T00:00:00Z\norigin: human\nscope_type: execution\nscope_id: E\n---\n`,
+      })),
+    ];
+    expect(rows.every((row) => isCanonicalLifecyclePath(row.path))).toBe(true);
+    const result = readCanonicalLifecycleRecords([...ignored, ...rows]);
+    expect(result.executions).toHaveLength(1);
+    expect(result.executions[0]).toMatchObject({ id: "E", originId: "C", status: "blocked" });
+    expect(result.changes).toHaveLength(1);
+    expect(result.changes[0]).toMatchObject({ id: "H", sourceId: "T" });
+    expect(result.decisions).toHaveLength(2);
+    expect(
+      readCanonicalLifecycleRecords([
+        {
+          path: `.agents/${layout}/executions/E/execution.md`,
+          content: "---\nid: [invalid\n---\n",
+        },
+      ]).executions,
+    ).toEqual([]);
+  }
+});

package/templates/.agents/dashboard/packages/local-runtime/src/sqlite-cost-dimension-facts.test.ts

@@ -258,8 +258,19 @@ describe("cost invocation dimension rebuild", () => {
     expect(factRows(database, "cost_invocation_dimension_facts")).toEqual(
       factRows(database, "legacy_cost_invocation_dimension_facts"),
     );
+    // SQLite versions bundled with supported Node runtimes may serialize REALs
+    // with different precision. The contract is exact legacy JSON parity on
+    // that engine, not a hard-coded decimal spelling from SQLite 3.49.
+    const expectedCosts = database
+      .prepare(`
+        SELECT json_extract(payload, '$.cost_usd') AS cost_usd,
+          json_extract(payload, '$.cost_brl') AS cost_brl
+        FROM (SELECT json_object('cost_usd', ?, 'cost_brl', ?) AS payload)
+      `)
+      .get(0.1 + 0.2, 1234567.8912345679);
+    expect(expectedCosts).toEqual({ cost_usd: expect.any(Number), cost_brl: expect.any(Number) });
     expect(factRows(database, "cost_invocation_dimension_facts")).toContainEqual(
-      expect.objectContaining({ residual: 0, cost_usd: 0.3, cost_brl: 1234567.89123457 }),
+      expect.objectContaining({ residual: 0, ...expectedCosts }),
     );
   });