legacy-squad 1.0.1 → 1.3.0

package/dist/cli.mjs

@@ -2,7 +2,7 @@
 
 // apps/cli/src/index.ts
 import { Command } from "commander";
-import path8 from "node:path";
+import path10 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,19 +1318,21 @@ 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.3.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 claudeCommandsRoot = path7.join(effectiveRoot, ".claude", "commands");
+    const claudeCommandsDir = path7.join(claudeCommandsRoot, "legacy-squad");
+    await mkdir2(claudeCommandsDir, { recursive: true });
     await this.copySlashCommands(templateDir, claudeCommandsDir);
+    await this.copyOrchestrator(templateDir, claudeCommandsRoot);
     await this.generateAgentsMd(effectiveRoot, repoIndex.project.name);
     const logContent = [
       `Legacy Squad Framework \u2014 Install Log`,
@@ -1259,8 +1348,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,15 +1383,30 @@ 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 {
       }
     }
   }
+  /**
+   * DA-012: copia o template do orchestrator para `.claude/commands/legacy-squad.md`
+   * (raiz de commands, não subdir). No Claude Code, arquivos na raiz de commands viram
+   * o comando puro `/<filename>` — então este caminho expressa `/legacy-squad` (validado
+   * emp.). Falha silenciosamente se o template não existir, no mesmo estilo de copySlashCommands.
+   */
+  async copyOrchestrator(templateDir, commandsRoot) {
+    const sourcePath = path7.join(templateDir, "legacy-squad.md");
+    const targetPath = path7.join(commandsRoot, "legacy-squad.md");
+    try {
+      const content = await readFile2(sourcePath, "utf-8");
+      await writeFile2(targetPath, content, "utf-8");
+    } catch {
+    }
+  }
   async generateAgentsMd(projectRoot, projectName) {
     const lines = [
       `# Legacy Squad Agents \u2014 ${projectName}`,
@@ -1321,7 +1425,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,23 +1450,58 @@ 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"));
+    checks.push(await this.checkFile(projectRoot, ".claude/commands/legacy-squad.md", "Orchestrator /legacy-squad"));
     checks.push(await this.checkFile(projectRoot, "AGENTS.md", "Codex AGENTS.md"));
     checks.push(await this.checkDir(projectRoot, ".legacy-squad/outputs/assessments", "Assessments Dir"));
     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 +1513,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` };
@@ -1386,19 +1525,281 @@ var Doctor = class {
   }
 };
 
+// packages/agents/src/lifecycle-detector.ts
+import path9 from "node:path";
+var REPO_INDEX_PATH = ".legacy-squad/memory/repo-index.json";
+var FINDINGS_INDEX_PATH = ".legacy-squad/memory/findings/index.json";
+var assessmentPath = (slug) => `.legacy-squad/outputs/assessments/${slug}-assessment.md`;
+var PRS_PATH = ".legacy-squad/outputs/reports/PRS.md";
+var SDD_PATH = ".legacy-squad/outputs/sdd/SDD.md";
+var MMP_PATH = ".legacy-squad/outputs/mmp/MMP.md";
+var SPECS_PATH = ".legacy-squad/outputs/specs/INDEX.md";
+var MATURITY_LABELS = {
+  1: "Unknown",
+  2: "Understood",
+  3: "Assessed",
+  4: "Planned",
+  5: "Modernization Ready",
+  6: "Continuously Modernized"
+};
+var STEPS = [
+  {
+    id: "scan",
+    label: "Scan",
+    command: null,
+    phase: "discovery",
+    target: REPO_INDEX_PATH,
+    reason: "Rode `npx legacy-squad install` para escanear o projeto e gerar o repo-index."
+  },
+  {
+    id: "security",
+    label: "Security assessment",
+    command: "/legacy-squad:security",
+    phase: "assessment",
+    target: assessmentPath("security"),
+    reason: "Inicie os assessments rodando `/legacy-squad:security`."
+  },
+  {
+    id: "architecture",
+    label: "Architecture assessment",
+    command: "/legacy-squad:architecture",
+    phase: "assessment",
+    target: assessmentPath("architecture"),
+    reason: "Rode `/legacy-squad:architecture`."
+  },
+  {
+    id: "legacy-code",
+    label: "Legacy code assessment",
+    command: "/legacy-squad:legacy-code",
+    phase: "assessment",
+    target: assessmentPath("legacy-code"),
+    reason: "Rode `/legacy-squad:legacy-code`."
+  },
+  {
+    id: "business-rules",
+    label: "Business rules assessment",
+    command: "/legacy-squad:business-rules",
+    phase: "assessment",
+    target: assessmentPath("business-rules"),
+    reason: "Rode `/legacy-squad:business-rules`."
+  },
+  {
+    id: "modernization",
+    label: "Modernization assessment",
+    command: "/legacy-squad:modernization",
+    phase: "assessment",
+    target: assessmentPath("modernization"),
+    reason: "Rode `/legacy-squad:modernization`."
+  },
+  {
+    id: "generate-prs",
+    label: "PRS",
+    command: "/legacy-squad:generate-prs",
+    phase: "assessment",
+    target: PRS_PATH,
+    reason: "Consolide o diagn\xF3stico com `/legacy-squad:generate-prs`."
+  },
+  {
+    id: "generate-sdd",
+    label: "SDD",
+    command: "/legacy-squad:generate-sdd",
+    phase: "design",
+    target: SDD_PATH,
+    reason: "Gere o desenho t\xE9cnico com `/legacy-squad:generate-sdd`."
+  },
+  {
+    id: "generate-mmp",
+    label: "MMP",
+    command: "/legacy-squad:generate-mmp",
+    phase: "planning",
+    target: MMP_PATH,
+    reason: "Gere o plano mestre com `/legacy-squad:generate-mmp`."
+  },
+  {
+    id: "generate-specs",
+    label: "Execution Specs",
+    command: "/legacy-squad:generate-specs",
+    phase: "execution",
+    target: SPECS_PATH,
+    reason: "Decomponha em specs com `/legacy-squad:generate-specs`."
+  }
+];
+var PHASE_ORDER = [
+  { id: "discovery", label: "Discovery" },
+  { id: "assessment", label: "Assessment" },
+  { id: "design", label: "Design" },
+  { id: "planning", label: "Planning" },
+  { id: "execution", label: "Execution" }
+];
+var ASSESSMENT_STEP_IDS = [
+  "security",
+  "architecture",
+  "legacy-code",
+  "business-rules",
+  "modernization"
+];
+var LifecycleDetector = class {
+  constructor(fs) {
+    this.fs = fs;
+  }
+  fs;
+  /** Detecta e retorna o snapshot determinístico do lifecycle em `projectRoot`. */
+  async detect(projectRoot) {
+    const done = /* @__PURE__ */ new Map();
+    for (const step of STEPS) {
+      done.set(step.id, await this.fs.exists(path9.join(projectRoot, step.target)));
+    }
+    const installed = done.get("scan") === true;
+    const project = installed ? await this.readProject(projectRoot) : null;
+    const findingCount = installed ? await this.readFindingCount(projectRoot) : 0;
+    const maturityLevel = this.computeMaturity(done);
+    return {
+      project,
+      installed,
+      findingCount,
+      maturityLevel,
+      maturityLabel: MATURITY_LABELS[maturityLevel],
+      phases: this.buildPhases(done),
+      nextStep: this.computeNextStep(done),
+      complete: done.get("generate-specs") === true
+    };
+  }
+  /** Agrupa os passos por fase, calculando a contagem de concluídos. */
+  buildPhases(done) {
+    return PHASE_ORDER.map(({ id, label }) => {
+      const steps = STEPS.filter((s) => s.phase === id).map((s) => ({
+        id: s.id,
+        label: s.label,
+        command: s.command,
+        done: done.get(s.id) === true
+      }));
+      return {
+        id,
+        label,
+        steps,
+        doneCount: steps.filter((s) => s.done).length,
+        totalCount: steps.length
+      };
+    });
+  }
+  /** Deriva o Maturity Level (§10) a partir dos artefatos presentes. */
+  computeMaturity(done) {
+    if (done.get("generate-specs")) return 5;
+    if (done.get("generate-mmp")) return 4;
+    if (ASSESSMENT_STEP_IDS.every((id) => done.get(id))) return 3;
+    if (done.get("scan")) return 2;
+    return 1;
+  }
+  /** Próximo passo = primeiro `target` ausente na ordem canônica; null se tudo concluído. */
+  computeNextStep(done) {
+    const [scanStep] = STEPS;
+    if (!done.get("scan")) {
+      return { id: "install", command: null, reason: scanStep.reason };
+    }
+    for (const step of STEPS) {
+      if (!done.get(step.id)) {
+        return { id: step.id, command: step.command, reason: step.reason };
+      }
+    }
+    return null;
+  }
+  /** Lê nome, tipo e stack do repo-index; null se ausente ou ilegível. */
+  async readProject(root) {
+    try {
+      const raw = await this.fs.readFile(path9.join(root, REPO_INDEX_PATH));
+      const idx = JSON.parse(raw);
+      return {
+        name: idx.project?.name ?? "unknown",
+        type: idx.project?.type ?? "unknown",
+        stack: (idx.stack ?? []).map((s) => s.name ?? "").filter((n) => n.length > 0)
+      };
+    } catch {
+      return null;
+    }
+  }
+  /** Conta os achados no index slim (DA-011); 0 se ausente ou ilegível. */
+  async readFindingCount(root) {
+    try {
+      const raw = await this.fs.readFile(path9.join(root, FINDINGS_INDEX_PATH));
+      const parsed = JSON.parse(raw);
+      return Array.isArray(parsed) ? parsed.length : 0;
+    } catch {
+      return 0;
+    }
+  }
+};
+
+// packages/output/src/dashboard-renderer.ts
+var RULE = "\u2501".repeat(40);
+var STEP_DISPLAY = {
+  scan: "scan",
+  security: "security",
+  architecture: "architecture",
+  "legacy-code": "legacy-code",
+  "business-rules": "business-rules",
+  modernization: "modernization",
+  "generate-prs": "PRS",
+  "generate-sdd": "SDD",
+  "generate-mmp": "MMP",
+  "generate-specs": "Specs"
+};
+var display = (id) => STEP_DISPLAY[id] ?? id;
+function phaseIcon(phase) {
+  if (phase.totalCount > 0 && phase.doneCount === phase.totalCount) return "\u2713";
+  if (phase.doneCount > 0) return "\u25D0";
+  return "\xB7";
+}
+function phaseDetail(phase) {
+  if (phase.steps.length === 1) {
+    return display(phase.steps[0].id);
+  }
+  const names = phase.steps.map((s) => display(s.id)).join(" \xB7 ");
+  return `${phase.doneCount}/${phase.totalCount}   ${names}`;
+}
+var DashboardRenderer = class {
+  render(snapshot) {
+    const lines = [RULE];
+    if (snapshot.project) {
+      const stack = snapshot.project.stack.join(", ");
+      lines.push(`  Legacy Squad \u2014 ${snapshot.project.name}`);
+      lines.push(`  ${snapshot.project.type}${stack ? ` \xB7 ${stack}` : ""}`);
+    } else {
+      lines.push("  Legacy Squad");
+      lines.push("  (framework n\xE3o instalado neste diret\xF3rio)");
+    }
+    lines.push(RULE, "");
+    lines.push(`  Maturity   Level ${snapshot.maturityLevel} \u2014 ${snapshot.maturityLabel}`);
+    lines.push(`  Findings   ${snapshot.findingCount}`, "");
+    const labelWidth = Math.max(...snapshot.phases.map((p) => p.label.length));
+    for (const phase of snapshot.phases) {
+      lines.push(`  ${phaseIcon(phase)} ${phase.label.padEnd(labelWidth)}   ${phaseDetail(phase)}`);
+    }
+    lines.push("");
+    if (snapshot.nextStep) {
+      const target = snapshot.nextStep.command ?? "npx legacy-squad install";
+      lines.push(`  \u2192 Pr\xF3ximo passo: ${target}`);
+      lines.push(`    ${snapshot.nextStep.reason}`);
+    } else {
+      lines.push("  \u2713 Lifecycle V1 completo \u2014 specs prontas para execu\xE7\xE3o.");
+    }
+    lines.push(RULE);
+    return lines.join("\n");
+  }
+};
+
 // 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 = path10.dirname(fileURLToPath(import.meta.url));
+  const bundledPath = path10.resolve(cliDir, "templates", "claude-commands");
   if (existsSync(bundledPath)) return bundledPath;
-  const devPath = path8.resolve(cliDir, "..", "..", "..", "templates", "claude-commands");
+  const devPath = path10.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.3.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 = path10.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");
@@ -1440,21 +1841,21 @@ program.command("install").description("Install Legacy Squad Framework inside th
   console.log("    1. Open Claude Code: claude");
   console.log("");
   console.log("  Analysis (run in order):");
-  console.log("    /legacy-squad-security");
-  console.log("    /legacy-squad-architecture");
-  console.log("    /legacy-squad-legacy-code");
-  console.log("    /legacy-squad-business-rules");
-  console.log("    /legacy-squad-modernization");
+  console.log("    /legacy-squad:security");
+  console.log("    /legacy-squad:architecture");
+  console.log("    /legacy-squad:legacy-code");
+  console.log("    /legacy-squad:business-rules");
+  console.log("    /legacy-squad:modernization");
   console.log("");
   console.log("  Consolidated artifacts (run after analysis):");
-  console.log("    /legacy-squad-generate-prs    (Product Refactor Specification)");
-  console.log("    /legacy-squad-generate-sdd    (Software Design Document)");
-  console.log("    /legacy-squad-generate-mmp    (Modernization Master Plan)");
-  console.log("    /legacy-squad-generate-specs  (Execution Specs for V2)");
+  console.log("    /legacy-squad:generate-prs    (Product Refactor Specification)");
+  console.log("    /legacy-squad:generate-sdd    (Software Design Document)");
+  console.log("    /legacy-squad:generate-mmp    (Modernization Master Plan)");
+  console.log("    /legacy-squad:generate-specs  (Execution Specs for V2)");
   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 = path10.resolve(opts.path);
   console.log(`
 \u{1F50D} Re-scanning: ${projectRoot}
 `);
@@ -1468,19 +1869,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 = path10.join(effectiveRoot, ".legacy-squad", "memory");
+  await mkdir3(memoryDir, { recursive: true });
+  await writeFile3(path10.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: ${path10.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 = path10.resolve(opts.path);
   console.log("\n\u{1FA7A} Legacy Squad Doctor\n");
   const doctor = new Doctor();
   const checks = await doctor.check(projectRoot);
@@ -1497,4 +1898,16 @@ program.command("doctor").description("Verify Legacy Squad installation health")
     console.log("\n\u2705 All checks passed.\n");
   }
 });
+program.command("status").description("Show the project lifecycle dashboard and the recommended next step").option("-p, --path <dir>", "Project root directory", ".").option("--json", "Output the raw lifecycle snapshot as JSON").action(async (opts) => {
+  const projectRoot = path10.resolve(opts.path);
+  const fs = new NodeFileSystem();
+  const snapshot = await new LifecycleDetector(fs).detect(projectRoot);
+  if (opts.json) {
+    console.log(JSON.stringify(snapshot, null, 2));
+    return;
+  }
+  console.log("");
+  console.log(new DashboardRenderer().render(snapshot));
+  console.log("");
+});
 program.parse();