@zaip-ai/cli 2.2.0 → 3.0.0

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

@@ -7,22 +7,43 @@ import {
   parseAgentCatalog,
   parseProjectConfig,
   parseYaml,
+  resolveAutonomy,
   serializeYaml,
   type WorkspaceFileSystem,
 } from "@zaip-ai/core";
+import {
+  installationProfile,
+  type PROJECT_INSTALLATION_TOTAL,
+  type ProjectStatusSummary,
+  readDocumentAvailability,
+  summarizeProjectInstallation,
+  summarizeProjectStatus,
+} from "./project-installation-summary.js";
+
+export {
+  PROJECT_INSTALLATION_AREA_REQUIREMENTS,
+  PROJECT_INSTALLATION_STACK_REQUIREMENTS,
+  PROJECT_INSTALLATION_TOTAL,
+  summarizeProjectInstallation,
+  summarizeProjectStatus,
+} from "./project-installation-summary.js";
 
 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 type ProjectOverview = {
+export type ProjectOverview = ProjectStatusSummary & {
   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;
   }>;
@@ -33,6 +54,7 @@ export type ProjectOverview = {
     source: string | null;
     verification: "exact" | "constraint" | "unavailable";
     installation: "runtime" | "installed" | "missing" | "bundled";
+    probe?: "verified" | "missing" | "unknown";
   }>;
   areas: Array<{
     id:
@@ -44,7 +66,7 @@ export type ProjectOverview = {
       | "sales_playbook";
     label: string;
     artifact: string;
-    available: boolean;
+    available: boolean | null;
   }>;
 };
 
@@ -72,38 +94,44 @@ 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 [project, stack_components, areas] = await Promise.all([
+    readProjectSettings(filesystem),
+    readVerifiedStackComponents(filesystem),
+    Promise.all(
+      projectOverviewArtifacts.map(async (area) => ({
+        ...area,
+        available: await readDocumentAvailability(filesystem, area.artifact),
+      })),
+    ),
   ]);
+  const installation = summarizeProjectInstallation(stack_components, areas);
+  const status = summarizeProjectStatus(
+    installationProfile(project),
+    stack_components,
+    areas,
+    "healthy",
+  );
   return {
     framework_version: frameworkVersion,
+    installation,
+    ...status,
     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,
   };
 }
 
@@ -191,13 +219,19 @@ async function readVerifiedStackComponents(
   ];
 }
 
-type InstalledPackage = { name: string; version: string | null; source: string | null };
+type InstalledPackage = {
+  name: string;
+  version: string | null;
+  source: string | null;
+  probe: "verified" | "missing" | "unknown";
+};
 type DashboardStackDependencies = { node: string | null; packages: Map<string, string> };
 
 async function readInstalledPackageVersion(
   filesystem: WorkspaceFileSystem,
   name: string,
 ): Promise<InstalledPackage> {
+  let uncertain = false;
   const roots = ["node_modules"];
   if (name === "hono") roots.push(".agents/dashboard/packages/local-runtime/node_modules");
   if (name === "react") roots.push(".agents/dashboard/apps/frontend/node_modules");
@@ -212,15 +246,18 @@ async function readInstalledPackageVersion(
         version === null ||
         !/^\d+\.\d+\.\d+(?:-[\w.-]+)?(?:\+[\w.-]+)?$/.test(version) ||
         entrypoint === null
-      )
+      ) {
+        uncertain = true;
         continue;
+      }
       await filesystem.readText(`${root}/${name}/${entrypoint}`);
-      return { name, version, source };
-    } catch {
-      // A pnpm workspace can install dependencies in the owning package only.
+      return { name, version, source, probe: "verified" };
+    } catch (error) {
+      // Absence is known only for ENOENT; invalid JSON and denied reads are unknown.
+      if ((error as NodeJS.ErrnoException).code !== "ENOENT") uncertain = true;
     }
   }
-  return { name, version: null, source: null };
+  return { name, version: null, source: null, probe: uncertain ? "unknown" : "missing" };
 }
 
 async function readDashboardStackDependencies(
@@ -319,6 +356,7 @@ async function executableComponent(
       source: executable === command ? `Comando do workspace: ${command}` : local,
       verification: "exact",
       installation: executable === command ? "runtime" : "installed",
+      probe: "verified",
     };
   } catch {
     return {
@@ -328,6 +366,7 @@ async function executableComponent(
       source: null,
       verification: "unavailable",
       installation: "missing",
+      probe: "unknown",
     };
   }
 }
@@ -344,6 +383,7 @@ function runtimeComponent(
     source: `Runtime do Dashboard: ${process.execPath}`,
     verification: "exact",
     installation: "runtime",
+    probe: "verified",
   };
 }
 
@@ -363,6 +403,7 @@ function packageComponent(
       source: installed.get(packageName)?.source ?? null,
       verification: "exact",
       installation: "installed",
+      probe: "verified",
     };
   if (bundled)
     return {
@@ -375,6 +416,7 @@ function packageComponent(
           : ".agents/dashboard/apps/frontend/dist",
       verification: "unavailable",
       installation: "bundled",
+      probe: "unknown",
     };
   return {
     name,
@@ -383,6 +425,7 @@ function packageComponent(
     source: null,
     verification: "unavailable",
     installation: "missing",
+    probe: installed.get(packageName)?.probe ?? "missing",
   };
 }
 
@@ -480,6 +523,7 @@ const architectureLabels: Record<string, string> = {
 };
 
 export function renderSoftwareArchitecture(config: ProjectConfig): string {
+  const autonomy = resolveAutonomy(config.autonomy);
   const overrides = recordValue(config.stack.overrides);
   const components = recordValue(overrides.components);
   const languages = recordValue(overrides.languages);
@@ -501,14 +545,14 @@ export function renderSoftwareArchitecture(config: ProjectConfig): string {
     "",
   ]);
   const executionDetails =
-    config.execution?.runtime === "autonomous"
+    config.execution && config.execution.runtime !== "manual"
       ? [
-          "- **Runtime:** autonomous",
+          `- **Runtime:** ${config.execution.runtime}`,
           `- **Provider:** ${markdownCell(config.execution.autonomous.provider)}`,
           `- **Modelo-base:** ${markdownCell(config.execution.autonomous.model)}`,
           `- **Paralelismo máximo:** ${config.execution.autonomous.max_parallelism}`,
           `- **Lease configurado:** ${config.execution.autonomous.lease_ms} ms`,
-          `- **Limite total de invocações:** ${config.execution.autonomous.max_total_invocations ?? "Não definido"}`,
+          `- **Limite total de invocações:** ${config.autonomy ? "Por Task; sem teto agregado de SPEC/PRD" : (config.execution.autonomous.max_total_invocations ?? "Não definido")}`,
         ]
       : [`- **Runtime:** ${config.execution?.runtime ?? "manual (padrão implícito)"}`];
   const assuranceDetails =
@@ -547,6 +591,18 @@ export function renderSoftwareArchitecture(config: ProjectConfig): string {
     "## Execução",
     "",
     ...executionDetails,
+    ...(config.autonomy
+      ? [
+          "",
+          "### Autonomia",
+          "",
+          `- **Perfil:** ${autonomy.label}`,
+          `- **Execuções por Task:** ${autonomy.attempts ?? "Ilimitadas"}`,
+          `- **Replanejamentos por Task:** ${autonomy.replans ?? "Ilimitados"}`,
+          "- Sem abandono por tempo. Tasks iniciadas preservam o perfil e os contadores.",
+          "- Subagentes podem ter modelo/esforço diferentes do principal, com aviso explícito.",
+        ]
+      : []),
     "",
     "## Assurance",
     "",

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-browser-lease.test.ts

@@ -0,0 +1,91 @@
+import { Hono } from "hono";
+import { afterEach, describe, expect, it, vi } from "vitest";
+import { registerBrowserLeaseRoute } from "./server-browser-lease.js";
+
+afterEach(() => {
+  vi.useRealTimers();
+  vi.restoreAllMocks();
+});
+
+async function openLease(app: Hono) {
+  const response = await app.request("/api/v2/browser-lease");
+  if (response.body === null) throw new Error("Missing SSE body");
+  const reader = response.body.getReader();
+  const chunks: string[] = [];
+  const drained = (async () => {
+    for (;;) {
+      const chunk = await reader.read();
+      if (chunk.done) return;
+      chunks.push(new TextDecoder().decode(chunk.value));
+    }
+  })();
+  await vi.advanceTimersByTimeAsync(0);
+  expect(response.headers.get("content-type")).toContain("text/event-stream");
+  expect(chunks[0]).toContain("event: lease\ndata: active");
+  return {
+    chunks,
+    close: async () => {
+      await reader.cancel();
+      await drained;
+    },
+  };
+}
+
+describe("browser lease lifecycle", () => {
+  it("keeps the real SSE body active past a five-minute idle timeout", async () => {
+    vi.useFakeTimers();
+    const exit = vi.spyOn(process, "exit").mockImplementation(() => undefined as never);
+    const app = new Hono();
+    registerBrowserLeaseRoute(app, "/api/v2", true);
+    const lease = await openLease(app);
+    try {
+      for (let interval = 0; interval < 31; interval++) {
+        const before = lease.chunks.length;
+        await vi.advanceTimersByTimeAsync(10_000);
+        expect(lease.chunks.length).toBeGreaterThan(before);
+        expect(lease.chunks.at(-1)).toContain(": keep-alive\n\n");
+        expect(exit).not.toHaveBeenCalled();
+      }
+    } finally {
+      await lease.close();
+    }
+    expect(vi.getTimerCount()).toBe(1);
+    await vi.advanceTimersByTimeAsync(11_999);
+    expect(exit).not.toHaveBeenCalled();
+    await vi.advanceTimersByTimeAsync(1);
+    expect(exit).toHaveBeenCalledExactlyOnceWith(0);
+  });
+
+  it("expires only after the last client closes and a replacement cancels expiry", async () => {
+    vi.useFakeTimers();
+    const exit = vi.spyOn(process, "exit").mockImplementation(() => undefined as never);
+    const app = new Hono();
+    registerBrowserLeaseRoute(app, "/api/v2", true);
+    const first = await openLease(app);
+    const second = await openLease(app);
+    await first.close();
+    await vi.advanceTimersByTimeAsync(13_000);
+    expect(exit).not.toHaveBeenCalled();
+    await second.close();
+    await vi.advanceTimersByTimeAsync(11_000);
+    const replacement = await openLease(app);
+    await vi.advanceTimersByTimeAsync(13_000);
+    expect(exit).not.toHaveBeenCalled();
+    await replacement.close();
+    await vi.advanceTimersByTimeAsync(12_000);
+    expect(exit).toHaveBeenCalledExactlyOnceWith(0);
+    expect(vi.getTimerCount()).toBe(0);
+  });
+
+  it("does not terminate an unmanaged server or retain a heartbeat after cancellation", async () => {
+    vi.useFakeTimers();
+    const exit = vi.spyOn(process, "exit").mockImplementation(() => undefined as never);
+    const app = new Hono();
+    registerBrowserLeaseRoute(app, "/api/v2");
+    const lease = await openLease(app);
+    await lease.close();
+    await vi.advanceTimersByTimeAsync(60_000);
+    expect(exit).not.toHaveBeenCalled();
+    expect(vi.getTimerCount()).toBe(0);
+  });
+});

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

@@ -13,7 +13,7 @@ export function registerBrowserLeaseRoute(
     browserLeaseDeadline.unref();
   }
   const releaseBrowserLease = (lease: object) => {
-    browserLeases.delete(lease);
+    if (!browserLeases.delete(lease)) return;
     if (!launcherOwned || browserLeases.size !== 0) return;
     if (browserLeaseDeadline !== undefined) clearTimeout(browserLeaseDeadline);
     browserLeaseDeadline = setTimeout(() => process.exit(0), 12_000);
@@ -25,9 +25,29 @@ export function registerBrowserLeaseRoute(
     browserLeaseDeadline = undefined;
     browserLeases.add(lease);
     return streamSSE(context, async (stream) => {
-      stream.onAbort(() => releaseBrowserLease(lease));
-      await stream.writeSSE({ event: "lease", data: "active" });
-      await new Promise(() => {});
+      let heartbeat: NodeJS.Timeout | undefined;
+      let wake: (() => void) | undefined;
+      stream.onAbort(() => {
+        if (heartbeat !== undefined) clearTimeout(heartbeat);
+        wake?.();
+        releaseBrowserLease(lease);
+      });
+      try {
+        await stream.writeSSE({ event: "lease", data: "active" });
+        while (!stream.aborted) {
+          await new Promise<void>((resolve) => {
+            wake = resolve;
+            heartbeat = setTimeout(resolve, 10_000);
+            heartbeat.unref();
+          });
+          // SSE comments keep idle HTTP clients alive without changing the
+          // browser's lease event contract or accumulating overlapping writes.
+          if (!stream.aborted) await stream.write(": keep-alive\n\n");
+        }
+      } finally {
+        if (heartbeat !== undefined) clearTimeout(heartbeat);
+        releaseBrowserLease(lease);
+      }
     });
   });
 }

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,
+    );
+  });
+}