@zaip-ai/cli 1.0.7 → 1.3.0

package/templates/.agents/dashboard/packages/local-runtime/package.json

@@ -1,12 +1,16 @@
 {
   "name": "@zaip-ai/dashboard-local-runtime",
-  "version": "1.0.0",
+  "version": "1.3.0",
   "private": true,
   "type": "module",
   "scripts": {
-    "build": "node ../../../../scripts/build-package.mjs src/server.ts dist/server.js",
+    "build": "node scripts/build-sqlite-runtime.mjs",
     "clean": "node ../../../../scripts/clean.mjs",
-    "dashboard:open": "node ./src/start-dashboard.mjs",
+    "dashboard:open": "node ./start-dashboard.mjs",
+    "sqlite:rebuild": "node scripts/rebuild-sqlite-read-model.mjs",
+    "sqlite:verify": "node scripts/build-sqlite-runtime.mjs && node scripts/rebuild-sqlite-read-model.mjs",
+    "sqlite:validate": "node scripts/build-sqlite-runtime.mjs && node scripts/validate-sqlite-read-model.mjs",
+    "launcher:unix:contract": "node scripts/test-unix-launchers.mjs",
     "test": "vitest run --passWithNoTests",
     "typecheck": "tsc --noEmit"
   },
@@ -17,6 +21,7 @@
     "@zaip-ai/dashboard-cost-monitor": "workspace:*",
     "@zaip-ai/dashboard-data-export": "workspace:*",
     "@zaip-ai/dashboard-frontend": "workspace:*",
+    "@zaip-ai/lifecycle-manifests": "workspace:*",
     "@zaip-ai/dashboard-operations": "workspace:*",
     "@zaip-ai/dashboard-traceability": "workspace:*",
     "hono": "4.12.34",

package/templates/.agents/dashboard/packages/local-runtime/scripts/build-sqlite-dashboard.mjs

@@ -0,0 +1,20 @@
+import { spawn } from "node:child_process";
+import { resolve } from "node:path";
+
+const root = resolve(import.meta.dirname, "../../../../..");
+const run = (cwd, args) =>
+  new Promise((resolveRun, rejectRun) => {
+    const child = spawn(process.execPath, args, { cwd, stdio: "inherit", windowsHide: true });
+    child.once("error", rejectRun);
+    child.once("exit", (code) =>
+      code === 0 ? resolveRun(undefined) : rejectRun(new Error(`build failed: ${code}`)),
+    );
+  });
+await run(resolve(root, ".agents/dashboard/apps/frontend"), [
+  resolve(root, "node_modules/vite/bin/vite.js"),
+  "build",
+]);
+await run(resolve(root, ".agents/dashboard/packages/local-runtime"), [
+  resolve(root, ".agents/dashboard/packages/local-runtime/scripts/build-sqlite-runtime.mjs"),
+]);
+process.stdout.write("SQLite dashboard artifacts rebuilt.\n");

package/templates/.agents/dashboard/packages/local-runtime/scripts/build-sqlite-runtime.mjs

@@ -0,0 +1,114 @@
+import { copyFile, mkdir, readFile, writeFile } from "node:fs/promises";
+import { createRequire } from "node:module";
+import { dirname, resolve } from "node:path";
+
+const root = resolve(import.meta.dirname, "../../../../..");
+const packageRoot = resolve(root, ".agents/dashboard/packages/local-runtime");
+const require = createRequire(resolve(root, "package.json"));
+const { build } = require("esbuild");
+await mkdir(resolve(packageRoot, "dist"), { recursive: true });
+const buildOptions = {
+  bundle: true,
+  platform: "node",
+  format: "cjs",
+  target: "node22",
+  // The launcher pays V8's parse/compile cost before `main` can run. This is
+  // a distributed runtime artifact, so preserve external source maps while
+  // minimizing the executable JavaScript it must evaluate on every click.
+  minify: true,
+  sourcemap: true,
+  alias: {
+    "@hono/node-server/serve-static": resolve(
+      root,
+      "node_modules/.pnpm/@hono+node-server@2.0.10_hono@4.12.34/node_modules/@hono/node-server/dist/serve-static.mjs",
+    ),
+    "@hono/node-server": resolve(
+      root,
+      "node_modules/.pnpm/@hono+node-server@2.0.10_hono@4.12.34/node_modules/@hono/node-server/dist/index.mjs",
+    ),
+    "hono/cookie": resolve(
+      root,
+      "node_modules/.pnpm/hono@4.12.34/node_modules/hono/dist/helper/cookie/index.js",
+    ),
+    "hono/utils/mime": resolve(
+      root,
+      "node_modules/.pnpm/hono@4.12.34/node_modules/hono/dist/utils/mime.js",
+    ),
+    "hono/ws": resolve(
+      root,
+      "node_modules/.pnpm/hono@4.12.34/node_modules/hono/dist/helper/websocket/index.js",
+    ),
+    hono: resolve(root, "node_modules/.pnpm/hono@4.12.34/node_modules/hono/dist/index.js"),
+    zod: resolve(root, "node_modules/.pnpm/zod@4.4.3/node_modules/zod"),
+    "@zaip-ai/core": resolve(root, "packages/core/src/index.ts"),
+    "@zaip-ai/costs": resolve(root, "packages/costs/src/index.ts"),
+    "@zaip-ai/decisions": resolve(root, "packages/decisions/src/index.ts"),
+    "@zaip-ai/lifecycle-manifests": resolve(root, "packages/lifecycle-manifests/src/index.ts"),
+    "@zaip-ai/specs": resolve(root, "packages/specs/src/index.ts"),
+    "@zaip-ai/tasks": resolve(root, "packages/tasks/src/index.ts"),
+    "@zaip-ai/dashboard-operations/contracts": resolve(
+      root,
+      ".agents/dashboard/modules/operations/src/contracts.ts",
+    ),
+    "@zaip-ai/dashboard-operations/work-board-model": resolve(
+      root,
+      ".agents/dashboard/modules/operations/src/work-board-model.ts",
+    ),
+    "@zaip-ai/dashboard-operations/server": resolve(
+      root,
+      ".agents/dashboard/modules/operations/src/server/index.ts",
+    ),
+    "@zaip-ai/dashboard-traceability/server": resolve(
+      root,
+      ".agents/dashboard/modules/traceability/src/server/index.ts",
+    ),
+    "@zaip-ai/dashboard-cost-monitor/server": resolve(
+      root,
+      ".agents/dashboard/modules/cost-monitor/src/server/index.ts",
+    ),
+  },
+};
+const buildResults = await Promise.all([
+  // The local rebuild and validation helpers import CommonJS directly.
+  build({
+    ...buildOptions,
+    entryPoints: [resolve(packageRoot, "src/server.ts")],
+    outfile: resolve(packageRoot, "dist/server.cjs"),
+    metafile: process.env.ZAIP_RUNTIME_METAFILE === "1",
+  }),
+  // `server.js` is the portable runtime consumed by the launchers and copied
+  // verbatim to server.mjs/release. Keep that distributed ESM artifact in the
+  // same build invocation as the CJS helper so it cannot retain an older Run
+  // transport parser than the live read model.
+  build({
+    ...buildOptions,
+    format: "esm",
+    banner: {
+      js: 'import { createRequire as __zaipCreateRequire } from "node:module"; const require = __zaipCreateRequire(import.meta.url);',
+    },
+    entryPoints: [resolve(packageRoot, "src/server.ts")],
+    outfile: resolve(packageRoot, "dist/server.js"),
+  }),
+  // Keep the standalone read-model artifact coherent with the bundled server.
+  // Tooling and diagnostics may import it directly during a live refresh.
+  build({
+    ...buildOptions,
+    entryPoints: [resolve(packageRoot, "src/sqlite-read-model.ts")],
+    outfile: resolve(packageRoot, "dist/sqlite-read-model.cjs"),
+  }),
+]);
+const distributedServer = resolve(packageRoot, "dist/server.js");
+await writeFile(
+  distributedServer,
+  (await readFile(distributedServer, "utf8")).replace(/[ \t]+$/gm, ""),
+  "utf8",
+);
+await copyFile(distributedServer, resolve(packageRoot, "server.mjs"));
+if (process.env.ZAIP_RUNTIME_METAFILE === "1") {
+  await writeFile(
+    resolve(packageRoot, "dist/server.cjs.metafile.json"),
+    JSON.stringify(buildResults[0].metafile, null, 2),
+    "utf8",
+  );
+}
+process.stdout.write("SQLite dashboard runtime rebuilt.\n");

package/templates/.agents/dashboard/packages/local-runtime/scripts/rebuild-sqlite-read-model.mjs

@@ -0,0 +1,31 @@
+import { rm } from "node:fs/promises";
+import { relative, resolve } from "node:path";
+
+const workspaceRoot = resolve(import.meta.dirname, "../../../../..");
+process.env.ZAIP_UI_ROOT ??= resolve(workspaceRoot, ".agents/dashboard/apps/frontend/dist");
+const { default: runtime } = await import("../dist/server.cjs");
+const { rebuildSqliteReadModel, validateSqliteReadModelSchema } = runtime;
+const cleanupPath =
+  process.env.ZAIP_SQLITE_REFRESH_CLEANUP === "1" ? process.env.ZAIP_SQLITE_DB_PATH : null;
+try {
+  const result = await rebuildSqliteReadModel(workspaceRoot);
+  const schema = validateSqliteReadModelSchema(result.path);
+  process.stdout.write(
+    `${JSON.stringify({ storage_mode: "sqlite_read_model", ...result, schema })}\n`,
+  );
+} finally {
+  // The background seed refresher owns only its generated refresh-*.sqlite
+  // path. Cleanup belongs to this worker so a launcher exit cannot leak it.
+  if (typeof cleanupPath === "string") {
+    const refreshDirectory = resolve(workspaceRoot, ".local", "dashboard-sqlite");
+    const candidate = resolve(cleanupPath);
+    const name = relative(refreshDirectory, candidate);
+    const safeGeneratedRefresh =
+      name !== "" &&
+      !name.startsWith("..") &&
+      !name.includes("/") &&
+      !name.includes("\\") &&
+      /^refresh-\d+-[0-9a-f]+\.sqlite$/i.test(name);
+    if (safeGeneratedRefresh) await rm(candidate, { force: true }).catch(() => {});
+  }
+}

package/templates/.agents/dashboard/packages/local-runtime/scripts/source-size-runtime-scripts/sqlite-read-model-fixture.mjs

@@ -0,0 +1,397 @@
+import { mkdir, writeFile } from "node:fs/promises";
+import { join } from "node:path";
+
+export async function fixture(createSqliteTestDirectory) {
+  const directory = await createSqliteTestDirectory("parity-");
+  await mkdir(join(directory, ".agents/records/lifecycle/views"), { recursive: true });
+  await mkdir(join(directory, ".agents/records/lifecycle/chunks"), { recursive: true });
+  await mkdir(join(directory, ".agents/config"), { recursive: true });
+  await writeFile(join(directory, ".agents/config/project.yaml"), "zaip:\n  enabled: true\n");
+  await mkdir(join(directory, ".agents/config/agents"), { recursive: true });
+  await writeFile(
+    join(directory, ".agents/config/agents/catalog.yaml"),
+    "agents:\n  - id: agent-a\n    codex_name: agent-a\n    persona: { nome: ana, cargo: quality_engineer }\n    role: reviewer\n",
+  );
+  await mkdir(join(directory, ".agents/records/telemetry/2026/08/writers/w/chunks"), {
+    recursive: true,
+  });
+  const summary = (id, hash, occurred_at, segments) => ({
+    schema_version: 1,
+    agent_invocation_id: id,
+    summary_hash: hash,
+    root_agent_invocation_id: id,
+    parent_agent_invocation_id: null,
+    invocation_kind: "orchestrator",
+    delegation_depth: 0,
+    execution_id: null,
+    task_id: null,
+    spec_id: null,
+    prd_id: null,
+    change_id: null,
+    run_id: id,
+    occurred_at,
+    status: "completed",
+    coverage: "complete",
+    source_event_count: 1,
+    llm_call_count: 2,
+    historical_cost: { estimated_usd: 2, estimated_brl: 10 },
+    quantitative_coverage: { tokens: "complete", duration_ms: "complete" },
+    quantitative_metrics: {
+      duration_ms: { known_sum: 100 },
+      tokens_total: { known_sum: 15 },
+      estimated_usd: { known_sum: 2 },
+      estimated_brl: { known_sum: 10 },
+    },
+    usage_segments: segments,
+  });
+  const mixed = [
+    {
+      provider: "openai",
+      model: "a",
+      service_tier: null,
+      reasoning_effort: null,
+      coverage: "complete",
+      tokens: { input: 2, cached_input: 1, output: 3, reasoning: 4, total: 10 },
+      historical_cost: { estimated_usd: 1, estimated_brl: 5 },
+    },
+    {
+      provider: "other",
+      model: "b",
+      service_tier: null,
+      reasoning_effort: null,
+      coverage: "complete",
+      tokens: { input: 5, cached_input: 0, output: 0, reasoning: 0, total: 5 },
+      historical_cost: { estimated_usd: 1, estimated_brl: 5 },
+    },
+  ];
+  const canonical = {
+    ...summary("AINV-edge", "hash-edge", "2026-08-01T01:00:00.000Z", mixed),
+    execution_id: "EXEC-a",
+    task_id: "TASK-a",
+    conversation_id: "CONV-a",
+    zaip_agent: "agent-a",
+    phase: "execution",
+  };
+  const augustBefore = {
+    ...summary("AINV-aug-before", "hash-aug-before", "2026-08-05T04:00:00.000Z", mixed),
+    zaip_agent: "agent-a",
+    phase: "execution",
+    quantitative_metrics: {
+      duration_ms: { known_sum: 200 },
+      tokens_total: { known_sum: 15 },
+      estimated_usd: { known_sum: 2 },
+      estimated_brl: { known_sum: 10 },
+    },
+  };
+  const unavailable = {
+    ...summary("AINV-unavailable", "hash-unavailable", "2026-08-15T04:00:00.000Z", []),
+    llm_call_count: null,
+    status: "failed",
+    zaip_agent: "agent-b",
+    phase: "review",
+    historical_cost: null,
+    quantitative_coverage: { tokens: "unavailable", duration_ms: "unavailable" },
+    quantitative_metrics: {
+      duration_ms: { known_sum: null },
+      tokens_total: { known_sum: null },
+      estimated_usd: { known_sum: null },
+      estimated_brl: { known_sum: null },
+    },
+  };
+  const augustInside = {
+    ...summary("AINV-aug-inside", "hash-aug-inside", "2026-08-20T04:00:00.000Z", mixed),
+    zaip_agent: "agent-a",
+    phase: "execution",
+    quantitative_metrics: {
+      duration_ms: { known_sum: 300 },
+      tokens_total: { known_sum: 15 },
+      estimated_usd: { known_sum: 2 },
+      estimated_brl: { known_sum: 10 },
+    },
+  };
+  const lifecycle = [
+    {
+      operation: "upsert",
+      entity: {
+        kind: "task",
+        id: "TASK-a",
+        updated_at: "2026-07-31T22:00:00.000Z",
+        data: {
+          title: "Causal task",
+          status: "active",
+          risk: "critical",
+          created_at: "2026-07-31T22:00:00.000Z",
+        },
+      },
+    },
+    {
+      operation: "upsert",
+      entity: {
+        kind: "task",
+        id: "TASK-zero",
+        updated_at: "2026-08-10T22:00:00.000Z",
+        data: {
+          title: "Task without invocation",
+          status: "ready",
+          risk: "lite",
+          created_at: "2026-08-10T22:00:00.000Z",
+        },
+      },
+    },
+    {
+      operation: "upsert",
+      entity: {
+        kind: "spec",
+        id: "SPEC-zero",
+        updated_at: "2026-08-10T22:00:00.000Z",
+        data: {
+          title: "SPEC without invocation",
+          status: "ready",
+          risk: "lite",
+          created_at: "2026-08-10T22:00:00.000Z",
+        },
+      },
+    },
+    {
+      operation: "upsert",
+      entity: {
+        kind: "prd",
+        id: "PRD-zero",
+        updated_at: "2026-08-10T22:00:00.000Z",
+        data: {
+          title: "PRD without invocation",
+          status: "ready",
+          risk: "lite",
+          created_at: "2026-08-10T22:00:00.000Z",
+        },
+      },
+    },
+    {
+      operation: "upsert",
+      entity: {
+        kind: "execution",
+        id: "EXEC-a",
+        updated_at: "2026-07-31T22:00:00.000Z",
+        data: { status: "completed", created_at: "2026-07-31T22:00:00.000Z" },
+      },
+    },
+    {
+      operation: "upsert",
+      entity: {
+        kind: "conversation",
+        id: "CONV-a",
+        updated_at: "2026-07-31T22:00:00.000Z",
+        data: { status: "active", created_at: "2026-07-31T22:00:00.000Z" },
+      },
+    },
+    {
+      operation: "upsert",
+      entity: {
+        kind: "decision",
+        id: "DEC-edge",
+        updated_at: "2026-07-31T22:00:00.000Z",
+        data: { status: "accepted", risk: "standard", created_at: "2026-07-31T22:00:00.000Z" },
+      },
+    },
+    {
+      operation: "upsert",
+      entity: {
+        kind: "change",
+        id: "CHG-edge",
+        updated_at: "2026-07-31T22:00:00.000Z",
+        data: { status: "active", risk: "critical", created_at: "2026-07-31T22:00:00.000Z" },
+      },
+    },
+  ];
+  await writeFile(
+    join(directory, ".agents/records/lifecycle/chunks/entities.jsonl"),
+    `${lifecycle.map(JSON.stringify).join("\n")}\n`,
+  );
+  await writeFile(
+    join(directory, ".agents/records/telemetry/2026/08/writers/w/chunks/c.jsonl"),
+    `${JSON.stringify(canonical)}\n${JSON.stringify(canonical)}\n${JSON.stringify(augustBefore)}\n${JSON.stringify(unavailable)}\n${JSON.stringify(augustInside)}\n`,
+  );
+  await writeFile(
+    join(directory, ".agents/records/telemetry/2026/08/writers/w/manifest.json"),
+    JSON.stringify({
+      chunks: [{ path: ".agents/records/telemetry/2026/08/writers/w/chunks/c.jsonl" }],
+    }),
+  );
+  const canonicalRun = ({
+    runId,
+    invocationId,
+    occurredAt,
+    duration,
+    status = "completed",
+    agent = "agent-a",
+    phase = "execution",
+    executionId = null,
+    taskId = null,
+    conversationId,
+    segments = [],
+  }) => {
+    const started = {
+      schema_version: 2,
+      event_id: `${runId}:000001`,
+      run_id: runId,
+      sequence: 1,
+      occurred_at: occurredAt,
+      type: "run.started",
+      attribution_status: "attributed",
+      phase,
+      run_role: "orchestrator",
+      run_purpose: phase === "execution" ? "execution" : "orchestration",
+      requires_finalizer: false,
+      execution_kind: phase === "execution" ? "delivery" : "interaction",
+      execution_eligibility: [phase === "execution" ? "delivery" : "interaction"],
+      entrypoint: taskId === null ? "conversation" : "task",
+      work_type: "new",
+      storage_mode: "tracked_sanitized",
+      client: "codex",
+      agent,
+      agent_name: agent,
+      provider: segments.length > 0 ? segments[0].provider : null,
+      model: segments.length > 0 ? segments[0].model : "unknown",
+      reasoning_effort: null,
+      client_thread_id: `thread-${runId}`,
+      client_turn_id: `turn-${runId}`,
+      conversation_id: conversationId,
+      execution_id: executionId,
+      task_id: taskId,
+      spec_id: null,
+      prd_id: null,
+      change_id: null,
+      parent_run_id: null,
+      continuation_of_run_id: null,
+      retry_of_run_id: null,
+      ...(invocationId === null
+        ? {}
+        : {
+            agent_invocation_id: invocationId,
+            root_agent_invocation_id: invocationId,
+            parent_agent_invocation_id: null,
+            invocation_kind: "orchestrator",
+            delegation_depth: 0,
+          }),
+    };
+    const usage = segments.map((segment, index) => ({
+      schema_version: 2,
+      event_id: `${runId}:${String(index + 2).padStart(6, "0")}`,
+      run_id: runId,
+      sequence: index + 2,
+      occurred_at: occurredAt,
+      type: "usage.recorded",
+      phase,
+      activity_kind: "model_usage",
+      classification_source: "explicit",
+      tokens: { ...segment.tokens, source: "provider_reported" },
+      cost: { usd: segment.cost.usd, brl: segment.cost.brl, fx_rate: 5 },
+      provider: segment.provider,
+      model: segment.model,
+      source_segment_key: `${runId}:${index}`,
+      model_call_id: `MCALL-${runId}-${index}`,
+      runtime: { reasoning_effort: null, service_tier: null },
+      supersedes_event_id: null,
+      duration_ms: null,
+      duration_provenance: null,
+    }));
+    const finished = {
+      schema_version: 2,
+      event_id: `${runId}:${String(usage.length + 2).padStart(6, "0")}`,
+      run_id: runId,
+      sequence: usage.length + 2,
+      occurred_at: occurredAt,
+      type: "run.finished",
+      phase,
+      status,
+      duration_ms: duration,
+      duration_provenance: duration === null ? "unavailable" : "observed",
+    };
+    return `${[...[started], ...usage, finished].map(JSON.stringify).join("\n")}\n`;
+  };
+  await mkdir(join(directory, ".agents/records/runs/2026/07"), { recursive: true });
+  await mkdir(join(directory, ".agents/records/runs/2026/08"), { recursive: true });
+  const canonicalSegments = [
+    {
+      provider: "openai",
+      model: "a",
+      tokens: { input: 2, cached_input: 1, output: 3, reasoning: 4, total: 10 },
+      cost: { usd: 1, brl: 5 },
+    },
+    {
+      provider: "other",
+      model: "b",
+      tokens: { input: 5, cached_input: 0, output: 0, reasoning: 0, total: 5 },
+      cost: { usd: 1, brl: 5 },
+    },
+  ];
+  const runs = [
+    [
+      "2026/07/RUN-edge.jsonl",
+      {
+        runId: "RUN-edge",
+        invocationId: "AINV-edge",
+        occurredAt: "2026-08-01T01:00:00.000Z",
+        duration: 100,
+        executionId: "EXEC-a",
+        taskId: "TASK-a",
+        conversationId: "CONV-a",
+        segments: canonicalSegments,
+      },
+    ],
+    [
+      "2026/08/RUN-aug-before.jsonl",
+      {
+        runId: "RUN-aug-before",
+        invocationId: "AINV-aug-before",
+        occurredAt: "2026-08-05T04:00:00.000Z",
+        duration: 200,
+        executionId: "EXEC-before",
+        conversationId: "CONV-before",
+        segments: canonicalSegments,
+      },
+    ],
+    [
+      "2026/08/RUN-unavailable.jsonl",
+      {
+        runId: "RUN-unavailable",
+        invocationId: "AINV-unavailable",
+        occurredAt: "2026-08-15T04:00:00.000Z",
+        duration: null,
+        status: "failed",
+        agent: "agent-b",
+        phase: "conversation",
+        conversationId: "CONV-unavailable",
+        segments: [],
+      },
+    ],
+    [
+      "2026/08/RUN-aug-inside.jsonl",
+      {
+        runId: "RUN-aug-inside",
+        invocationId: "AINV-aug-inside",
+        occurredAt: "2026-08-20T04:00:00.000Z",
+        duration: 300,
+        executionId: "EXEC-inside",
+        conversationId: "CONV-inside",
+        segments: canonicalSegments,
+      },
+    ],
+    [
+      "2026/08/RUN-unassisted.jsonl",
+      {
+        runId: "RUN-unassisted",
+        invocationId: null,
+        occurredAt: "2026-08-20T05:00:00.000Z",
+        duration: null,
+        agent: "root",
+        phase: "conversation",
+        conversationId: "CONV-unassisted",
+        segments: [],
+      },
+    ],
+  ];
+  for (const [path, value] of runs)
+    await writeFile(join(directory, ".agents/records/runs", path), canonicalRun(value));
+  return directory;
+}