@codexa/cli 9.0.22 → 9.0.24

package/commands/review.ts

@@ -4,6 +4,7 @@ import { enforceGate } from "../gates/validator";
 import { resolveSpec } from "./spec-resolver";
 import { CodexaError, GateError } from "../errors";
 import { cleanupContextFiles } from "../context/file-writer";
+import { simplifyAudit } from "./simplify";
 
 // ═══════════════════════════════════════════════════════════════
 // P1-2: Review Score — Threshold Automatico
@@ -264,6 +265,17 @@ export function reviewStart(json: boolean = false, specId?: string): void {
     console.log(`\nNenhum desvio encontrado.`);
   }
 
+  // v10.1: Simplify audit
+  try {
+    const simplifyContextPath = simplifyAudit(spec.id);
+    if (simplifyContextPath) {
+      console.log(`\nAuditoria de Simplificacao:`);
+      console.log(`  Prompt gerado com standards do projeto`);
+      console.log(`  Contexto: ${simplifyContextPath}`);
+      console.log(`  Invoque o simplifier agent em modo audit para analise de qualidade`);
+    }
+  } catch { /* nao-critico */ }
+
   if (score.total < 50) {
     console.log(`\n[!] Score abaixo de 50. Aprovacao requer: review approve --force --force-reason "motivo"`);
   } else {

package/commands/simplify.ts

@@ -0,0 +1,142 @@
+// ═══════════════════════════════════════════════════════════════
+// SIMPLIFY COMMAND (v10.1)
+// Generates simplification prompts enriched with Codexa standards.
+// Used post-task (Option A) and pre-review (Option C).
+// ═══════════════════════════════════════════════════════════════
+
+import { getDb } from "../db/connection";
+import { initSchema } from "../db/schema";
+import { resolveSpec } from "./spec-resolver";
+import { getAgentDomain, domainToScope } from "../context/domains";
+import { CodexaError } from "../errors";
+import {
+  buildSimplifyPrompt,
+  writeSimplifyContext,
+  type SimplifyFile,
+  type SimplifyMode,
+} from "../simplify/prompt-builder";
+
+// ═══════════════════════════════════════════════════════════════
+// SIMPLIFY FOR TASK (Option A)
+// ═══════════════════════════════════════════════════════════════
+
+export function simplifyTask(
+  taskId: string,
+  options: { audit?: boolean; specId?: string } = {}
+): void {
+  initSchema();
+
+  const db = getDb();
+  const id = parseInt(taskId);
+  const task = db.query("SELECT * FROM tasks WHERE id = ?").get(id) as any;
+
+  if (!task) {
+    throw new CodexaError(`Task #${id} nao encontrada.`);
+  }
+
+  if (task.status !== "done") {
+    throw new CodexaError(
+      `Task #${id} nao esta concluida (status: ${task.status}). Complete com 'task done' primeiro.`
+    );
+  }
+
+  // Get files from artifacts
+  const artifacts = db
+    .query(
+      "SELECT path, action FROM artifacts WHERE spec_id = ? AND task_ref = ?"
+    )
+    .all(task.spec_id, task.number) as any[];
+
+  if (artifacts.length === 0) {
+    console.log(`\nTask #${task.number} nao tem arquivos registrados. Nada para simplificar.\n`);
+    return;
+  }
+
+  const files: SimplifyFile[] = artifacts.map((a: any) => ({
+    path: a.path,
+    action: a.action === "created" ? "created" as const : "modified" as const,
+  }));
+
+  // Determine agent domain for scope filtering
+  const domain = getAgentDomain(task.agent);
+  const scope = domainToScope(domain);
+  const mode: SimplifyMode = options.audit ? "audit" : "refactor";
+
+  // Build prompt with standards
+  const prompt = buildSimplifyPrompt(files, scope, mode);
+
+  // Write context file
+  const contextPath = writeSimplifyContext(`task-${task.number}`, prompt);
+
+  // Output
+  const modeLabel = mode === "audit" ? "AUDITORIA" : "REFATORACAO";
+  console.log(`\n${"=".repeat(55)}`);
+  console.log(`SIMPLIFY (${modeLabel}) — Task #${task.number}`);
+  console.log(`${"=".repeat(55)}`);
+  console.log(`  Arquivos: ${files.length}`);
+  console.log(`  Scope: ${scope}`);
+  console.log(`  Modo: ${mode}`);
+  console.log(`  Contexto: ${contextPath}`);
+  console.log(`\n  O orchestrador deve invocar o simplifier agent com o prompt acima.`);
+  console.log(`  Leia o contexto com: Read ${contextPath}`);
+  console.log(`${"=".repeat(55)}\n`);
+}
+
+// ═══════════════════════════════════════════════════════════════
+// SIMPLIFY AUDIT FOR REVIEW (Option C)
+// ═══════════════════════════════════════════════════════════════
+
+export function simplifyAudit(specId?: string): string | null {
+  initSchema();
+
+  const db = getDb();
+  const spec = resolveSpec(specId, ["implementing", "reviewing"]);
+
+  // Get all feature artifacts
+  const artifacts = db
+    .query("SELECT DISTINCT path, action FROM artifacts WHERE spec_id = ?")
+    .all(spec.id) as any[];
+
+  if (artifacts.length === 0) {
+    return null;
+  }
+
+  const files: SimplifyFile[] = artifacts.map((a: any) => ({
+    path: a.path,
+    action: a.action === "created" ? "created" as const : "modified" as const,
+  }));
+
+  // Use "all" scope for review (covers all domains)
+  const prompt = buildSimplifyPrompt(files, "all", "audit");
+
+  // Write context file
+  const contextPath = writeSimplifyContext(`audit-${spec.id}`, prompt);
+
+  return contextPath;
+}
+
+// ═══════════════════════════════════════════════════════════════
+// AUTO-SIMPLIFY CHECK
+// ═══════════════════════════════════════════════════════════════
+
+export function isAutoSimplifyEnabled(): boolean {
+  try {
+    const db = getDb();
+    const project = db
+      .query("SELECT auto_simplify FROM project WHERE id = 'default'")
+      .get() as any;
+    return project?.auto_simplify === 1;
+  } catch {
+    return false;
+  }
+}
+
+export function setAutoSimplify(enabled: boolean): void {
+  initSchema();
+  const db = getDb();
+  db.run(
+    "UPDATE project SET auto_simplify = ?, updated_at = ? WHERE id = 'default'",
+    [enabled ? 1 : 0, new Date().toISOString()]
+  );
+  console.log(`\nauto_simplify ${enabled ? "habilitado" : "desabilitado"}.\n`);
+}

package/commands/task.ts

@@ -16,6 +16,8 @@ import { getModelForTask } from "../context/model-profiles";
 import { getContextBudget, formatContextWarning, estimateTokens } from "../context/monitor";
 import { invalidateCache } from "../context/cache";
 import { cleanupContextFiles } from "../context/file-writer";
+import { isAutoSimplifyEnabled } from "./simplify";
+import { buildSimplifyPrompt, writeSimplifyContext, type SimplifyFile } from "../simplify/prompt-builder";
 
 export function taskNext(json: boolean = false, specId?: string): void {
   initSchema();
@@ -369,7 +371,7 @@ export function taskStart(ids: string, json: boolean = false, minimalContext: bo
   console.log(`\nAo concluir, use: task done <id> --checkpoint "resumo"\n`);
 }
 
-export function taskDone(id: string, options: { checkpoint: string; files?: string; force?: boolean; forceReason?: string; output?: string }): void {
+export function taskDone(id: string, options: { checkpoint: string; files?: string; force?: boolean; forceReason?: string; output?: string; simplify?: boolean }): void {
   initSchema();
 
   const taskId = parseInt(id);
@@ -505,6 +507,26 @@ export function taskDone(id: string, options: { checkpoint: string; files?: stri
 
   // Nota: Validacao de standards agora e feita pelo Gate 4.2 (standards-follow) em enforceGate
 
+  // v10.1: Simplify pos-task (opt-in)
+  try {
+    const shouldSimplify = options.simplify || isAutoSimplifyEnabled();
+    if (shouldSimplify && expectedFiles.length > 0) {
+      const domain = getAgentDomain(task.agent);
+      const scope = domainToScope(domain);
+      const simplifyFiles: SimplifyFile[] = expectedFiles.map((f: string) => ({
+        path: f,
+        action: (subagentData?.files_created?.includes(f) ? "created" : "modified") as "created" | "modified",
+      }));
+
+      const prompt = buildSimplifyPrompt(simplifyFiles, scope, "refactor");
+      const contextPath = writeSimplifyContext(`task-${task.number}`, prompt);
+
+      console.log(`\n[simplify] Prompt gerado com ${simplifyFiles.length} arquivo(s) e standards do projeto`);
+      console.log(`[simplify] Contexto: ${contextPath}`);
+      console.log(`[simplify] Invoque o simplifier agent com o prompt acima`);
+    }
+  } catch { /* nao-critico: nao falhar task done por simplify */ }
+
   // v9.0: Atualizar patterns incrementalmente com arquivos da task
   try {
     if (subagentData && subagentData.status === "completed") {

package/db/schema.ts

@@ -496,6 +496,13 @@ const MIGRATIONS: Migration[] = [
       db.exec(`ALTER TABLE context ADD COLUMN current_phase INTEGER DEFAULT 1`);
     },
   },
+  {
+    version: "10.1.0",
+    description: "Adicionar auto_simplify na tabela project para simplificacao automatica pos-task",
+    up: (db) => {
+      db.exec(`ALTER TABLE project ADD COLUMN auto_simplify INTEGER DEFAULT 0`);
+    },
+  },
 ];
 
 export function runMigrations(): void {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@codexa/cli",
-  "version": "9.0.22",
+  "version": "9.0.24",
   "description": "Orchestrated workflow system for Claude Code - manages feature development through parallel subagents with structured phases, gates, and quality enforcement.",
   "type": "module",
   "bin": {
@@ -15,6 +15,7 @@
     "gates/",
     "protocol/",
     "detectors/",
+    "simplify/",
     "templates/"
   ],
   "scripts": {

package/simplify/prompt-builder.test.ts

@@ -0,0 +1,256 @@
+import { describe, it, expect, beforeEach } from "bun:test";
+import { getDb } from "../db/connection";
+import { initSchema, runMigrations } from "../db/schema";
+import {
+  buildSimplifyPrompt,
+  getStandardsForSimplify,
+  formatStandardsBlock,
+  type SimplifyFile,
+} from "./prompt-builder";
+import { writeFileSync, mkdirSync, existsSync, rmSync } from "fs";
+import { join } from "path";
+
+// ═══════════════════════════════════════════════════════════════
+// HELPERS
+// ═══════════════════════════════════════════════════════════════
+
+const TMP_DIR = join(process.cwd(), ".codexa", "test-tmp-simplify");
+
+function ensureTmpDir() {
+  if (!existsSync(TMP_DIR)) {
+    mkdirSync(TMP_DIR, { recursive: true });
+  }
+}
+
+function createTmpFile(name: string, content: string): string {
+  ensureTmpDir();
+  const path = join(TMP_DIR, name);
+  writeFileSync(path, content);
+  return path;
+}
+
+function insertStandard(opts: {
+  category: string;
+  scope: string;
+  rule: string;
+  enforcement?: string;
+  examples?: string;
+  anti_examples?: string;
+  semantic_query?: string | null;
+}) {
+  const db = getDb();
+  db.run(
+    `INSERT INTO standards (category, scope, rule, examples, anti_examples, enforcement, semantic_query, expect, source, created_at)
+     VALUES (?, ?, ?, ?, ?, ?, ?, 'no_match', 'test', datetime('now'))`,
+    [
+      opts.category,
+      opts.scope,
+      opts.rule,
+      opts.examples || null,
+      opts.anti_examples || null,
+      opts.enforcement || "required",
+      opts.semantic_query || null,
+    ]
+  );
+}
+
+// ═══════════════════════════════════════════════════════════════
+// TESTS
+// ═══════════════════════════════════════════════════════════════
+
+describe("simplify prompt-builder", () => {
+  beforeEach(() => {
+    initSchema();
+    runMigrations();
+    const db = getDb();
+    db.run("DELETE FROM standards");
+    // Cleanup tmp
+    if (existsSync(TMP_DIR)) {
+      rmSync(TMP_DIR, { recursive: true, force: true });
+    }
+  });
+
+  // ── getStandardsForSimplify ─────────────────────────────────
+
+  describe("getStandardsForSimplify", () => {
+    it("returns standards filtered by scope", () => {
+      insertStandard({ category: "code", scope: "all", rule: "Global rule" });
+      insertStandard({ category: "code", scope: "backend", rule: "Backend rule" });
+      insertStandard({ category: "code", scope: "frontend", rule: "Frontend rule" });
+
+      const backendStds = getStandardsForSimplify("backend");
+      expect(backendStds.length).toBe(2);
+      expect(backendStds.map(s => s.rule)).toContain("Global rule");
+      expect(backendStds.map(s => s.rule)).toContain("Backend rule");
+      expect(backendStds.map(s => s.rule)).not.toContain("Frontend rule");
+    });
+
+    it("returns all standards when scope is 'all'", () => {
+      insertStandard({ category: "code", scope: "all", rule: "Global rule" });
+      insertStandard({ category: "code", scope: "backend", rule: "Backend rule" });
+
+      const allStds = getStandardsForSimplify("all");
+      expect(allStds.length).toBe(1);
+      expect(allStds[0].rule).toBe("Global rule");
+    });
+
+    it("returns empty array when no standards exist", () => {
+      const stds = getStandardsForSimplify("backend");
+      expect(stds.length).toBe(0);
+    });
+
+    it("orders required before recommended", () => {
+      insertStandard({ category: "code", scope: "all", rule: "Recommended", enforcement: "recommended" });
+      insertStandard({ category: "code", scope: "all", rule: "Required", enforcement: "required" });
+
+      const stds = getStandardsForSimplify("all");
+      expect(stds[0].rule).toBe("Required");
+      expect(stds[1].rule).toBe("Recommended");
+    });
+  });
+
+  // ── formatStandardsBlock ────────────────────────────────────
+
+  describe("formatStandardsBlock", () => {
+    it("formats standards with examples and anti_examples", () => {
+      const standards = [
+        {
+          id: 1,
+          category: "code",
+          scope: "all",
+          rule: "Use function declaration",
+          examples: JSON.stringify(["function foo() {}"]),
+          anti_examples: JSON.stringify(["const foo = () => {}"]),
+          enforcement: "required",
+          semantic_query: null,
+        },
+      ];
+
+      const block = formatStandardsBlock(standards);
+      expect(block).toContain("## Standards do Projeto");
+      expect(block).toContain("### Obrigatorios (required)");
+      expect(block).toContain("[code] Use function declaration");
+      expect(block).toContain("Bom: function foo() {}");
+      expect(block).toContain("Ruim: const foo = () => {}");
+    });
+
+    it("formats standards with semantic_query", () => {
+      const standards = [
+        {
+          id: 1,
+          category: "practice",
+          scope: "all",
+          rule: "No console.log in production",
+          examples: null,
+          anti_examples: null,
+          enforcement: "required",
+          semantic_query: "console.log statements in non-test files",
+        },
+      ];
+
+      const block = formatStandardsBlock(standards);
+      expect(block).toContain('Detectar: "console.log statements in non-test files"');
+    });
+
+    it("separates required and recommended sections", () => {
+      const standards = [
+        {
+          id: 1, category: "code", scope: "all", rule: "Required rule",
+          examples: null, anti_examples: null, enforcement: "required", semantic_query: null,
+        },
+        {
+          id: 2, category: "code", scope: "all", rule: "Recommended rule",
+          examples: null, anti_examples: null, enforcement: "recommended", semantic_query: null,
+        },
+      ];
+
+      const block = formatStandardsBlock(standards);
+      expect(block).toContain("### Obrigatorios (required)");
+      expect(block).toContain("### Recomendados (recommended)");
+      expect(block).toContain("Required rule");
+      expect(block).toContain("Recommended rule");
+    });
+
+    it("returns empty string when no standards", () => {
+      expect(formatStandardsBlock([])).toBe("");
+    });
+  });
+
+  // ── buildSimplifyPrompt ─────────────────────────────────────
+
+  describe("buildSimplifyPrompt", () => {
+    it("builds refactor prompt with standards and files", () => {
+      insertStandard({
+        category: "code",
+        scope: "all",
+        rule: "Use function declarations",
+        examples: JSON.stringify(["function foo() {}"]),
+        anti_examples: JSON.stringify(["const foo = () => {}"]),
+      });
+
+      const filePath = createTmpFile("test.ts", "export function hello() {}");
+      const files: SimplifyFile[] = [{ path: filePath, action: "created" }];
+
+      const prompt = buildSimplifyPrompt(files, "all", "refactor");
+
+      expect(prompt).toContain("## Standards do Projeto");
+      expect(prompt).toContain("Use function declarations");
+      expect(prompt).toContain("## Arquivos para Simplificar");
+      expect(prompt).toContain("(criado)");
+      expect(prompt).toContain("## Instrucoes");
+      expect(prompt).toContain("Preservem funcionalidade");
+    });
+
+    it("builds audit prompt with analysis-only instructions", () => {
+      insertStandard({ category: "code", scope: "all", rule: "Some rule" });
+
+      const filePath = createTmpFile("test2.ts", "export const x = 1;");
+      const files: SimplifyFile[] = [{ path: filePath, action: "modified" }];
+
+      const prompt = buildSimplifyPrompt(files, "all", "audit");
+
+      expect(prompt).toContain("NAO aplique mudancas");
+      expect(prompt).toContain("reporte oportunidades");
+      expect(prompt).toContain("(modificado)");
+    });
+
+    it("handles no standards gracefully", () => {
+      const filePath = createTmpFile("test3.ts", "export const y = 2;");
+      const files: SimplifyFile[] = [{ path: filePath, action: "created" }];
+
+      const prompt = buildSimplifyPrompt(files, "all", "refactor");
+
+      // Should still have files and instructions sections
+      expect(prompt).toContain("## Arquivos para Simplificar");
+      expect(prompt).toContain("## Instrucoes");
+      // Should NOT have standards section
+      expect(prompt).not.toContain("## Standards do Projeto");
+    });
+
+    it("filters out non-existing files", () => {
+      const filePath = createTmpFile("exists.ts", "export const z = 3;");
+      const files: SimplifyFile[] = [
+        { path: filePath, action: "created" },
+        { path: "/nonexistent/file.ts", action: "modified" },
+      ];
+
+      const prompt = buildSimplifyPrompt(files, "all", "refactor");
+
+      expect(prompt).toContain("exists.ts");
+      expect(prompt).not.toContain("nonexistent");
+    });
+
+    it("filters standards by scope", () => {
+      insertStandard({ category: "code", scope: "backend", rule: "Backend only rule" });
+      insertStandard({ category: "code", scope: "frontend", rule: "Frontend only rule" });
+
+      const filePath = createTmpFile("test4.ts", "export const a = 1;");
+      const files: SimplifyFile[] = [{ path: filePath, action: "created" }];
+
+      const prompt = buildSimplifyPrompt(files, "backend", "refactor");
+
+      expect(prompt).toContain("Backend only rule");
+      expect(prompt).not.toContain("Frontend only rule");
+    });
+  });
+});

package/simplify/prompt-builder.ts

@@ -0,0 +1,198 @@
+// ═══════════════════════════════════════════════════════════════
+// SIMPLIFY PROMPT BUILDER (v10.1)
+// Builds rich simplification prompts using Codexa standards
+// from SQLite. Generates context files for the simplifier agent.
+// ═══════════════════════════════════════════════════════════════
+
+import { getDb } from "../db/connection";
+import { existsSync } from "fs";
+import { resolve, join } from "path";
+import { ensureContextDir } from "../context/file-writer";
+
+// ═══════════════════════════════════════════════════════════════
+// INTERFACES
+// ═══════════════════════════════════════════════════════════════
+
+interface StandardRow {
+  id: number;
+  category: string;
+  scope: string;
+  rule: string;
+  examples: string | null;
+  anti_examples: string | null;
+  enforcement: string;
+  semantic_query: string | null;
+}
+
+export interface SimplifyFile {
+  path: string;
+  action: "created" | "modified";
+}
+
+export type SimplifyMode = "refactor" | "audit";
+
+// ═══════════════════════════════════════════════════════════════
+// STANDARDS RETRIEVAL
+// ═══════════════════════════════════════════════════════════════
+
+export function getStandardsForSimplify(agentDomain: string): StandardRow[] {
+  const db = getDb();
+  return db
+    .query(
+      `SELECT id, category, scope, rule, examples, anti_examples, enforcement, semantic_query
+       FROM standards
+       WHERE (scope = 'all' OR scope = ?)
+       ORDER BY enforcement DESC, category`
+    )
+    .all(agentDomain) as StandardRow[];
+}
+
+// ═══════════════════════════════════════════════════════════════
+// STANDARDS FORMATTING
+// ═══════════════════════════════════════════════════════════════
+
+export function formatStandardsBlock(standards: StandardRow[]): string {
+  if (standards.length === 0) return "";
+
+  const required = standards.filter(s => s.enforcement === "required");
+  const recommended = standards.filter(s => s.enforcement === "recommended");
+
+  let block = "## Standards do Projeto\n";
+
+  if (required.length > 0) {
+    block += "\n### Obrigatorios (required)\n";
+    block += formatStandardsList(required);
+  }
+
+  if (recommended.length > 0) {
+    block += "\n### Recomendados (recommended)\n";
+    block += formatStandardsList(recommended);
+  }
+
+  return block;
+}
+
+function formatStandardsList(standards: StandardRow[]): string {
+  let result = "";
+
+  for (const std of standards) {
+    result += `\n- [${std.category}] ${std.rule}`;
+
+    // Add good examples
+    const examples = parseJsonArray(std.examples);
+    if (examples.length > 0) {
+      for (const ex of examples.slice(0, 2)) {
+        result += `\n  Bom: ${ex}`;
+      }
+    }
+
+    // Add bad examples (anti-patterns)
+    const antiExamples = parseJsonArray(std.anti_examples);
+    if (antiExamples.length > 0) {
+      for (const anti of antiExamples.slice(0, 2)) {
+        result += `\n  Ruim: ${anti}`;
+      }
+    }
+
+    // Add semantic detection hint
+    if (std.semantic_query) {
+      result += `\n  Detectar: "${std.semantic_query}"`;
+    }
+  }
+
+  return result + "\n";
+}
+
+function parseJsonArray(json: string | null): string[] {
+  if (!json) return [];
+  try {
+    const parsed = JSON.parse(json);
+    return Array.isArray(parsed) ? parsed : [];
+  } catch {
+    return [];
+  }
+}
+
+// ═══════════════════════════════════════════════════════════════
+// PROMPT BUILDER
+// ═══════════════════════════════════════════════════════════════
+
+export function buildSimplifyPrompt(
+  files: SimplifyFile[],
+  agentDomain: string,
+  mode: SimplifyMode
+): string {
+  const standards = getStandardsForSimplify(agentDomain);
+  const existingFiles = files.filter(f => existsSync(f.path));
+
+  let prompt = "";
+
+  // Standards section
+  const standardsBlock = formatStandardsBlock(standards);
+  if (standardsBlock) {
+    prompt += standardsBlock + "\n";
+  }
+
+  // Files section
+  prompt += "## Arquivos para Simplificar\n\n";
+  if (existingFiles.length === 0) {
+    prompt += "Nenhum arquivo encontrado.\n";
+  } else {
+    for (const file of existingFiles) {
+      prompt += `- \`${file.path}\` (${file.action === "created" ? "criado" : "modificado"})\n`;
+    }
+  }
+
+  // Instructions section
+  prompt += "\n## Instrucoes\n\n";
+
+  if (mode === "refactor") {
+    prompt += `Voce e um especialista em simplificacao de codigo. Analise os arquivos listados e aplique refinamentos que:
+
+1. **Preservem funcionalidade**: Nunca altere o que o codigo faz — apenas como faz.
+2. **Sigam os standards acima**: Aplique todas as regras obrigatorias. Considere as recomendadas.
+3. **Melhorem clareza**: Reduza complexidade, nesting, redundancias, abstracoes desnecessarias.
+4. **Mantenham equilibrio**: Evite over-simplificacao. Codigo explicito > codigo compacto.
+5. **Foquem no escopo**: Apenas refine os arquivos listados.
+
+Apos simplificar, liste as mudancas significativas realizadas.`;
+  } else {
+    prompt += `Voce e um especialista em simplificacao de codigo. Analise os arquivos listados e reporte oportunidades de simplificacao.
+
+**NAO aplique mudancas.** Apenas gere um relatorio com:
+
+1. **Oportunidades por arquivo**: Liste cada oportunidade com severidade (alta/media/baixa).
+2. **Violacoes de standards**: Identifique codigo que viola os standards obrigatorios acima.
+3. **Over-engineering**: Identifique abstracoes desnecessarias, complexidade excessiva.
+4. **Resumo**: Contagem de oportunidades por severidade.
+
+Formato do relatorio:
+\`\`\`
+### <arquivo>
+- [alta] <descricao da oportunidade>
+- [media] <descricao>
+- [baixa] <descricao>
+
+### Resumo
+- Alta: N oportunidades
+- Media: N oportunidades
+- Baixa: N oportunidades
+\`\`\``;
+  }
+
+  return prompt;
+}
+
+// ═══════════════════════════════════════════════════════════════
+// CONTEXT FILE WRITER
+// ═══════════════════════════════════════════════════════════════
+
+export function writeSimplifyContext(
+  identifier: string,
+  content: string
+): string {
+  const dir = ensureContextDir();
+  const filePath = join(dir, `simplify-${identifier}.md`);
+  Bun.write(filePath, content);
+  return resolve(filePath);
+}

package/workflow.ts

@@ -269,6 +269,7 @@ taskCmd
   .option("--files <files>", "Arquivos criados/modificados (extraido automaticamente de --output)")
   .option("--force", "Ignorar validacao de standards (sera registrado)")
   .option("--force-reason <reason>", "Motivo do bypass de validacao")
+  .option("--simplify", "Gerar prompt de simplificacao com standards do projeto")
   .action(wrapAction((id: string, options) => {
     // Resolver --output-file: ler conteudo do arquivo
     if (options.outputFile && !options.output) {
@@ -305,6 +306,7 @@ taskCmd
       force: options.force,
       forceReason: options.forceReason,
       output: options.output,
+      simplify: options.simplify,
     });
   }));
 
@@ -318,6 +320,20 @@ taskCmd
     taskPhaseAdvance({ noCompact: options.compact === false, json: options.json, spec: options.spec });
   }));
 
+// ═══════════════════════════════════════════════════════════════
+// SIMPLIFY (v10.1)
+// ═══════════════════════════════════════════════════════════════
+
+program
+  .command("simplify <taskId>")
+  .description("Gera prompt de simplificacao com standards do projeto para uma task")
+  .option("--audit", "Modo auditoria (apenas relatorio, sem aplicar mudancas)")
+  .option("--spec <id>", "ID do spec (padrao: mais recente)")
+  .action(wrapAction((taskId: string, options) => {
+    const { simplifyTask } = require("./commands/simplify");
+    simplifyTask(taskId, { audit: options.audit, specId: options.spec });
+  }));
+
 // ═══════════════════════════════════════════════════════════════
 // DECISOES
 // ═══════════════════════════════════════════════════════════════
@@ -610,6 +626,8 @@ discoverCmd
   .option("--testing <value>", "Testing (vitest, jest, playwright)")
   .option("--typecheck-command <cmd>", "Comando custom de typecheck (ex: 'mypy --strict', 'go vet ./...'). Vazio para usar preset automatico.")
   .option("--grepai-workspace <name>", "Nome do workspace grepai para busca semantica cross-project. Vazio para remover.")
+  .option("--auto-simplify", "Habilitar simplificacao automatica pos-task com standards do projeto")
+  .option("--no-auto-simplify", "Desabilitar simplificacao automatica pos-task")
   .action((options) => {
     // Tratar typecheck-command separadamente
     if (options.typecheckCommand !== undefined) {
@@ -648,10 +666,16 @@ discoverCmd
       // Auto-regenerate deep-explore agent with new workspace config
       ensureDeepExploreAgent();
     }
+    // Tratar auto-simplify
+    if (options.autoSimplify !== undefined) {
+      const { setAutoSimplify } = require("./commands/simplify");
+      setAutoSimplify(!!options.autoSimplify);
+    }
     // Tratar stack options normalmente
     const stackOptions = { ...options };
     delete stackOptions.typecheckCommand;
     delete stackOptions.grepaiWorkspace;
+    delete stackOptions.autoSimplify;
     if (Object.keys(stackOptions).length > 0) {
       discoverSetStack(stackOptions);
     }