@zaip-ai/cli 4.5.0 → 4.6.0

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

@@ -0,0 +1,111 @@
+import { mkdir, writeFile } from "node:fs/promises";
+import { join } from "node:path";
+import { describe, expect, it, vi } from "vitest";
+import { createDashboardApp } from "./server.js";
+import { withSqliteReadModelFixture } from "./server.test-fixtures.js";
+
+describe("recent telemetry command readiness", () => {
+  it("requires a POST capability and stays updating until capture and the SQLite commit finish", async () => {
+    await withSqliteReadModelFixture("telemetry-open", async ({ root, filesystem }) => {
+      await mkdir(join(root, ".agents/records/lifecycle"), { recursive: true });
+      await writeFile(
+        join(root, ".agents/records/lifecycle/manifest.json"),
+        JSON.stringify({
+          schema_version: 1,
+          updated_at: new Date().toISOString(),
+          offsets: {},
+        }),
+      );
+      await writeFile(
+        join(root, ".agents/records/lifecycle/summary.json"),
+        JSON.stringify({
+          schema_version: 1,
+          updated_at: new Date().toISOString(),
+          counts: { total: 0, by_kind: {}, by_status: {} },
+          freshness: {},
+          usage: {},
+          periods: {},
+        }),
+      );
+      let releaseCapture!: () => void;
+      let releaseCommit!: () => void;
+      const capture = vi.fn(async () => {
+        await new Promise<void>((resolve) => {
+          releaseCapture = resolve;
+        });
+        return {
+          captured_runs: 1,
+          captured_segments: null,
+          manifest_state: "initialized" as const,
+          skipped_reason: null,
+          last_capture_at: new Date().toISOString(),
+        };
+      });
+      const commit = vi.fn(async () => {
+        await new Promise<void>((resolve) => {
+          releaseCommit = resolve;
+        });
+      });
+      const reconcile = vi.fn();
+      const app = createDashboardApp(root, "session", undefined, {
+        filesystem,
+        captureTelemetry: capture,
+        refreshReadModel: commit,
+        reconcileOpenWork: reconcile,
+      });
+      const headers = { "x-zaip-session": "session" };
+      const ready = async () => (await app.request("/api/v2/ready", { headers })).json();
+      expect((await app.request("/api/v2/capture-telemetry", { method: "POST" })).status).toBe(401);
+      expect(capture).not.toHaveBeenCalled();
+      const response = await app.request("/api/v2/capture-telemetry", { method: "POST", headers });
+      expect(response.status).toBe(202);
+      expect(await response.json()).toEqual({ snapshot_state: "updating" });
+      await expect(ready()).resolves.toMatchObject({ snapshot_state: "updating" });
+      // Passive probes cannot start another capture. A second opening shares it.
+      await ready();
+      await app.request("/api/v2/capture-telemetry", { method: "POST", headers });
+      expect(capture).toHaveBeenCalledOnce();
+      expect(commit).not.toHaveBeenCalled();
+      releaseCapture();
+      await vi.waitFor(() => expect(commit).toHaveBeenCalledOnce());
+      await expect(ready()).resolves.toMatchObject({ snapshot_state: "updating" });
+      releaseCommit();
+      await vi.waitFor(async () =>
+        expect(await ready()).toMatchObject({
+          status: "ready",
+          snapshot_state: "current",
+          active_capture: { captured_segments: null },
+        }),
+      );
+      expect(reconcile).not.toHaveBeenCalled();
+    });
+  });
+
+  it("cannot advertise current after a failed capture even when canonical projection succeeds", async () => {
+    await withSqliteReadModelFixture("telemetry-failed", async ({ root, filesystem }) => {
+      const commit = vi.fn(async () => undefined);
+      const app = createDashboardApp(root, "session", undefined, {
+        filesystem,
+        refreshReadModel: commit,
+        captureTelemetry: async () => {
+          throw new Error("transcript timed out");
+        },
+      });
+      const headers = { "x-zaip-session": "session" };
+      await app.request("/api/v2/capture-telemetry", { method: "POST", headers });
+      await vi.waitFor(() => expect(commit).toHaveBeenCalledOnce());
+      const ready = await app.request("/api/v2/ready", { headers });
+      expect(await ready.json()).toMatchObject({
+        status: "degraded",
+        snapshot_state: "updating",
+        active_capture_failure: { code: "active_telemetry_capture_failed" },
+      });
+      const manual = await app.request("/api/v2/refresh-projection", { method: "POST", headers });
+      expect(manual.status).toBe(503);
+      expect(await manual.json()).toMatchObject({
+        error: "Telemetry capture is unavailable",
+        snapshot_state: "updating",
+      });
+    });
+  });
+});

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

@@ -0,0 +1,59 @@
+import { describe, expect, it, vi } from "vitest";
+import { createTelemetryProjectionRefresh } from "./server-telemetry-refresh.js";
+
+describe("telemetry before projection", () => {
+  it("shares startup/browser/refresh requests and cannot finish before capture or rebuild", async () => {
+    let finishCapture!: () => void;
+    let finishProjection!: () => void;
+    const order: string[] = [];
+    const capture = vi.fn(async () => {
+      order.push("capture");
+      await new Promise<void>((resolve) => {
+        finishCapture = resolve;
+      });
+      return {
+        captured_runs: 1,
+        captured_segments: null,
+        manifest_state: "initialized" as const,
+        skipped_reason: null,
+        last_capture_at: new Date().toISOString(),
+      };
+    });
+    const refresh = vi.fn(async () => {
+      order.push("projection");
+      await new Promise<void>((resolve) => {
+        finishProjection = resolve;
+      });
+    });
+    const sync = createTelemetryProjectionRefresh({ capture, refresh });
+    const startup = sync.refresh();
+    const browser = sync.refresh();
+    expect(browser).toBe(startup);
+    expect(sync.pending).toBe(true);
+    expect(order).toEqual(["capture"]);
+    finishCapture();
+    await vi.waitFor(() => expect(refresh).toHaveBeenCalledOnce());
+    expect(sync.pending).toBe(true);
+    finishProjection();
+    await startup;
+    expect(sync.pending).toBe(false);
+    expect(order).toEqual(["capture", "projection"]);
+  });
+
+  it("retains a failed capture while projecting canonical data and allows retry", async () => {
+    const failure = new Error("unavailable telemetry");
+    const onCaptureFailure = vi.fn();
+    const refresh = vi.fn(async () => undefined);
+    const sync = createTelemetryProjectionRefresh({
+      capture: vi.fn().mockRejectedValue(failure),
+      refresh,
+      onCaptureFailure,
+    });
+    await sync.refresh();
+    expect(onCaptureFailure).toHaveBeenCalledWith(failure);
+    expect(refresh).toHaveBeenCalledOnce();
+    expect(sync.pending).toBe(false);
+    await sync.refresh();
+    expect(refresh).toHaveBeenCalledTimes(2);
+  });
+});

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

@@ -0,0 +1,44 @@
+import type { ActiveCodexTelemetryCapture } from "./active-codex-telemetry.js";
+
+/** Startup, explicit browser opening, and manual refresh share one writer. */
+export function createTelemetryProjectionRefresh(input: {
+  capture?: () => Promise<ActiveCodexTelemetryCapture>;
+  refresh: () => Promise<void>;
+  onCaptureSuccess?: (result: ActiveCodexTelemetryCapture) => void;
+  onCaptureFailure?: (error: unknown) => void;
+}) {
+  let inFlight: Promise<void> | null = null;
+  let projecting = false;
+  const refresh = (catchUp = false): Promise<void> => {
+    if (inFlight !== null) {
+      // An explicit refresh may observe a source change after the SQLite
+      // worker started. Preserve the projection's bounded catch-up request.
+      if (catchUp && projecting) void input.refresh().catch(() => undefined);
+      return inFlight;
+    }
+    inFlight = (async () => {
+      try {
+        if (input.capture !== undefined) {
+          const result = await input.capture();
+          input.onCaptureSuccess?.(result);
+        }
+      } catch (error) {
+        input.onCaptureFailure?.(error);
+      }
+      // Keep canonical records readable even when telemetry is unavailable.
+      // The caller retains the capture failure separately from SQLite health.
+      projecting = true;
+      await input.refresh();
+    })().finally(() => {
+      projecting = false;
+      inFlight = null;
+    });
+    return inFlight;
+  };
+  return {
+    refresh,
+    get pending() {
+      return inFlight !== null;
+    },
+  };
+}

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

@@ -13,6 +13,26 @@ const changed: ReconciliationResult = {
 afterEach(() => vi.useRealTimers());
 
 describe("canonical host recovery", () => {
+  it("associates deduplicated queued requests with the original job instead of the preceding job", async () => {
+    let release!: (value: ReconciliationResult) => void;
+    const first = new Promise<ReconciliationResult>((resolve) => {
+      release = resolve;
+    });
+    const reconcile = vi.fn().mockReturnValueOnce(first).mockResolvedValue(clean);
+    const run = createWorkReconciliation({ reconcile, refresh: async () => undefined });
+    const previous = run("host-terminal", "JOB-HOST");
+    const queued = run("manual", "JOB-MANUAL");
+    const deduplicated = run("manual", "JOB-SECOND-CLICK");
+    expect(run.jobIdFor(previous)).toBe("JOB-HOST");
+    expect(run.jobIdFor(queued)).toBe("JOB-MANUAL");
+    expect(run.jobIdFor(deduplicated)).toBe("JOB-MANUAL");
+    release(clean);
+    await queued;
+    expect(reconcile.mock.calls).toEqual([
+      ["host-terminal", "JOB-HOST"],
+      ["manual", "JOB-MANUAL"],
+    ]);
+  });
   it("queues manual recovery after host-only work and deduplicates concurrent clicks", async () => {
     let release!: (value: ReconciliationResult) => void;
     const first = new Promise<ReconciliationResult>((resolve) => {

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

@@ -34,13 +34,14 @@ export async function waitForWorkReconciliation(
 
 /** Serialize canonical mutations from the button and the one-shot host recovery. */
 export function createWorkReconciliation(input: {
-  reconcile: (mode: ReconciliationMode) => Promise<ReconciliationResult>;
-  refresh: () => Promise<void>;
+  reconcile: (mode: ReconciliationMode, jobId?: string) => Promise<ReconciliationResult>;
+  refresh: (jobId?: string) => Promise<void>;
 }) {
   let tail = Promise.resolve();
   const pending = new Map<ReconciliationMode, Promise<ReconciliationResult>>();
-  const refresh = () => void input.refresh().catch(() => undefined);
-  return (mode: ReconciliationMode): Promise<ReconciliationResult> => {
+  const jobIds = new WeakMap<Promise<ReconciliationResult>, string>();
+  const refresh = (jobId?: string) => void input.refresh(jobId).catch(() => undefined);
+  const run = (mode: ReconciliationMode, jobId?: string): Promise<ReconciliationResult> => {
     // A manual command is an explicit operator action. It may wait for an
     // already-writing command, but it must never be represented by the host
     // recovery promise: that made the dialog appear to run forever while the
@@ -48,24 +49,28 @@ export function createWorkReconciliation(input: {
     const current = pending.get(mode);
     if (current !== undefined) return current;
     const job = tail
-      .then(() => input.reconcile(mode))
+      .then(() => (jobId === undefined ? input.reconcile(mode) : input.reconcile(mode, jobId)))
       .then(
         (result) => {
-          if (result.reconciled_ids.length > 0 || result.blocked.length > 0) refresh();
+          if (result.reconciled_ids.length > 0 || result.blocked.length > 0) refresh(jobId);
           return result;
         },
         (error: unknown) => {
           // A failed command may already have persisted part of the graph.
-          refresh();
+          refresh(jobId);
           throw error;
         },
       )
       .finally(() => pending.delete(mode));
     pending.set(mode, job);
+    if (jobId !== undefined) jobIds.set(job, jobId);
     tail = job.then(
       () => undefined,
       () => undefined,
     );
     return job;
   };
+  return Object.assign(run, {
+    jobIdFor: (job: Promise<ReconciliationResult>) => jobIds.get(job) ?? null,
+  });
 }

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

@@ -3,6 +3,7 @@ import { createHash } from "node:crypto";
 import { resolve } from "node:path";
 import { promisify } from "node:util";
 import type { WorkspaceFileSystem } from "@zaip-ai/core";
+import { createDashboardDiagnostics } from "../dashboard-diagnostics.mjs";
 
 const DASHBOARD_CONFIG_PATH = ".agents/dashboard/dashboard.config.json";
 const execFileAsync = promisify(execFile);
@@ -66,6 +67,15 @@ export interface ReconciliationResult {
   reconciled_ids: string[];
   blocked: ReconciliationItem[];
   not_reconciled: ReconciliationItem[];
+  outcomes?: Array<ReconciliationItem & { status: string }>;
+  diagnostics?: {
+    job_id: string;
+    started_at: string;
+    completed_at: string;
+    log_directory: string;
+    projection_updated_at: string | null;
+    latest_token_collected_at: string | null;
+  };
 }
 
 export const reconciliationCommandTimeoutMs = 170_000;
@@ -82,15 +92,19 @@ export class ReconciliationCommandTimeoutError extends Error {
 export async function reconcileOpenWork(
   filesystem: WorkspaceFileSystem,
   workspaceRoot: string,
-  options: { hostTerminalOnly?: boolean } = {},
+  options: { hostTerminalOnly?: boolean; jobId?: string } = {},
 ): Promise<ReconciliationResult> {
+  const diagnostics = createDashboardDiagnostics(workspaceRoot, "reconciliation");
+  const job_id = options.jobId ?? diagnostics.correlationId;
+  diagnostics.log("cli_start", { job_id, host_terminal_only: options.hostTerminalOnly === true });
   if (!(await filesystem.exists(".agents/runtime/bin/zaip.mjs"))) {
+    diagnostics.log("cli_unavailable", { job_id });
     throw new Error("ZAIP runtime is unavailable; open work could not be reconciled.");
   }
   const cliPath = resolve(workspaceRoot, ".agents", "runtime", "bin", "zaip.mjs");
   let stdout: string;
   try {
-    ({ stdout } = await execFileAsync(
+    const output = await execFileAsync(
       process.execPath,
       [
         cliPath,
@@ -107,20 +121,35 @@ export async function reconcileOpenWork(
         timeout: reconciliationCommandTimeoutMs,
         killSignal: "SIGTERM",
       },
-    ));
+    );
+    stdout = output.stdout;
+    diagnostics.log("cli_output", { job_id, stdout, stderr: output.stderr });
   } catch (error) {
+    diagnostics.log("cli_error", { job_id, error });
     if (typeof error === "object" && error !== null && "killed" in error && error.killed === true) {
       throw new ReconciliationCommandTimeoutError();
     }
     throw error;
   }
-  return reconciliationResult(JSON.parse(stdout) as unknown);
+  try {
+    const result = reconciliationResult(JSON.parse(stdout) as unknown);
+    diagnostics.log("cli_completed", { job_id, result });
+    return result;
+  } catch (error) {
+    diagnostics.log("cli_invalid_result", { job_id, error, stdout });
+    throw error;
+  }
 }
 
 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 outcomes = new Map<string, ReconciliationItem & { status: string }>();
+  const recordOutcome = (id: unknown, status: unknown, reason: unknown) => {
+    if (typeof id === "string" && typeof status === "string")
+      outcomes.set(id, { id, status, reason: typeof reason === "string" ? reason : 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);
@@ -145,6 +174,7 @@ export function reconciliationResult(value: unknown): ReconciliationResult {
         typeof record.id === "string"
       ) {
         reconciled.add(record.id);
+        recordOutcome(record.id, record.status, record.status_reason ?? reason);
       }
       if (record.status === "blocked") {
         remember(blocked, record.id, record.status_reason ?? reason);
@@ -159,8 +189,18 @@ export function reconciliationResult(value: unknown): ReconciliationResult {
   const closedRuns = Array.isArray(records.runs) ? records.runs : [];
   closedRuns.forEach((candidate) => {
     if (typeof candidate !== "object" || candidate === null) return;
-    const runId = (candidate as { run?: { run_id?: unknown } }).run?.run_id;
-    if (typeof runId === "string") reconciled.add(runId);
+    // CLI returns RunV2Fold: the started header is under run, terminal
+    // status/summary belong to the fold and its finished record.
+    const fold = candidate as {
+      run?: { run_id?: unknown };
+      status?: unknown;
+      finished?: { status?: unknown; summary?: unknown };
+    };
+    const run = fold.run;
+    if (typeof run?.run_id === "string") {
+      reconciled.add(run.run_id);
+      recordOutcome(run.run_id, fold.status ?? fold.finished?.status, fold.finished?.summary);
+    }
   });
   const orphanedExecutions = Array.isArray(records.orphaned_executions)
     ? records.orphaned_executions
@@ -183,6 +223,7 @@ export function reconciliationResult(value: unknown): ReconciliationResult {
       const entity = candidate as Record<string, unknown>;
       if (typeof entity.id !== "string" || !terminalStatuses.has(entity.status as string)) continue;
       reconciled.add(entity.id);
+      recordOutcome(entity.id, entity.status, entity.status_reason);
       if (entity.status === "blocked") remember(blocked, entity.id, entity.status_reason);
     }
   }
@@ -206,5 +247,6 @@ export function reconciliationResult(value: unknown): ReconciliationResult {
     reconciled_ids: [...reconciled].sort(),
     blocked: entries(blocked),
     not_reconciled: entries(notReconciled),
+    outcomes: [...outcomes.values()].sort((a, b) => a.id.localeCompare(b.id)),
   };
 }

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

@@ -283,6 +283,7 @@ describe("dashboard backend", () => {
     expect(reconcile).toHaveBeenCalledOnce();
     expect(reconcile).toHaveBeenCalledWith(canonicalFilesystem, workspaceRoot, {
       hostTerminalOnly: false,
+      jobId: expect.any(String),
     });
     expect(refresh).toHaveBeenCalledOnce();
     const rejected = await app.request("/api/v2/reconcile-open-work", { method: "POST" });
@@ -359,7 +360,6 @@ describe("dashboard backend", () => {
         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;
@@ -439,7 +439,7 @@ describe("dashboard backend", () => {
       });
       await expect(
         canonicalFilesystem.readText(".agents/dashboard/work-priority.json"),
-      ).resolves.toContain(priority.item_ids[0]!);
+      ).resolves.toContain(priority.item_ids[0]);
       const readsAfterPut = priorityReads.mock.calls.filter(
         ([path]) => path === ".agents/dashboard/work-priority.json",
       ).length;