@codexa/cli 9.0.2 → 9.0.3

package/commands/decide.ts

@@ -1,17 +1,5 @@
 import { getDb } from "../db/connection";
-import { initSchema } from "../db/schema";
-
-function getNextDecisionId(specId: string): string {
-  const db = getDb();
-  const last = db
-    .query("SELECT id FROM decisions WHERE spec_id = ? ORDER BY created_at DESC LIMIT 1")
-    .get(specId) as any;
-
-  if (!last) return "DEC-001";
-
-  const num = parseInt(last.id.replace("DEC-", "")) + 1;
-  return `DEC-${num.toString().padStart(3, "0")}`;
-}
+import { initSchema, getNextDecisionId } from "../db/schema";
 
 interface ConflictAnalysis {
   hasConflict: boolean;
@@ -182,21 +170,33 @@ export function decide(title: string, decision: string, options: { rationale?: s
     .query("SELECT * FROM tasks WHERE spec_id = ? AND status = 'running' LIMIT 1")
     .get(spec.id) as any;
 
-  const decisionId = getNextDecisionId(spec.id);
-
-  db.run(
-    `INSERT INTO decisions (id, spec_id, task_ref, title, decision, rationale, status, created_at)
-     VALUES (?, ?, ?, ?, ?, ?, 'active', ?)`,
-    [
-      decisionId,
-      spec.id,
-      currentTask?.number || null,
-      title,
-      decision,
-      options.rationale || null,
-      now,
-    ]
-  );
+  let decisionId = "";
+  let retries = 3;
+  while (retries > 0) {
+    decisionId = getNextDecisionId(spec.id);
+    try {
+      db.run(
+        `INSERT INTO decisions (id, spec_id, task_ref, title, decision, rationale, status, created_at)
+         VALUES (?, ?, ?, ?, ?, ?, 'active', ?)`,
+        [
+          decisionId,
+          spec.id,
+          currentTask?.number || null,
+          title,
+          decision,
+          options.rationale || null,
+          now,
+        ]
+      );
+      break;
+    } catch (e: any) {
+      if (e.message?.includes("UNIQUE constraint") && retries > 1) {
+        retries--;
+        continue;
+      }
+      throw e;
+    }
+  }
 
   console.log(`\nDecisao registrada: ${decisionId}`);
   console.log(`Titulo: ${title}`);

package/commands/discover.ts

@@ -183,9 +183,9 @@ export function discoverConfirm(): void {
   // Mover de pending para default
   db.run("DELETE FROM project WHERE id = 'pending'");
   db.run(
-    `INSERT INTO project (id, name, stack, discovered_at, updated_at, cli_version)
-     VALUES ('default', ?, ?, ?, ?, ?)`,
-    ["Projeto", JSON.stringify(data.stack), now, now, pkg.version]
+    `INSERT INTO project (id, name, stack, discovered_at, updated_at, cli_version, last_discover_at)
+     VALUES ('default', ?, ?, ?, ?, ?, ?)`,
+    ["Projeto", JSON.stringify(data.stack), now, now, pkg.version, now]
   );
 
   // Criar standards baseados na estrutura detectada
@@ -460,6 +460,131 @@ export async function discoverRefresh(options: { force?: boolean } = {}): Promis
   }
 }
 
+export async function discoverIncremental(): Promise<void> {
+  initSchema();
+  const db = getDb();
+
+  const project = db.query("SELECT * FROM project WHERE id = 'default'").get() as any;
+  if (!project) {
+    console.error("\nProjeto nao descoberto.");
+    console.error("Execute: discover start primeiro\n");
+    process.exit(1);
+  }
+
+  // Data de referencia: last_discover_at > discovered_at > fallback 30 dias
+  const sinceDate = project.last_discover_at || project.discovered_at ||
+    new Date(Date.now() - 30 * 24 * 60 * 60 * 1000).toISOString();
+
+  console.log(`\nDiscover incremental desde: ${sinceDate}\n`);
+
+  // Listar arquivos modificados via git
+  const gitResult = spawnSync("git", [
+    "diff", "--name-only", "--diff-filter=ACMR",
+    `--since=${sinceDate}`, "HEAD"
+  ], { encoding: "utf-8", timeout: 10000 });
+
+  // Fallback: se --since nao funciona com diff, usar log
+  let modifiedFiles: string[] = [];
+  if (gitResult.status !== 0 || !gitResult.stdout.trim()) {
+    const logResult = spawnSync("git", [
+      "log", "--since", sinceDate, "--name-only", "--pretty=format:", "--diff-filter=ACMR"
+    ], { encoding: "utf-8", timeout: 10000 });
+
+    if (logResult.status === 0 && logResult.stdout.trim()) {
+      modifiedFiles = [...new Set(logResult.stdout.trim().split("\n").filter(f => f.trim()))];
+    }
+  } else {
+    modifiedFiles = [...new Set(gitResult.stdout.trim().split("\n").filter(f => f.trim()))];
+  }
+
+  // Filtrar apenas arquivos que ainda existem e sao codigo
+  const codeExtensions = [".ts", ".tsx", ".js", ".jsx", ".py", ".go", ".cs", ".dart"];
+  const existingFiles = modifiedFiles.filter(f => {
+    const fullPath = join(process.cwd(), f);
+    return existsSync(fullPath) && codeExtensions.some(ext => f.endsWith(ext));
+  });
+
+  if (existingFiles.length === 0) {
+    console.log("Nenhum arquivo de codigo modificado desde ultimo discover.");
+    console.log("Stack e utilities estao atualizados.\n");
+
+    // Atualizar timestamp mesmo sem mudancas
+    const now = new Date().toISOString();
+    db.run("UPDATE project SET last_discover_at = ? WHERE id = 'default'", [now]);
+    return;
+  }
+
+  console.log(`[1/3] Analisando ${existingFiles.length} arquivo(s) modificado(s)...`);
+
+  // Importar funcoes de patterns
+  const { extractUtilitiesFromFile, inferScopeFromPath } = await import("./patterns");
+  const { upsertUtility } = await import("../db/schema");
+
+  // Extrair utilities dos arquivos modificados
+  let utilitiesUpdated = 0;
+  for (const file of existingFiles) {
+    const fullPath = join(process.cwd(), file);
+    const utilities = extractUtilitiesFromFile(fullPath);
+    const scope = inferScopeFromPath(file);
+
+    for (const util of utilities) {
+      upsertUtility({
+        filePath: file,
+        utilityName: util.name,
+        utilityType: util.type,
+        scope,
+        signature: util.signature,
+      });
+      utilitiesUpdated++;
+    }
+  }
+
+  console.log(`    ✓ ${utilitiesUpdated} utilities registradas/atualizadas`);
+
+  // Re-detectar stack e comparar
+  console.log("\n[2/3] Verificando mudancas no stack...");
+  const currentStack = JSON.parse(project.stack);
+  const newStack = await detectStack();
+
+  const stackChanges: { key: string; from: string | undefined; to: string | undefined }[] = [];
+  const allKeys = new Set([...Object.keys(currentStack), ...Object.keys(newStack)]);
+
+  for (const key of allKeys) {
+    const current = currentStack[key as keyof StackDetection];
+    const detected = newStack[key as keyof StackDetection];
+    if (current !== detected) {
+      stackChanges.push({ key, from: current, to: detected });
+    }
+  }
+
+  if (stackChanges.length > 0) {
+    console.log("    ⚠ Mudancas detectadas no stack:");
+    for (const change of stackChanges) {
+      const from = change.from || "(nao definido)";
+      const to = change.to || "(removido)";
+      console.log(`      ${change.key}: ${from} → ${to}`);
+    }
+    console.log("    Use: discover refresh --force para aplicar");
+  } else {
+    console.log("    ✓ Stack inalterado");
+  }
+
+  // Atualizar timestamp
+  console.log("\n[3/3] Atualizando timestamp...");
+  const now = new Date().toISOString();
+  db.run("UPDATE project SET last_discover_at = ?, updated_at = ? WHERE id = 'default'", [now, now]);
+
+  // Resumo
+  console.log("\n" + "═".repeat(50));
+  console.log("DISCOVER INCREMENTAL CONCLUIDO");
+  console.log("═".repeat(50));
+  console.log(`  Arquivos analisados: ${existingFiles.length}`);
+  console.log(`  Utilities atualizadas: ${utilitiesUpdated}`);
+  console.log(`  Mudancas no stack: ${stackChanges.length}`);
+  console.log(`  Timestamp atualizado: ${now}`);
+  console.log("═".repeat(50) + "\n");
+}
+
 function generateStandardsMarkdown(): void {
   const db = getDb();
   const project = db.query("SELECT * FROM project WHERE id = 'default'").get() as any;

package/commands/knowledge.ts

@@ -1,5 +1,5 @@
 import { getDb } from "../db/connection";
-import { initSchema, getRelatedDecisions, getRelatedFiles, findContradictions } from "../db/schema";
+import { initSchema, getRelatedDecisions, getRelatedFiles } from "../db/schema";
 
 type KnowledgeCategory = "discovery" | "decision" | "blocker" | "pattern" | "constraint";
 type KnowledgeSeverity = "info" | "warning" | "critical";
@@ -233,7 +233,6 @@ export function getUnreadKnowledgeForTask(specId: string, taskId: number): any[]
 export function queryGraph(options: {
   file?: string;
   decision?: string;
-  contradictions?: boolean;
   json?: boolean;
 }): void {
   initSchema();
@@ -245,29 +244,6 @@ export function queryGraph(options: {
     process.exit(1);
   }
 
-  // Buscar contradicoes
-  if (options.contradictions) {
-    const contradictions = findContradictions(spec.id);
-
-    if (options.json) {
-      console.log(JSON.stringify({ contradictions }));
-      return;
-    }
-
-    if (contradictions.length === 0) {
-      console.log("\nNenhuma contradicao detectada.\n");
-      return;
-    }
-
-    console.log(`\nContradicoes detectadas (${contradictions.length}):`);
-    console.log(`${"─".repeat(50)}`);
-    for (const c of contradictions) {
-      console.log(`  [!] "${c.decision1}" <-> "${c.decision2}"`);
-      console.log(`      Detectada em: ${c.createdAt}\n`);
-    }
-    return;
-  }
-
   // Buscar relacoes para um arquivo
   if (options.file) {
     const decisions = getRelatedDecisions(options.file, "file");
@@ -357,8 +333,7 @@ export function queryGraph(options: {
   }
   console.log(`\nComandos:`);
   console.log(`  knowledge graph --file <path>           Relacoes de um arquivo`);
-  console.log(`  knowledge graph --decision <id>         Arquivos afetados por decisao`);
-  console.log(`  knowledge graph --contradictions        Detectar contradicoes\n`);
+  console.log(`  knowledge graph --decision <id>         Arquivos afetados por decisao\n`);
 }
 
 // v9.0: Resolver/reconhecer knowledge critico (para desbloquear task start)

package/commands/patterns.test.ts

@@ -0,0 +1,169 @@
+import { describe, it, expect, afterAll } from "bun:test";
+import { extractUtilitiesFromFile, inferScopeFromPath } from "./patterns";
+import { writeFileSync, mkdirSync, rmSync } from "fs";
+import { join } from "path";
+
+const TMP_DIR = join(import.meta.dir, "__test_tmp__");
+
+function setupTmpDir() {
+  mkdirSync(TMP_DIR, { recursive: true });
+}
+
+function cleanTmpDir() {
+  try { rmSync(TMP_DIR, { recursive: true }); } catch {}
+}
+
+function writeTmpFile(name: string, content: string): string {
+  setupTmpDir();
+  const path = join(TMP_DIR, name);
+  writeFileSync(path, content);
+  return path;
+}
+
+describe("extractUtilitiesFromFile", () => {
+  afterAll(() => cleanTmpDir());
+
+  it("extracts exported function", () => {
+    const path = writeTmpFile("func.ts", 'export function createUser(name: string): User {\n  return { name };\n}');
+    const utils = extractUtilitiesFromFile(path);
+    expect(utils).toHaveLength(1);
+    expect(utils[0].name).toBe("createUser");
+    expect(utils[0].type).toBe("function");
+    expect(utils[0].signature).toContain("(name: string)");
+  });
+
+  it("extracts exported async function", () => {
+    const path = writeTmpFile("async.ts", 'export async function fetchData(url: string): Promise<Data> {\n  return await fetch(url);\n}');
+    const utils = extractUtilitiesFromFile(path);
+    expect(utils).toHaveLength(1);
+    expect(utils[0].name).toBe("fetchData");
+    expect(utils[0].type).toBe("function");
+  });
+
+  it("extracts exported const", () => {
+    const path = writeTmpFile("const.ts", 'export const MAX_RETRIES: number = 3;');
+    const utils = extractUtilitiesFromFile(path);
+    expect(utils).toHaveLength(1);
+    expect(utils[0].name).toBe("MAX_RETRIES");
+    expect(utils[0].type).toBe("const");
+    expect(utils[0].signature).toBe("number");
+  });
+
+  it("extracts exported const without type annotation", () => {
+    const path = writeTmpFile("const2.ts", 'export const config = { port: 3000 };');
+    const utils = extractUtilitiesFromFile(path);
+    expect(utils).toHaveLength(1);
+    expect(utils[0].name).toBe("config");
+    expect(utils[0].type).toBe("const");
+  });
+
+  it("extracts exported class", () => {
+    const path = writeTmpFile("class.ts", 'export class UserService {\n  constructor() {}\n}');
+    const utils = extractUtilitiesFromFile(path);
+    expect(utils).toHaveLength(1);
+    expect(utils[0].name).toBe("UserService");
+    expect(utils[0].type).toBe("class");
+  });
+
+  it("extracts exported interface", () => {
+    const path = writeTmpFile("iface.ts", 'export interface UserProps {\n  name: string;\n}');
+    const utils = extractUtilitiesFromFile(path);
+    expect(utils).toHaveLength(1);
+    expect(utils[0].name).toBe("UserProps");
+    expect(utils[0].type).toBe("interface");
+  });
+
+  it("extracts exported type", () => {
+    const path = writeTmpFile("type.ts", 'export type Status = "active" | "inactive";');
+    const utils = extractUtilitiesFromFile(path);
+    expect(utils).toHaveLength(1);
+    expect(utils[0].name).toBe("Status");
+    expect(utils[0].type).toBe("type");
+  });
+
+  it("extracts multiple exports from one file", () => {
+    const path = writeTmpFile("multi.ts", [
+      'export function foo() {}',
+      'export const BAR = 1;',
+      'export class Baz {}',
+      'export interface Qux {}',
+      'export type Quux = string;',
+    ].join("\n"));
+    const utils = extractUtilitiesFromFile(path);
+    expect(utils).toHaveLength(5);
+    expect(utils.map(u => u.name)).toEqual(["foo", "BAR", "Baz", "Qux", "Quux"]);
+  });
+
+  it("returns empty array for non-existent file", () => {
+    const utils = extractUtilitiesFromFile("/nonexistent/path.ts");
+    expect(utils).toEqual([]);
+  });
+
+  it("returns empty array for file without exports", () => {
+    const path = writeTmpFile("noexport.ts", 'const internal = 1;\nfunction helper() {}');
+    const utils = extractUtilitiesFromFile(path);
+    expect(utils).toEqual([]);
+  });
+
+  it("ignores non-export declarations", () => {
+    const path = writeTmpFile("mixed.ts", [
+      'const private1 = 1;',
+      'function private2() {}',
+      'export function public1() {}',
+    ].join("\n"));
+    const utils = extractUtilitiesFromFile(path);
+    expect(utils).toHaveLength(1);
+    expect(utils[0].name).toBe("public1");
+  });
+});
+
+describe("inferScopeFromPath", () => {
+  it("identifies backend paths", () => {
+    expect(inferScopeFromPath("src/app/api/users/route.ts")).toBe("backend");
+    expect(inferScopeFromPath("src/server/index.ts")).toBe("backend");
+    expect(inferScopeFromPath("src/backend/auth.ts")).toBe("backend");
+    expect(inferScopeFromPath("src/services/user.ts")).toBe("backend");
+    expect(inferScopeFromPath("src/actions/submit.ts")).toBe("backend");
+  });
+
+  it("identifies frontend paths", () => {
+    expect(inferScopeFromPath("src/components/Button.tsx")).toBe("frontend");
+    expect(inferScopeFromPath("src/hooks/useAuth.ts")).toBe("frontend");
+    expect(inferScopeFromPath("src/pages/index.tsx")).toBe("frontend");
+    expect(inferScopeFromPath("src/frontend/App.tsx")).toBe("frontend");
+  });
+
+  it("identifies frontend for /app/ paths without /api/", () => {
+    expect(inferScopeFromPath("src/app/dashboard/page.tsx")).toBe("frontend");
+  });
+
+  it("identifies database paths", () => {
+    expect(inferScopeFromPath("src/db/schema.ts")).toBe("database");
+    expect(inferScopeFromPath("src/schema/users.ts")).toBe("database");
+    expect(inferScopeFromPath("src/migrations/001.sql")).toBe("database");
+    expect(inferScopeFromPath("src/database/connection.ts")).toBe("database");
+  });
+
+  it("identifies testing paths", () => {
+    expect(inferScopeFromPath("src/tests/user.test.ts")).toBe("testing");
+    // Note: /components/ matches frontend before .test. matches testing
+    expect(inferScopeFromPath("src/components/Button.test.tsx")).toBe("frontend");
+    expect(inferScopeFromPath("src/lib/auth.spec.ts")).toBe("testing");
+  });
+
+  it("returns shared for unrecognized paths", () => {
+    expect(inferScopeFromPath("src/lib/utils.ts")).toBe("shared");
+    expect(inferScopeFromPath("src/config/env.ts")).toBe("shared");
+    expect(inferScopeFromPath("package.json")).toBe("shared");
+  });
+
+  it("handles Windows-style paths (backslashes)", () => {
+    expect(inferScopeFromPath("src\\components\\Button.tsx")).toBe("frontend");
+    expect(inferScopeFromPath("src\\db\\schema.ts")).toBe("database");
+  });
+
+  it("is case-insensitive", () => {
+    expect(inferScopeFromPath("src/Components/Button.tsx")).toBe("frontend");
+    expect(inferScopeFromPath("src/DB/Schema.ts")).toBe("database");
+  });
+});

package/commands/plan.test.ts

@@ -0,0 +1,73 @@
+import { describe, it, expect } from "bun:test";
+import { generateSpecId } from "./plan";
+
+describe("generateSpecId", () => {
+  it("generates ID with date-slug-hash format", () => {
+    const id = generateSpecId("Add user authentication");
+    // Format: YYYY-MM-DD-slug-hash
+    expect(id).toMatch(/^\d{4}-\d{2}-\d{2}-[a-z0-9-]+-[a-z0-9]{4}$/);
+  });
+
+  it("normalizes slug to lowercase", () => {
+    const id = generateSpecId("Add User Auth");
+    const parts = id.split("-");
+    // After date (3 parts), all slug parts should be lowercase
+    const slugAndHash = parts.slice(3).join("-");
+    expect(slugAndHash).toBe(slugAndHash.toLowerCase());
+  });
+
+  it("removes special characters from slug", () => {
+    const id = generateSpecId("Add auth (v2) @special!");
+    // Should not contain (, ), @, !
+    expect(id).not.toMatch(/[()@!]/);
+  });
+
+  it("truncates slug at 30 characters", () => {
+    const longName = "This is a very long feature name that exceeds thirty characters by a lot";
+    const id = generateSpecId(longName);
+    // Date is YYYY-MM-DD (10 chars) + dash + slug (max 30) + dash + hash (4)
+    const parts = id.split("-");
+    // date = parts[0]-parts[1]-parts[2], hash = last part
+    const datePart = parts.slice(0, 3).join("-"); // YYYY-MM-DD
+    const hashPart = parts[parts.length - 1]; // 4 char hash
+    const slugPart = parts.slice(3, -1).join("-"); // everything between date and hash
+    expect(slugPart.length).toBeLessThanOrEqual(30);
+  });
+
+  it("includes a 4-character hash suffix", () => {
+    const id = generateSpecId("Test feature");
+    const parts = id.split("-");
+    const hash = parts[parts.length - 1];
+    expect(hash.length).toBe(4);
+    // Hash should be base36
+    expect(hash).toMatch(/^[a-z0-9]+$/);
+  });
+
+  it("starts with today's date", () => {
+    const id = generateSpecId("Some feature");
+    const today = new Date().toISOString().split("T")[0];
+    expect(id.startsWith(today)).toBe(true);
+  });
+
+  it("generates different IDs for different names", () => {
+    const id1 = generateSpecId("Feature A");
+    const id2 = generateSpecId("Feature B");
+    expect(id1).not.toBe(id2);
+  });
+
+  it("removes trailing dashes from slug", () => {
+    const id = generateSpecId("test-feature-");
+    // Should not have double dashes or trailing dash before hash
+    expect(id).not.toMatch(/--/);
+  });
+
+  it("handles empty-ish name gracefully", () => {
+    const id = generateSpecId("a");
+    expect(id).toMatch(/^\d{4}-\d{2}-\d{2}-a-[a-z0-9]{4}$/);
+  });
+
+  it("converts spaces and special chars to dashes", () => {
+    const id = generateSpecId("add user auth");
+    expect(id).toContain("add-user-auth");
+  });
+});

package/commands/plan.ts

@@ -1,13 +1,15 @@
 import { getDb } from "../db/connection";
 import { initSchema, getArchitecturalAnalysisForSpec } from "../db/schema";
 
-function generateSpecId(name: string): string {
+export function generateSpecId(name: string): string {
     const date = new Date().toISOString().split("T")[0];
     const slug = name
         .toLowerCase()
         .replace(/[^a-z0-9]+/g, "-")
+        .replace(/-+$/, "")
         .substring(0, 30);
-    return `${date}-${slug}`;
+    const hash = Bun.hash(name + Date.now()).toString(36).substring(0, 4);
+    return `${date}-${slug}-${hash}`;
 }
 
 // v8.4: Suporte a --from-analysis para import automatico de baby steps

package/commands/sync.ts

@@ -0,0 +1,90 @@
+import { execSync } from "child_process";
+import { existsSync, mkdirSync, copyFileSync, readdirSync, readFileSync } from "fs";
+import { join } from "path";
+
+// Agents que sao referencias (nao spawnables como subagent_type)
+const REFERENCE_FILES = new Set([
+  "common-directives.md",
+  "subagent-return-protocol.md",
+]);
+
+function findPluginAgentsDir(): string | null {
+  // 1. Dev repo: git root + plugins/codexa-workflow/agents/
+  try {
+    const gitRoot = execSync("git rev-parse --show-toplevel", { encoding: "utf-8" }).trim();
+    const pluginDir = join(gitRoot, "plugins", "codexa-workflow", "agents");
+    if (existsSync(pluginDir)) return pluginDir;
+  } catch {
+    // Not in git repo
+  }
+
+  // 2. Global install: resolve from @codexa/cli package location
+  try {
+    const cliPath = execSync("bun pm ls -g 2>/dev/null || npm list -g @codexa/cli --parseable 2>/dev/null", {
+      encoding: "utf-8",
+    }).trim();
+    if (cliPath) {
+      // Navigate from cli package to sibling plugin
+      const lines = cliPath.split("\n").filter(l => l.includes("codexa"));
+      for (const line of lines) {
+        const trimmed = line.trim();
+        // Try parent paths to find the monorepo root
+        const parts = trimmed.split(/[/\\]/);
+        for (let i = parts.length - 1; i >= 0; i--) {
+          const candidate = join(parts.slice(0, i + 1).join("/"), "plugins", "codexa-workflow", "agents");
+          if (existsSync(candidate)) return candidate;
+        }
+      }
+    }
+  } catch {
+    // Package manager not available
+  }
+
+  return null;
+}
+
+export function syncAgents(options: { force?: boolean } = {}): void {
+  const pluginDir = findPluginAgentsDir();
+
+  if (!pluginDir) {
+    console.error("\n[ERRO] Diretorio de agents do plugin nao encontrado.");
+    console.error("  Verifique se voce esta no repositorio codexa ou se @codexa/cli esta instalado globalmente.\n");
+    process.exit(1);
+  }
+
+  const targetDir = join(process.cwd(), ".claude", "agents");
+  mkdirSync(targetDir, { recursive: true });
+
+  const agentFiles = readdirSync(pluginDir).filter(
+    (f) => f.endsWith(".md") && !REFERENCE_FILES.has(f)
+  );
+
+  let copied = 0;
+  let skipped = 0;
+
+  for (const file of agentFiles) {
+    const src = join(pluginDir, file);
+    const dst = join(targetDir, file);
+
+    if (existsSync(dst) && !options.force) {
+      skipped++;
+      continue;
+    }
+
+    copyFileSync(src, dst);
+    copied++;
+  }
+
+  console.log(`\n[OK] Agents sincronizados para .claude/agents/`);
+  console.log(`  Copiados: ${copied}`);
+  if (skipped > 0) {
+    console.log(`  Ignorados (ja existem): ${skipped} — use --force para sobrescrever`);
+  }
+  console.log(`  Total disponivel: ${agentFiles.length}`);
+  console.log(`\nAgents disponiveis como subagent_type:`);
+  for (const file of agentFiles) {
+    const name = file.replace(".md", "");
+    console.log(`  - ${name}`);
+  }
+  console.log();
+}