@codexa/cli 9.0.2 → 9.0.4

package/commands/utils.ts

@@ -1,35 +1,25 @@
 import { getDb } from "../db/connection";
-import { initSchema, getPatternsForFiles, getLastSessionSummary, getSessionSummaries, getRelatedDecisions, findContradictions, getArchitecturalAnalysisForSpec, getUtilitiesForContext } from "../db/schema";
+import { initSchema, getArchitecturalAnalysisForSpec } from "../db/schema";
 import { getKnowledgeForTask } from "./knowledge";
 import { getLibContextsForAgent } from "./research";
+import { resolveSpec, resolveSpecOrNull, getAllActiveSpecs } from "./spec-resolver";
+import { CodexaError } from "../errors";
 import pkg from "../package.json";
 
-// v8.3: Limite maximo de contexto para subagents (16KB)
-const MAX_CONTEXT_SIZE = 16384;
+// Re-export context modules for backward compatibility
+export { getContextForSubagent, getMinimalContextForSubagent } from "../context/generator";
+export { AGENT_SECTIONS, MAX_CONTEXT_SIZE } from "../context/assembly";
 
 export function contextUpdate(options: {
     approach?: string;
     pattern?: string;
     constraint?: string;
+    specId?: string;
 }): void {
     initSchema();
     const db = getDb();
 
-    const spec = db
-        .query("SELECT * FROM specs WHERE phase NOT IN ('completed', 'cancelled') ORDER BY created_at DESC LIMIT 1")
-        .get() as any;
-
-    if (!spec) {
-        console.error("\nNenhuma feature ativa.\n");
-        process.exit(1);
-    }
-
-    // Verificar se está na fase de implementação
-    if (spec.phase !== "implementing") {
-        console.error(`\nContexto só pode ser atualizado na fase 'implementing'.`);
-        console.error(`Fase atual: ${spec.phase}\n`);
-        process.exit(1);
-    }
+    const spec = resolveSpec(options.specId, ["implementing"]);
 
     const context = db.query("SELECT * FROM context WHERE spec_id = ?").get(spec.id) as any;
     const now = new Date().toISOString();
@@ -98,18 +88,24 @@ export function contextUpdate(options: {
     console.log(`\nContexto atualizado para: ${spec.name}\n`);
 }
 
-export function status(json: boolean = false): void {
+export function status(json: boolean = false, specId?: string): void {
     initSchema();
 
     const db = getDb();
 
-    const spec = db
-        .query("SELECT * FROM specs WHERE phase NOT IN ('completed', 'cancelled') ORDER BY created_at DESC LIMIT 1")
-        .get() as any;
+    // Se --spec fornecido, mostra spec especifico
+    // Se nao fornecido, mostra todos os ativos (multi-spec)
+    if (specId) {
+        const spec = resolveSpec(specId);
+        showSingleSpecStatus(db, spec, json);
+        return;
+    }
+
+    const allSpecs = getAllActiveSpecs();
 
-    if (!spec) {
+    if (allSpecs.length === 0) {
         if (json) {
-            console.log(JSON.stringify({ active: false, version: pkg.version, message: "Nenhuma feature ativa" }));
+            console.log(JSON.stringify({ active: false, version: pkg.version, specs: [], message: "Nenhuma feature ativa" }));
         } else {
             console.log(`\nCodexa Workflow v${pkg.version}`);
             console.log("\nNenhuma feature ativa.");
@@ -118,13 +114,23 @@ export function status(json: boolean = false): void {
         return;
     }
 
+    if (allSpecs.length === 1) {
+        showSingleSpecStatus(db, allSpecs[0], json);
+        return;
+    }
+
+    // Multi-spec: show summary table
+    showMultiSpecStatus(db, allSpecs, json);
+}
+
+function showSingleSpecStatus(db: any, spec: any, json: boolean): void {
     const context = db.query("SELECT * FROM context WHERE spec_id = ?").get(spec.id) as any;
     const tasks = db.query("SELECT * FROM tasks WHERE spec_id = ?").all(spec.id) as any[];
     const decisions = db.query("SELECT * FROM decisions WHERE spec_id = ? AND status = 'active'").all(spec.id) as any[];
 
-    const tasksDone = tasks.filter((t) => t.status === "done").length;
-    const tasksRunning = tasks.filter((t) => t.status === "running").length;
-    const tasksPending = tasks.filter((t) => t.status === "pending").length;
+    const tasksDone = tasks.filter((t: any) => t.status === "done").length;
+    const tasksRunning = tasks.filter((t: any) => t.status === "running").length;
+    const tasksPending = tasks.filter((t: any) => t.status === "pending").length;
 
     const progress = tasks.length > 0 ? Math.round((tasksDone / tasks.length) * 100) : 0;
 
@@ -156,7 +162,7 @@ export function status(json: boolean = false): void {
     console.log(`Aprovado: ${spec.approved_at ? "Sim" : "Nao"}`);
 
     console.log(`\nProgresso:`);
-    const bar = "█".repeat(Math.floor(progress / 5)) + "░".repeat(20 - Math.floor(progress / 5));
+    const bar = "\u2588".repeat(Math.floor(progress / 5)) + "\u2591".repeat(20 - Math.floor(progress / 5));
     console.log(`  [${bar}] ${progress}%`);
     console.log(`  Concluidas: ${tasksDone}/${tasks.length}`);
     console.log(`  Em execucao: ${tasksRunning}`);
@@ -171,35 +177,6 @@ export function status(json: boolean = false): void {
         console.log(`\nDecisoes ativas: ${decisions.length}`);
     }
 
-    // v8.1: Mostrar ultimo session summary para continuidade
-    const lastSession = getLastSessionSummary(spec.id);
-    if (lastSession) {
-        console.log(`\nUltima sessao:`);
-        console.log(`  ${lastSession.summary}`);
-        if (lastSession.next_steps) {
-            try {
-                const nextSteps = JSON.parse(lastSession.next_steps);
-                if (nextSteps.length > 0) {
-                    console.log(`  Proximos passos sugeridos:`);
-                    for (const step of nextSteps.slice(0, 3)) {
-                        console.log(`    - ${step}`);
-                    }
-                }
-            } catch { /* ignore */ }
-        }
-        if (lastSession.blockers) {
-            try {
-                const blockers = JSON.parse(lastSession.blockers);
-                if (blockers.length > 0) {
-                    console.log(`  Blockers pendentes:`);
-                    for (const b of blockers) {
-                        console.log(`    [!] ${b}`);
-                    }
-                }
-            } catch { /* ignore */ }
-        }
-    }
-
     console.log(`\n${"─".repeat(60)}`);
 
     // Sugerir proximo passo
@@ -220,20 +197,50 @@ export function status(json: boolean = false): void {
     console.log();
 }
 
-export function contextExport(options: { task?: string; json?: boolean; }): void {
-    initSchema();
+function showMultiSpecStatus(db: any, specs: any[], json: boolean): void {
+    if (json) {
+        const specsData = specs.map((spec: any) => {
+            const tasks = db.query("SELECT * FROM tasks WHERE spec_id = ?").all(spec.id) as any[];
+            const done = tasks.filter((t: any) => t.status === "done").length;
+            return {
+                id: spec.id,
+                name: spec.name,
+                phase: spec.phase,
+                progress: tasks.length > 0 ? Math.round((done / tasks.length) * 100) : 0,
+                tasks: { done, total: tasks.length },
+            };
+        });
+        console.log(JSON.stringify({ active: true, version: pkg.version, specs: specsData }));
+        return;
+    }
 
-    const db = getDb();
+    console.log(`\n${"=".repeat(60)}`);
+    console.log(`Codexa Workflow v${pkg.version} | ${specs.length} FEATURES ATIVAS`);
+    console.log(`${"=".repeat(60)}\n`);
 
-    const spec = db
-        .query("SELECT * FROM specs WHERE phase NOT IN ('completed', 'cancelled') ORDER BY created_at DESC LIMIT 1")
-        .get() as any;
+    for (const spec of specs) {
+        const tasks = db.query("SELECT * FROM tasks WHERE spec_id = ?").all(spec.id) as any[];
+        const done = tasks.filter((t: any) => t.status === "done").length;
+        const progress = tasks.length > 0 ? Math.round((done / tasks.length) * 100) : 0;
+        const bar = "\u2588".repeat(Math.floor(progress / 5)) + "\u2591".repeat(20 - Math.floor(progress / 5));
 
-    if (!spec) {
-        console.error("\nNenhuma feature ativa.\n");
-        process.exit(1);
+        console.log(`  ${spec.name}`);
+        console.log(`    Fase: ${spec.phase} | [${bar}] ${progress}% (${done}/${tasks.length})`);
+        console.log(`    ID: ${spec.id}`);
+        console.log();
     }
 
+    console.log(`${"─".repeat(60)}`);
+    console.log(`Use: status --spec <id> para detalhes de uma feature\n`);
+}
+
+export function contextExport(options: { task?: string; json?: boolean; specId?: string; }): void {
+    initSchema();
+
+    const db = getDb();
+
+    const spec = resolveSpec(options.specId);
+
     const context = db.query("SELECT * FROM context WHERE spec_id = ?").get(spec.id) as any;
     const decisions = db
         .query("SELECT * FROM decisions WHERE spec_id = ? AND status = 'active'")
@@ -345,642 +352,11 @@ export function contextExport(options: { task?: string; json?: boolean; }): void
     console.log(JSON.stringify(exportData, null, 2));
 }
 
-// v9.0: Contexto minimo para subagent (max ~2KB)
-const MAX_MINIMAL_CONTEXT = 2048;
-
-export function getMinimalContextForSubagent(taskId: number): string {
+export function contextDetail(section: string, json: boolean = false, specId?: string): void {
     initSchema();
     const db = getDb();
 
-    const task = db.query("SELECT * FROM tasks WHERE id = ?").get(taskId) as any;
-    if (!task) return "ERRO: Task nao encontrada";
-
-    const spec = db.query("SELECT * FROM specs WHERE id = ?").get(task.spec_id) as any;
-    const context = db.query("SELECT * FROM context WHERE spec_id = ?").get(task.spec_id) as any;
-
-    const taskFiles = task.files ? JSON.parse(task.files) : [];
-    const domain = task.agent?.split("-")[0] || "all";
-
-    // 1. Standards REQUIRED apenas (nao recommended)
-    const requiredStandards = db.query(
-        `SELECT rule FROM standards
-         WHERE enforcement = 'required' AND (scope = 'all' OR scope = ?)
-         LIMIT 10`
-    ).all(domain) as any[];
-
-    // 2. Blockers CRITICAL apenas
-    const criticalBlockers = db.query(
-        `SELECT content FROM knowledge
-         WHERE spec_id = ? AND severity = 'critical'
-         ORDER BY created_at DESC LIMIT 5`
-    ).all(task.spec_id) as any[];
-
-    // 3. Contradicoes (se existir)
-    let contradictions: any[] = [];
-    try {
-        contradictions = findContradictions(task.spec_id);
-    } catch { /* ignore */ }
-
-    // 4. Decisoes da task anterior (dependency direta)
-    const dependsOn = task.depends_on ? JSON.parse(task.depends_on) : [];
-    let depDecisions: any[] = [];
-    if (dependsOn.length > 0) {
-        const placeholders = dependsOn.map(() => '?').join(',');
-        const depTasks = db.query(
-            `SELECT id FROM tasks WHERE spec_id = ? AND number IN (${placeholders})`
-        ).all(task.spec_id, ...dependsOn) as any[];
-
-        for (const dt of depTasks) {
-            const reasoning = db.query(
-                `SELECT thought FROM reasoning_log
-                 WHERE spec_id = ? AND task_id = ? AND category = 'recommendation'
-                 ORDER BY created_at DESC LIMIT 2`
-            ).all(task.spec_id, dt.id) as any[];
-            depDecisions.push(...reasoning);
-        }
-    }
-
-    // Montar output minimo
-    let output = `## CONTEXTO MINIMO (Task #${task.number})
-
-**Feature:** ${spec.name}
-**Objetivo:** ${context?.objective || "N/A"}
-**Arquivos:** ${taskFiles.join(", ") || "Nenhum especificado"}
-`;
-
-    if (requiredStandards.length > 0) {
-        output += `\n**Standards (OBRIGATORIOS):**\n${requiredStandards.map((s: any) => `- ${s.rule}`).join("\n")}\n`;
-    }
-
-    if (criticalBlockers.length > 0) {
-        output += `\n**BLOCKERS CRITICOS:**\n${criticalBlockers.map((b: any) => `[X] ${b.content}`).join("\n")}\n`;
-    }
-
-    if (contradictions.length > 0) {
-        output += `\n**CONTRADICOES:**\n${contradictions.map((c: any) => `[!] "${c.decision1}" <-> "${c.decision2}"`).join("\n")}\n`;
-    }
-
-    if (depDecisions.length > 0) {
-        output += `\n**Recomendacoes de tasks anteriores:**\n${depDecisions.map((d: any) => `- ${d.thought}`).join("\n")}\n`;
-    }
-
-    output += `
-**Contexto expandido**: Se precisar de mais contexto, execute:
-  codexa context detail standards    # Todos os standards
-  codexa context detail decisions    # Todas as decisoes
-  codexa context detail patterns     # Patterns do projeto
-  codexa context detail knowledge    # Knowledge completo
-  codexa context detail architecture # Analise arquitetural
-`;
-
-    // Truncar se exceder limite
-    if (output.length > MAX_MINIMAL_CONTEXT) {
-        output = output.substring(0, MAX_MINIMAL_CONTEXT - 100) + "\n\n[CONTEXTO TRUNCADO - use: codexa context detail <secao>]\n";
-    }
-
-    return output;
-}
-
-// Funcao helper para formatar contexto para subagent (uso interno)
-// v8.1: Contexto COMPLETO mas ESTRUTURADO - todas as fontes relevantes incluidas
-export function getContextForSubagent(taskId: number): string {
-    initSchema();
-
-    const db = getDb();
-
-    const task = db.query("SELECT * FROM tasks WHERE id = ?").get(taskId) as any;
-    if (!task) {
-        return "ERRO: Task nao encontrada";
-    }
-
-    const spec = db.query("SELECT * FROM specs WHERE id = ?").get(task.spec_id) as any;
-    const context = db.query("SELECT * FROM context WHERE spec_id = ?").get(task.spec_id) as any;
-    const project = db.query("SELECT * FROM project WHERE id = 'default'").get() as any;
-
-    // v8.4: Analise arquitetural (link explicito via analysis_id ou nome)
-    const archAnalysis = getArchitecturalAnalysisForSpec(spec.name, task.spec_id);
-
-    // Arquivos da task para filtrar contexto relevante
-    const taskFiles = task.files ? JSON.parse(task.files) : [];
-    const domain = task.agent?.split("-")[0] || "all";
-
-    // Decisoes relevantes (max 8, priorizando as que mencionam arquivos da task)
-    const allDecisions = db
-        .query("SELECT * FROM decisions WHERE spec_id = ? AND status = 'active' ORDER BY created_at DESC")
-        .all(task.spec_id) as any[];
-    const decisions = filterRelevantDecisions(allDecisions, taskFiles, 8);
-
-    // Standards required + recommended que se aplicam aos arquivos
-    const standards = db
-        .query(
-            `SELECT * FROM standards
-       WHERE (scope = 'all' OR scope = ?)
-       ORDER BY enforcement DESC, category`
-        )
-        .all(domain) as any[];
-    const relevantStandards = filterRelevantStandards(standards, taskFiles);
-
-    // v8.3: Knowledge com TTL, caps e indicadores de truncamento
-    const allKnowledge = getKnowledgeForTask(task.spec_id, taskId);
-    const now48h = new Date(Date.now() - 48 * 60 * 60 * 1000).toISOString();
-    const recentKnowledge = allKnowledge.filter((k: any) => k.created_at > now48h);
-    const staleKnowledge = allKnowledge.filter((k: any) => k.created_at <= now48h);
-    // Conhecimento recente primeiro; stale so se critical
-    const effectiveKnowledge = [
-        ...recentKnowledge,
-        ...staleKnowledge.filter((k: any) => k.severity === 'critical'),
-    ];
-    const allCriticalKnowledge = effectiveKnowledge.filter((k: any) => k.severity === 'critical' || k.severity === 'warning');
-    const criticalKnowledge = allCriticalKnowledge.slice(0, 20);
-    const truncatedCritical = allCriticalKnowledge.length - criticalKnowledge.length;
-    const allInfoKnowledge = effectiveKnowledge.filter((k: any) => k.severity === 'info');
-    const infoKnowledge = allInfoKnowledge.slice(0, 10);
-    const truncatedInfo = allInfoKnowledge.length - infoKnowledge.length;
-
-    // v8.1: Contexto de produto (resumido - problema, usuarios, restricoes)
-    const productContext = db.query("SELECT * FROM product_context WHERE id = 'default'").get() as any;
-
-    // v8.1: Patterns de implementacao matchados aos arquivos da task
-    const patterns = getPatternsForFiles(taskFiles);
-
-    // v8.2: Reasoning de tasks dependentes + todas tasks completas recentes
-    const dependsOn = task.depends_on ? JSON.parse(task.depends_on) : [];
-    const depReasoning: any[] = [];
-    const seenTaskIds = new Set<number>();
-
-    // 1. Reasoning de dependencias diretas (prioridade maxima)
-    if (dependsOn.length > 0) {
-        const placeholders = dependsOn.map(() => '?').join(',');
-        const depTasks = db.query(
-            `SELECT id, number FROM tasks WHERE spec_id = ? AND number IN (${placeholders})`
-        ).all(task.spec_id, ...dependsOn) as any[];
-
-        for (const depTask of depTasks) {
-            seenTaskIds.add(depTask.id);
-            const reasoning = db.query(
-                `SELECT category, thought FROM reasoning_log
-                 WHERE spec_id = ? AND task_id = ?
-                 AND category IN ('recommendation', 'decision', 'challenge')
-                 ORDER BY
-                   CASE importance WHEN 'critical' THEN 1 WHEN 'high' THEN 2 ELSE 3 END,
-                   created_at DESC
-                 LIMIT 3`
-            ).all(task.spec_id, depTask.id) as any[];
-            for (const r of reasoning) {
-                depReasoning.push({ ...r, fromTask: depTask.number });
-            }
-        }
-    }
-
-    // 2. Reasoning de TODAS tasks completas (recommendations e challenges de alta importancia)
-    const completedTasks = db.query(
-        `SELECT t.id, t.number FROM tasks t
-         WHERE t.spec_id = ? AND t.status = 'done' AND t.id != ?
-         ORDER BY t.completed_at DESC LIMIT 10`
-    ).all(task.spec_id, taskId) as any[];
-
-    for (const ct of completedTasks) {
-        if (seenTaskIds.has(ct.id)) continue;
-        const reasoning = db.query(
-            `SELECT category, thought FROM reasoning_log
-             WHERE spec_id = ? AND task_id = ?
-             AND category IN ('recommendation', 'challenge')
-             AND importance IN ('critical', 'high')
-             ORDER BY
-               CASE importance WHEN 'critical' THEN 1 ELSE 2 END,
-               created_at DESC
-             LIMIT 2`
-        ).all(task.spec_id, ct.id) as any[];
-        for (const r of reasoning) {
-            depReasoning.push({ ...r, fromTask: ct.number });
-        }
-    }
-
-    // v8.1: Lib contexts do projeto (resumido - nomes e versoes)
-    const libContexts = db.query(
-        "SELECT lib_name, version FROM lib_contexts ORDER BY lib_name LIMIT 10"
-    ).all() as any[];
-
-    // v8.3: Sessoes compostas para continuidade cross-session (todas, nao so ultima)
-    const sessions = getSessionSummaries(task.spec_id, 5);
-
-    // v8.2: Knowledge graph - decisoes que afetam arquivos da task
-    const graphDecisions: any[] = [];
-    for (const file of taskFiles) {
-        try {
-            const related = getRelatedDecisions(file, "file");
-            for (const d of related) {
-                if (!graphDecisions.find((gd: any) => gd.id === d.id)) {
-                    graphDecisions.push(d);
-                }
-            }
-        } catch { /* ignore if graph empty */ }
-    }
-
-    // v8.2: Deteccao de contradicoes
-    let contradictions: any[] = [];
-    try {
-        contradictions = findContradictions(task.spec_id);
-    } catch { /* ignore if no contradictions */ }
-
-    // v8.2: Patterns descobertos por subagents anteriores
-    const discoveredPatterns = context?.patterns ? JSON.parse(context.patterns) : [];
-
-    // ===== MONTAR OUTPUT ESTRUTURADO =====
-
-    let output = `## CONTEXTO (Task #${task.number})
-
-**Feature:** ${spec.name}
-**Objetivo:** ${context?.objective || "N/A"}
-**Arquivos:** ${taskFiles.join(", ") || "Nenhum especificado"}
-`;
-
-    // Contexto de produto
-    if (productContext) {
-        output += `
-### PRODUTO
-- **Problema:** ${productContext.problem || "N/A"}
-- **Usuarios:** ${productContext.target_users || "N/A"}`;
-        if (productContext.constraints) {
-            try {
-                const constraints = JSON.parse(productContext.constraints);
-                if (constraints.length > 0) {
-                    output += `\n- **Restricoes:** ${constraints.slice(0, 3).join("; ")}${constraints.length > 3 ? ` [+${constraints.length - 3} mais]` : ''}`;
-                }
-            } catch { /* ignore parse errors */ }
-        }
-        output += "\n";
-    }
-
-    // v8.3: Secao ARQUITETURA (Fase 3 - Architect Pipeline)
-    if (archAnalysis) {
-        output += `
-### ARQUITETURA (${archAnalysis.id})`;
-        if (archAnalysis.approach) {
-            const approachPreview = archAnalysis.approach.length > 500
-                ? archAnalysis.approach.substring(0, 500) + "..."
-                : archAnalysis.approach;
-            output += `\n**Abordagem:** ${approachPreview}`;
-        }
-        if (archAnalysis.risks) {
-            try {
-                const risks = JSON.parse(archAnalysis.risks);
-                if (risks.length > 0) {
-                    const highRisks = risks.filter((r: any) => r.impact === 'high' || r.probability === 'high');
-                    const risksToShow = highRisks.length > 0 ? highRisks.slice(0, 3) : risks.slice(0, 3);
-                    output += `\n**Riscos:**`;
-                    for (const r of risksToShow) {
-                        output += `\n  - ${r.description} (${r.probability}/${r.impact}) -> ${r.mitigation}`;
-                    }
-                    if (risks.length > risksToShow.length) {
-                        output += `\n  [+${risks.length - risksToShow.length} mais riscos]`;
-                    }
-                }
-            } catch { /* ignore */ }
-        }
-        if (archAnalysis.decisions) {
-            try {
-                const archDecisions = JSON.parse(archAnalysis.decisions);
-                if (archDecisions.length > 0) {
-                    output += `\n**Decisoes arquiteturais:**`;
-                    for (const d of archDecisions.slice(0, 5)) {
-                        output += `\n  - ${d.decision}: ${d.rationale || ''}`;
-                    }
-                    if (archDecisions.length > 5) {
-                        output += `\n  [+${archDecisions.length - 5} mais]`;
-                    }
-                }
-            } catch { /* ignore */ }
-        }
-        output += "\n";
-    }
-
-    // Standards
-    const requiredStds = relevantStandards.filter((s: any) => s.enforcement === 'required');
-    const recommendedStds = relevantStandards.filter((s: any) => s.enforcement === 'recommended');
-
-    output += `
-### STANDARDS (${relevantStandards.length})`;
-    if (requiredStds.length > 0) {
-        output += `\n**Obrigatorios:**\n${requiredStds.map((s: any) => `- ${s.rule}`).join("\n")}`;
-    }
-    if (recommendedStds.length > 0) {
-        output += `\n**Recomendados:**\n${recommendedStds.map((s: any) => `- ${s.rule}`).join("\n")}`;
-    }
-    if (relevantStandards.length === 0) {
-        output += "\nNenhum standard aplicavel";
-    }
-    output += "\n";
-
-    // v8.3: Decisoes com indicador de truncamento
-    const truncatedDecisions = allDecisions.length - decisions.length;
-    output += `
-### DECISOES (${decisions.length}${truncatedDecisions > 0 ? ` [+${truncatedDecisions} mais - use: decisions list]` : ''})
-${decisions.length > 0 ? decisions.map((d) => `- **${d.title}**: ${d.decision}`).join("\n") : "Nenhuma"}
-`;
-
-    // Reasoning de tasks anteriores
-    if (depReasoning.length > 0) {
-        output += `
-### CONTEXTO DE TASKS ANTERIORES
-${depReasoning.map((r: any) => `- [Task #${r.fromTask}/${r.category}] ${r.thought}`).join("\n")}
-`;
-    }
-
-    // v8.3: Alertas com cap de 20 e indicador de truncamento
-    if (criticalKnowledge.length > 0) {
-        const severityIcon: Record<string, string> = { warning: "!!", critical: "XX" };
-        output += `
-### ALERTAS (${criticalKnowledge.length}${truncatedCritical > 0 ? ` [+${truncatedCritical} mais - use: knowledge list --severity warning]` : ''})
-${criticalKnowledge.map((k: any) => `[${severityIcon[k.severity] || "!"}] ${k.content}`).join("\n")}
-`;
-    }
-
-    // v8.3: Discoveries com indicador de truncamento
-    if (infoKnowledge.length > 0) {
-        output += `
-### DISCOVERIES DE TASKS ANTERIORES (${infoKnowledge.length}${truncatedInfo > 0 ? ` [+${truncatedInfo} mais - use: knowledge list]` : ''})
-${infoKnowledge.map((k: any) => `- ${k.content}`).join("\n")}
-`;
-    }
-
-    // Patterns de implementacao matchados
-    if (patterns.length > 0) {
-        output += `
-### PATTERNS DO PROJETO (${patterns.length})
-${patterns.map((p: any) => {
-    const tmpl = p.template || "";
-    const preview = tmpl.length > 200 ? tmpl.substring(0, 200) + `... [truncado de ${tmpl.length} chars]` : tmpl;
-    return `- **${p.name}** (${p.category}): ${preview || p.description || "Sem template"}`;
-}).join("\n")}
-`;
-    }
-
-    // v8.5: Utility Map (DRY prevention - Camada 1)
-    try {
-        const taskDirs = [...new Set(taskFiles.map((f: string) => {
-            const parts = f.replace(/\\/g, "/").split("/");
-            return parts.slice(0, -1).join("/");
-        }).filter(Boolean))];
-
-        const agentScope = task.agent?.split("-")[0] || undefined;
-        let relevantUtilities = getUtilitiesForContext(taskDirs, undefined, 15);
-
-        // Se poucos resultados por diretorio, ampliar para scope do agent
-        if (relevantUtilities.length < 5 && agentScope) {
-            const scopeUtils = getUtilitiesForContext([], agentScope, 15);
-            const existingKeys = new Set(relevantUtilities.map((u: any) => `${u.file_path}:${u.utility_name}`));
-            for (const u of scopeUtils) {
-                if (!existingKeys.has(`${u.file_path}:${u.utility_name}`)) {
-                    relevantUtilities.push(u);
-                }
-                if (relevantUtilities.length >= 15) break;
-            }
-        }
-
-        if (relevantUtilities.length > 0) {
-            const totalCount = (db.query("SELECT COUNT(*) as c FROM project_utilities").get() as any)?.c || 0;
-            const truncated = totalCount - relevantUtilities.length;
-            output += `
-### UTILITIES EXISTENTES (${relevantUtilities.length}${truncated > 0 ? ` [+${truncated} mais]` : ''})
-**REGRA DRY**: Reutilize ao inves de recriar. Importe do arquivo existente.
-${relevantUtilities.map((u: any) => {
-    const sig = u.signature ? ` ${u.signature}` : '';
-    return `- **${u.utility_name}** [${u.utility_type}]${sig} <- \`${u.file_path}\``;
-}).join("\n")}
-`;
-        }
-    } catch { /* tabela pode nao existir ainda */ }
-
-    // v8.3: Sessoes compostas (todas, nao so ultima)
-    if (sessions.length > 0) {
-        output += `
-### HISTORICO DE SESSOES (${sessions.length})`;
-        // Sessao mais recente: detalhes completos
-        const latest = sessions[0];
-        output += `\n**Ultima:** ${latest.summary}`;
-        if (latest.next_steps) {
-            try {
-                const steps = JSON.parse(latest.next_steps);
-                if (steps.length > 0) {
-                    output += `\n**Proximos passos:** ${steps.slice(0, 3).join("; ")}${steps.length > 3 ? ` [+${steps.length - 3} mais]` : ''}`;
-                }
-            } catch { /* ignore */ }
-        }
-        if (latest.blockers) {
-            try {
-                const blockers = JSON.parse(latest.blockers);
-                if (blockers.length > 0) {
-                    output += `\n**Blockers:** ${blockers.join("; ")}`;
-                }
-            } catch { /* ignore */ }
-        }
-        // Sessoes anteriores: resumo de 1 linha
-        if (sessions.length > 1) {
-            output += `\n**Sessoes anteriores:**`;
-            for (const s of sessions.slice(1)) {
-                output += `\n  - ${s.summary.substring(0, 100)}${s.summary.length > 100 ? '...' : ''} (${s.tasks_completed || 0} tasks)`;
-            }
-        }
-        output += "\n";
-    }
-
-    // Decisoes do knowledge graph que afetam arquivos desta task
-    if (graphDecisions.length > 0) {
-        output += `
-### DECISOES QUE AFETAM SEUS ARQUIVOS (${graphDecisions.length})
-${graphDecisions.map((d: any) => `- **${d.title}**: ${d.decision}`).join("\n")}
-`;
-    }
-
-    // Contradicoes detectadas
-    if (contradictions.length > 0) {
-        output += `
-### [!!] CONTRADICOES DETECTADAS (${contradictions.length})
-${contradictions.map((c: any) => `- "${c.decision1}" <-> "${c.decision2}"`).join("\n")}
-Verifique estas contradicoes antes de prosseguir.
-`;
-    }
-
-    // v8.3: Patterns descobertos com indicador de truncamento
-    if (discoveredPatterns.length > 0) {
-        const patternsToShow = discoveredPatterns.slice(-10);
-        output += `
-### PATTERNS DESCOBERTOS (${discoveredPatterns.length})
-${discoveredPatterns.length > 10 ? `[mostrando ultimos 10 de ${discoveredPatterns.length}]\n` : ''}${patternsToShow.map((p: any) => `- ${p.pattern}${p.source_task ? ` (Task #${p.source_task})` : ""}`).join("\n")}
-`;
-    }
-
-    // Stack
-    if (project) {
-        const stack = JSON.parse(project.stack);
-        const allStackEntries = Object.entries(stack);
-        const mainStack = allStackEntries.slice(0, 6);
-        output += `
-### STACK
-${mainStack.map(([k, v]) => `${k}: ${v}`).join(" | ")}${allStackEntries.length > 6 ? ` [+${allStackEntries.length - 6} mais]` : ''}
-`;
-    }
-
-    // Bibliotecas do projeto
-    if (libContexts.length > 0) {
-        output += `
-### BIBLIOTECAS
-${libContexts.map((l: any) => `- ${l.lib_name}${l.version ? ` v${l.version}` : ""}`).join("\n")}
-`;
-    }
-
-    // Protocolo de retorno
-    output += `
-### RETORNO OBRIGATORIO
-\`\`\`json
-{"status": "completed|blocked", "summary": "...", "files_created": [], "files_modified": [], "reasoning": {"approach": "como abordou", "challenges": [], "recommendations": "para proximas tasks"}}
-\`\`\`
-`;
-
-    // v8.3: Overall size cap com truncamento inteligente por secao
-    if (output.length > MAX_CONTEXT_SIZE) {
-        const sections = output.split('\n### ');
-        let trimmed = sections[0]; // Sempre manter header
-
-        for (let i = 1; i < sections.length; i++) {
-            const candidate = trimmed + '\n### ' + sections[i];
-            if (candidate.length > MAX_CONTEXT_SIZE - 200) {
-                break;
-            }
-            trimmed = candidate;
-        }
-
-        const omittedSections = sections.length - trimmed.split('\n### ').length;
-        if (omittedSections > 0) {
-            trimmed += `\n\n[CONTEXTO TRUNCADO: ${omittedSections} secao(oes) omitida(s) por limite de ${MAX_CONTEXT_SIZE} chars. Use: context-export para contexto completo]`;
-        }
-
-        output = trimmed;
-    }
-
-    return output;
-}
-
-// v8.3: Filtrar decisoes relevantes com scoring melhorado
-function filterRelevantDecisions(decisions: any[], taskFiles: string[], maxCount: number): any[] {
-    if (decisions.length === 0) return [];
-    if (taskFiles.length === 0) return decisions.slice(0, maxCount);
-
-    // Extrair keywords semanticas dos arquivos da task
-    const fileExtensions = new Set(taskFiles.map(f => f.split('.').pop()?.toLowerCase()).filter(Boolean));
-    const fileDirs = new Set(taskFiles.flatMap(f => f.split('/').slice(0, -1)).filter(Boolean));
-
-    // Keywords de dominio para scoring contextual
-    const domainKeywords: Record<string, string[]> = {
-        frontend: ['component', 'page', 'layout', 'css', 'style', 'ui', 'react', 'next', 'hook'],
-        backend: ['api', 'route', 'handler', 'middleware', 'server', 'endpoint', 'controller'],
-        database: ['schema', 'migration', 'query', 'table', 'index', 'sql', 'model'],
-        testing: ['test', 'spec', 'mock', 'fixture', 'assert', 'jest', 'vitest'],
-    };
-
-    const scored = decisions.map((d) => {
-        let score = 0;
-        const combined = `${d.decision || ''} ${d.title || ''} ${d.rationale || ''}`.toLowerCase();
-
-        // Arquivo exato e diretorio (+10/+5)
-        for (const file of taskFiles) {
-            const fileName = file.split("/").pop() || file;
-            const dirName = file.split("/").slice(-2, -1)[0] || "";
-
-            if (combined.includes(fileName.toLowerCase())) score += 10;
-            if (dirName && combined.includes(dirName.toLowerCase())) score += 5;
-        }
-
-        // v8.3: Extensao dos arquivos (+3)
-        for (const ext of fileExtensions) {
-            if (combined.includes(`.${ext}`)) { score += 3; break; }
-        }
-
-        // v8.3: Diretorio mencionado (+4)
-        for (const dir of fileDirs) {
-            if (combined.includes(dir.toLowerCase())) { score += 4; break; }
-        }
-
-        // v8.3: Keywords de dominio (+2)
-        const taskCombined = taskFiles.join(' ').toLowerCase();
-        for (const [, keywords] of Object.entries(domainKeywords)) {
-            for (const kw of keywords) {
-                if (combined.includes(kw) && taskCombined.includes(kw)) {
-                    score += 2;
-                    break;
-                }
-            }
-        }
-
-        // Recencia (+3/+1)
-        const age = Date.now() - new Date(d.created_at).getTime();
-        const hoursOld = age / (1000 * 60 * 60);
-        if (hoursOld < 1) score += 3;
-        else if (hoursOld < 24) score += 1;
-
-        return { ...d, _relevanceScore: score };
-    });
-
-    return scored
-        .sort((a, b) => b._relevanceScore - a._relevanceScore)
-        .slice(0, maxCount)
-        .map(({ _relevanceScore, ...d }) => d);
-}
-
-// v8.0: Filtrar standards relevantes para os arquivos da task
-function filterRelevantStandards(standards: any[], taskFiles: string[]): any[] {
-    if (standards.length === 0) return [];
-    if (taskFiles.length === 0) return standards;
-
-    // Extrair extensoes e diretorios dos arquivos da task
-    const extensions = new Set(taskFiles.map((f) => {
-        const ext = f.split(".").pop();
-        return ext ? `.${ext}` : "";
-    }).filter(Boolean));
-
-    const directories = new Set(taskFiles.map((f) => {
-        const parts = f.split("/");
-        return parts.length > 1 ? parts.slice(0, -1).join("/") : "";
-    }).filter(Boolean));
-
-    // Filtrar standards que se aplicam
-    return standards.filter((s) => {
-        // Standards de naming sempre aplicam
-        if (s.category === "naming") return true;
-
-        // Standards de code aplicam se mencionam extensao dos arquivos
-        if (s.category === "code") {
-            for (const ext of extensions) {
-                if (s.rule?.includes(ext) || s.scope === "all") return true;
-            }
-        }
-
-        // Standards de structure aplicam se mencionam diretorio
-        if (s.category === "structure") {
-            for (const dir of directories) {
-                if (s.rule?.includes(dir)) return true;
-            }
-            return s.scope === "all";
-        }
-
-        // Outros standards: incluir se scope combina
-        return true;
-    });
-}
-
-export function contextDetail(section: string, json: boolean = false): void {
-    initSchema();
-    const db = getDb();
-
-    const spec = db
-        .query("SELECT * FROM specs WHERE phase NOT IN ('completed', 'cancelled') ORDER BY created_at DESC LIMIT 1")
-        .get() as any;
-
-    if (!spec) {
-        console.error("\nNenhuma feature ativa.\n");
-        process.exit(1);
-    }
+    const spec = resolveSpec(specId);
 
     // Encontrar task running (para contexto relevante)
     const runningTask = db.query(
@@ -1109,9 +485,7 @@ export function contextDetail(section: string, json: boolean = false): void {
         }
 
         default:
-            console.error(`\nSecao invalida: ${section}`);
-            console.error("Secoes validas: standards, decisions, patterns, knowledge, architecture\n");
-            process.exit(1);
+            throw new CodexaError("Secao invalida: " + section + "\nSecoes validas: standards, decisions, patterns, knowledge, architecture");
     }
 
     console.log(output || "\nNenhum dado encontrado.\n");
@@ -1160,8 +534,7 @@ export function recover(options: {
         }
 
         if (!snapshot) {
-            console.error("\nNenhum snapshot para restaurar.\n");
-            process.exit(1);
+            throw new CodexaError("Nenhum snapshot para restaurar.");
         }
 
         const data = JSON.parse(snapshot.data);
@@ -1232,8 +605,7 @@ export function recover(options: {
         const snapshot = db.query("SELECT * FROM snapshots WHERE id = ?").get(snapshotId) as any;
 
         if (!snapshot) {
-            console.error(`\nSnapshot #${snapshotId} nao encontrado.\n`);
-            process.exit(1);
+            throw new CodexaError("Snapshot #" + snapshotId + " nao encontrado.");
         }
 
         const data = JSON.parse(snapshot.data);