@codexa/cli 9.0.2 → 9.0.4

package/commands/plan.test.ts

@@ -0,0 +1,73 @@
+import { describe, it, expect } from "bun:test";
+import { generateSpecId } from "./plan";
+
+describe("generateSpecId", () => {
+  it("generates ID with date-slug-hash format", () => {
+    const id = generateSpecId("Add user authentication");
+    // Format: YYYY-MM-DD-slug-hash
+    expect(id).toMatch(/^\d{4}-\d{2}-\d{2}-[a-z0-9-]+-[a-z0-9]{4}$/);
+  });
+
+  it("normalizes slug to lowercase", () => {
+    const id = generateSpecId("Add User Auth");
+    const parts = id.split("-");
+    // After date (3 parts), all slug parts should be lowercase
+    const slugAndHash = parts.slice(3).join("-");
+    expect(slugAndHash).toBe(slugAndHash.toLowerCase());
+  });
+
+  it("removes special characters from slug", () => {
+    const id = generateSpecId("Add auth (v2) @special!");
+    // Should not contain (, ), @, !
+    expect(id).not.toMatch(/[()@!]/);
+  });
+
+  it("truncates slug at 30 characters", () => {
+    const longName = "This is a very long feature name that exceeds thirty characters by a lot";
+    const id = generateSpecId(longName);
+    // Date is YYYY-MM-DD (10 chars) + dash + slug (max 30) + dash + hash (4)
+    const parts = id.split("-");
+    // date = parts[0]-parts[1]-parts[2], hash = last part
+    const datePart = parts.slice(0, 3).join("-"); // YYYY-MM-DD
+    const hashPart = parts[parts.length - 1]; // 4 char hash
+    const slugPart = parts.slice(3, -1).join("-"); // everything between date and hash
+    expect(slugPart.length).toBeLessThanOrEqual(30);
+  });
+
+  it("includes a 4-character hash suffix", () => {
+    const id = generateSpecId("Test feature");
+    const parts = id.split("-");
+    const hash = parts[parts.length - 1];
+    expect(hash.length).toBe(4);
+    // Hash should be base36
+    expect(hash).toMatch(/^[a-z0-9]+$/);
+  });
+
+  it("starts with today's date", () => {
+    const id = generateSpecId("Some feature");
+    const today = new Date().toISOString().split("T")[0];
+    expect(id.startsWith(today)).toBe(true);
+  });
+
+  it("generates different IDs for different names", () => {
+    const id1 = generateSpecId("Feature A");
+    const id2 = generateSpecId("Feature B");
+    expect(id1).not.toBe(id2);
+  });
+
+  it("removes trailing dashes from slug", () => {
+    const id = generateSpecId("test-feature-");
+    // Should not have double dashes or trailing dash before hash
+    expect(id).not.toMatch(/--/);
+  });
+
+  it("handles empty-ish name gracefully", () => {
+    const id = generateSpecId("a");
+    expect(id).toMatch(/^\d{4}-\d{2}-\d{2}-a-[a-z0-9]{4}$/);
+  });
+
+  it("converts spaces and special chars to dashes", () => {
+    const id = generateSpecId("add user auth");
+    expect(id).toContain("add-user-auth");
+  });
+});

package/commands/plan.ts

@@ -1,13 +1,17 @@
 import { getDb } from "../db/connection";
 import { initSchema, getArchitecturalAnalysisForSpec } from "../db/schema";
+import { resolveSpec } from "./spec-resolver";
+import { CodexaError, ValidationError } from "../errors";
 
-function generateSpecId(name: string): string {
+export function generateSpecId(name: string): string {
     const date = new Date().toISOString().split("T")[0];
     const slug = name
         .toLowerCase()
         .replace(/[^a-z0-9]+/g, "-")
+        .replace(/-+$/, "")
         .substring(0, 30);
-    return `${date}-${slug}`;
+    const hash = Bun.hash(name + Date.now()).toString(36).substring(0, 4);
+    return `${date}-${slug}-${hash}`;
 }
 
 // v8.4: Suporte a --from-analysis para import automatico de baby steps
@@ -15,28 +19,6 @@ export function planStart(description: string, options: { fromAnalysis?: string;
     initSchema();
     const db = getDb();
 
-    // Verificar se ja existe spec ativo (ignorar completed e cancelled)
-    const existing = db
-        .query("SELECT * FROM specs WHERE phase NOT IN ('completed', 'cancelled') ORDER BY created_at DESC LIMIT 1")
-        .get() as any;
-
-    if (existing) {
-        if (options.json) {
-            console.log(JSON.stringify({
-                error: "FEATURE_ACTIVE",
-                name: existing.name,
-                id: existing.id,
-                phase: existing.phase,
-            }));
-        } else {
-            console.error(`\nJa existe uma feature ativa: ${existing.name} (${existing.id})`);
-            console.error(`Fase atual: ${existing.phase}`);
-            console.error(`\nPara continuar, use: status`);
-            console.error(`Para cancelar a atual, use: plan cancel\n`);
-        }
-        process.exit(1);
-    }
-
     // v8.4: Buscar analise arquitetural se --from-analysis fornecido
     let analysis: any = null;
     if (options.fromAnalysis) {
@@ -50,7 +32,7 @@ export function planStart(description: string, options: { fromAnalysis?: string;
             } else {
                 console.error(`\n[ERRO] Analise arquitetural '${options.fromAnalysis}' nao encontrada.\n`);
             }
-            process.exit(1);
+            throw new CodexaError(`Analise arquitetural '${options.fromAnalysis}' nao encontrada.`);
         }
 
         if (analysis.status !== "approved") {
@@ -60,7 +42,7 @@ export function planStart(description: string, options: { fromAnalysis?: string;
                 console.error(`\n[ERRO] Analise '${analysis.id}' nao esta aprovada (status: ${analysis.status}).`);
                 console.error("Use 'architect approve' primeiro.\n");
             }
-            process.exit(1);
+            throw new CodexaError(`Analise '${analysis.id}' nao esta aprovada (status: ${analysis.status}). Use 'architect approve' primeiro.`);
         }
     } else {
         // v8.4: Auto-deteccao por nome
@@ -159,19 +141,11 @@ export function planStart(description: string, options: { fromAnalysis?: string;
     }
 }
 
-export function planShow(json: boolean = false): void {
+export function planShow(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;
-
-    if (!spec) {
-        console.error("\nNenhuma feature ativa.");
-        console.error("Inicie com: /codexa:feature'\n");
-        process.exit(1);
-    }
+    const spec = resolveSpec(specId);
 
     const tasks = db
         .query("SELECT * FROM tasks WHERE spec_id = ? ORDER BY number")
@@ -225,25 +199,12 @@ export function planTaskAdd(options: {
     depends?: string;
     files?: string;
     sequential?: boolean;
+    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.");
-        console.error("Inicie com: /codexa:feature\n");
-        process.exit(1);
-    }
-
-    if (spec.phase !== "planning") {
-        console.error(`\nNao e possivel adicionar tasks na fase '${spec.phase}'.`);
-        console.error("Tasks so podem ser adicionadas na fase 'planning'.\n");
-        process.exit(1);
-    }
+    const spec = resolveSpec(options.specId, ["planning"]);
 
     // Pegar proximo numero
     const lastTask = db
@@ -260,8 +221,7 @@ export function planTaskAdd(options: {
                 .query("SELECT id FROM tasks WHERE spec_id = ? AND number = ?")
                 .get(spec.id, depId);
             if (!exists) {
-                console.error(`\nDependencia invalida: task #${depId} nao existe.\n`);
-                process.exit(2);
+                throw new ValidationError(`Dependencia invalida: task #${depId} nao existe.`);
             }
         }
 
@@ -300,10 +260,9 @@ export function planTaskAdd(options: {
         }
 
         if (hasCycle(nextNumber)) {
-            console.error(`\nERRO: Dependencia circular detectada!`);
-            console.error(`Task #${nextNumber} -> [${dependsOn.join(", ")}] cria um ciclo.`);
-            console.error(`Corrija as dependencias para evitar deadlocks.\n`);
-            process.exit(2);
+            throw new ValidationError(
+              `Dependencia circular detectada! Task #${nextNumber} -> [${dependsOn.join(", ")}] cria um ciclo.\nCorrija as dependencias para evitar deadlocks.`
+            );
         }
     }
 
@@ -342,18 +301,11 @@ export function planTaskAdd(options: {
     console.log(`  Paralelizavel: ${options.sequential ? "Nao" : "Sim"}\n`);
 }
 
-export function planCancel(): void {
+export function planCancel(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 para cancelar.\n");
-        process.exit(1);
-    }
+    const spec = resolveSpec(specId);
 
     const now = new Date().toISOString();
 

package/commands/product.ts

@@ -2,6 +2,7 @@ import { getDb } from "../db/connection";
 import { initSchema } from "../db/schema";
 import { existsSync, readFileSync, writeFileSync } from "fs";
 import { join } from "path";
+import { CodexaError } from "../errors";
 
 interface ProductContext {
   name: string;
@@ -93,15 +94,13 @@ export function productImport(options: { file?: string; content?: string }): voi
 
   if (options.file) {
     if (!existsSync(options.file)) {
-      console.error(`\nArquivo nao encontrado: ${options.file}\n`);
-      process.exit(1);
+      throw new CodexaError("Arquivo nao encontrado: " + options.file);
     }
     prdContent = readFileSync(options.file, "utf-8");
   } else if (options.content) {
     prdContent = options.content;
   } else {
-    console.error("\nForneca --file ou --content\n");
-    process.exit(1);
+    throw new CodexaError("Forneca --file ou --content");
   }
 
   // Salvar como pendente para o agente processar
@@ -286,21 +285,15 @@ export function productConfirm(): void {
 
   const pending = db.query("SELECT * FROM product_context WHERE id = 'pending'").get() as any;
   if (!pending) {
-    console.error("\nNenhum contexto de produto pendente.");
-    console.error("Execute: product guide ou product import primeiro\n");
-    process.exit(1);
+    throw new CodexaError("Nenhum contexto de produto pendente.\nExecute: product guide ou product import primeiro");
   }
 
   // Validar campos obrigatorios
   if (!pending.name || pending.name === "Pendente") {
-    console.error("\nCampo obrigatorio ausente: name");
-    console.error("Use: product set --name \"Nome do Produto\"\n");
-    process.exit(1);
+    throw new CodexaError("Campo obrigatorio ausente: name\nUse: product set --name \"Nome do Produto\"");
   }
   if (!pending.problem || pending.problem === "") {
-    console.error("\nCampo obrigatorio ausente: problem");
-    console.error("Use: product set --problem \"Problema que resolve\"\n");
-    process.exit(1);
+    throw new CodexaError("Campo obrigatorio ausente: problem\nUse: product set --problem \"Problema que resolve\"");
   }
 
   const now = new Date().toISOString();
@@ -358,12 +351,10 @@ export function productShow(options: { json?: boolean; pending?: boolean } = {})
 
   if (!product) {
     if (options.pending) {
-      console.error("\nNenhum contexto pendente.");
+      throw new CodexaError("Nenhum contexto pendente.");
     } else {
-      console.error("\nContexto de produto nao definido.");
-      console.error("Execute: product guide ou product import\n");
+      throw new CodexaError("Contexto de produto nao definido.\nExecute: product guide ou product import");
     }
-    process.exit(1);
   }
 
   const goals = db.query(`SELECT * FROM product_goals WHERE product_id = ? ORDER BY priority, category`).all(id) as any[];

package/commands/research.ts

@@ -2,6 +2,7 @@ import { getDb } from "../db/connection";
 import { initSchema } from "../db/schema";
 import { existsSync, readFileSync, writeFileSync, mkdirSync } from "fs";
 import { join } from "path";
+import { CodexaError } from "../errors";
 import { getDetectors } from "../detectors/loader";
 
 // ============================================================
@@ -359,7 +360,7 @@ export async function researchStart(options: { json?: boolean } = {}): Promise<v
             console.error("Certifique-se de estar na raiz do projeto.");
             console.error("Ecossistemas suportados: Node.js, Python, Go, .NET, Rust, Java/Kotlin, Flutter\n");
         }
-        process.exit(1);
+        throw new CodexaError("Nenhum ecossistema ou biblioteca detectada.\nCertifique-se de estar na raiz do projeto.");
     }
 
     const libContextDir = ensureLibContextDir();
@@ -517,7 +518,7 @@ export function researchShow(options: { json?: boolean; lib?: string } = {}): vo
             console.error("\nNenhuma biblioteca registrada.");
             console.error("Execute: research start\n");
         }
-        process.exit(1);
+        throw new CodexaError("Nenhuma biblioteca registrada.\nExecute: research start");
     }
 
     if (options.json) {
@@ -590,7 +591,7 @@ export function researchFill(libName: string, options: { json?: boolean } = {}):
             console.error(`\nBiblioteca '${libName}' nao encontrada.`);
             console.error("Execute: research show para ver bibliotecas disponiveis.\n");
         }
-        process.exit(1);
+        throw new CodexaError("Biblioteca '" + libName + "' nao encontrada.\nExecute: research show para ver bibliotecas disponiveis.");
     }
 
     const versionStr = lib.version && lib.version !== "latest" ? lib.version : "latest";

package/commands/review.ts

@@ -1,17 +1,135 @@
 import { getDb } from "../db/connection";
 import { initSchema, getArchitecturalAnalysisForSpec } from "../db/schema";
 import { enforceGate } from "../gates/validator";
+import { resolveSpec } from "./spec-resolver";
+import { CodexaError, GateError } from "../errors";
+
+// ═══════════════════════════════════════════════════════════════
+// P1-2: Review Score — Threshold Automatico
+// ═══════════════════════════════════════════════════════════════
+
+export interface ReviewScore {
+  total: number;        // 0-100
+  breakdown: {
+    tasksCompleted: number;      // % tasks done vs planned (25 pts)
+    gatesPassedClean: number;    // % gates sem bypass (25 pts)
+    filesDelivered: number;      // % arquivos planejados vs criados (25 pts)
+    standardsFollowed: number;   // % standards sem violacao (25 pts)
+  };
+  autoApproveEligible: boolean;  // score >= 80 AND zero critical bypasses
+  mustReviewItems: string[];     // Items que exigem atencao humana
+}
+
+export function calculateReviewScore(specId: string): ReviewScore {
+  const db = getDb();
+
+  const mustReviewItems: string[] = [];
+
+  // 1. Tasks: (completed / total) * 25
+  const totalTasks = (db.query(
+    "SELECT COUNT(*) as c FROM tasks WHERE spec_id = ?"
+  ).get(specId) as any).c;
+  const completedTasks = (db.query(
+    "SELECT COUNT(*) as c FROM tasks WHERE spec_id = ? AND status = 'done'"
+  ).get(specId) as any).c;
+  const tasksCompleted = totalTasks > 0
+    ? Math.round((completedTasks / totalTasks) * 25)
+    : 25;
+
+  if (completedTasks < totalTasks) {
+    mustReviewItems.push(`${totalTasks - completedTasks} task(s) nao concluida(s)`);
+  }
+
+  // 2. Gates: (clean passes / total gate events) * 25
+  // Total gate events = tasks * 7 gates per task
+  const totalGateEvents = totalTasks * 7;
+  const bypassCount = (db.query(
+    "SELECT COUNT(*) as c FROM gate_bypasses WHERE spec_id = ?"
+  ).get(specId) as any).c;
+  const cleanGateEvents = Math.max(0, totalGateEvents - bypassCount);
+  const gatesPassedClean = totalGateEvents > 0
+    ? Math.round((cleanGateEvents / totalGateEvents) * 25)
+    : 25;
+
+  // Check for critical bypasses
+  const criticalBypasses = db.query(
+    "SELECT * FROM gate_bypasses WHERE spec_id = ? AND gate_name IN ('standards-follow', 'dry-check', 'typecheck-pass')"
+  ).all(specId) as any[];
+  if (criticalBypasses.length > 0) {
+    mustReviewItems.push(`${criticalBypasses.length} bypass(es) de gates criticos`);
+  }
+
+  // 3. Files: (delivered / planned) * 25
+  const plannedFiles = db.query(
+    "SELECT files FROM tasks WHERE spec_id = ? AND files IS NOT NULL"
+  ).all(specId) as any[];
+  const allPlannedFiles = new Set<string>();
+  for (const t of plannedFiles) {
+    try {
+      const files = JSON.parse(t.files) as string[];
+      for (const f of files) allPlannedFiles.add(f);
+    } catch { /* ignore */ }
+  }
+
+  const deliveredFiles = new Set(
+    (db.query(
+      "SELECT DISTINCT path FROM artifacts WHERE spec_id = ?"
+    ).all(specId) as any[]).map(a => a.path)
+  );
+
+  let filesDelivered: number;
+  if (allPlannedFiles.size === 0) {
+    filesDelivered = deliveredFiles.size > 0 ? 25 : 0;
+  } else {
+    let matchCount = 0;
+    for (const f of allPlannedFiles) {
+      if (deliveredFiles.has(f)) matchCount++;
+    }
+    filesDelivered = Math.round((matchCount / allPlannedFiles.size) * 25);
+  }
+
+  const missingFiles = [...allPlannedFiles].filter(f => !deliveredFiles.has(f));
+  if (missingFiles.length > 0) {
+    mustReviewItems.push(`${missingFiles.length} arquivo(s) planejado(s) nao entregue(s)`);
+  }
 
-export function reviewStart(json: boolean = false): void {
+  // 4. Standards: (followed / total) * 25
+  // Inverse of standards-follow bypasses relative to total tasks
+  const standardsBypasses = (db.query(
+    "SELECT COUNT(*) as c FROM gate_bypasses WHERE spec_id = ? AND gate_name = 'standards-follow'"
+  ).get(specId) as any).c;
+  const standardsFollowed = totalTasks > 0
+    ? Math.round(((totalTasks - standardsBypasses) / totalTasks) * 25)
+    : 25;
+
+  if (standardsBypasses > 0) {
+    mustReviewItems.push(`${standardsBypasses} bypass(es) de standards`);
+  }
+
+  const total = tasksCompleted + gatesPassedClean + filesDelivered + standardsFollowed;
+  const autoApproveEligible = total >= 80 && criticalBypasses.length === 0;
+
+  return {
+    total,
+    breakdown: {
+      tasksCompleted,
+      gatesPassedClean,
+      filesDelivered,
+      standardsFollowed,
+    },
+    autoApproveEligible,
+    mustReviewItems,
+  };
+}
+
+export function reviewStart(json: boolean = false, specId?: string): void {
   initSchema();
   enforceGate("review-start");
 
   const db = getDb();
   const now = new Date().toISOString();
 
-  const spec = db
-    .query("SELECT * FROM specs WHERE phase = 'implementing' ORDER BY created_at DESC LIMIT 1")
-    .get() as any;
+  const spec = resolveSpec(specId, ["implementing"]);
 
   const tasks = db
     .query("SELECT * FROM tasks WHERE spec_id = ? ORDER BY number")
@@ -87,8 +205,11 @@ export function reviewStart(json: boolean = false): void {
   // Atualizar fase
   db.run("UPDATE specs SET phase = 'reviewing', updated_at = ? WHERE id = ?", [now, spec.id]);
 
+  // P1-2: Calcular score automatico
+  const score = calculateReviewScore(spec.id);
+
   if (json) {
-    console.log(JSON.stringify({ spec, reviewData, deviations }));
+    console.log(JSON.stringify({ spec, reviewData, deviations, score }));
     return;
   }
 
@@ -96,6 +217,25 @@ export function reviewStart(json: boolean = false): void {
   console.log(`REVIEW: ${spec.name}`);
   console.log(`${"=".repeat(60)}`);
 
+  // P1-2: Mostrar score
+  const scoreIcon = score.total >= 80 ? "[OK]" : score.total >= 50 ? "[!]" : "[X]";
+  console.log(`\n${scoreIcon} REVIEW SCORE: ${score.total}/100`);
+  console.log(`  Tasks concluidas:    ${score.breakdown.tasksCompleted}/25`);
+  console.log(`  Gates limpos:        ${score.breakdown.gatesPassedClean}/25`);
+  console.log(`  Arquivos entregues:  ${score.breakdown.filesDelivered}/25`);
+  console.log(`  Standards seguidos:  ${score.breakdown.standardsFollowed}/25`);
+
+  if (score.autoApproveEligible) {
+    console.log(`\n  Elegivel para aprovacao automatica.`);
+  }
+
+  if (score.mustReviewItems.length > 0) {
+    console.log(`\n  Items que exigem atencao:`);
+    for (const item of score.mustReviewItems) {
+      console.log(`    - ${item}`);
+    }
+  }
+
   console.log(`\nResumo da implementacao:`);
   console.log(`  Tasks concluidas: ${tasks.length}`);
   console.log(`  Artefatos criados: ${artifacts.length}`);
@@ -123,24 +263,48 @@ export function reviewStart(json: boolean = false): void {
     console.log(`\nNenhum desvio encontrado.`);
   }
 
-  console.log(`\nPara aprovar: review approve`);
+  if (score.total < 50) {
+    console.log(`\n[!] Score abaixo de 50. Aprovacao requer: review approve --force --force-reason "motivo"`);
+  } else {
+    console.log(`\nPara aprovar: review approve`);
+  }
   console.log(`Para ver status: status\n`);
 }
 
-export function reviewApprove(): void {
+export function reviewApprove(options?: { specId?: string; force?: boolean; forceReason?: string } | string): void {
   initSchema();
   enforceGate("review-approve");
 
   const db = getDb();
   const now = new Date().toISOString();
 
-  const spec = db
-    .query("SELECT * FROM specs WHERE phase = 'reviewing' ORDER BY created_at DESC LIMIT 1")
-    .get() as any;
+  // Backward compat: accept string (old API) or options object
+  const opts = typeof options === "string"
+    ? { specId: options }
+    : (options || {});
+
+  const spec = resolveSpec(opts.specId, ["reviewing"]);
+
+  // P1-2: Enforce minimum score
+  const score = calculateReviewScore(spec.id);
+  if (score.total < 50 && !opts.force) {
+    throw new GateError(
+      `Review score muito baixo: ${score.total}/100.\n` +
+      `  Items criticos:\n` +
+      score.mustReviewItems.map(i => `    - ${i}`).join("\n"),
+      `Use: review approve --force --force-reason "motivo" para aprovar mesmo assim`,
+      "review-approve"
+    );
+  }
 
-  if (!spec) {
-    console.error("\nNenhum review em andamento.\n");
-    process.exit(1);
+  if (score.total < 50 && opts.force) {
+    // Log the forced approval
+    db.run(
+      `INSERT INTO gate_bypasses (spec_id, task_id, gate_name, reason, created_at)
+       VALUES (?, 0, 'review-low-score', ?, ?)`,
+      [spec.id, opts.forceReason || `Score ${score.total}/100 - forced approval`, now]
+    );
+    console.log(`\n[!] Review aprovado com score baixo (${score.total}/100). Bypass registrado.`);
   }
 
   // Atualizar review
@@ -175,27 +339,19 @@ export function reviewApprove(): void {
   ]);
 
   // Mostrar relatorio final completo
-  showReviewReport(spec, tasks, artifacts, decisions, knowledge, review);
+  showReviewReport(spec, tasks, artifacts, decisions, knowledge, review, score);
 }
 
 /**
  * Pula o review e finaliza a feature diretamente
  */
-export function reviewSkip(): void {
+export function reviewSkip(specId?: string): void {
   initSchema();
 
   const db = getDb();
   const now = new Date().toISOString();
 
-  // Buscar spec em implementacao com todas tasks concluidas
-  const spec = db
-    .query("SELECT * FROM specs WHERE phase = 'implementing' ORDER BY created_at DESC LIMIT 1")
-    .get() as any;
-
-  if (!spec) {
-    console.error("\nNenhuma feature em fase de implementacao.\n");
-    process.exit(1);
-  }
+  const spec = resolveSpec(specId, ["implementing"]);
 
   // Verificar se todas tasks estao done
   const pending = db
@@ -203,9 +359,7 @@ export function reviewSkip(): void {
     .get(spec.id) as any;
 
   if (pending.c > 0) {
-    console.error(`\nAinda existem ${pending.c} tasks pendentes.`);
-    console.error("Complete todas as tasks antes de pular o review.\n");
-    process.exit(1);
+    throw new CodexaError(`Ainda existem ${pending.c} tasks pendentes.\nComplete todas as tasks antes de pular o review.`);
   }
 
   // Buscar dados
@@ -265,7 +419,8 @@ function showReviewReport(
   artifacts: any[],
   decisions: any[],
   knowledge: any[],
-  review: any
+  review: any,
+  score?: ReviewScore
 ): void {
   const reviewData = review.planned_vs_done ? JSON.parse(review.planned_vs_done) : {};
   const deviations = review.deviations ? JSON.parse(review.deviations) : [];
@@ -278,6 +433,13 @@ function showReviewReport(
   console.log(`   Status: ✅ COMPLETA E APROVADA`);
   console.log(`   ID: ${spec.id}`);
 
+  // P1-2: Score no relatorio final
+  if (score) {
+    const scoreIcon = score.total >= 80 ? "✅" : score.total >= 50 ? "⚠️" : "❌";
+    console.log(`   Score: ${scoreIcon} ${score.total}/100`);
+    console.log(`     Tasks: ${score.breakdown.tasksCompleted}/25 | Gates: ${score.breakdown.gatesPassedClean}/25 | Files: ${score.breakdown.filesDelivered}/25 | Standards: ${score.breakdown.standardsFollowed}/25`);
+  }
+
   // Resumo de execucao
   console.log(`\n${"─".repeat(60)}`);
   console.log(`📊 RESUMO DA EXECUCAO`);