@zaip-ai/cli 1.0.7 → 1.0.8

package/templates/.agents/dashboard/packages/local-runtime/src/agent-adapter-sync.ts

@@ -0,0 +1,30 @@
+import { execFile } from "node:child_process";
+import { resolve } from "node:path";
+import { promisify } from "node:util";
+import type { AgentAdapterSyncResult } from "./agent-catalog-settings.js";
+
+const execFileAsync = promisify(execFile);
+
+export async function runAgentAdapterSync(workspaceRoot: string): Promise<AgentAdapterSyncResult> {
+  const cliPath = resolve(workspaceRoot, ".agents", "runtime", "bin", "zaip.mjs");
+  const commandOptions = {
+    cwd: workspaceRoot,
+    encoding: "utf8" as const,
+    windowsHide: true,
+    timeout: 120_000,
+    maxBuffer: 10 * 1_024 * 1_024,
+  };
+  await execFileAsync(process.execPath, [cliPath, "adapters", "build", "--json"], commandOptions);
+  const { stdout } = await execFileAsync(
+    process.execPath,
+    [cliPath, "adapters", "check", "--json"],
+    commandOptions,
+  );
+  const result = JSON.parse(stdout) as { valid?: unknown; drifted?: unknown };
+  return {
+    valid: result.valid === true,
+    drifted: Array.isArray(result.drifted)
+      ? result.drifted.filter((value): value is string => typeof value === "string")
+      : [],
+  };
+}

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

@@ -18,10 +18,11 @@ async function currentCatalog() {
 }
 
 describe("agent catalog settings", () => {
-  it("protects exactly the 18 current catalog agents as framework agents", async () => {
+  it("protects the current catalog agents as framework agents", async () => {
     const current = await currentCatalog();
 
-    expect(FRAMEWORK_AGENT_IDS).toHaveLength(18);
+    expect(FRAMEWORK_AGENT_IDS.length).toBeGreaterThan(0);
+    expect(new Set(FRAMEWORK_AGENT_IDS).size).toBe(FRAMEWORK_AGENT_IDS.length);
     expect(FRAMEWORK_AGENT_IDS).toEqual(current.agents.map((agent) => agent.id));
   });
 

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

@@ -31,6 +31,11 @@ export const FRAMEWORK_AGENT_IDS = [
   "agent-cloud-engineer",
   "agent-security-auditor",
   "agent-marketing-analyst",
+  "agent-brand-strategist",
+  "agent-growth-strategist",
+  "agent-sales-specialist",
+  "agent-general-operations",
+  "agent-governance-compliance",
 ] as const;
 
 const frameworkAgentIds = new Set<string>(FRAMEWORK_AGENT_IDS);

package/templates/.agents/dashboard/packages/local-runtime/src/manifest-runs.ts

@@ -9,43 +9,82 @@ export function mergeManifestRuns(
   const runs = new Map<string, RunProjection>(legacyRuns.map((run) => [run.id, run]));
   for (const run of summaries.map((summary) => manifestRun(summary, summaries))) {
     const legacy = runs.get(run.id);
-    const preserveObservedSourceTiming =
-      run.source_duration_ms === null &&
-      legacy !== undefined &&
-      legacy.source_duration_ms !== null &&
-      (legacy.source_duration_ms ?? 0) > 0 &&
-      legacy.duration_ms !== null;
-    const preserveLegacyDuration =
-      run.source_duration_ms === null &&
-      legacy !== undefined &&
-      (legacy.source_duration_ms === null || legacy.source_duration_ms === 0) &&
-      legacy.duration_ms !== null;
-    runs.set(
-      run.id,
-      preserveObservedSourceTiming
-        ? { ...legacy, ...run, ...observedTiming(legacy) }
-        : preserveLegacyDuration
-          ? {
-              ...legacy,
-              ...run,
-              duration_ms: legacy.duration_ms,
-              source_duration_ms: null,
-              source_started_at: null,
-              source_finished_at: null,
-              capture_lag_ms: null,
-            }
-          : {
-              ...(legacy ?? {}),
-              ...run,
-              ...(legacy !== undefined && run.duration_ms === null
-                ? { started_at: legacy.started_at, finished_at: legacy.finished_at }
-                : {}),
-            },
-    );
+    if (legacy === undefined) {
+      runs.set(run.id, run);
+      continue;
+    }
+    // Lifecycle Runs are the canonical accounting and calendar population.
+    // Invocation summaries may enrich missing dimensions, but must never move
+    // an existing Run to another day or replace its persisted tokens/cost.
+    runs.set(run.id, {
+      ...run,
+      ...legacy,
+      // Preserve lifecycle accounting when it is known, but do not let a
+      // shallow legacy object erase detailed invocation token fields that
+      // were absent from the old projection.
+      usage: mergeUsage(legacy.usage, run.usage),
+      provider: legacy.provider ?? run.provider,
+      model: legacy.model === "unknown" ? run.model : legacy.model,
+      reasoning_effort: legacy.reasoning_effort ?? run.reasoning_effort,
+      service_tier: legacy.service_tier ?? run.service_tier ?? null,
+      call_count: legacy.call_count ?? run.call_count,
+      terminal_call_count: legacy.terminal_call_count ?? run.terminal_call_count,
+      ...((legacy.pricing_segments?.length ?? 0) > 0
+        ? { pricing_segments: legacy.pricing_segments }
+        : run.pricing_segments === undefined
+          ? {}
+          : { pricing_segments: run.pricing_segments }),
+      ...(legacy.duration_ms !== null &&
+      (legacy.source_duration_ms === null || legacy.source_duration_ms === 0)
+        ? {
+            duration_ms: legacy.duration_ms,
+            source_duration_ms: null,
+            source_started_at: null,
+            source_finished_at: null,
+            capture_lag_ms: null,
+          }
+        : observedTiming(legacy)),
+    });
   }
   return [...runs.values()];
 }
 
+function mergeUsage(
+  lifecycle: RunProjection["usage"],
+  manifest: RunProjection["usage"],
+): RunProjection["usage"] {
+  const metric = (
+    retained: RunProjection["usage"]["total"],
+    enriched: RunProjection["usage"]["total"],
+  ) => ({
+    ...enriched,
+    ...retained,
+    tokens: {
+      ...enriched.tokens,
+      ...retained.tokens,
+      input: retained.tokens.input ?? enriched.tokens.input,
+      cached_input: retained.tokens.cached_input ?? enriched.tokens.cached_input,
+      output: retained.tokens.output ?? enriched.tokens.output,
+      reasoning: retained.tokens.reasoning ?? enriched.tokens.reasoning,
+      total: retained.tokens.total ?? enriched.tokens.total,
+    },
+    cost: {
+      ...enriched.cost,
+      ...retained.cost,
+      usd: retained.cost.usd ?? enriched.cost.usd,
+      brl: retained.cost.brl ?? enriched.cost.brl,
+    },
+  });
+  return {
+    conversation: metric(lifecycle.conversation, manifest.conversation),
+    planning: metric(lifecycle.planning, manifest.planning),
+    execution: metric(lifecycle.execution, manifest.execution),
+    total: metric(lifecycle.total, manifest.total),
+    new_work: metric(lifecycle.new_work, manifest.new_work),
+    rework: metric(lifecycle.rework, manifest.rework),
+  };
+}
+
 function observedTiming(
   run: RunProjection,
 ): Pick<

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

@@ -1,9 +1,20 @@
 import { mkdir, mkdtemp, readFile, rm, writeFile } from "node:fs/promises";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
-import { parseProjectConfig, parseYaml, WorkspaceFileSystem } from "@zaip-ai/core";
+import {
+  parseProjectConfig,
+  parseYaml,
+  PROJECT_CONFIG_PATH,
+  serializeYaml,
+  WorkspaceFileSystem,
+} from "@zaip-ai/core";
 import { afterEach, describe, expect, it } from "vitest";
-import { persistProjectSettings, readProjectSettings } from "./project-settings.js";
+import {
+  persistProjectSettings,
+  readProjectOverview,
+  readProjectSettings,
+  SOFTWARE_ARCHITECTURE_PATH,
+} from "./project-settings.js";
 
 const fixtures: string[] = [];
 
@@ -15,7 +26,74 @@ async function fixtureProject() {
   const root = await mkdtemp(join(tmpdir(), "zaip-project-settings-"));
   fixtures.push(root);
   const configPath = join(root, ".agents", "config", "project.yaml");
-  await mkdir(join(root, ".agents", "config"), { recursive: true });
+  await mkdir(join(root, ".agents", "config", "agents"), { recursive: true });
+  const agent = (id: string, nome: string, cargo: string) => ({
+    id,
+    version: 1,
+    purpose: "Fixture agent",
+    use_when: ["Fixture work"],
+    do_not_use: ["Outside fixture"],
+    codex_name: `zaip-agent-${id.slice("agent-".length)}`,
+    codex_task_name: `${nome}_${cargo}_zaip_agent`,
+    persona: { nome, cargo },
+    nickname_candidates: [`${nome}_${cargo}_zaip_agent`],
+    role: "task-executor",
+    priority: 1,
+    inherits: null,
+    capabilities: ["fixture-capability"],
+    execution_eligibility: ["delivery"],
+    tools: ["test-runner"],
+    skills: ["fixture-skill"],
+    write_scopes: [".agents/dashboard/*"],
+    permissions: {
+      filesystem: { allow: ["declared-write-scope"], deny: ["outside-workspace"] },
+      network: { allow: ["none"], deny: ["external"] },
+      shell: { allow: ["tests"], deny: ["deploy"] },
+      deployment: { allow: ["none"], deny: ["all"] },
+    },
+    model: { required_capabilities: ["code"], preferred: ["fixture-model"] },
+    budget: { soft_cycles: 1 },
+    contract: {
+      inputs: ["task"],
+      outputs: ["result"],
+      evidence: ["acceptance-evidence"],
+    },
+    review: { can_approve: false, cannot_review_roles: ["task-executor"] },
+    escalation: ["agent-one"],
+  });
+  const agents = [
+    agent("agent-one", "one", "fixture"),
+    agent("agent-two", "two", "fixture"),
+    agent("agent-three", "three", "fixture"),
+  ];
+  const squad = (id: string) => ({
+    id,
+    version: 1,
+    purpose: "Fixture squad",
+    members: ["agent-one", "agent-two"],
+    max_parallelism: 1,
+    delegation: [],
+    review_policy: {
+      independent: true,
+      executor_roles: ["task-executor"],
+      reviewer_roles: ["reviewer"],
+    },
+    escalation: ["agent-one"],
+  });
+  await writeFile(
+    join(root, ".agents", "config", "agents", "catalog.yaml"),
+    serializeYaml({
+      schema_version: 1,
+      agents,
+      squads: [squad("squad-one"), squad("squad-two")],
+    }),
+    "utf8",
+  );
+  await writeFile(
+    join(root, ".agents", "config", "framework.lock.yaml"),
+    ["lock_version: 2", "framework:", "  version: 1.2.3", ""].join("\n"),
+    "utf8",
+  );
   await writeFile(
     configPath,
     [
@@ -27,7 +105,7 @@ async function fixtureProject() {
       "  name: Fixture",
       "  timezone: UTC",
       "stack:",
-      "  id: typescript-hono-kysely",
+      "  id: zaip-aios-stack",
       "  overrides:",
       "    database: postgres",
       "clients:",
@@ -74,6 +152,11 @@ describe("project settings persistence", () => {
       },
     });
     expect(parseProjectConfig(parseYaml(await readFile(configPath, "utf8")))).toEqual(updated);
+    const architecture = await filesystem.readText(SOFTWARE_ARCHITECTURE_PATH);
+    expect(architecture).toContain("# Arquitetura de Software");
+    expect(architecture).toContain("**Nome:** Updated fixture");
+    expect(architecture).toContain("| Banco de dados | Não definido | Não fixada | — |");
+    expect(architecture).toContain("- TypeScript");
   });
 
   it("rejects invalid settings before touching the project file", async () => {
@@ -89,4 +172,252 @@ describe("project settings persistence", () => {
     ).rejects.toThrow();
     await expect(readFile(configPath, "utf8")).resolves.toBe(original);
   });
+
+  it("rejects local-only storage before touching the project file", async () => {
+    const { configPath, filesystem } = await fixtureProject();
+    const original = await readFile(configPath, "utf8");
+    const current = await readProjectSettings(filesystem);
+
+    await expect(
+      persistProjectSettings(filesystem, {
+        ...current,
+        tracking: { ...current.tracking, storage_mode: "local_only" },
+      }),
+    ).rejects.toThrow("Git-native");
+    await expect(readFile(configPath, "utf8")).resolves.toBe(original);
+  });
+
+  it("keeps model orchestration fixed when a request tries to change it", async () => {
+    const { filesystem } = await fixtureProject();
+    const current = await readProjectSettings(filesystem);
+    const fixed = parseProjectConfig({
+      ...current,
+      model_orchestration: {
+        mode: "auto",
+        default_model: "gpt-5.6-terra",
+        default_effort: "medium",
+        default_velocity: "standard",
+        allowed_models: ["gpt-5.6-luna", "gpt-5.6-terra", "gpt-5.6-sol"],
+        allowed_efforts: ["low", "medium", "high", "xhigh"],
+        max_auto_effort: "xhigh",
+        automatic_sources: ["spec", "prd"],
+        notice: "mismatch",
+      },
+    });
+    await filesystem.writeTextAtomic(PROJECT_CONFIG_PATH, serializeYaml(fixed));
+    const updated = await persistProjectSettings(filesystem, {
+      ...fixed,
+      model_orchestration: {
+        mode: "off",
+        default_model: "changed-outside-the-ui",
+        default_effort: "high",
+        default_velocity: "fast",
+        notice: "always",
+      },
+    });
+
+    expect(updated.model_orchestration).toEqual(fixed.model_orchestration);
+  });
+
+  it("keeps clients and tracking fixed when a request tries to change them", async () => {
+    const { filesystem } = await fixtureProject();
+    const current = await readProjectSettings(filesystem);
+    const updated = await persistProjectSettings(filesystem, {
+      ...current,
+      clients: { codex: false, claude: true },
+      tracking: {
+        ...current.tracking,
+        enabled: false,
+        currency: "USD",
+      },
+    });
+
+    expect(updated.clients).toEqual(current.clients);
+    expect(updated.tracking).toEqual(current.tracking);
+  });
+
+  it("persists execution and assurance controls in the central project file", async () => {
+    const { filesystem } = await fixtureProject();
+    const current = await readProjectSettings(filesystem);
+    const execution = {
+      runtime: "autonomous" as const,
+      autonomous: {
+        provider: "claude" as const,
+        model: "test-model",
+        max_parallelism: 4,
+        lease_ms: 120_000,
+        max_total_invocations: 12,
+      },
+    };
+    const assurance = {
+      version: 1 as const,
+      standard_depth: "elevated" as const,
+      require_final_commit: false,
+    };
+
+    await persistProjectSettings(filesystem, { ...current, execution, assurance });
+    const persisted = await readProjectSettings(filesystem);
+
+    expect(persisted.execution).toEqual(execution);
+    expect(persisted.assurance).toEqual(assurance);
+    const architecture = await filesystem.readText(SOFTWARE_ARCHITECTURE_PATH);
+    expect(architecture).toContain("**Runtime:** autonomous");
+    expect(architecture).toContain("**Provider:** claude");
+    expect(architecture).toContain("**Profundidade padrão:** elevated");
+
+    const { execution: _execution, assurance: _assurance, ...withoutOptionalBlocks } = persisted;
+    await persistProjectSettings(filesystem, withoutOptionalBlocks);
+    const removed = await readProjectSettings(filesystem);
+    expect(removed.execution).toBeUndefined();
+    expect(removed.assurance).toBeUndefined();
+    const updatedArchitecture = await filesystem.readText(SOFTWARE_ARCHITECTURE_PATH);
+    expect(updatedArchitecture).toContain("**Runtime:** manual (padrão implícito)");
+    expect(updatedArchitecture).toContain("- Não configurada.");
+  });
+
+  it("rolls the project config back when the architecture projection cannot be updated", async () => {
+    const { configPath, filesystem } = await fixtureProject();
+    const original = await readFile(configPath, "utf8");
+    const current = await readProjectSettings(filesystem);
+    const failingFilesystem = new (class extends WorkspaceFileSystem {
+      override async writeTextAtomic(path: string, content: string): Promise<void> {
+        if (path === SOFTWARE_ARCHITECTURE_PATH) throw new Error("simulated projection failure");
+        await super.writeTextAtomic(path, content);
+      }
+    })(filesystem.root);
+
+    await expect(
+      persistProjectSettings(failingFilesystem, {
+        ...current,
+        project: { ...current.project, name: "Must roll back" },
+      }),
+    ).rejects.toThrow("rolled back");
+    await expect(readFile(configPath, "utf8")).resolves.toBe(original);
+  });
+
+  it("reports project capabilities from their actual canonical artifacts", async () => {
+    const { filesystem } = await fixtureProject();
+    await mkdir(join(filesystem.root, ".agents", "design"), { recursive: true });
+    await writeFile(join(filesystem.root, ".agents", "design", "DESIGN.md"), "# Design", "utf8");
+    await mkdir(join(filesystem.root, ".local", "dashboard-sqlite"), { recursive: true });
+    await writeFile(
+      join(filesystem.root, ".local", "dashboard-sqlite", "read-model.sqlite"),
+      "",
+      "utf8",
+    );
+    await mkdir(join(filesystem.root, ".agents", "skills", "skill-one"), { recursive: true });
+    await mkdir(join(filesystem.root, ".agents", "skills", "skill-two"), { recursive: true });
+    await mkdir(join(filesystem.root, ".agents", "skills", "not-a-skill"), { recursive: true });
+    await writeFile(
+      join(filesystem.root, ".agents", "skills", "skill-one", "SKILL.md"),
+      "# Skill one",
+      "utf8",
+    );
+    await writeFile(
+      join(filesystem.root, ".agents", "skills", "skill-two", "SKILL.md"),
+      "# Skill two",
+      "utf8",
+    );
+    await mkdir(join(filesystem.root, ".agents", "rules", "nested"), { recursive: true });
+    await writeFile(join(filesystem.root, ".agents", "rules", "core.md"), "# Core", "utf8");
+    await writeFile(join(filesystem.root, ".agents", "rules", "quality.md"), "# Quality", "utf8");
+    await writeFile(
+      join(filesystem.root, ".agents", "rules", "nested", "ignored.md"),
+      "# Nested",
+      "utf8",
+    );
+    await mkdir(join(filesystem.root, ".codex"), { recursive: true });
+    await writeFile(
+      join(filesystem.root, ".codex", "config.toml"),
+      [
+        "[[hooks.PreToolUse]]",
+        'matcher = "*"',
+        "[[hooks.PreToolUse.hooks]]",
+        'type = "command"',
+        "[[hooks.SubagentStart]]",
+        'matcher = "*"',
+        "[[hooks.SubagentStop]]",
+        'matcher = "*"',
+        "[[hooks.SubagentStop.hooks]]",
+        'type = "command"',
+        "",
+      ].join("\n"),
+      "utf8",
+    );
+
+    const overview = await readProjectOverview(filesystem);
+
+    expect(overview).toEqual({
+      framework_version: "1.2.3",
+      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: "Ativo" }),
+      ],
+      stack_components: [
+        expect.objectContaining({
+          name: "Node.js",
+          version: process.versions.node,
+          source: expect.stringContaining(process.execPath),
+          verification: "exact",
+        }),
+        expect.objectContaining({ name: "TypeScript", verification: "unavailable" }),
+        expect.objectContaining({ name: "Vite", verification: "unavailable" }),
+        expect.objectContaining({ name: "Astro", verification: "unavailable" }),
+        expect.objectContaining({ name: "Redis", verification: "unavailable" }),
+        expect.objectContaining({ name: "BullMQ", verification: "unavailable" }),
+        expect.objectContaining({ name: "Hono", verification: "unavailable" }),
+        expect.objectContaining({ name: "React", verification: "unavailable" }),
+      ],
+      areas: expect.arrayContaining([
+        expect.objectContaining({
+          id: "design_system",
+          artifact: ".agents/design/DESIGN.md",
+          available: true,
+        }),
+        expect.objectContaining({
+          id: "software_architecture",
+          artifact: SOFTWARE_ARCHITECTURE_PATH,
+          available: false,
+        }),
+        expect.objectContaining({
+          id: "brandbook",
+          artifact: ".agents/brand/brandbook.md",
+          available: false,
+        }),
+      ]),
+    });
+    expect(overview.metrics.map((metric) => metric.id)).toEqual([
+      "agents",
+      "squads",
+      "skills",
+      "rules",
+      "hooks",
+      "database",
+    ]);
+    expect(overview.metrics.map((metric) => metric.label)).toEqual([
+      "Agentes",
+      "Squads",
+      "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.areas.map((area) => area.id)).toEqual([
+      "software_architecture",
+      "design_system",
+      "brandbook",
+      "marketing_strategy",
+      "sales_playbook",
+      "growth_strategy",
+    ]);
+  });
 });