aiwcli 0.10.2 → 0.11.0

package/dist/templates/cc-native/_cc-native/lib-ts/json-parser.ts

@@ -0,0 +1,162 @@
+/**
+ * JSON parsing utilities for LLM responses.
+ * See cc-native-plan-review-spec.md §4.10-4.11
+ */
+
+import type { ReviewData, Verdict } from "./types.js";
+import { logDebug, logWarn } from "../../_shared/lib-ts/base/logger.js";
+
+/**
+ * Try strict JSON parse. If that fails, attempt to extract the first {...} block.
+ *
+ * @param text - Raw text that may contain JSON
+ * @param requireFields - Optional list of field names to check for
+ * @returns Parsed dict or null if parsing failed entirely
+ */
+export function parseJsonMaybe(
+  text: string,
+  requireFields?: string[],
+): null | Record<string, unknown> {
+  const trimmed = text.trim();
+  if (!trimmed) return null;
+
+  let obj: null | Record<string, unknown> = null;
+  let parseMethod: null | string = null;
+
+  // Strict parse
+  try {
+    const parsed: unknown = JSON.parse(trimmed);
+    if (parsed !== null && typeof parsed === "object" && !Array.isArray(parsed)) {
+      obj = parsed as Record<string, unknown>;
+      parseMethod = "strict";
+    }
+  } catch {
+    // Fall through to heuristic
+  }
+
+  // Heuristic: try to extract a JSON object substring
+  if (obj === null) {
+    const start = trimmed.indexOf("{");
+    const end = trimmed.lastIndexOf("}");
+    if (start !== -1 && end !== -1 && end > start) {
+      const candidate = trimmed.slice(start, end + 1);
+      try {
+        const parsed: unknown = JSON.parse(candidate);
+        if (
+          parsed !== null &&
+          typeof parsed === "object" &&
+          !Array.isArray(parsed)
+        ) {
+          obj = parsed as Record<string, unknown>;
+          parseMethod = "heuristic";
+          logDebug(
+            "parse",
+            `Used heuristic extraction (chars ${start}-${end})`,
+          );
+        }
+      } catch {
+        logDebug(
+          "parse",
+          `Heuristic extraction failed for candidate at chars ${start}-${end}`,
+        );
+        return null;
+      }
+    }
+  }
+
+  // Validate required fields if parsed
+  if (obj && requireFields) {
+    const missing = requireFields.filter((f) => !(f in obj!) || !obj![f]);
+    if (missing.length > 0) {
+      logWarn(
+        "parse",
+        `Parsed JSON (${parseMethod}) missing/empty fields: ${JSON.stringify(missing)}`,
+      );
+      logDebug("parse", `Keys present: ${JSON.stringify(Object.keys(obj))}`);
+    }
+  }
+
+  return obj;
+}
+
+/**
+ * Validate/normalize parsed JSON to ReviewData shape with safe defaults.
+ *
+ * @param obj - Parsed JSON object (possibly null)
+ * @param defaultFixMsg - Default suggested_fix message for error case
+ * @returns Tuple of [ok, verdict, normalizedData]
+ */
+export function coerceToReview(
+  obj: null | Record<string, unknown>,
+  defaultFixMsg = "Retry or check configuration.",
+): [boolean, Verdict, ReviewData] {
+  if (!obj) {
+    logWarn("coerce", "No object provided to coerceToReview");
+    return [
+      false,
+      "error",
+      {
+        verdict: "fail",
+        summary: "No structured output returned.",
+        summary_source: "default",
+        issues: [
+          {
+            severity: "high",
+            category: "tooling",
+            issue: "Reviewer returned no JSON.",
+            suggested_fix: defaultFixMsg,
+          },
+        ],
+        missing_sections: [],
+        questions: [],
+      },
+    ];
+  }
+
+  const rawVerdict = obj.verdict;
+  let verdict: Verdict;
+  if (rawVerdict === "pass" || rawVerdict === "warn" || rawVerdict === "fail") {
+    verdict = rawVerdict;
+  } else {
+    logWarn(
+      "coerce",
+      `Invalid or missing verdict '${String(rawVerdict)}', defaulting to 'warn'`,
+    );
+    verdict = "warn";
+  }
+
+  // Log when fields are being defaulted
+  const summaryRaw = String(obj.summary ?? "").trim();
+  if (!summaryRaw) {
+    logWarn(
+      "coerce",
+      "summary missing or empty from parsed output, using default",
+    );
+    logDebug("coerce", `Raw object keys: ${JSON.stringify(Object.keys(obj))}`);
+    logDebug(
+      "coerce",
+      `verdict=${obj.verdict}, issues_count=${Array.isArray(obj.issues) ? (obj.issues as unknown[]).length : 0}`,
+    );
+  }
+
+  if (!obj.issues) {
+    logDebug("coerce", "issues array empty or missing");
+  }
+
+  const norm: ReviewData = {
+    verdict,
+    summary: summaryRaw || "No summary provided.",
+    summary_source: summaryRaw ? "reviewer" : "default",
+    issues: Array.isArray(obj.issues)
+      ? (obj.issues as ReviewData["issues"])
+      : [],
+    missing_sections: Array.isArray(obj.missing_sections)
+      ? (obj.missing_sections as string[])
+      : [],
+    questions: Array.isArray(obj.questions)
+      ? (obj.questions as string[])
+      : [],
+  };
+
+  return [true, verdict, norm];
+}

package/dist/templates/cc-native/_cc-native/lib-ts/nul

@@ -0,0 +1,3 @@
+FINDSTR: Cannot open I:/
+FINDSTR: Cannot open \.py
+FINDSTR: Cannot open reviewers*.ts

package/dist/templates/cc-native/_cc-native/lib-ts/orchestrator.ts

@@ -0,0 +1,249 @@
+/**
+ * Plan orchestrator — analyzes complexity and selects reviewer agents.
+ * See cc-native-plan-review-spec.md §4.8
+ */
+
+import { parseCliOutput } from "./cli-output-parser.js";
+import type { AgentConfig, ComplexityCategory, OrchestratorConfig, OrchestratorResult } from "./types.js";
+import { ORCHESTRATOR_SCHEMA } from "./types.js";
+import { logDebug, logError, logInfo, logWarn } from "../../_shared/lib-ts/base/logger.js";
+import { execFileAsync, findExecutable, getInternalSubprocessEnv } from "../../_shared/lib-ts/base/subprocess-utils.js";
+
+// ---------------------------------------------------------------------------
+// Constants
+// ---------------------------------------------------------------------------
+
+const DEFAULT_AGENT_SELECTION: Record<string, unknown> = {
+  simple: { min: 3, max: 3 },
+  medium: { min: 8, max: 8 },
+  high: { min: 12, max: 12 },
+  fallbackCount: 3,
+};
+
+const DEFAULT_COMPLEXITY_CATEGORIES = [
+  "code",
+  "infrastructure",
+  "documentation",
+  "life",
+  "business",
+  "design",
+  "research",
+];
+
+// ---------------------------------------------------------------------------
+// Schema Builder
+// ---------------------------------------------------------------------------
+
+/**
+ * Build orchestrator JSON schema with enum-constrained agent names.
+ */
+export function buildOrchestratorSchema(
+  validAgentNames: string[],
+  categories: string[],
+): Record<string, unknown> {
+  const itemsSchema: Record<string, unknown> = { type: "string" };
+  if (validAgentNames.length > 0) {
+    itemsSchema.enum = validAgentNames;
+  }
+
+  return {
+    type: "object",
+    properties: {
+      complexity: { type: "string", enum: ["simple", "medium", "high"] },
+      category: { type: "string", enum: categories },
+      selectedAgents: {
+        type: "array",
+        items: itemsSchema,
+      },
+      reasoning: { type: "string" },
+      skipReason: { type: "string" },
+    },
+    required: ["complexity", "category", "selectedAgents", "reasoning"],
+    additionalProperties: false,
+  };
+}
+
+// ---------------------------------------------------------------------------
+// Orchestrator
+// ---------------------------------------------------------------------------
+
+/**
+ * Run the orchestrator agent to analyze plan complexity and select reviewers.
+ * Never throws — returns fallback OrchestratorResult on failure.
+ */
+export async function runOrchestrator(
+  plan: string,
+  agentLibrary: AgentConfig[],
+  config: OrchestratorConfig,
+  settings: Record<string, unknown>,
+  mandatoryNames?: Set<string>,
+): Promise<OrchestratorResult> {
+  logInfo("orchestrator", "Starting plan analysis...");
+
+  const mandatory = mandatoryNames ?? new Set<string>();
+  const selection = (settings.agentSelection as Record<string, unknown>) ?? DEFAULT_AGENT_SELECTION;
+  const categories = (settings.complexityCategories as string[]) ?? DEFAULT_COMPLEXITY_CATEGORIES;
+  const fallbackCount = (selection.fallbackCount as number) ?? 2;
+
+  // Filter out mandatory agents — they always run
+  const nonMandatory = agentLibrary.filter(
+    (a) => a.enabled && !mandatory.has(a.name),
+  );
+  const validNames = nonMandatory.map((a) => a.name);
+
+  logDebug("orchestrator", `Mandatory agents (always run): ${[...mandatory].sort().join(", ")}`);
+  logDebug("orchestrator", `Non-mandatory agents for selection: ${validNames.join(", ")}`);
+
+  const claudePath = findExecutable("claude");
+  if (!claudePath) {
+    logWarn(
+      "orchestrator",
+      "Claude CLI not found on PATH, falling back to medium complexity",
+    );
+    return makeFallback(nonMandatory, fallbackCount, "Orchestrator skipped - Claude CLI not found", "claude CLI not found on PATH");
+  }
+
+  logDebug("orchestrator", `Found Claude CLI at: ${claudePath}`);
+
+  // Build agent list from non-mandatory agents
+  const agentList = nonMandatory
+    .map(
+      (a) =>
+        `- ${a.name} [${a.categories.join(", ")}]\n  Focus: ${a.focus}\n  Expertise: ${a.description}`,
+    )
+    .join("\n");
+  const categoryList = categories.join("/");
+
+  // Compute additional agent counts
+  const mandatoryCount = agentLibrary.filter((a) => mandatory.has(a.name)).length;
+  const simpleAdditional = Math.max(0, ((selection.simple as Record<string, number> | undefined)?.max ?? 3) - mandatoryCount);
+  const mediumAdditional = Math.max(0, ((selection.medium as Record<string, number> | undefined)?.max ?? 8) - mandatoryCount);
+  const highAdditional = Math.max(0, ((selection.high as Record<string, number> | undefined)?.max ?? 12) - mandatoryCount);
+
+  const systemPrompt = `You are a plan orchestrator for code review. Your job is to analyze plans and select appropriate reviewer agents.
+
+You MUST call StructuredOutput immediately with your analysis. Do NOT ask questions or use any other tools.
+
+When selecting agents:
+- Match agent expertise to plan requirements
+- Consider what each agent specializes in
+- Only select agents whose categories match the plan category
+- Fewer agents for simple plans, more for complex plans`;
+
+  const prompt = `Analyze this plan and select appropriate reviewer agents.
+
+Available agents (select ONLY from this list):
+${agentList}
+
+Selection rules (number of ADDITIONAL agents to select from the list above):
+- simple complexity = ${simpleAdditional} agents
+- medium complexity = ${mediumAdditional} agents
+- high complexity = ${highAdditional} agents
+- Only select agents whose categories match the plan category (${categoryList})
+- Non-technical plans (life, business) typically need 0 code-focused agents
+- Note: mandatory agents run separately and are NOT listed above
+
+PLAN:
+<<<
+${plan}
+>>>
+
+Call StructuredOutput now with: complexity, category, selectedAgents, reasoning`;
+
+  const schema =
+    validNames.length > 0
+      ? buildOrchestratorSchema(validNames, categories)
+      : ORCHESTRATOR_SCHEMA;
+  const schemaJson = JSON.stringify(schema);
+
+  const cmdArgs = [
+    "--model", config.model,
+    "--output-format", "json",
+    "--json-schema", schemaJson,
+    "--max-turns", "3",
+    "--setting-sources", "",
+    "--system-prompt", systemPrompt,
+    "-p",
+  ];
+
+  logInfo("orchestrator", `Running with model: ${config.model}, timeout: ${config.timeout}s`);
+
+  const env = getInternalSubprocessEnv();
+
+  const result = await execFileAsync(claudePath, cmdArgs, {
+    input: prompt,
+    timeout: config.timeout * 1000,
+    env: env as Record<string, string>,
+    maxBuffer: 10 * 1024 * 1024,
+  });
+
+  if (result.killed || result.signal === "SIGTERM") {
+    logWarn("orchestrator", `TIMEOUT after ${config.timeout}s, falling back to medium complexity`);
+    return makeFallback(nonMandatory, fallbackCount, "Orchestrator timed out - defaulting to medium complexity", `Orchestrator timed out after ${config.timeout}s`);
+  }
+
+  const raw = result.stdout.trim();
+  if (result.stderr) logDebug("orchestrator", `stderr: ${result.stderr.slice(0, 300)}`);
+
+  if (!raw && !result.stderr && result.exitCode !== 0) {
+    logError("orchestrator", `Process exited with code ${result.exitCode}, falling back to medium complexity`);
+    return makeFallback(nonMandatory, fallbackCount, `Orchestrator failed (exit ${result.exitCode})`, `Exit code ${result.exitCode}`);
+  }
+
+  const obj = parseCliOutput(raw);
+
+  logDebug("orchestrator", `Raw output length: ${raw.length} chars`);
+  if (raw) logDebug("orchestrator", `Raw output (first 500 chars): ${raw.slice(0, 500)}`);
+  logDebug("orchestrator", `Parsed obj: ${JSON.stringify(obj)}`);
+
+  if (!obj) {
+    logWarn("orchestrator", "Failed to parse output, falling back to medium complexity");
+    return makeFallback(nonMandatory, fallbackCount, "Orchestrator output could not be parsed", "Failed to parse orchestrator output");
+  }
+
+  // Extract and validate fields
+  const rawComplexity = String(obj.complexity ?? "medium");
+  const complexity: ComplexityCategory =
+    rawComplexity === "simple" || rawComplexity === "medium" || rawComplexity === "high"
+      ? rawComplexity
+      : "medium";
+
+  let category = (obj.category as string) ?? "code";
+  if (!categories.includes(category)) category = "code";
+
+  let {selectedAgents} = obj;
+  if (!Array.isArray(selectedAgents)) selectedAgents = [];
+
+  const reasoning = String(obj.reasoning ?? "").trim() || "No reasoning provided";
+  const skipReason = obj.skipReason as string | undefined;
+
+  logInfo("orchestrator", `Result: complexity=${complexity}, category=${category}, agents=${JSON.stringify(selectedAgents)}`);
+  logDebug("orchestrator", `Reasoning: ${reasoning}`);
+
+  return {
+    complexity,
+    category,
+    selected_agents: selectedAgents as string[],
+    reasoning,
+    skip_reason: skipReason || undefined,
+  };
+}
+
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+
+function makeFallback(
+  nonMandatory: AgentConfig[],
+  fallbackCount: number,
+  reasoning: string,
+  error: string,
+): OrchestratorResult {
+  return {
+    complexity: "medium",
+    category: "code",
+    selected_agents: nonMandatory.slice(0, fallbackCount).map((a) => a.name),
+    reasoning,
+    error,
+  };
+}

package/dist/templates/cc-native/_cc-native/lib-ts/reviewers/agent.ts

@@ -0,0 +1,155 @@
+/**
+ * Claude Code agent-based plan reviewer.
+ * Uses --system-prompt with agent persona for specialized review.
+ * See cc-native-plan-review-spec.md §4.10
+ */
+
+import * as _path from "node:path";
+
+import { logDebug, logError, logInfo, logWarn } from "../../../_shared/lib-ts/base/logger.js";
+import { execFileAsync, findExecutable, getInternalSubprocessEnv } from "../../../_shared/lib-ts/base/subprocess-utils.js";
+import { parseCliOutput } from "../cli-output-parser.js";
+import { debugLog, debugRaw } from "../debug.js";
+import { coerceToReview } from "../json-parser.js";
+import type { AgentConfig, ReviewerResult, ReviewOptions } from "../types.js";
+import { AGENT_REVIEW_PROMPT_PREFIX } from "../types.js";
+import { makeResult } from "./types.js";
+import type { Reviewer } from "./types.js";
+
+/**
+ * Agent reviewer — runs a Claude Code instance with a custom persona.
+ */
+export class AgentReviewer implements Reviewer {
+  constructor(private agent: AgentConfig) {}
+
+  async review(
+    plan: string,
+    schema: Record<string, unknown>,
+    options: ReviewOptions,
+  ): Promise<ReviewerResult> {
+    return runAgentReview(
+      plan,
+      this.agent,
+      schema,
+      options.timeout,
+      options.context_path,
+      options.session_name ?? "unknown",
+    );
+  }
+}
+
+/**
+ * Run a single Claude Code agent to review the plan.
+ * Never throws — returns error ReviewerResult on failure.
+ */
+export async function runAgentReview(
+  plan: string,
+  agent: AgentConfig,
+  schema: Record<string, unknown>,
+  timeout: number,
+  contextPath?: string,
+  sessionName = "unknown",
+): Promise<ReviewerResult> {
+  const claudePath = findExecutable("claude");
+  if (!claudePath) {
+    logWarn(agent.name, "Claude CLI not found on PATH");
+    return makeResult(agent.name, false, "skip", {}, "", "claude CLI not found on PATH");
+  }
+
+  logDebug(agent.name, `Found Claude CLI at: ${claudePath}`);
+
+  const prompt = `IMMEDIATELY call StructuredOutput with your review of the plan below.
+Do NOT output any text before calling StructuredOutput.
+
+PLAN:
+<<<
+${plan}
+>>>
+`;
+
+  const schemaJson = JSON.stringify(schema);
+  const cmdArgs = [
+    "--model", agent.model,
+    "--output-format", "json",
+    "--json-schema", schemaJson,
+    "--max-turns", "3",
+    "--setting-sources", "",
+    "-p",
+  ];
+
+  if (agent.system_prompt) {
+    const fullPrompt = AGENT_REVIEW_PROMPT_PREFIX + "\n\n---\n\n" + agent.system_prompt;
+    cmdArgs.push("--system-prompt", fullPrompt);
+  }
+
+  logInfo(agent.name, `Running with model: ${agent.model}, timeout: ${timeout}s`);
+
+  const env = getInternalSubprocessEnv();
+
+  const result = await execFileAsync(claudePath, cmdArgs, {
+    input: prompt,
+    timeout: timeout * 1000,
+    env: env as Record<string, string>,
+    maxBuffer: 10 * 1024 * 1024,
+  });
+
+  if (result.killed || result.signal === "SIGTERM") {
+    logWarn(agent.name, `TIMEOUT after ${timeout}s`);
+    return makeResult(agent.name, false, "error", {}, "", `${agent.name} timed out after ${timeout}s`);
+  }
+
+  const raw = result.stdout.trim();
+  const err = result.stderr.trim();
+
+  if (!raw && !err && result.exitCode !== 0) {
+    logError(agent.name, `Process exited with code ${result.exitCode} and no output`);
+    return makeResult(agent.name, false, "error", {}, "", `${agent.name} failed to run (exit ${result.exitCode})`);
+  }
+
+  logDebug(agent.name, `Exit code: ${result.exitCode}`);
+  logDebug(agent.name, `stdout length: ${raw.length} chars`);
+  if (err) logDebug(agent.name, `stderr: ${err.slice(0, 500)}`);
+
+  // Debug logging
+  if (contextPath) {
+    debugRaw(contextPath, sessionName, `agent:${agent.name}`, "stdout", raw);
+    if (err) {
+      debugRaw(contextPath, sessionName, `agent:${agent.name}`, "stderr", err);
+    }
+
+    debugLog(contextPath, sessionName, `agent:${agent.name}`, "subprocess_info", {
+      exit_code: result.exitCode,
+      stdout_len: raw.length,
+      stderr_len: err.length,
+      model: agent.model,
+      timeout,
+    });
+  }
+
+  if (raw) logDebug(agent.name, `stdout preview: ${raw.slice(0, 500)}`);
+
+  const obj = parseCliOutput(raw, ["verdict", "summary"]);
+
+  if (contextPath) {
+    debugLog(contextPath, sessionName, `agent:${agent.name}`, "parsed_result", {
+      parsed_keys: obj ? Object.keys(obj) : null,
+      verdict: obj?.verdict ?? null,
+      has_summary: obj ? Boolean(obj.summary) : false,
+      issues_count: obj && Array.isArray(obj.issues) ? (obj.issues as unknown[]).length : 0,
+    });
+  }
+
+  if (obj) {
+    logInfo(agent.name, `Parsed JSON successfully, verdict: ${obj.verdict ?? "N/A"}`);
+  } else {
+    logWarn(agent.name, "Failed to parse JSON from output");
+  }
+
+  const [ok, verdict, norm] = coerceToReview(
+    obj as null | Record<string, unknown>,
+    "Retry or check agent configuration.",
+  );
+
+  return makeResult(agent.name, ok, verdict, norm, raw, err);
+}
+

package/dist/templates/cc-native/_cc-native/lib-ts/reviewers/codex.ts

@@ -0,0 +1,130 @@
+/**
+ * Codex CLI plan reviewer.
+ * Runs Codex in non-interactive mode with read-only sandbox.
+ * See cc-native-plan-review-spec.md §4.11
+ */
+
+import * as fs from "node:fs";
+import * as os from "node:os";
+import * as path from "node:path";
+
+import { logDebug, logError, logInfo as _logInfo, logWarn } from "../../../_shared/lib-ts/base/logger.js";
+import { execFileAsync, findExecutable } from "../../../_shared/lib-ts/base/subprocess-utils.js";
+import { coerceToReview, parseJsonMaybe } from "../json-parser.js";
+import { REVIEW_PROMPT_PREFIX } from "../types.js";
+import type { ReviewerResult, ReviewOptions } from "../types.js";
+import { makeResult } from "./types.js";
+import type { Reviewer } from "./types.js";
+
+/**
+ * Codex reviewer — runs codex exec --sandbox read-only.
+ */
+export class CodexReviewer implements Reviewer {
+  private settings: Record<string, unknown>;
+
+  constructor(settings: Record<string, unknown>) {
+    this.settings = settings;
+  }
+
+  async review(
+    plan: string,
+    schema: Record<string, unknown>,
+    _options: ReviewOptions,
+  ): Promise<ReviewerResult> {
+    return runCodexReview(plan, schema, this.settings);
+  }
+}
+
+/**
+ * Run Codex CLI to review the plan.
+ * Never throws — returns error ReviewerResult on failure.
+ */
+export async function runCodexReview(
+  plan: string,
+  schema: Record<string, unknown>,
+  settings: Record<string, unknown>,
+): Promise<ReviewerResult> {
+  const codexSettings =
+    ((settings.reviewers as Record<string, unknown> | undefined)?.codex as
+      | Record<string, unknown>
+      | undefined) ?? {};
+  const timeout = (codexSettings.timeout as number) ?? 120;
+  const model = (codexSettings.model as string) ?? "";
+
+  const codexPath = findExecutable("codex");
+  if (!codexPath) {
+    logWarn("codex", "CLI not found on PATH");
+    return makeResult("codex", false, "skip", {}, "", "codex CLI not found on PATH");
+  }
+
+  logDebug("codex", `Found CLI at: ${codexPath}`);
+
+  const prompt = `${REVIEW_PROMPT_PREFIX}
+Return ONLY a JSON object that matches this JSON Schema:
+${JSON.stringify(schema)}
+
+PLAN:
+<<<
+${plan}
+>>>
+`;
+
+  const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "codex-review-"));
+
+  try {
+    const schemaPath = path.join(tmpDir, "schema.json");
+    const outPath = path.join(tmpDir, "codex_review.json");
+
+    fs.writeFileSync(schemaPath, JSON.stringify(schema, null, 2), "utf-8");
+
+    const cmdArgs = ["exec", "--sandbox", "read-only"];
+
+    if (model) {
+      cmdArgs.push("--model", model);
+    }
+
+    cmdArgs.push("--output-schema", schemaPath, "-o", outPath, "-");
+
+    logDebug("codex", `Running command: codex ${cmdArgs.join(" ")}`);
+
+    const result = await execFileAsync(codexPath, cmdArgs, {
+      input: prompt,
+      timeout: timeout * 1000,
+      maxBuffer: 10 * 1024 * 1024,
+    });
+
+    if (result.killed || result.signal === "SIGTERM") {
+      logWarn("codex", `TIMEOUT after ${timeout}s`);
+      return makeResult("codex", false, "error", {}, "", `codex timed out after ${timeout}s`);
+    }
+
+    if (!result.stdout && !result.stderr && !fs.existsSync(outPath) && result.exitCode !== 0) {
+      logError("codex", `Process exited with code ${result.exitCode} and no output`);
+      return makeResult("codex", false, "error", {}, "", `codex failed to run (exit ${result.exitCode})`);
+    }
+
+    logDebug("codex", `Exit code: ${result.exitCode}`);
+
+    let raw = "";
+    if (fs.existsSync(outPath)) {
+      raw = fs.readFileSync(outPath, "utf8");
+    }
+
+    const obj = parseJsonMaybe(raw) ?? parseJsonMaybe(result.stdout);
+    const [ok, verdict, norm] = coerceToReview(
+      obj,
+      "Retry or check CLI auth/config.",
+    );
+
+    const err = result.stderr.trim();
+    return makeResult("codex", ok, verdict, norm, raw || result.stdout, err);
+  } finally {
+    // Clean up temp directory
+    try {
+      fs.rmSync(tmpDir, { recursive: true, force: true });
+    } catch {
+      // Best effort cleanup
+    }
+  }
+}
+