legacy-squad 1.0.1 → 1.2.0

package/dist/cli.mjs

@@ -2,7 +2,7 @@
 
 // apps/cli/src/index.ts
 import { Command } from "commander";
-import path8 from "node:path";
+import path9 from "node:path";
 import { existsSync } from "node:fs";
 import { fileURLToPath } from "node:url";
 
@@ -224,13 +224,89 @@ var ALL_AGENTS = [
   MODERNIZATION_AGENT
 ];
 
+// packages/agents/src/findings-writer.ts
+import path from "node:path";
+
+// packages/core/src/paths.ts
+function toPosix(p) {
+  return p.replace(/\\/g, "/");
+}
+
+// packages/agents/src/findings-writer.ts
+var FINDINGS_DIR = "findings";
+var INDEX_FILE = "index.json";
+var FindingsWriter = class {
+  /**
+   * @param fs Porta de escrita injetada; implementação concreta na camada externa.
+   */
+  constructor(fs) {
+    this.fs = fs;
+  }
+  fs;
+  /**
+   * Particiona e grava os findings:
+   * - `findings/index.json`: lista slim (id, pillar, severity, title, priority);
+   * - `findings/<pilar>.json`: findings completos do pilar. Pilar sem achados
+   *   não gera arquivo.
+   *
+   * O `index.json` é sempre gravado (mesmo vazio): é o ponto de entrada que
+   * sinaliza a nova estrutura para o `doctor.ts` e para os geradores.
+   *
+   * @param findings Findings consolidados pelo Compliance Engine.
+   * @param memoryDir Caminho de `.legacy-squad/memory` (nativo do SO; normalizado
+   *   para POSIX na escrita — ver DA-006).
+   * @returns Promise resolvida quando todos os arquivos foram gravados.
+   */
+  async write(findings, memoryDir) {
+    const findingsDir = toPosix(path.join(memoryDir, FINDINGS_DIR));
+    await this.fs.mkdir(findingsDir);
+    const index = findings.map((finding) => ({
+      id: finding.id,
+      pillar: finding.pillar,
+      severity: finding.severity,
+      title: finding.title,
+      priority: finding.priority
+    }));
+    await this.fs.writeFile(
+      toPosix(path.join(findingsDir, INDEX_FILE)),
+      JSON.stringify(index, null, 2)
+    );
+    for (const [pillar, pillarFindings] of this.groupByPillar(findings)) {
+      await this.fs.writeFile(
+        toPosix(path.join(findingsDir, this.pillarToFileName(pillar))),
+        JSON.stringify(pillarFindings, null, 2)
+      );
+    }
+  }
+  /** Agrupa os findings por pilar, preservando a ordem de inserção. */
+  groupByPillar(findings) {
+    const byPillar = /* @__PURE__ */ new Map();
+    for (const finding of findings) {
+      const bucket = byPillar.get(finding.pillar);
+      if (bucket) {
+        bucket.push(finding);
+      } else {
+        byPillar.set(finding.pillar, [finding]);
+      }
+    }
+    return byPillar;
+  }
+  /**
+   * Converte o pilar (enum com `_`) no nome do arquivo (com `-`).
+   * Ex.: `legacy_code` → `legacy-code.json`.
+   */
+  pillarToFileName(pillar) {
+    return `${pillar.replace(/_/g, "-")}.json`;
+  }
+};
+
 // packages/agents/src/installer.ts
-import { writeFile, mkdir, readFile as readFile2 } from "node:fs/promises";
-import path6 from "node:path";
+import { writeFile as writeFile2, mkdir as mkdir2, readFile as readFile2 } from "node:fs/promises";
+import path7 from "node:path";
 
 // packages/scanner/src/node-filesystem.ts
-import { readdir, readFile, stat } from "node:fs/promises";
-import path from "node:path";
+import { readdir, readFile, stat, mkdir, writeFile } from "node:fs/promises";
+import path2 from "node:path";
 var IGNORED_DIRS = /* @__PURE__ */ new Set([
   "node_modules",
   ".git",
@@ -248,7 +324,7 @@ var IGNORED_DIRS = /* @__PURE__ */ new Set([
 var NodeFileSystem = class {
   async readDir(dirPath) {
     const entries = await readdir(dirPath, { withFileTypes: true });
-    return entries.filter((e) => !IGNORED_DIRS.has(e.name)).map((e) => path.join(dirPath, e.name));
+    return entries.filter((e) => !IGNORED_DIRS.has(e.name)).map((e) => path2.join(dirPath, e.name));
   }
   async readFile(filePath) {
     return readFile(filePath, "utf-8");
@@ -270,11 +346,25 @@ var NodeFileSystem = class {
     await this.walkForGlob(rootPath, pattern, results);
     return results;
   }
+  /**
+   * Garante a existência do diretório criando todos os intermediários.
+   * Idempotente — não lança se o diretório já existir.
+   */
+  async mkdir(dirPath) {
+    await mkdir(dirPath, { recursive: true });
+  }
+  /**
+   * Escreve (sobrescrevendo) o arquivo com `content` em UTF-8.
+   * Pré-condição: o diretório-pai deve existir — chame `mkdir` antes.
+   */
+  async writeFile(filePath, content) {
+    await writeFile(filePath, content, "utf-8");
+  }
   async walkForGlob(dir, pattern, results) {
     const entries = await readdir(dir, { withFileTypes: true });
     for (const entry of entries) {
       if (IGNORED_DIRS.has(entry.name)) continue;
-      const fullPath = path.join(dir, entry.name);
+      const fullPath = path2.join(dir, entry.name);
       if (entry.isDirectory()) {
         await this.walkForGlob(fullPath, pattern, results);
       } else if (entry.name.match(pattern)) {
@@ -285,10 +375,10 @@ var NodeFileSystem = class {
 };
 
 // packages/scanner/src/repo-scanner.ts
-import path3 from "node:path";
+import path4 from "node:path";
 
 // packages/scanner/src/stack-detector.ts
-import path2 from "node:path";
+import path3 from "node:path";
 var packageJsonDetector = {
   filename: "package.json",
   detect(content, filePath) {
@@ -351,7 +441,7 @@ var packageJsonDetector = {
       stack,
       dependencies,
       projectType,
-      projectName: pkg.name ?? path2.basename(path2.dirname(filePath))
+      projectName: pkg.name ?? path3.basename(path3.dirname(filePath))
     };
   }
 };
@@ -409,7 +499,7 @@ var csprojDetector = {
         stack.push({ name: "asp.net", type: "framework", version: match[2], source: filePath });
       }
     }
-    return { stack, dependencies, projectType: "backend", projectName: path2.basename(filePath, ".csproj") };
+    return { stack, dependencies, projectType: "backend", projectName: path3.basename(filePath, ".csproj") };
   }
 };
 var pomXmlDetector = {
@@ -459,7 +549,7 @@ async function detectFromManifests(rootPath, fs) {
       }
       continue;
     }
-    const manifestPath = path2.join(rootPath, detector.filename);
+    const manifestPath = path3.join(rootPath, detector.filename);
     if (await fs.exists(manifestPath)) {
       const content = await fs.readFile(manifestPath);
       return detector.detect(content, manifestPath);
@@ -488,7 +578,7 @@ async function detectFromExtensions(rootPath, fs) {
 }
 
 // packages/scanner/src/repo-scanner.ts
-function toPosix(p) {
+function toPosix2(p) {
   return p.replace(/\\/g, "/");
 }
 var SOURCE_EXTENSIONS = /\.(tsx?|jsx?|php|cs|java|py|dart|vue|svelte)$/;
@@ -504,7 +594,7 @@ var RepoScanner = class {
     if (stack.length === 0) {
       stack = await detectFromExtensions(effectiveRoot, this.fs);
     }
-    const projectName = manifestResult?.projectName ?? path3.basename(effectiveRoot);
+    const projectName = manifestResult?.projectName ?? path4.basename(effectiveRoot);
     const projectType = manifestResult?.projectType ?? "backend";
     const dependencies = manifestResult?.dependencies ?? [];
     const sourceFiles = await this.collectSourceFiles(effectiveRoot);
@@ -568,7 +658,7 @@ var RepoScanner = class {
   detectModules(rootPath, files) {
     const moduleMap = /* @__PURE__ */ new Map();
     for (const file of files) {
-      const relative = toPosix(path3.relative(rootPath, file));
+      const relative = toPosix2(path4.relative(rootPath, file));
       const parts = relative.split("/");
       if (parts.length >= 2) {
         const moduleKey = parts.slice(0, 2).join("/");
@@ -578,7 +668,7 @@ var RepoScanner = class {
       }
     }
     return Array.from(moduleMap.entries()).map(([modulePath, moduleFiles]) => ({
-      name: path3.basename(modulePath),
+      name: path4.basename(modulePath),
       path: modulePath,
       type: "module",
       filesCount: moduleFiles.length,
@@ -589,7 +679,7 @@ var RepoScanner = class {
     const entrypoints = [];
     if (projectType === "mobile") {
       for (const file of files) {
-        const relative = toPosix(path3.relative(rootPath, file));
+        const relative = toPosix2(path4.relative(rootPath, file));
         if (relative.match(/src\/screens\/[^/]+\/index\.(tsx?|jsx?)$/)) {
           const screenName = relative.split("/").slice(-2, -1)[0];
           entrypoints.push({
@@ -602,11 +692,11 @@ var RepoScanner = class {
       }
     }
     for (const file of files) {
-      const relative = toPosix(path3.relative(rootPath, file));
+      const relative = toPosix2(path4.relative(rootPath, file));
       if (relative.match(/^(index|main|App)\.(tsx?|jsx?|js)$/)) {
         entrypoints.push({
           type: "component",
-          name: path3.basename(relative),
+          name: path4.basename(relative),
           path: relative,
           method: "main"
         });
@@ -620,7 +710,7 @@ var RepoScanner = class {
     for (const file of files) {
       try {
         const content = await this.fs.readFile(file);
-        const relative = toPosix(path3.relative(rootPath, file));
+        const relative = toPosix2(path4.relative(rootPath, file));
         const urlMatches = content.matchAll(/https?:\/\/[^\s'"`,)]+/g);
         for (const match of urlMatches) {
           const url = match[0];
@@ -659,7 +749,7 @@ var RepoScanner = class {
     for (const file of files) {
       try {
         const s = await this.fs.stat(file);
-        const relative = toPosix(path3.relative(rootPath, file));
+        const relative = toPosix2(path4.relative(rootPath, file));
         if (s.size > LARGE_FILE_THRESHOLD) {
           hotspots.push({
             path: relative,
@@ -675,8 +765,8 @@ var RepoScanner = class {
 };
 
 // packages/context/src/context-builder.ts
-import path4 from "node:path";
-function toPosix2(p) {
+import path5 from "node:path";
+function toPosix3(p) {
   return p.replace(/\\/g, "/");
 }
 var TOKENS_PER_CHAR = 0.25;
@@ -694,12 +784,12 @@ var ContextBuilder = class {
     return packs;
   }
   async buildModulePack(rootPath, moduleName, modulePath, repoIndex) {
-    const fullModulePath = path4.join(rootPath, modulePath);
+    const fullModulePath = path5.join(rootPath, modulePath);
     let keyFiles = [];
     let totalSize = 0;
     try {
       const files = await this.fs.glob(fullModulePath, "\\.(tsx?|jsx?|php|cs|java)$");
-      keyFiles = files.map((f) => toPosix2(path4.relative(rootPath, f))).slice(0, 10);
+      keyFiles = files.map((f) => toPosix3(path5.relative(rootPath, f))).slice(0, 10);
       for (const file of files.slice(0, 10)) {
         try {
           const stat3 = await this.fs.stat(file);
@@ -725,7 +815,7 @@ var ContextBuilder = class {
 };
 
 // packages/rules/src/compliance-engine.ts
-import path5 from "node:path";
+import path6 from "node:path";
 
 // packages/rules/src/rule-catalog.ts
 var BACKEND_LANGUAGES = [
@@ -1029,9 +1119,6 @@ var CODE_QUALITY_RULES = [
 var ALL_RULES = [...SECURITY_RULES, ...CODE_QUALITY_RULES];
 
 // packages/rules/src/compliance-engine.ts
-function toPosix3(p) {
-  return p.replace(/\\/g, "/");
-}
 var SEVERITY_TO_PRIORITY = {
   critical: "P0",
   high: "P1",
@@ -1089,7 +1176,7 @@ var ComplianceEngine = class {
       try {
         const content = await this.fs.readFile(file);
         const lines = content.split("\n");
-        const relative = toPosix3(path5.relative(rootPath, file));
+        const relative = toPosix(path6.relative(rootPath, file));
         for (const pattern of rule.detection.patterns) {
           const regex = new RegExp(pattern, "gi");
           for (let i = 0; i < lines.length; i++) {
@@ -1124,7 +1211,7 @@ var ComplianceEngine = class {
     for (const pattern of rule.detection.patterns) {
       const matchingFiles = await this.fs.glob(rootPath, pattern);
       for (const file of matchingFiles) {
-        const relative = toPosix3(path5.relative(rootPath, file));
+        const relative = toPosix(path6.relative(rootPath, file));
         allEvidence.push({
           file: relative,
           line: 0,
@@ -1162,7 +1249,7 @@ var ComplianceEngine = class {
       pillar: rule.category,
       severity: rule.severity,
       evidence: jsFiles.slice(0, 5).map((f) => ({
-        file: toPosix3(path5.relative(rootPath, f)),
+        file: toPosix(path6.relative(rootPath, f)),
         line: 0,
         snippet: "JavaScript file in a TypeScript project"
       })),
@@ -1201,16 +1288,16 @@ var Installer = class {
     const findings = await compliance.evaluate(effectiveRoot, repoIndex);
     const contextBuilder = new ContextBuilder(fs);
     const contextPacks = await contextBuilder.buildPacks(effectiveRoot, repoIndex);
-    const memoryDir = path6.join(effectiveRoot, ".legacy-squad", "memory");
-    await mkdir(memoryDir, { recursive: true });
-    const repoIndexPath = path6.join(memoryDir, "repo-index.json");
-    const findingsPath = path6.join(memoryDir, "findings.json");
-    const contextPacksPath = path6.join(memoryDir, "context-packs.json");
-    await writeFile(repoIndexPath, JSON.stringify(repoIndex, null, 2), "utf-8");
-    await writeFile(findingsPath, JSON.stringify(findings, null, 2), "utf-8");
-    await writeFile(contextPacksPath, JSON.stringify(contextPacks, null, 2), "utf-8");
-    const configDir = path6.join(effectiveRoot, ".legacy-squad", "config");
-    await mkdir(configDir, { recursive: true });
+    const memoryDir = path7.join(effectiveRoot, ".legacy-squad", "memory");
+    await mkdir2(memoryDir, { recursive: true });
+    const repoIndexPath = path7.join(memoryDir, "repo-index.json");
+    const findingsPath = path7.join(memoryDir, "findings", "index.json");
+    const contextPacksPath = path7.join(memoryDir, "context-packs.json");
+    await writeFile2(repoIndexPath, JSON.stringify(repoIndex, null, 2), "utf-8");
+    await new FindingsWriter(fs).write(findings, memoryDir);
+    await writeFile2(contextPacksPath, JSON.stringify(contextPacks, null, 2), "utf-8");
+    const configDir = path7.join(effectiveRoot, ".legacy-squad", "config");
+    await mkdir2(configDir, { recursive: true });
     const projectConfig = {
       project: {
         name: repoIndex.project.name,
@@ -1231,18 +1318,18 @@ var Installer = class {
       mode: { execution: "read_only" },
       ide: { primary: "claude-code" },
       installed_at: (/* @__PURE__ */ new Date()).toISOString(),
-      framework_version: "1.0.0"
+      framework_version: "1.2.0"
     };
-    await writeFile(
-      path6.join(configDir, "project.yaml"),
+    await writeFile2(
+      path7.join(configDir, "project.yaml"),
       this.toYaml(projectConfig),
       "utf-8"
     );
-    await mkdir(path6.join(effectiveRoot, ".legacy-squad", "outputs", "reports"), { recursive: true });
-    await mkdir(path6.join(effectiveRoot, ".legacy-squad", "outputs", "assessments"), { recursive: true });
-    await mkdir(path6.join(effectiveRoot, ".legacy-squad", "logs"), { recursive: true });
-    const claudeCommandsDir = path6.join(effectiveRoot, ".claude", "commands", "legacy-squad");
-    await mkdir(claudeCommandsDir, { recursive: true });
+    await mkdir2(path7.join(effectiveRoot, ".legacy-squad", "outputs", "reports"), { recursive: true });
+    await mkdir2(path7.join(effectiveRoot, ".legacy-squad", "outputs", "assessments"), { recursive: true });
+    await mkdir2(path7.join(effectiveRoot, ".legacy-squad", "logs"), { recursive: true });
+    const claudeCommandsDir = path7.join(effectiveRoot, ".claude", "commands", "legacy-squad");
+    await mkdir2(claudeCommandsDir, { recursive: true });
     await this.copySlashCommands(templateDir, claudeCommandsDir);
     await this.generateAgentsMd(effectiveRoot, repoIndex.project.name);
     const logContent = [
@@ -1259,8 +1346,8 @@ var Installer = class {
       `Requested root: ${projectRoot}`,
       `Effective root:  ${effectiveRoot}`
     ].join("\n");
-    await writeFile(
-      path6.join(effectiveRoot, ".legacy-squad", "logs", "install.log"),
+    await writeFile2(
+      path7.join(effectiveRoot, ".legacy-squad", "logs", "install.log"),
       logContent,
       "utf-8"
     );
@@ -1294,11 +1381,11 @@ var Installer = class {
       "scan.md"
     ];
     for (const file of commandFiles) {
-      const sourcePath = path6.join(templateDir, file);
-      const targetPath = path6.join(targetDir, file);
+      const sourcePath = path7.join(templateDir, file);
+      const targetPath = path7.join(targetDir, file);
       try {
         const content = await readFile2(sourcePath, "utf-8");
-        await writeFile(targetPath, content, "utf-8");
+        await writeFile2(targetPath, content, "utf-8");
       } catch {
       }
     }
@@ -1321,7 +1408,7 @@ var Installer = class {
       lines.push("Leia `.legacy-squad/memory/` para contexto e produza o assessment em `.legacy-squad/outputs/assessments/`.");
       lines.push("");
     }
-    await writeFile(path6.join(projectRoot, "AGENTS.md"), lines.join("\n"), "utf-8");
+    await writeFile2(path7.join(projectRoot, "AGENTS.md"), lines.join("\n"), "utf-8");
   }
   toYaml(obj, indent = 0) {
     const lines = [];
@@ -1346,12 +1433,12 @@ var Installer = class {
 
 // packages/agents/src/doctor.ts
 import { stat as stat2 } from "node:fs/promises";
-import path7 from "node:path";
+import path8 from "node:path";
 var Doctor = class {
   async check(projectRoot) {
     const checks = [];
     checks.push(await this.checkFile(projectRoot, ".legacy-squad/memory/repo-index.json", "Repo Index"));
-    checks.push(await this.checkFile(projectRoot, ".legacy-squad/memory/findings.json", "Findings"));
+    checks.push(await this.checkFindingsStructure(projectRoot));
     checks.push(await this.checkFile(projectRoot, ".legacy-squad/memory/context-packs.json", "Context Packs"));
     checks.push(await this.checkFile(projectRoot, ".legacy-squad/config/project.yaml", "Project Config"));
     checks.push(await this.checkDir(projectRoot, ".claude/commands/legacy-squad", "Claude Code Agents"));
@@ -1360,9 +1447,43 @@ var Doctor = class {
     checks.push(await this.checkDir(projectRoot, ".legacy-squad/outputs/reports", "Reports Dir"));
     return checks;
   }
+  /**
+   * Verifica a estrutura de findings conforme DA-011:
+   * - `findings/index.json` presente → ok (estrutura particionada)
+   * - `findings.json` presente sem `findings/` → error com orientação de re-install
+   * - Nenhum dos dois → error (não instalado)
+   */
+  async checkFindingsStructure(root) {
+    const indexPath = path8.join(root, ".legacy-squad", "memory", "findings", "index.json");
+    const legacyPath = path8.join(root, ".legacy-squad", "memory", "findings.json");
+    if (await this.pathExists(indexPath)) {
+      return { name: "Findings", status: "ok", message: ".legacy-squad/memory/findings/index.json \u2713" };
+    }
+    if (await this.pathExists(legacyPath)) {
+      return {
+        name: "Findings",
+        status: "error",
+        message: "Estrutura legada detectada (.legacy-squad/memory/findings.json). Execute npx legacy-squad install para regenerar na estrutura particionada (DA-011). A migra\xE7\xE3o n\xE3o \xE9 autom\xE1tica \u2014 nenhum dado foi alterado."
+      };
+    }
+    return {
+      name: "Findings",
+      status: "error",
+      message: ".legacy-squad/memory/findings/index.json not found"
+    };
+  }
+  /** Retorna true se o path existir (arquivo ou diretório), false caso contrário. */
+  async pathExists(fullPath) {
+    try {
+      await stat2(fullPath);
+      return true;
+    } catch {
+      return false;
+    }
+  }
   async checkFile(root, relativePath, label) {
     try {
-      const fullPath = path7.join(root, relativePath);
+      const fullPath = path8.join(root, relativePath);
       const s = await stat2(fullPath);
       if (s.size === 0) {
         return { name: label, status: "warning", message: `${relativePath} exists but is empty` };
@@ -1374,7 +1495,7 @@ var Doctor = class {
   }
   async checkDir(root, relativePath, label) {
     try {
-      const fullPath = path7.join(root, relativePath);
+      const fullPath = path8.join(root, relativePath);
       const s = await stat2(fullPath);
       if (!s.isDirectory()) {
         return { name: label, status: "error", message: `${relativePath} is not a directory` };
@@ -1389,16 +1510,16 @@ var Doctor = class {
 // apps/cli/src/index.ts
 var program = new Command();
 function getTemplateDir() {
-  const cliDir = path8.dirname(fileURLToPath(import.meta.url));
-  const bundledPath = path8.resolve(cliDir, "templates", "claude-commands");
+  const cliDir = path9.dirname(fileURLToPath(import.meta.url));
+  const bundledPath = path9.resolve(cliDir, "templates", "claude-commands");
   if (existsSync(bundledPath)) return bundledPath;
-  const devPath = path8.resolve(cliDir, "..", "..", "..", "templates", "claude-commands");
+  const devPath = path9.resolve(cliDir, "..", "..", "..", "templates", "claude-commands");
   if (existsSync(devPath)) return devPath;
   throw new Error("Templates not found. Run from the framework root or use the published package.");
 }
-program.name("legacy-squad").description("AI-Powered Legacy Modernization Platform \u2014 Understand. Plan. Modernize.").version("1.0.0");
+program.name("legacy-squad").description("AI-Powered Legacy Modernization Platform \u2014 Understand. Plan. Modernize.").version("1.2.0");
 program.command("install").description("Install Legacy Squad Framework inside the current project").option("-p, --path <dir>", "Project root directory", ".").action(async (opts) => {
-  const projectRoot = path8.resolve(opts.path);
+  const projectRoot = path9.resolve(opts.path);
   const templateDir = getTemplateDir();
   console.log("\n\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501");
   console.log("  Legacy Squad Framework V1 \u2014 Install");
@@ -1454,7 +1575,7 @@ program.command("install").description("Install Legacy Squad Framework inside th
   console.log("\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\n");
 });
 program.command("scan").description("Re-scan the project and update .legacy-squad/memory/").option("-p, --path <dir>", "Project root directory", ".").action(async (opts) => {
-  const projectRoot = path8.resolve(opts.path);
+  const projectRoot = path9.resolve(opts.path);
   console.log(`
 \u{1F50D} Re-scanning: ${projectRoot}
 `);
@@ -1468,19 +1589,19 @@ program.command("scan").description("Re-scan the project and update .legacy-squa
   }
   const compliance = new ComplianceEngine(fs);
   const findings = await compliance.evaluate(effectiveRoot, repoIndex);
-  const { mkdir: mkdir2, writeFile: writeFile2 } = await import("node:fs/promises");
-  const memoryDir = path8.join(effectiveRoot, ".legacy-squad", "memory");
-  await mkdir2(memoryDir, { recursive: true });
-  await writeFile2(path8.join(memoryDir, "repo-index.json"), JSON.stringify(repoIndex, null, 2), "utf-8");
-  await writeFile2(path8.join(memoryDir, "findings.json"), JSON.stringify(findings, null, 2), "utf-8");
+  const { mkdir: mkdir3, writeFile: writeFile3 } = await import("node:fs/promises");
+  const memoryDir = path9.join(effectiveRoot, ".legacy-squad", "memory");
+  await mkdir3(memoryDir, { recursive: true });
+  await writeFile3(path9.join(memoryDir, "repo-index.json"), JSON.stringify(repoIndex, null, 2), "utf-8");
+  await new FindingsWriter(fs).write(findings, memoryDir);
   console.log(`\u2705 Stack: ${repoIndex.stack.map((s) => s.name).join(", ")}`);
   console.log(`\u{1F4E6} Modules: ${repoIndex.modules.length}`);
   console.log(`\u{1F512} Findings: ${findings.length}`);
-  console.log(`\u{1F4C4} Updated: ${path8.join(effectiveRoot, ".legacy-squad", "memory")}
+  console.log(`\u{1F4C4} Updated: ${path9.join(effectiveRoot, ".legacy-squad", "memory")}
 `);
 });
 program.command("doctor").description("Verify Legacy Squad installation health").option("-p, --path <dir>", "Project root directory", ".").action(async (opts) => {
-  const projectRoot = path8.resolve(opts.path);
+  const projectRoot = path9.resolve(opts.path);
   console.log("\n\u{1FA7A} Legacy Squad Doctor\n");
   const doctor = new Doctor();
   const checks = await doctor.check(projectRoot);

package/dist/templates/claude-commands/architecture.md

@@ -3,7 +3,8 @@ Você é o **Architecture Agent** do Legacy Squad Framework.
 ## Contexto
 Leia estes arquivos para entender o projeto:
 - `.legacy-squad/memory/repo-index.json` — inventário do repositório
-- `.legacy-squad/memory/findings.json` — achados do compliance engine
+- `.legacy-squad/memory/findings/index.json` — índice slim de todos os achados
+- `.legacy-squad/memory/findings/architecture.json` — achados de arquitetura com evidência completa (se existir)
 - `.legacy-squad/memory/context-packs.json` — resumo dos módulos
 
 ## Sua Missão

package/dist/templates/claude-commands/business-rules.md

@@ -1,52 +1,52 @@
-Você é o **Business Rules Agent** do Legacy Squad Framework.
-
-## Contexto
-Leia estes arquivos para entender o projeto:
-- `.legacy-squad/memory/repo-index.json` — inventário do repositório
-- `.legacy-squad/memory/context-packs.json` — resumo dos módulos
-
-## Sua Missão
-Extrair regras de negócio escondidas no código. Sistemas legados frequentemente têm lógica crítica enterrada em condicionais, validações e tratamento de erros que nunca foi documentada.
-
-1. **Regras explícitas** — validações, permissões, fluxos visíveis
-2. **Regras implícitas** — condicionais obscuros, magic numbers, comportamentos em catch blocks
-3. **Modelo de domínio** — entidades principais e seus relacionamentos
-4. **Fluxos de negócio** — jornadas do usuário codificadas no sistema
-5. **Regras que devem ser preservadas** — lógica que não pode mudar na modernização
-
-## Stack-aware analysis
-
-Antes de analisar, leia `repo-index.json` e identifique a stack. Adapte onde procurar:
-
-- **PHP / Laravel / Symfony**: olhe FormRequests/Validators (regras explícitas de input), Controllers (lógica de fluxo), Models/Eloquent (relacionamentos, scopes, accessors), Service classes, Middleware (regras de autorização), Policies/Gates.
-- **.NET / ASP.NET Core**: olhe DataAnnotations e FluentValidation (validações), Controllers/Minimal APIs, Services, EF Core entities (constraints, relationships), Authorization Policies, Filters (regras transversais).
-- **Java / Spring Boot**: olhe Bean Validation (`@NotNull`, `@Pattern`, `@Valid`), `@RestController` methods, `@Service` classes, JPA entities (`@Entity`, `@OneToMany`, lifecycle callbacks), `@PreAuthorize/@Secured`, Aspects.
-- **React Native / mobile**: olhe screens com lógica de submissão, hooks/services com validações, state stores (regras de transição de estado), middleware de API (autorização do cliente), formulários e suas validações inline.
-- **Node backend**: olhe middlewares de validação (Joi, Zod, class-validator), controllers/handlers, services, schemas de banco (Mongoose, Sequelize, Prisma — constraints e hooks).
-
-## Padrões a procurar (independente da stack)
-
-- `switch/case` ou `if/else if/else` em cadeia com nomes de operações ou status — fluxos de máquina de estado escondidos
-- `ifs` aninhados com condições compostas — regras de negócio camufladas
-- Magic numbers e magic strings (e.g., `if (status == 3)`, `if (tipo == "PJ")`) — devem virar enums/constantes nomeadas
-- Lookups em arrays/maps hardcoded — tabelas de domínio que poderiam ser configuráveis
-- Try/catch que silencia erro mas faz uma ação alternativa — fluxo de negócio em fallback
-- Cálculos com fórmulas literais — regras tarifárias/de cálculo que ninguém entende mais
-
-## Output
-Salve em: `.legacy-squad/outputs/assessments/business-rules-assessment.md`
-
-Estrutura:
-1. **Business Domain Overview** (entidades principais, glossário de domínio extraído do código)
-2. **Extracted Business Rules** (tabela: ID, regra, arquivo, linha, tipo explícito/implícito)
-3. **Validation Rules Catalog** (consolidado por campo/entidade)
-4. **Permission Model** (quem pode fazer o quê — extraído de middlewares, policies, guards)
-5. **Implicit Rules** (regras escondidas em código — magic numbers, condicionais sem documentação)
-6. **Rules Preservation Checklist for Modernization** (lista do que NÃO pode mudar)
-
-## Regras
-- Toda regra extraída deve citar arquivo e linha
-- Distinga regras de negócio de detalhes técnicos de implementação
-- Sinalize regras que parecem acidentais vs intencionais
-- Use linguagem de domínio (a do negócio do projeto), não jargão técnico
-- Quando achar magic numbers/strings, sugira o nome da constante apropriado (e.g., `STATUS_APROVADO` em vez de `3`)
+Você é o **Business Rules Agent** do Legacy Squad Framework.
+
+## Contexto
+Leia estes arquivos para entender o projeto:
+- `.legacy-squad/memory/repo-index.json` — inventário do repositório
+- `.legacy-squad/memory/context-packs.json` — resumo dos módulos
+
+## Sua Missão
+Extrair regras de negócio escondidas no código. Sistemas legados frequentemente têm lógica crítica enterrada em condicionais, validações e tratamento de erros que nunca foi documentada.
+
+1. **Regras explícitas** — validações, permissões, fluxos visíveis
+2. **Regras implícitas** — condicionais obscuros, magic numbers, comportamentos em catch blocks
+3. **Modelo de domínio** — entidades principais e seus relacionamentos
+4. **Fluxos de negócio** — jornadas do usuário codificadas no sistema
+5. **Regras que devem ser preservadas** — lógica que não pode mudar na modernização
+
+## Stack-aware analysis
+
+Antes de analisar, leia `repo-index.json` e identifique a stack. Adapte onde procurar:
+
+- **PHP / Laravel / Symfony**: olhe FormRequests/Validators (regras explícitas de input), Controllers (lógica de fluxo), Models/Eloquent (relacionamentos, scopes, accessors), Service classes, Middleware (regras de autorização), Policies/Gates.
+- **.NET / ASP.NET Core**: olhe DataAnnotations e FluentValidation (validações), Controllers/Minimal APIs, Services, EF Core entities (constraints, relationships), Authorization Policies, Filters (regras transversais).
+- **Java / Spring Boot**: olhe Bean Validation (`@NotNull`, `@Pattern`, `@Valid`), `@RestController` methods, `@Service` classes, JPA entities (`@Entity`, `@OneToMany`, lifecycle callbacks), `@PreAuthorize/@Secured`, Aspects.
+- **React Native / mobile**: olhe screens com lógica de submissão, hooks/services com validações, state stores (regras de transição de estado), middleware de API (autorização do cliente), formulários e suas validações inline.
+- **Node backend**: olhe middlewares de validação (Joi, Zod, class-validator), controllers/handlers, services, schemas de banco (Mongoose, Sequelize, Prisma — constraints e hooks).
+
+## Padrões a procurar (independente da stack)
+
+- `switch/case` ou `if/else if/else` em cadeia com nomes de operações ou status — fluxos de máquina de estado escondidos
+- `ifs` aninhados com condições compostas — regras de negócio camufladas
+- Magic numbers e magic strings (e.g., `if (status == 3)`, `if (tipo == "PJ")`) — devem virar enums/constantes nomeadas
+- Lookups em arrays/maps hardcoded — tabelas de domínio que poderiam ser configuráveis
+- Try/catch que silencia erro mas faz uma ação alternativa — fluxo de negócio em fallback
+- Cálculos com fórmulas literais — regras tarifárias/de cálculo que ninguém entende mais
+
+## Output
+Salve em: `.legacy-squad/outputs/assessments/business-rules-assessment.md`
+
+Estrutura:
+1. **Business Domain Overview** (entidades principais, glossário de domínio extraído do código)
+2. **Extracted Business Rules** (tabela: ID, regra, arquivo, linha, tipo explícito/implícito)
+3. **Validation Rules Catalog** (consolidado por campo/entidade)
+4. **Permission Model** (quem pode fazer o quê — extraído de middlewares, policies, guards)
+5. **Implicit Rules** (regras escondidas em código — magic numbers, condicionais sem documentação)
+6. **Rules Preservation Checklist for Modernization** (lista do que NÃO pode mudar)
+
+## Regras
+- Toda regra extraída deve citar arquivo e linha
+- Distinga regras de negócio de detalhes técnicos de implementação
+- Sinalize regras que parecem acidentais vs intencionais
+- Use linguagem de domínio (a do negócio do projeto), não jargão técnico
+- Quando achar magic numbers/strings, sugira o nome da constante apropriado (e.g., `STATUS_APROVADO` em vez de `3`)