@codexa/cli 9.0.2 → 9.0.3

package/commands/utils.ts

@@ -1,5 +1,5 @@
 import { getDb } from "../db/connection";
-import { initSchema, getPatternsForFiles, getLastSessionSummary, getSessionSummaries, getRelatedDecisions, findContradictions, getArchitecturalAnalysisForSpec, getUtilitiesForContext } from "../db/schema";
+import { initSchema, getPatternsForFiles, getRelatedDecisions, getArchitecturalAnalysisForSpec, getUtilitiesForContext } from "../db/schema";
 import { getKnowledgeForTask } from "./knowledge";
 import { getLibContextsForAgent } from "./research";
 import pkg from "../package.json";
@@ -171,35 +171,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
@@ -375,13 +346,7 @@ export function getMinimalContextForSubagent(taskId: number): string {
          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)
+    // 3. Decisoes da task anterior (dependency direta)
     const dependsOn = task.depends_on ? JSON.parse(task.depends_on) : [];
     let depDecisions: any[] = [];
     if (dependsOn.length > 0) {
@@ -416,10 +381,6 @@ export function getMinimalContextForSubagent(taskId: number): string {
         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`;
     }
@@ -441,17 +402,45 @@ export function getMinimalContextForSubagent(taskId: number): string {
     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();
+// ═══════════════════════════════════════════════════════════════
+// CONTEXT BUILDER (v9.0 — decomposed from v8.1 monolith)
+// ═══════════════════════════════════════════════════════════════
+
+interface ContextSection {
+    name: string;
+    content: string;
+    priority: number; // Lower = kept during truncation
+}
 
+interface ContextData {
+    db: any;
+    task: any;
+    spec: any;
+    context: any;
+    project: any;
+    taskFiles: string[];
+    domain: string;
+    archAnalysis: any;
+    decisions: any[];
+    allDecisions: any[];
+    relevantStandards: any[];
+    criticalKnowledge: any[];
+    truncatedCritical: number;
+    infoKnowledge: any[];
+    truncatedInfo: number;
+    productContext: any;
+    patterns: any[];
+    depReasoning: any[];
+    libContexts: any[];
+    graphDecisions: any[];
+    discoveredPatterns: any[];
+}
+
+function fetchContextData(taskId: number): ContextData | null {
     const db = getDb();
 
     const task = db.query("SELECT * FROM tasks WHERE id = ?").get(taskId) as any;
-    if (!task) {
-        return "ERRO: Task nao encontrada";
-    }
+    if (!task) return null;
 
     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;
@@ -480,27 +469,16 @@ export function getContextForSubagent(taskId: number): string {
         .all(domain) as any[];
     const relevantStandards = filterRelevantStandards(standards, taskFiles);
 
-    // v8.3: Knowledge com TTL, caps e indicadores de truncamento
+    // Knowledge com 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 allCriticalKnowledge = allKnowledge.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 allInfoKnowledge = allKnowledge.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
@@ -508,7 +486,6 @@ export function getContextForSubagent(taskId: number): string {
     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(
@@ -532,7 +509,6 @@ export function getContextForSubagent(taskId: number): string {
         }
     }
 
-    // 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 != ?
@@ -556,15 +532,10 @@ export function getContextForSubagent(taskId: number): string {
         }
     }
 
-    // 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 {
@@ -577,138 +548,152 @@ export function getContextForSubagent(taskId: number): string {
         } 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 =====
+    return {
+        db, task, spec, context, project, taskFiles, domain, archAnalysis,
+        decisions, allDecisions, relevantStandards,
+        criticalKnowledge, truncatedCritical, infoKnowledge, truncatedInfo,
+        productContext, patterns, depReasoning, libContexts,
+        graphDecisions, discoveredPatterns,
+    };
+}
 
-    let output = `## CONTEXTO (Task #${task.number})
+// ── Section Builders ──────────────────────────────────────────
 
-**Feature:** ${spec.name}
-**Objetivo:** ${context?.objective || "N/A"}
-**Arquivos:** ${taskFiles.join(", ") || "Nenhum especificado"}
-`;
+function buildProductSection(data: ContextData): ContextSection | null {
+    if (!data.productContext) return null;
 
-    // Contexto de produto
-    if (productContext) {
-        output += `
+    let content = `
 ### 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";
+- **Problema:** ${data.productContext.problem || "N/A"}
+- **Usuarios:** ${data.productContext.target_users || "N/A"}`;
+    if (data.productContext.constraints) {
+        try {
+            const constraints = JSON.parse(data.productContext.constraints);
+            if (constraints.length > 0) {
+                content += `\n- **Restricoes:** ${constraints.slice(0, 3).join("; ")}${constraints.length > 3 ? ` [+${constraints.length - 3} mais]` : ''}`;
+            }
+        } catch { /* ignore parse errors */ }
     }
+    content += "\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]`;
-                    }
+    return { name: "PRODUTO", content, priority: 7 };
+}
+
+function buildArchitectureSection(data: ContextData): ContextSection | null {
+    if (!data.archAnalysis) return null;
+
+    let content = `
+### ARQUITETURA (${data.archAnalysis.id})`;
+    if (data.archAnalysis.approach) {
+        const approachPreview = data.archAnalysis.approach.length > 500
+            ? data.archAnalysis.approach.substring(0, 500) + "..."
+            : data.archAnalysis.approach;
+        content += `\n**Abordagem:** ${approachPreview}`;
+    }
+    if (data.archAnalysis.risks) {
+        try {
+            const risks = JSON.parse(data.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);
+                content += `\n**Riscos:**`;
+                for (const r of risksToShow) {
+                    content += `\n  - ${r.description} (${r.probability}/${r.impact}) -> ${r.mitigation}`;
                 }
-            } 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]`;
-                    }
+                if (risks.length > risksToShow.length) {
+                    content += `\n  [+${risks.length - risksToShow.length} mais riscos]`;
                 }
-            } catch { /* ignore */ }
-        }
-        output += "\n";
+            }
+        } catch { /* ignore */ }
     }
+    if (data.archAnalysis.decisions) {
+        try {
+            const archDecisions = JSON.parse(data.archAnalysis.decisions);
+            if (archDecisions.length > 0) {
+                content += `\n**Decisoes arquiteturais:**`;
+                for (const d of archDecisions.slice(0, 5)) {
+                    content += `\n  - ${d.decision}: ${d.rationale || ''}`;
+                }
+                if (archDecisions.length > 5) {
+                    content += `\n  [+${archDecisions.length - 5} mais]`;
+                }
+            }
+        } catch { /* ignore */ }
+    }
+    content += "\n";
+
+    return { name: "ARQUITETURA", content, priority: 3 };
+}
 
-    // Standards
-    const requiredStds = relevantStandards.filter((s: any) => s.enforcement === 'required');
-    const recommendedStds = relevantStandards.filter((s: any) => s.enforcement === 'recommended');
+function buildStandardsSection(data: ContextData): ContextSection {
+    const requiredStds = data.relevantStandards.filter((s: any) => s.enforcement === 'required');
+    const recommendedStds = data.relevantStandards.filter((s: any) => s.enforcement === 'recommended');
 
-    output += `
-### STANDARDS (${relevantStandards.length})`;
+    let content = `
+### STANDARDS (${data.relevantStandards.length})`;
     if (requiredStds.length > 0) {
-        output += `\n**Obrigatorios:**\n${requiredStds.map((s: any) => `- ${s.rule}`).join("\n")}`;
+        content += `\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")}`;
+        content += `\n**Recomendados:**\n${recommendedStds.map((s: any) => `- ${s.rule}`).join("\n")}`;
     }
-    if (relevantStandards.length === 0) {
-        output += "\nNenhum standard aplicavel";
+    if (data.relevantStandards.length === 0) {
+        content += "\nNenhum standard aplicavel";
     }
-    output += "\n";
+    content += "\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"}
+    return { name: "STANDARDS", content, priority: 1 };
+}
+
+function buildDecisionsSection(data: ContextData): ContextSection {
+    const truncatedDecisions = data.allDecisions.length - data.decisions.length;
+    const content = `
+### DECISOES (${data.decisions.length}${truncatedDecisions > 0 ? ` [+${truncatedDecisions} mais - use: decisions list]` : ''})
+${data.decisions.length > 0 ? data.decisions.map((d) => `- **${d.title}**: ${d.decision}`).join("\n") : "Nenhuma"}
 `;
+    return { name: "DECISOES", content, priority: 4 };
+}
+
+function buildReasoningSection(data: ContextData): ContextSection | null {
+    if (data.depReasoning.length === 0) return null;
 
-    // Reasoning de tasks anteriores
-    if (depReasoning.length > 0) {
-        output += `
+    const content = `
 ### CONTEXTO DE TASKS ANTERIORES
-${depReasoning.map((r: any) => `- [Task #${r.fromTask}/${r.category}] ${r.thought}`).join("\n")}
+${data.depReasoning.map((r: any) => `- [Task #${r.fromTask}/${r.category}] ${r.thought}`).join("\n")}
 `;
-    }
+    return { name: "CONTEXTO DE TASKS ANTERIORES", content, priority: 5 };
+}
+
+function buildAlertsSection(data: ContextData): ContextSection | null {
+    if (data.criticalKnowledge.length === 0) return null;
 
-    // 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")}
+    const severityIcon: Record<string, string> = { warning: "!!", critical: "XX" };
+    const content = `
+### ALERTAS (${data.criticalKnowledge.length}${data.truncatedCritical > 0 ? ` [+${data.truncatedCritical} mais - use: knowledge list --severity warning]` : ''})
+${data.criticalKnowledge.map((k: any) => `[${severityIcon[k.severity] || "!"}] ${k.content}`).join("\n")}
 `;
-    }
+    return { name: "ALERTAS", content, priority: 2 };
+}
+
+function buildDiscoveriesSection(data: ContextData): ContextSection | null {
+    if (data.infoKnowledge.length === 0) return null;
 
-    // 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")}
+    const content = `
+### DISCOVERIES DE TASKS ANTERIORES (${data.infoKnowledge.length}${data.truncatedInfo > 0 ? ` [+${data.truncatedInfo} mais - use: knowledge list]` : ''})
+${data.infoKnowledge.map((k: any) => `- ${k.content}`).join("\n")}
 `;
-    }
+    return { name: "DISCOVERIES", content, priority: 8 };
+}
 
-    // Patterns de implementacao matchados
-    if (patterns.length > 0) {
-        output += `
-### PATTERNS DO PROJETO (${patterns.length})
-${patterns.map((p: any) => {
+function buildPatternsSection(data: ContextData): ContextSection | null {
+    let content = "";
+
+    if (data.patterns.length > 0) {
+        content += `
+### PATTERNS DO PROJETO (${data.patterns.length})
+${data.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"}`;
@@ -716,17 +701,28 @@ ${patterns.map((p: any) => {
 `;
     }
 
-    // v8.5: Utility Map (DRY prevention - Camada 1)
+    if (data.discoveredPatterns.length > 0) {
+        const patternsToShow = data.discoveredPatterns.slice(-10);
+        content += `
+### PATTERNS DESCOBERTOS (${data.discoveredPatterns.length})
+${data.discoveredPatterns.length > 10 ? `[mostrando ultimos 10 de ${data.discoveredPatterns.length}]\n` : ''}${patternsToShow.map((p: any) => `- ${p.pattern}${p.source_task ? ` (Task #${p.source_task})` : ""}`).join("\n")}
+`;
+    }
+
+    if (!content) return null;
+    return { name: "PATTERNS", content, priority: 9 };
+}
+
+function buildUtilitiesSection(data: ContextData): ContextSection | null {
     try {
-        const taskDirs = [...new Set(taskFiles.map((f: string) => {
+        const taskDirs = [...new Set(data.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;
+        const agentScope = data.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}`));
@@ -738,10 +734,11 @@ ${patterns.map((p: any) => {
             }
         }
 
-        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 += `
+        if (relevantUtilities.length === 0) return null;
+
+        const totalCount = (data.db.query("SELECT COUNT(*) as c FROM project_utilities").get() as any)?.c || 0;
+        const truncated = totalCount - relevantUtilities.length;
+        const content = `
 ### UTILITIES EXISTENTES (${relevantUtilities.length}${truncated > 0 ? ` [+${truncated} mais]` : ''})
 **REGRA DRY**: Reutilize ao inves de recriar. Importe do arquivo existente.
 ${relevantUtilities.map((u: any) => {
@@ -749,88 +746,61 @@ ${relevantUtilities.map((u: any) => {
     return `- **${u.utility_name}** [${u.utility_type}]${sig} <- \`${u.file_path}\``;
 }).join("\n")}
 `;
-        }
+        return { name: "UTILITIES", content, priority: 8 };
     } catch { /* tabela pode nao existir ainda */ }
+    return null;
+}
 
-    // 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";
-    }
+function buildGraphSection(data: ContextData): ContextSection | null {
+    let content = "";
 
-    // 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")}
+    if (data.graphDecisions.length > 0) {
+        content += `
+### DECISOES QUE AFETAM SEUS ARQUIVOS (${data.graphDecisions.length})
+${data.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.
-`;
-    }
+    if (!content) return null;
+    return { name: "GRAPH", content, priority: 6 };
+}
 
-    // 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")}
-`;
-    }
+function buildStackSection(data: ContextData): ContextSection | null {
+    let content = "";
 
-    // Stack
-    if (project) {
-        const stack = JSON.parse(project.stack);
+    if (data.project) {
+        const stack = JSON.parse(data.project.stack);
         const allStackEntries = Object.entries(stack);
         const mainStack = allStackEntries.slice(0, 6);
-        output += `
+        content += `
 ### STACK
 ${mainStack.map(([k, v]) => `${k}: ${v}`).join(" | ")}${allStackEntries.length > 6 ? ` [+${allStackEntries.length - 6} mais]` : ''}
 `;
     }
 
-    // Bibliotecas do projeto
-    if (libContexts.length > 0) {
-        output += `
+    if (data.libContexts.length > 0) {
+        content += `
 ### BIBLIOTECAS
-${libContexts.map((l: any) => `- ${l.lib_name}${l.version ? ` v${l.version}` : ""}`).join("\n")}
+${data.libContexts.map((l: any) => `- ${l.lib_name}${l.version ? ` v${l.version}` : ""}`).join("\n")}
 `;
     }
 
-    // Protocolo de retorno
+    if (!content) return null;
+    return { name: "STACK", content, priority: 11 };
+}
+
+// ── Assembly + Truncation ─────────────────────────────────────
+
+function assembleSections(header: string, sections: ContextSection[]): string {
+    // Sort by priority (lower = higher priority, kept during truncation)
+    const sorted = [...sections].sort((a, b) => a.priority - b.priority);
+
+    let output = header;
+    for (const section of sorted) {
+        output += section.content;
+    }
+
+    // Protocolo de retorno (sempre incluido)
     output += `
 ### RETORNO OBRIGATORIO
 \`\`\`json
@@ -840,18 +810,18 @@ ${libContexts.map((l: any) => `- ${l.lib_name}${l.version ? ` v${l.version}` : "
 
     // 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
+        const parts = output.split('\n### ');
+        let trimmed = parts[0]; // Sempre manter header
 
-        for (let i = 1; i < sections.length; i++) {
-            const candidate = trimmed + '\n### ' + sections[i];
+        for (let i = 1; i < parts.length; i++) {
+            const candidate = trimmed + '\n### ' + parts[i];
             if (candidate.length > MAX_CONTEXT_SIZE - 200) {
                 break;
             }
             trimmed = candidate;
         }
 
-        const omittedSections = sections.length - trimmed.split('\n### ').length;
+        const omittedSections = parts.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]`;
         }
@@ -862,6 +832,38 @@ ${libContexts.map((l: any) => `- ${l.lib_name}${l.version ? ` v${l.version}` : "
     return output;
 }
 
+// ── Main Entry Point ──────────────────────────────────────────
+
+export function getContextForSubagent(taskId: number): string {
+    initSchema();
+
+    const data = fetchContextData(taskId);
+    if (!data) return "ERRO: Task nao encontrada";
+
+    const header = `## CONTEXTO (Task #${data.task.number})
+
+**Feature:** ${data.spec.name}
+**Objetivo:** ${data.context?.objective || "N/A"}
+**Arquivos:** ${data.taskFiles.join(", ") || "Nenhum especificado"}
+`;
+
+    const sections = [
+        buildProductSection(data),
+        buildArchitectureSection(data),
+        buildStandardsSection(data),
+        buildDecisionsSection(data),
+        buildReasoningSection(data),
+        buildAlertsSection(data),
+        buildDiscoveriesSection(data),
+        buildPatternsSection(data),
+        buildUtilitiesSection(data),
+        buildGraphSection(data),
+        buildStackSection(data),
+    ].filter((s): s is ContextSection => s !== null);
+
+    return assembleSections(header, sections);
+}
+
 // v8.3: Filtrar decisoes relevantes com scoring melhorado
 function filterRelevantDecisions(decisions: any[], taskFiles: string[], maxCount: number): any[] {
     if (decisions.length === 0) return [];