@zaip-ai/cli 2.0.0 → 2.6.0

package/templates/.agents/dashboard/packages/local-runtime/src/active-codex-telemetry.ts

@@ -0,0 +1,25 @@
+import { execFile } from "node:child_process";
+import { resolve } from "node:path";
+import { promisify } from "node:util";
+
+const execFileAsync = promisify(execFile);
+
+/**
+ * Captures only active Runs whose persisted Codex correlation names a concrete
+ * turn. The CLI reuses source segment and loop keys as its durable cursor;
+ * this never reconciles or changes a Run lifecycle.
+ */
+export async function captureActiveCodexTelemetry(workspaceRoot: string): Promise<void> {
+  const cliPath = resolve(workspaceRoot, ".agents", "runtime", "bin", "zaip.mjs");
+  await execFileAsync(
+    process.execPath,
+    [cliPath, "run", "usage", "--active", "--disable-codex-raw", "--json"],
+    {
+      cwd: workspaceRoot,
+      encoding: "utf8",
+      windowsHide: true,
+      timeout: 55_000,
+      maxBuffer: 1_024 * 1_024,
+    },
+  );
+}

package/templates/.agents/dashboard/packages/local-runtime/src/agent-catalog-settings.test.ts

@@ -32,7 +32,7 @@ describe("agent catalog settings", () => {
     expect(settings).toMatchObject({
       default_model: "gpt-5.6-terra",
       default_reasoning_effort: "medium",
-      allowed_models: ["gpt-5.6-luna", "gpt-5.6-terra", "gpt-5.6-sol"],
+      allowed_models: ["gpt-5.6-luna", "gpt-5.6-terra", "gpt-5.6-sol", "gpt-6-astra"],
       allowed_reasoning_efforts: ["low", "medium", "high", "xhigh"],
     });
   });

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

@@ -10,10 +10,13 @@ import {
 } from "@zaip-ai/core";
 import { afterEach, describe, expect, it } from "vitest";
 import {
+  PROJECT_INSTALLATION_STACK_REQUIREMENTS,
+  type ProjectOverview,
   persistProjectSettings,
   readProjectOverview,
   readProjectSettings,
   SOFTWARE_ARCHITECTURE_PATH,
+  summarizeProjectInstallation,
 } from "./project-settings.js";
 
 const fixtures: string[] = [];
@@ -401,13 +404,13 @@ describe("project settings persistence", () => {
 
     expect(overview).toEqual({
       framework_version: "1.2.3",
+      installation: expect.objectContaining({ total: 16, state: "incomplete" }),
       metrics: [
         expect.objectContaining({ id: "agents", value: 3 }),
         expect.objectContaining({ id: "squads", value: 2 }),
         expect.objectContaining({ id: "skills", value: 2 }),
         expect.objectContaining({ id: "rules", value: 2 }),
         expect.objectContaining({ id: "hooks", value: 3 }),
-        expect.objectContaining({ id: "database", value: "Inativo" }),
       ],
       stack_components: [
         expect.objectContaining({
@@ -453,7 +456,6 @@ describe("project settings persistence", () => {
       "skills",
       "rules",
       "hooks",
-      "database",
     ]);
     expect(overview.metrics.map((metric) => metric.label)).toEqual([
       "Agentes",
@@ -461,13 +463,9 @@ describe("project settings persistence", () => {
       "Skills",
       "Rules",
       "Hooks",
-      "Database",
     ]);
-    await rm(join(filesystem.root, ".local", "dashboard-sqlite", "read-model.sqlite"));
-    const withoutDatabase = await readProjectOverview(filesystem);
-    expect(withoutDatabase.metrics.at(-1)).toEqual(
-      expect.objectContaining({ id: "database", value: "Inativo" }),
-    );
+    expect(overview.installation.total).toBe(16);
+    expect(overview.installation.percent).toBeLessThan(100);
     expect(overview.areas.map((area) => area.id)).toEqual([
       "software_architecture",
       "design_system",
@@ -478,6 +476,53 @@ describe("project settings persistence", () => {
     ]);
   });
 
+  it("counts only exact local requirements and non-empty overview artifacts toward 16/16", () => {
+    const stack: ProjectOverview["stack_components"] = PROJECT_INSTALLATION_STACK_REQUIREMENTS.map(
+      (name) => ({
+        name,
+        version: "1.0.0",
+        configured_version: "1.0.0",
+        source: "local",
+        verification: "exact" as const,
+        installation: "installed" as const,
+      }),
+    );
+    const areas: ProjectOverview["areas"] = [
+      "software_architecture",
+      "design_system",
+      "brandbook",
+      "marketing_strategy",
+      "sales_playbook",
+      "growth_strategy",
+    ].map((id) => ({
+      id: id as ProjectOverview["areas"][number]["id"],
+      label: id,
+      artifact: id,
+      available: true,
+    }));
+
+    expect(summarizeProjectInstallation(stack, areas)).toEqual({
+      completed: 16,
+      total: 16,
+      percent: 100,
+      state: "complete",
+    });
+
+    stack[0] = {
+      ...stack[0]!,
+      installation: "bundled",
+      verification: "unavailable",
+      version: null,
+    };
+    areas[0] = { ...areas[0]!, available: false };
+    expect(summarizeProjectInstallation(stack, areas)).toEqual({
+      completed: 14,
+      total: 16,
+      percent: 87.5,
+      state: "incomplete",
+    });
+  });
+
   it("reports the project-local installed version separately from configured stack versions", async () => {
     const { filesystem } = await fixtureProject();
     const current = await readProjectSettings(filesystem);

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

@@ -14,15 +14,42 @@ import {
 const AGENT_CATALOG_PATH = ".agents/config/agents/catalog.yaml";
 const CODEX_CONFIG_PATH = ".codex/config.toml";
 const FRAMEWORK_LOCK_PATH = ".agents/config/framework.lock.yaml";
-const SQLITE_READ_MODEL_PATH = ".local/sqlite/zaip-aios-dashboard.sqlite";
 const DASHBOARD_STACK_DEPENDENCIES_PATH = ".agents/dashboard/stack-dependencies.json";
 const exec = promisify(execFile);
 export const SOFTWARE_ARCHITECTURE_PATH = ".agents/architecture/software-architecture.md";
+export const PROJECT_INSTALLATION_STACK_REQUIREMENTS = [
+  "Node.js",
+  "TypeScript",
+  "Vite",
+  "Astro",
+  "Redis",
+  "BullMQ",
+  "Hono",
+  "React",
+  "Git",
+  "Terraform",
+] as const;
+export const PROJECT_INSTALLATION_AREA_REQUIREMENTS = [
+  "software_architecture",
+  "design_system",
+  "brandbook",
+  "marketing_strategy",
+  "sales_playbook",
+  "growth_strategy",
+] as const;
+export const PROJECT_INSTALLATION_TOTAL =
+  PROJECT_INSTALLATION_STACK_REQUIREMENTS.length + PROJECT_INSTALLATION_AREA_REQUIREMENTS.length;
 
 export type ProjectOverview = {
   framework_version: string | null;
+  installation: {
+    completed: number;
+    total: typeof PROJECT_INSTALLATION_TOTAL;
+    percent: number;
+    state: "complete" | "incomplete";
+  };
   metrics: Array<{
-    id: "agents" | "squads" | "skills" | "rules" | "hooks" | "database";
+    id: "agents" | "squads" | "skills" | "rules" | "hooks";
     label: string;
     value: number | string;
   }>;
@@ -72,41 +99,69 @@ export async function readProjectSettings(filesystem: WorkspaceFileSystem): Prom
 export async function readProjectOverview(
   filesystem: WorkspaceFileSystem,
 ): Promise<ProjectOverview> {
-  const [
-    catalog,
-    frameworkVersion,
-    sqliteActive,
-    installedSkills,
-    installedRules,
-    configuredHooks,
-  ] = await Promise.all([
-    filesystem.readText(AGENT_CATALOG_PATH).then(parseYaml).then(parseAgentCatalog),
-    readFrameworkVersion(filesystem),
-    filesystem.exists(SQLITE_READ_MODEL_PATH),
-    countInstalledSkills(filesystem),
-    countDirectMarkdownFiles(filesystem, ".agents/rules"),
-    countCodexHookEvents(filesystem),
+  const [catalog, frameworkVersion, installedSkills, installedRules, configuredHooks] =
+    await Promise.all([
+      filesystem.readText(AGENT_CATALOG_PATH).then(parseYaml).then(parseAgentCatalog),
+      readFrameworkVersion(filesystem),
+      countInstalledSkills(filesystem),
+      countDirectMarkdownFiles(filesystem, ".agents/rules"),
+      countCodexHookEvents(filesystem),
+    ]);
+  const [stack_components, areas] = await Promise.all([
+    readVerifiedStackComponents(filesystem),
+    Promise.all(
+      projectOverviewArtifacts.map(async (area) => ({
+        ...area,
+        available: await hasNonEmptyFile(filesystem, area.artifact),
+      })),
+    ),
   ]);
+  const installation = summarizeProjectInstallation(stack_components, areas);
   return {
     framework_version: frameworkVersion,
+    installation,
     metrics: [
       { id: "agents", label: "Agentes", value: catalog.agents.length },
       { id: "squads", label: "Squads", value: catalog.squads.length },
       { id: "skills", label: "Skills", value: installedSkills },
       { id: "rules", label: "Rules", value: installedRules },
       { id: "hooks", label: "Hooks", value: configuredHooks },
-      { id: "database", label: "Database", value: sqliteActive ? "Ativo" : "Inativo" },
     ],
-    stack_components: await readVerifiedStackComponents(filesystem),
-    areas: await Promise.all(
-      projectOverviewArtifacts.map(async (area) => ({
-        ...area,
-        available: await filesystem.exists(area.artifact),
-      })),
-    ),
+    stack_components,
+    areas,
+  };
+}
+
+export function summarizeProjectInstallation(
+  stackComponents: ProjectOverview["stack_components"],
+  areas: ProjectOverview["areas"],
+): ProjectOverview["installation"] {
+  const completed =
+    PROJECT_INSTALLATION_STACK_REQUIREMENTS.filter((name) =>
+      stackComponents.some(
+        (component) => component.name === name && isInstalledLocalRequirement(component),
+      ),
+    ).length +
+    PROJECT_INSTALLATION_AREA_REQUIREMENTS.filter((id) =>
+      areas.some((area) => area.id === id && area.available),
+    ).length;
+  return {
+    completed,
+    total: PROJECT_INSTALLATION_TOTAL,
+    percent: (completed / PROJECT_INSTALLATION_TOTAL) * 100,
+    state: completed === PROJECT_INSTALLATION_TOTAL ? "complete" : "incomplete",
   };
 }
 
+function isInstalledLocalRequirement(
+  component: ProjectOverview["stack_components"][number],
+): boolean {
+  return (
+    component.verification === "exact" &&
+    (component.installation === "runtime" || component.installation === "installed")
+  );
+}
+
 async function readFrameworkVersion(filesystem: WorkspaceFileSystem): Promise<string | null> {
   try {
     const lock = recordValue(parseYaml(await filesystem.readText(FRAMEWORK_LOCK_PATH)));

package/templates/.agents/dashboard/packages/local-runtime/src/projection-refresh-diagnostics.ts

@@ -0,0 +1,35 @@
+export interface ProjectionRefreshFailure {
+  trigger: "stale_seed" | "source_change";
+  occurred_at: string;
+  code: "projection_refresh_failed";
+  cause: string;
+}
+
+export function createProjectionRefreshDiagnostics() {
+  let failure: ProjectionRefreshFailure | null = null;
+  return {
+    get failure() {
+      return failure;
+    },
+    get healthStatus() {
+      return failure === null ? "ok" : "degraded";
+    },
+    clear: () => {
+      failure = null;
+    },
+    record: ({
+      trigger,
+      error,
+    }: {
+      trigger: ProjectionRefreshFailure["trigger"];
+      error: unknown;
+    }) => {
+      failure = {
+        trigger,
+        occurred_at: new Date().toISOString(),
+        code: "projection_refresh_failed",
+        cause: error instanceof Error && error.name.length > 0 ? error.name : "unknown_error",
+      };
+    },
+  };
+}

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

@@ -0,0 +1,168 @@
+import { buildCostSummaryProjection } from "@zaip-ai/dashboard-cost-monitor/server";
+import type { OperationsProjection } from "@zaip-ai/dashboard-operations/contracts";
+import type { Hono } from "hono";
+import { API_PREFIX, headOrJson, V2WorkspaceRequiredError } from "./server-http-contracts.js";
+import { projectionPeriodFilter } from "./server-period.js";
+import {
+  buildCanonicalOperationsProjection,
+  buildManifestCostRunPage,
+  buildManifestFirstCostProjection,
+  isUnfilteredCostRequest,
+  readCurrentFxRate,
+} from "./server-projections.js";
+import { firstFoldCostSource } from "./server-read-projections.js";
+import type { DashboardRouteContext } from "./server-route-context.js";
+import { queryValues, selectedCurrency } from "./server-summary-helpers.js";
+import { SqliteReadModelFileSystem } from "./sqlite-read-model.js";
+export function registerCostsRoutes(app: Hono, dependencies: DashboardRouteContext) {
+  const {
+    filesystem,
+    canonicalFilesystem,
+    isSqliteSnapshot,
+    readLayout,
+    readSnapshot,
+    readAggregate,
+    clearSnapshotCache,
+  } = dependencies;
+  app.on(["GET", "HEAD"], `${API_PREFIX}/cost-monitor`, async (context) => {
+    try {
+      const scope = context.req.query("scope") ?? "summary";
+      if (scope === "summary") {
+        const layout = await readLayout();
+        const { from, to } = projectionPeriodFilter(context);
+        const currency = selectedCurrency(context);
+        const aggregateStartedAt = performance.now();
+        const [source, rate] = await Promise.all([
+          firstFoldCostSource(filesystem, {
+            from,
+            to,
+            providers: queryValues(context, "provider"),
+            models: queryValues(context, "model"),
+            agents: queryValues(context, "agent"),
+            phases: queryValues(context, "phase"),
+            statuses: queryValues(context, "status"),
+            tasks: queryValues(context, "task"),
+            specs: queryValues(context, "spec"),
+            prds: queryValues(context, "prd"),
+            executions: queryValues(context, "execution"),
+            changes: queryValues(context, "change"),
+          }),
+          currency === "BRL" ? readCurrentFxRate(filesystem) : Promise.resolve(null),
+        ]);
+        // First fold receives only aggregate facts. Detailed Runs and entity
+        // arrays remain on their explicit paginated endpoints.
+        const aggregateMs = performance.now() - aggregateStartedAt;
+        const costOperations = {
+          schema_version: 1,
+          layout_version: layout.version,
+          readonly: true,
+          source: ".agents/records",
+          filters: { from, to },
+          summary: { task_count: source.task_count ?? 0 },
+          prds: [],
+          specs: [],
+          runs: [],
+        } as unknown as OperationsProjection;
+        const projectionStartedAt = performance.now();
+        const payload = buildCostSummaryProjection(
+          source,
+          costOperations,
+          currency,
+          rate?.rate ?? null,
+        );
+        context.header(
+          "Server-Timing",
+          `cost_sql;dur=${aggregateMs.toFixed(1)},cost_projection;dur=${(performance.now() - projectionStartedAt).toFixed(1)}`,
+        );
+        return headOrJson(context, payload, 200, true);
+      }
+      if (scope === "runs") {
+        const layout = await readLayout();
+        const { from, to } = projectionPeriodFilter(context);
+        const offset = Math.max(0, Number.parseInt(context.req.query("offset") ?? "0", 10) || 0);
+        const limit = Math.min(
+          500,
+          Math.max(1, Number.parseInt(context.req.query("limit") ?? "100", 10) || 100),
+        );
+        return headOrJson(
+          context,
+          // The paged Cost adapter reads the lifecycle summary. That canonical
+          // artifact is intentionally not copied into SQLite; use its current
+          // filesystem alongside the immutable SQL facts rather than failing
+          // a filtered page with a synthetic missing-file error.
+          await buildManifestCostRunPage(
+            isSqliteSnapshot ? canonicalFilesystem : filesystem,
+            layout,
+            context,
+            { from, to },
+            offset,
+            limit,
+          ),
+          200,
+          true,
+        );
+      }
+      if (isUnfilteredCostRequest(context))
+        return headOrJson(context, (await readSnapshot(context)).costs);
+      const layout = await readLayout();
+      const { from, to } = projectionPeriodFilter(context);
+      // Cost and Operations must start from the same manifest-corrected Run
+      // population; financial availability is represented on each row, never
+      // by dropping lifecycle Runs before the Cost projection.
+      const operations = await buildCanonicalOperationsProjection(filesystem, layout, { from, to });
+      return headOrJson(
+        context,
+        await buildManifestFirstCostProjection(filesystem, operations, context),
+      );
+    } catch (error) {
+      if (error instanceof V2WorkspaceRequiredError) throw error;
+      return headOrJson(
+        context,
+        { error: error instanceof Error ? error.message : String(error) },
+        400,
+      );
+    }
+  });
+  /** Compact factual attribution view used by both Cost Monitor and Operations.
+   * It is intentionally read-only and is available only from a coherent SQLite
+   * generation, never by reopening mutable JSONL streams on a request. */
+  app.on(["GET", "HEAD"], `${API_PREFIX}/developers`, async (context) => {
+    if (!(filesystem instanceof SqliteReadModelFileSystem))
+      return headOrJson(
+        context,
+        { error: "Developer attribution requires the SQLite read model" },
+        409,
+      );
+    const { from, to } = projectionPeriodFilter(context);
+    return headOrJson(
+      context,
+      filesystem.developerCostAggregate({
+        from,
+        to,
+        accountIds: queryValues(context, "account_id"),
+      }),
+      200,
+      true,
+    );
+  });
+  /** Operations keeps its developer facts separate from Cost Monitor columns. */
+  app.on(["GET", "HEAD"], `${API_PREFIX}/operations/developers`, async (context) => {
+    if (!(filesystem instanceof SqliteReadModelFileSystem))
+      return headOrJson(
+        context,
+        { error: "Developer attribution requires the SQLite read model" },
+        409,
+      );
+    const { from, to } = projectionPeriodFilter(context);
+    return headOrJson(
+      context,
+      filesystem.operationsDeveloperAggregate({
+        from,
+        to,
+        accountIds: queryValues(context, "account_id"),
+      }),
+      200,
+      true,
+    );
+  });
+}