@zaip-ai/cli 2.2.0 → 3.0.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", "--limit", "1", "--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-installation-summary.test.ts

@@ -0,0 +1,142 @@
+import type { WorkspaceFileSystem } from "@zaip-ai/core";
+import { describe, expect, it } from "vitest";
+import {
+  PROJECT_INSTALLATION_AREA_REQUIREMENTS,
+  PROJECT_INSTALLATION_STACK_REQUIREMENTS,
+  readDocumentAvailability,
+  summarizeProjectStatus,
+} from "./project-installation-summary.js";
+import type { ProjectOverview } from "./project-settings.js";
+
+function stack(): ProjectOverview["stack_components"] {
+  return PROJECT_INSTALLATION_STACK_REQUIREMENTS.map((name) => ({
+    name,
+    version: "1.0.0",
+    configured_version: "1.0.0",
+    source: "local",
+    verification: "exact",
+    installation: "installed",
+    probe: "verified",
+  }));
+}
+function docs(available: boolean | null): ProjectOverview["areas"] {
+  return PROJECT_INSTALLATION_AREA_REQUIREMENTS.map((id) => ({
+    id,
+    label: id,
+    artifact: id,
+    available,
+  }));
+}
+
+describe("project status dimensions", () => {
+  it("reports 100% technical installation with 10 dependencies and zero of six documents", () => {
+    expect(summarizeProjectStatus("full", stack(), docs(false), "healthy")).toMatchObject({
+      health: { state: "healthy", scope: "settings_runtime" },
+      dependencies: { applicable: 10, installed: 10, percent: 100, state: "complete" },
+      documentation: { applicable: 6, available: 0, missing: 6, percent: 0, state: "incomplete" },
+    });
+  });
+
+  it("does not infer runtime health from dependencies or documents", () => {
+    expect(summarizeProjectStatus("full", stack(), docs(true)).health.state).toBe("unknown");
+    const components = stack();
+    components[0] = { ...components[0]!, version: null, probe: "missing", installation: "missing" };
+    const result = summarizeProjectStatus("full", components, docs(true), "healthy");
+    expect(result.health.state).toBe("healthy");
+    expect(result.dependencies).toMatchObject({ missing: 1, percent: 90, state: "incomplete" });
+  });
+
+  it("preserves unknown probes and absent or duplicate snapshot entries", () => {
+    const components = stack();
+    components[1] = {
+      ...components[1]!,
+      version: null,
+      verification: "unavailable",
+      probe: "unknown",
+    };
+    expect(summarizeProjectStatus("full", components, docs(null)).dependencies).toMatchObject({
+      installed: 9,
+      missing: 0,
+      unknown: 1,
+      percent: null,
+      state: "unknown",
+    });
+    expect(summarizeProjectStatus("full", [], []).dependencies).toMatchObject({
+      installed: 0,
+      missing: 0,
+      unknown: 10,
+      percent: null,
+      state: "unknown",
+    });
+    expect(
+      summarizeProjectStatus("full", [...stack(), stack()[0]!], docs(true)).dependencies.unknown,
+    ).toBe(1);
+    expect(summarizeProjectStatus("full", stack(), docs(null)).documentation).toMatchObject({
+      available: 0,
+      missing: 0,
+      unknown: 6,
+      percent: null,
+      state: "unknown",
+    });
+  });
+
+  it("excludes only dependencies declared in lite or dev-lite profiles", () => {
+    const components = stack();
+    components[1] = {
+      ...components[1]!,
+      version: null,
+      verification: "unavailable",
+      probe: "unknown",
+    };
+    expect(summarizeProjectStatus("lite", components, docs(false)).dependencies).toMatchObject({
+      applicable: 2,
+      installed: 2,
+      unknown: 0,
+      not_applicable: 8,
+      percent: 100,
+    });
+    expect(summarizeProjectStatus("dev-lite", components, docs(false)).dependencies).toMatchObject({
+      applicable: 9,
+      installed: 8,
+      unknown: 1,
+      not_applicable: 1,
+      percent: null,
+    });
+    expect(summarizeProjectStatus("custom", components, docs(false))).toMatchObject({
+      dependencies: {
+        applicable: null,
+        installed: null,
+        not_applicable: null,
+        percent: null,
+        state: "unknown",
+      },
+      documentation: { applicable: null, available: null, percent: null, state: "unknown" },
+    });
+  });
+
+  it("distinguishes absent documents from failed probes without converting unavailable into false", async () => {
+    const filesystem = (readText: () => Promise<string>) =>
+      ({ readText }) as unknown as WorkspaceFileSystem;
+    expect(
+      await readDocumentAvailability(
+        filesystem(async () => "  "),
+        "doc.md",
+      ),
+    ).toBe(false);
+    expect(
+      await readDocumentAvailability(
+        filesystem(async () => "content"),
+        "doc.md",
+      ),
+    ).toBe(true);
+    for (const code of ["ENOENT", "EACCES", "EIO"]) {
+      const result = await readDocumentAvailability(
+        filesystem(async () => {
+          throw Object.assign(new Error(code), { code });
+        }),
+        "doc.md",
+      );
+      expect(result).toBe(code === "ENOENT" ? false : null);
+    }
+  });
+});

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

@@ -0,0 +1,190 @@
+import type { ProjectConfig, WorkspaceFileSystem } from "@zaip-ai/core";
+import type { ProjectOverview } from "./project-settings.js";
+
+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 InstallationProfile = "full" | "dev-lite" | "lite" | "custom";
+type StatusState = "complete" | "incomplete" | "unknown" | "not_applicable";
+type Dimension = {
+  applicable: number | null;
+  missing: number | null;
+  unknown: number | null;
+  not_applicable: number | null;
+  percent: number | null;
+  state: StatusState;
+};
+export type ProjectStatusSummary = {
+  installation_profile: InstallationProfile;
+  health: { state: "healthy" | "degraded" | "unknown"; scope: "settings_runtime" };
+  dependencies: Dimension & { installed: number | null };
+  documentation: Dimension & { available: number | null };
+};
+
+export function installationProfile(project: ProjectConfig): InstallationProfile {
+  const value = project.stack.overrides.installation_profile;
+  return value === "full" || value === "dev-lite" || value === "lite" ? value : "custom";
+}
+
+export async function readDocumentAvailability(
+  filesystem: WorkspaceFileSystem,
+  path: string,
+): Promise<boolean | null> {
+  try {
+    return (await filesystem.readText(path)).trim().length > 0;
+  } catch (error) {
+    return (error as NodeJS.ErrnoException).code === "ENOENT" ? false : null;
+  }
+}
+
+/** Health is an observed runtime result, never a synonym for dependency/document completeness. */
+export function summarizeProjectStatus(
+  profile: InstallationProfile,
+  stack: ProjectOverview["stack_components"],
+  areas: ProjectOverview["areas"],
+  runtimeHealth: ProjectStatusSummary["health"]["state"] = "unknown",
+): ProjectStatusSummary {
+  const health = { state: runtimeHealth, scope: "settings_runtime" as const };
+  if (profile === "custom") {
+    // Undeclared/custom applicability is unknown, not an exemption or zero-percent installation.
+    const unknown: Dimension = {
+      applicable: null,
+      missing: null,
+      unknown: null,
+      not_applicable: null,
+      percent: null,
+      state: "unknown",
+    };
+    return {
+      installation_profile: profile,
+      health,
+      dependencies: { ...unknown, installed: null },
+      documentation: { ...unknown, available: null },
+    };
+  }
+  const required: readonly string[] =
+    profile === "full"
+      ? PROJECT_INSTALLATION_STACK_REQUIREMENTS
+      : profile === "dev-lite"
+        ? PROJECT_INSTALLATION_STACK_REQUIREMENTS.filter((name) => name !== "Terraform")
+        : ["Node.js", "Git"];
+  let installed = 0,
+    missing = 0,
+    unknown = 0;
+  for (const name of required) {
+    const matches = stack.filter((component) => component.name === name);
+    const component = matches.length === 1 ? matches[0] : undefined;
+    if (component && isInstalledLocalRequirement(component) && component.probe !== "unknown")
+      installed++;
+    else if (component?.probe === "missing") missing++;
+    else unknown++;
+  }
+  let available = 0,
+    missingDocs = 0,
+    unknownDocs = 0;
+  for (const id of PROJECT_INSTALLATION_AREA_REQUIREMENTS) {
+    const matches = areas.filter((area) => area.id === id);
+    const availability = matches.length === 1 ? matches[0]?.available : null;
+    if (availability === true) available++;
+    else if (availability === false) missingDocs++;
+    else unknownDocs++;
+  }
+  return {
+    installation_profile: profile,
+    health,
+    dependencies: {
+      ...dimension(
+        required.length,
+        installed,
+        missing,
+        unknown,
+        PROJECT_INSTALLATION_STACK_REQUIREMENTS.length - required.length,
+      ),
+      installed,
+    },
+    documentation: {
+      ...dimension(
+        PROJECT_INSTALLATION_AREA_REQUIREMENTS.length,
+        available,
+        missingDocs,
+        unknownDocs,
+        0,
+      ),
+      available,
+    },
+  };
+}
+
+function dimension(
+  applicable: number,
+  complete: number,
+  missing: number,
+  unknown: number,
+  excluded: number,
+): Dimension {
+  return {
+    applicable,
+    missing,
+    unknown,
+    not_applicable: excluded,
+    percent: applicable > 0 && unknown === 0 ? (complete / applicable) * 100 : null,
+    state:
+      applicable === 0
+        ? "not_applicable"
+        : unknown > 0
+          ? "unknown"
+          : missing > 0
+            ? "incomplete"
+            : "complete",
+  };
+}
+
+/** Transitional legacy field; new consumers use the independent dimensions above. */
+export function summarizeProjectInstallation(
+  stack: ProjectOverview["stack_components"],
+  areas: ProjectOverview["areas"],
+): ProjectOverview["installation"] {
+  const completed =
+    PROJECT_INSTALLATION_STACK_REQUIREMENTS.filter((name) =>
+      stack.some((component) => component.name === name && isInstalledLocalRequirement(component)),
+    ).length +
+    PROJECT_INSTALLATION_AREA_REQUIREMENTS.filter((id) =>
+      areas.some((area) => area.id === id && area.available === true),
+    ).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.version !== null &&
+    (component.installation === "runtime" || component.installation === "installed")
+  );
+}

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[] = [];
@@ -123,6 +126,27 @@ async function fixtureProject() {
 }
 
 describe("project settings persistence", () => {
+  it.each([
+    "essential",
+    "balanced",
+    "persistent",
+  ] as const)("round-trips autonomy %s through project YAML", async (preset) => {
+    const { filesystem } = await fixtureProject();
+    const current = await readProjectSettings(filesystem);
+    const autonomy = { version: 1 as const, preset };
+    const saved = await persistProjectSettings(filesystem, { ...current, autonomy });
+    expect(saved.autonomy).toEqual(autonomy);
+    expect((await readProjectSettings(filesystem)).autonomy).toEqual(autonomy);
+    expect(saved.assurance).toEqual(current.assurance);
+    const before = await filesystem.readText(PROJECT_CONFIG_PATH);
+    await expect(
+      persistProjectSettings(filesystem, {
+        ...saved,
+        autonomy: { version: 1, preset: "invented" },
+      }),
+    ).rejects.toThrow();
+    expect(await filesystem.readText(PROJECT_CONFIG_PATH)).toBe(before);
+  });
   it("uses the canonical lowercase architecture artifact path", () => {
     expect(SOFTWARE_ARCHITECTURE_PATH).toBe(".agents/architecture/software-architecture.md");
   });
@@ -401,13 +425,33 @@ describe("project settings persistence", () => {
 
     expect(overview).toEqual({
       framework_version: "1.2.3",
+      installation: expect.objectContaining({ total: 16, state: "incomplete" }),
+      installation_profile: "custom",
+      health: { state: "healthy", scope: "settings_runtime" },
+      dependencies: {
+        applicable: null,
+        installed: null,
+        missing: null,
+        unknown: null,
+        not_applicable: null,
+        percent: null,
+        state: "unknown",
+      },
+      documentation: {
+        applicable: null,
+        available: null,
+        missing: null,
+        unknown: null,
+        not_applicable: null,
+        percent: null,
+        state: "unknown",
+      },
       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 +497,6 @@ describe("project settings persistence", () => {
       "skills",
       "rules",
       "hooks",
-      "database",
     ]);
     expect(overview.metrics.map((metric) => metric.label)).toEqual([
       "Agentes",
@@ -461,13 +504,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 +517,77 @@ 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,
+        probe: "verified" 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("uses only stack.overrides.installation_profile, never stack.id, for applicability", async () => {
+    const { filesystem } = await fixtureProject();
+    expect((await readProjectOverview(filesystem)).installation_profile).toBe("custom");
+
+    const current = await readProjectSettings(filesystem);
+    await filesystem.writeTextAtomic(
+      PROJECT_CONFIG_PATH,
+      serializeYaml({
+        ...current,
+        stack: {
+          ...current.stack,
+          overrides: { ...current.stack.overrides, installation_profile: "lite" },
+        },
+      }),
+    );
+
+    expect(await readProjectOverview(filesystem)).toMatchObject({
+      installation_profile: "lite",
+      dependencies: { applicable: 2, not_applicable: 8 },
+      documentation: { applicable: 6 },
+    });
+  });
+
   it("reports the project-local installed version separately from configured stack versions", async () => {
     const { filesystem } = await fixtureProject();
     const current = await readProjectSettings(filesystem);