aiwcli 0.11.0 → 0.11.1

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

@@ -73,6 +73,7 @@ export {
 
 // Iteration state
 export {
+  DEFAULT_REVIEW_ITERATIONS,
   deleteState,
   getIterationState,
   getStateFilePath,

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

@@ -73,6 +73,12 @@ export function parseJsonMaybe(
         `Parsed JSON (${parseMethod}) missing/empty fields: ${JSON.stringify(missing)}`,
       );
       logDebug("parse", `Keys present: ${JSON.stringify(Object.keys(obj))}`);
+      // Heuristic extraction grabbed the wrong object — reject it.
+      // Strict parse still returns partial objects (caller handles defaults).
+      if (parseMethod === "heuristic") {
+        logWarn("parse", "Rejecting heuristic result due to missing required fields");
+        return null;
+      }
     }
   }
 
@@ -137,7 +143,7 @@ export function coerceToReview(
       "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");

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

@@ -3,11 +3,11 @@
  * See cc-native-plan-review-spec.md §4.8
  */
 
+import { logDebug, logInfo, logWarn, logError } from "../../_shared/lib-ts/base/logger.js";
+import { getInternalSubprocessEnv, findExecutable, execFileAsync } from "../../_shared/lib-ts/base/subprocess-utils.js";
 import { parseCliOutput } from "./cli-output-parser.js";
-import type { AgentConfig, ComplexityCategory, OrchestratorConfig, OrchestratorResult } from "./types.js";
+import type { AgentConfig, OrchestratorConfig, OrchestratorResult, ComplexityCategory } 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
@@ -175,6 +175,7 @@ Call StructuredOutput now with: complexity, category, selectedAgents, reasoning`
     timeout: config.timeout * 1000,
     env: env as Record<string, string>,
     maxBuffer: 10 * 1024 * 1024,
+    shell: process.platform === "win32",
   });
 
   if (result.killed || result.signal === "SIGTERM") {
@@ -211,7 +212,7 @@ Call StructuredOutput now with: complexity, category, selectedAgents, reasoning`
   let category = (obj.category as string) ?? "code";
   if (!categories.includes(category)) category = "code";
 
-  let {selectedAgents} = obj;
+  let selectedAgents = obj.selectedAgents;
   if (!Array.isArray(selectedAgents)) selectedAgents = [];
 
   const reasoning = String(obj.reasoning ?? "").trim() || "No reasoning provided";

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

@@ -1,23 +1,24 @@
 /**
- * Claude Code agent-based plan reviewer.
- * Uses --system-prompt with agent persona for specialized review.
+ * Agent-based plan reviewer with multi-provider support.
+ * Routes to Claude or Codex CLI based on agent.provider field.
  * 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 * as fs from "node:fs";
+import * as os from "node:os";
+import * as path from "node:path";
+import { logDebug, logInfo, logWarn, logError } from "../../../_shared/lib-ts/base/logger.js";
+import { getInternalSubprocessEnv, findExecutable, execFileAsync } from "../../../_shared/lib-ts/base/subprocess-utils.js";
 import { parseCliOutput } from "../cli-output-parser.js";
+import { parseJsonMaybe, coerceToReview } from "../json-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.
+ * Agent reviewer — runs a CLI instance with a custom persona.
  */
 export class AgentReviewer implements Reviewer {
   constructor(private agent: AgentConfig) {}
@@ -39,7 +40,8 @@ export class AgentReviewer implements Reviewer {
 }
 
 /**
- * Run a single Claude Code agent to review the plan.
+ * Run a single agent to review the plan.
+ * Routes to provider-specific implementation based on agent.provider.
  * Never throws — returns error ReviewerResult on failure.
  */
 export async function runAgentReview(
@@ -49,6 +51,24 @@ export async function runAgentReview(
   timeout: number,
   contextPath?: string,
   sessionName = "unknown",
+): Promise<ReviewerResult> {
+  if (agent.provider === "codex") {
+    return runAgentReviewCodex(plan, agent, schema, timeout, contextPath, sessionName);
+  }
+  // Default: Claude (existing implementation)
+  return runAgentReviewClaude(plan, agent, schema, timeout, contextPath, sessionName);
+}
+
+/**
+ * Run a single Claude Code agent to review the plan.
+ */
+async function runAgentReviewClaude(
+  plan: string,
+  agent: AgentConfig,
+  schema: Record<string, unknown>,
+  timeout: number,
+  contextPath?: string,
+  sessionName = "unknown",
 ): Promise<ReviewerResult> {
   const claudePath = findExecutable("claude");
   if (!claudePath) {
@@ -82,7 +102,7 @@ ${plan}
     cmdArgs.push("--system-prompt", fullPrompt);
   }
 
-  logInfo(agent.name, `Running with model: ${agent.model}, timeout: ${timeout}s`);
+  logInfo(agent.name, `Running Claude with model: ${agent.model}, timeout: ${timeout}s`);
 
   const env = getInternalSubprocessEnv();
 
@@ -91,10 +111,11 @@ ${plan}
     timeout: timeout * 1000,
     env: env as Record<string, string>,
     maxBuffer: 10 * 1024 * 1024,
+    shell: process.platform === "win32",
   });
 
   if (result.killed || result.signal === "SIGTERM") {
-    logWarn(agent.name, `TIMEOUT after ${timeout}s`);
+    logWarn(agent.name, `Claude TIMEOUT after ${timeout}s`);
     return makeResult(agent.name, false, "error", {}, "", `${agent.name} timed out after ${timeout}s`);
   }
 
@@ -116,12 +137,12 @@ ${plan}
     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,
+      provider: "claude",
       timeout,
     });
   }
@@ -146,10 +167,109 @@ ${plan}
   }
 
   const [ok, verdict, norm] = coerceToReview(
-    obj as null | Record<string, unknown>,
+    obj as Record<string, unknown> | null,
     "Retry or check agent configuration.",
   );
 
   return makeResult(agent.name, ok, verdict, norm, raw, err);
 }
 
+/**
+ * Run a single Codex CLI agent to review the plan.
+ * Adapts the codex.ts reviewer pattern for agent-based review with persona.
+ */
+async function runAgentReviewCodex(
+  plan: string,
+  agent: AgentConfig,
+  schema: Record<string, unknown>,
+  timeout: number,
+  contextPath?: string,
+  sessionName = "unknown",
+): Promise<ReviewerResult> {
+  const codexPath = findExecutable("codex");
+  if (!codexPath) {
+    logWarn(agent.name, "Codex CLI not found on PATH, skipping");
+    return makeResult(agent.name, false, "skip", {}, "", "codex CLI not found on PATH");
+  }
+
+  // Codex has no --system-prompt flag, so we prepend the agent persona to stdin.
+  const fullPrompt = [
+    AGENT_REVIEW_PROMPT_PREFIX,
+    "---",
+    agent.system_prompt || "",
+    "---",
+    `Return ONLY a JSON object matching this schema:\n${JSON.stringify(schema)}`,
+    "",
+    "PLAN:",
+    "<<<",
+    plan,
+    ">>>",
+  ].join("\n\n");
+
+  const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), `codex-agent-${agent.name}-`));
+
+  try {
+    const schemaPath = path.join(tmpDir, "schema.json");
+    const outPath = path.join(tmpDir, "output.json");
+    fs.writeFileSync(schemaPath, JSON.stringify(schema, null, 2), "utf-8");
+
+    const cmdArgs = ["exec", "--sandbox", "read-only"];
+    if (agent.model) cmdArgs.push("--model", agent.model);
+    cmdArgs.push("--output-schema", schemaPath, "-o", outPath, "-");
+
+    logInfo(agent.name, `Running Codex with model: ${agent.model}, timeout: ${timeout}s`);
+
+    const result = await execFileAsync(codexPath, cmdArgs, {
+      input: fullPrompt,
+      timeout: timeout * 1000,
+      maxBuffer: 10 * 1024 * 1024,
+      shell: process.platform === "win32",
+    });
+
+    if (result.killed || result.signal === "SIGTERM") {
+      logWarn(agent.name, `Codex TIMEOUT after ${timeout}s`);
+      return makeResult(agent.name, false, "error", {}, "", `${agent.name} (codex) timed out after ${timeout}s`);
+    }
+
+    if (!result.stdout && !result.stderr && !fs.existsSync(outPath) && result.exitCode !== 0) {
+      logError(agent.name, `Codex exited with code ${result.exitCode} and no output`);
+      return makeResult(agent.name, false, "error", {}, "", `${agent.name} (codex) failed (exit ${result.exitCode})`);
+    }
+
+    // Read output: prefer temp file, fallback to stdout
+    let raw = "";
+    if (fs.existsSync(outPath)) {
+      raw = fs.readFileSync(outPath, "utf-8");
+    }
+    const err = result.stderr.trim();
+
+    // Debug logging
+    if (contextPath) {
+      debugRaw(contextPath, sessionName, `agent:${agent.name}`, "stdout", raw || result.stdout);
+      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 || result.stdout).length,
+        stderr_len: err.length,
+        model: agent.model,
+        provider: "codex",
+        timeout,
+      });
+    }
+
+    // Parse output
+    const obj = parseJsonMaybe(raw) ?? parseJsonMaybe(result.stdout);
+    const [ok, verdict, norm] = coerceToReview(
+      obj,
+      "Retry or check Codex CLI auth/config.",
+    );
+
+    return makeResult(agent.name, ok, verdict, norm, raw || result.stdout, err);
+  } finally {
+    try {
+      fs.rmSync(tmpDir, { recursive: true, force: true });
+    } catch (e) {
+      logDebug(agent.name, `Failed to cleanup temp dir ${tmpDir}: ${e}`);
+    }
+  }
+}

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

@@ -7,10 +7,9 @@
 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 { logDebug, logInfo, logWarn, logError } from "../../../_shared/lib-ts/base/logger.js";
+import { findExecutable, execFileAsync } from "../../../_shared/lib-ts/base/subprocess-utils.js";
+import { parseJsonMaybe, coerceToReview } from "../json-parser.js";
 import { REVIEW_PROMPT_PREFIX } from "../types.js";
 import type { ReviewerResult, ReviewOptions } from "../types.js";
 import { makeResult } from "./types.js";
@@ -29,7 +28,7 @@ export class CodexReviewer implements Reviewer {
   async review(
     plan: string,
     schema: Record<string, unknown>,
-    _options: ReviewOptions,
+    options: ReviewOptions,
   ): Promise<ReviewerResult> {
     return runCodexReview(plan, schema, this.settings);
   }
@@ -91,6 +90,7 @@ ${plan}
       input: prompt,
       timeout: timeout * 1000,
       maxBuffer: 10 * 1024 * 1024,
+      shell: process.platform === "win32",
     });
 
     if (result.killed || result.signal === "SIGTERM") {
@@ -107,7 +107,7 @@ ${plan}
 
     let raw = "";
     if (fs.existsSync(outPath)) {
-      raw = fs.readFileSync(outPath, "utf8");
+      raw = fs.readFileSync(outPath, "utf-8");
     }
 
     const obj = parseJsonMaybe(raw) ?? parseJsonMaybe(result.stdout);

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

@@ -4,9 +4,9 @@
  * See cc-native-plan-review-spec.md §4.12
  */
 
-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 { logDebug, logInfo, logWarn, logError } from "../../../_shared/lib-ts/base/logger.js";
+import { findExecutable, execFileAsync } from "../../../_shared/lib-ts/base/subprocess-utils.js";
+import { parseJsonMaybe, coerceToReview } from "../json-parser.js";
 import type { ReviewerResult, ReviewOptions } from "../types.js";
 import { makeResult } from "./types.js";
 import type { Reviewer } from "./types.js";
@@ -24,7 +24,7 @@ export class GeminiReviewer implements Reviewer {
   async review(
     plan: string,
     schema: Record<string, unknown>,
-    _options: ReviewOptions,
+    options: ReviewOptions,
   ): Promise<ReviewerResult> {
     return runGeminiReview(plan, schema, this.settings);
   }
@@ -78,6 +78,7 @@ ${JSON.stringify(schema)}
     input: plan,
     timeout: timeout * 1000,
     maxBuffer: 10 * 1024 * 1024,
+    shell: process.platform === "win32",
   });
 
   if (result.killed || result.signal === "SIGTERM") {

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

@@ -5,13 +5,12 @@
  */
 
 import * as fs from "node:fs";
-import * as path from "node:path";
-
-import { validatePlanPath } from "./constants.js";
-import type { IterationEntry, IterationState } from "./types.js";
+import * as path from "node:path";
 import { atomicWrite } from "../../_shared/lib-ts/base/atomic-write.js";
-import { logError, logInfo, logWarn } from "../../_shared/lib-ts/base/logger.js";
+import { logInfo, logWarn, logError } from "../../_shared/lib-ts/base/logger.js";
 import { nowIso } from "../../_shared/lib-ts/base/utils.js";
+import { validatePlanPath } from "./constants.js";
+import type { IterationState, IterationEntry } from "./types.js";
 
 // ---------------------------------------------------------------------------
 // Constants
@@ -19,10 +18,10 @@ import { nowIso } from "../../_shared/lib-ts/base/utils.js";
 
 const STATE_SCHEMA_VERSION = "1.0.0";
 
-const DEFAULT_REVIEW_ITERATIONS: Record<string, number> = {
+export const DEFAULT_REVIEW_ITERATIONS: Record<string, number> = {
   simple: 1,
-  medium: 1,
-  high: 2,
+  medium: 3,
+  high: 5,
 };
 
 // ---------------------------------------------------------------------------
@@ -44,7 +43,7 @@ export function getStateFilePath(planPath: string): string {
 /**
  * Load state file with schema validation and migration.
  */
-export function loadState(planPath: string): null | Record<string, unknown> {
+export function loadState(planPath: string): Record<string, unknown> | null {
   try {
     const stateFile = getStateFilePath(planPath);
 
@@ -53,7 +52,7 @@ export function loadState(planPath: string): null | Record<string, unknown> {
     }
 
     const state = JSON.parse(
-      fs.readFileSync(stateFile, "utf8"),
+      fs.readFileSync(stateFile, "utf-8"),
     ) as Record<string, unknown>;
 
     // Handle schema version (backward compatible)
@@ -73,13 +72,12 @@ export function loadState(planPath: string): null | Record<string, unknown> {
     }
 
     return state;
-  } catch (error: unknown) {
-    if (error instanceof Error && error.message.includes("Invalid plan path")) {
-      logError("state", `SECURITY: Invalid plan path: ${error}`);
+  } catch (e: unknown) {
+    if (e instanceof Error && e.message.includes("Invalid plan path")) {
+      logError("state", `SECURITY: Invalid plan path: ${e}`);
     } else {
-      logError("state", `Failed to load state: ${error}`);
-    }
-
+      logError("state", `Failed to load state: ${e}`);
+    }
     return null;
   }
 }
@@ -111,13 +109,12 @@ export function saveStateToPlan(
     }
 
     return true;
-  } catch (error: unknown) {
-    if (error instanceof Error && error.message.includes("Invalid plan path")) {
-      logError("state", `SECURITY: Invalid plan path: ${error}`);
+  } catch (e: unknown) {
+    if (e instanceof Error && e.message.includes("Invalid plan path")) {
+      logError("state", `SECURITY: Invalid plan path: ${e}`);
     } else {
-      logError("state", String(error));
-    }
-
+      logError("state", String(e));
+    }
     return false;
   }
 }
@@ -132,16 +129,14 @@ export function deleteState(planPath: string): boolean {
     if (fs.existsSync(stateFile)) {
       fs.unlinkSync(stateFile);
       logInfo("state", `Deleted state file: ${stateFile}`);
-    }
-
+    }
     return true;
-  } catch (error: unknown) {
-    if (error instanceof Error && error.message.includes("Invalid plan path")) {
-      logError("state", `SECURITY: Invalid plan path in delete: ${error}`);
+  } catch (e: unknown) {
+    if (e instanceof Error && e.message.includes("Invalid plan path")) {
+      logError("state", `SECURITY: Invalid plan path in delete: ${e}`);
       return false;
-    }
-
-    logWarn("state", `Failed to delete state file: ${error}`);
+    }
+    logWarn("state", `Failed to delete state file: ${e}`);
     return false;
   }
 }
@@ -178,6 +173,9 @@ export function getIterationState(
     max: reviewIterations[complexity] ?? 1,
     complexity,
     history: [],
+    graduated: [],
+    passStreaks: {},
+    lastPlanHash: "",
   };
 }
 
@@ -209,7 +207,7 @@ export function shouldContinueIterating(
   verdict: string,
   config?: Record<string, unknown>,
 ): boolean {
-  const {current} = iteration;
+  const current = iteration.current;
   const maxIter = iteration.max;
 
   // At or past max iterations
@@ -225,8 +223,7 @@ export function shouldContinueIterating(
   let earlyExit = true;
   if (config) {
     earlyExit = (config.earlyExitOnAllPass as boolean) ?? true;
-  }
-
+  }
   if (earlyExit && verdict === "pass") {
     logInfo(
       "state",