aiwcli 0.11.0 → 0.12.0

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",

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

@@ -12,71 +12,106 @@ export type { ContextState, HookInput, HookOutput } from "../../_shared/lib-ts/t
 // ---------------------------------------------------------------------------
 
 /** Verdict from a single reviewer */
-export type Verdict = "error" | "fail" | "pass" | "skip" | "warn";
+export type Verdict = "pass" | "warn" | "fail" | "error" | "skip";
 
 /** Decision after aggregating all verdicts */
 export type ReviewDecision = "allow" | "deny";
 
 /** Complexity level assigned by orchestrator */
-export type ComplexityCategory = "high" | "medium" | "simple";
+export type ComplexityCategory = "simple" | "medium" | "high";
 
 // ---------------------------------------------------------------------------
 // Review Data Structures
 // ---------------------------------------------------------------------------
 
+/** Dimension classification for corroboration-based verdict */
+export type IssueDimension =
+  | "completeness"
+  | "simplicity"
+  | "security"
+  | "performance"
+  | "reliability"
+  | "maintainability"
+  | "testability"
+  | "scope"
+  | "feasibility"
+  | "clarity";
+
 /** A single issue found during review */
 export interface ReviewIssue {
+  severity: "high" | "medium" | "low";
   category: string;
   issue: string;
-  severity: "high" | "low" | "medium";
   suggested_fix: string;
+  dimension?: IssueDimension;
+}
+
+/** A group of issues in one dimension, classified as blocking or solo */
+export interface DimensionGroup {
+  dimension: IssueDimension;
+  issues: Array<{ agent: string; issue: ReviewIssue }>;
+  agentCount: number;
+  threshold: number; // 2 × agentCount
+}
+
+/** Corroborated (blocking) group — threshold exceeded */
+export type CorroboratedGroup = DimensionGroup;
+
+/** Solo finding — below threshold, informational only */
+export type SoloFinding = DimensionGroup;
+
+/** Result of corroboration-based verdict computation */
+export interface CorroborationResult {
+  blocking: CorroboratedGroup[];
+  solo: SoloFinding[];
+  unclassified: Array<{ agent: string; issue: ReviewIssue }>;
+  verdict: "pass" | "warn" | "fail";
 }
 
 /** Normalized review data from any reviewer */
 export interface ReviewData {
+  verdict: Verdict;
+  summary: string;
+  summary_source: "reviewer" | "default";
   issues: ReviewIssue[];
   missing_sections: string[];
   questions: string[];
-  summary: string;
-  summary_source: "default" | "reviewer";
-  verdict: Verdict;
 }
 
 /** Result from a single plan reviewer (Codex, Gemini, or Claude agent) */
 export interface ReviewerResult {
-  data: Record<string, unknown>;
-  err: string;
   name: string;
   ok: boolean;
-  raw: string;
   verdict: Verdict;
+  data: Record<string, unknown>;
+  raw: string;
+  err: string;
 }
 
 /** Result from the plan orchestrator */
 export interface OrchestratorResult {
-  category: string;
   complexity: ComplexityCategory;
-  error?: string;
-  reasoning: string;
+  category: string;
   selected_agents: string[];
+  reasoning: string;
   skip_reason?: string;
+  error?: string;
 }
 
 /** Combined result from all review phases */
 export interface CombinedReviewResult {
-  agents: Record<string, ReviewerResult>;
-  cli_reviewers: Record<string, ReviewerResult>;
-  orchestration: null | OrchestratorResult;
-  overall_verdict: Verdict;
   plan_hash: string;
+  overall_verdict: Verdict;
+  orchestration: OrchestratorResult | null;
+  agents: Record<string, ReviewerResult>;
   timestamp: string;
 }
 
 /** Result from verdict aggregation */
 export interface ReviewDecisionResult {
+  should_deny: boolean;
   reason: string; // "fail_veto" | "acceptable" | "no_signal"
   score: number;
-  should_deny: boolean;
 }
 
 // ---------------------------------------------------------------------------
@@ -85,12 +120,13 @@ export interface ReviewDecisionResult {
 
 /** Configuration for a Claude Code review agent */
 export interface AgentConfig {
+  name: string;
+  model: string;
+  provider: string; // e.g. "claude" | "codex" — assigned at runtime by assignModelsToAgents()
+  focus: string;
+  enabled: boolean;
   categories: string[];
   description: string;
-  enabled: boolean;
-  focus: string;
-  model: string;
-  name: string;
   system_prompt: string; // Markdown body content for --system-prompt
 }
 
@@ -101,6 +137,17 @@ export interface OrchestratorConfig {
   timeout: number;
 }
 
+/** Configuration for a model provider (Claude, Codex, etc.) */
+export interface ProviderConfig {
+  enabled: boolean;
+  models: string[];
+}
+
+/** Model provider pool configuration */
+export interface ModelsConfig {
+  providers: Record<string, ProviderConfig>;
+}
+
 // ---------------------------------------------------------------------------
 // State Interfaces
 // ---------------------------------------------------------------------------
@@ -108,37 +155,40 @@ export interface OrchestratorConfig {
 /** A single iteration history entry */
 export interface IterationEntry {
   hash: string;
-  timestamp: string;
   verdict: string;
+  timestamp: string;
 }
 
 /** Iteration tracking state (stored adjacent to plan file) */
 export interface IterationState {
-  complexity: string;
   current: number;
-  graduated: string[];
-  history: IterationEntry[];
   max: number;
+  complexity: string;
+  history: IterationEntry[];
+  graduated: string[];
+  passStreaks: Record<string, number>;
+  lastPlanHash: string;
 }
 
 /** CC-native state stored in context state.json under cc_native key */
 export interface CcNativeState {
-  [key: string]: unknown;
   plan_review?: PlanReviewState;
   questions_asked?: QuestionsAskedState;
+  stuck_detection?: StuckDetectionState;
+  [key: string]: unknown;
 }
 
 /** Plan review state within cc_native */
 export interface PlanReviewState {
+  plan_hash: string;
+  reviewed_at: string;
   decision: string;
   iteration?: {
-    complexity: string;
     current: number;
-    latest_verdict?: string;
     max: number;
+    complexity: string;
+    latest_verdict?: string;
   };
-  plan_hash: string;
-  reviewed_at: string;
 }
 
 /** Questions-asked tracking state */
@@ -147,6 +197,15 @@ export interface QuestionsAskedState {
   asked_at: string;
 }
 
+/** Stuck detection state — tracks repeated errors, file edits, and test failures */
+export interface StuckDetectionState {
+  error_hashes: Record<string, number>;
+  file_edits: Record<string, number>;
+  test_failures: number;
+  tool_calls_since_suggestion: number;
+  suggestion_count: number;
+}
+
 // ---------------------------------------------------------------------------
 // Configuration
 // ---------------------------------------------------------------------------
@@ -160,25 +219,25 @@ export interface DisplaySettings {
 
 /** Full plan review configuration (from plan-review.config.json) */
 export interface PlanReviewConfig {
-  [key: string]: unknown;
-  display?: Partial<DisplaySettings>;
   planReview?: {
+    enabled?: boolean;
+    reviewers?: {
+      codex?: { enabled?: boolean; timeout?: number; model?: string };
+      gemini?: { enabled?: boolean; timeout?: number; model?: string };
+    };
     agentReview?: {
-      agentSelection?: Record<string, unknown>;
-      complexityCategories?: string[];
       enabled?: boolean;
-      orchestrator?: { enabled?: boolean; model?: string; timeout?: number };
       timeout?: number;
+      orchestrator?: { enabled?: boolean; model?: string; timeout?: number };
+      agentSelection?: Record<string, unknown>;
+      complexityCategories?: string[];
     };
     display?: Partial<DisplaySettings>;
-    earlyExitOnAllPass?: boolean;
-    enabled?: boolean;
-    reviewers?: {
-      codex?: { enabled?: boolean; model?: string; timeout?: number; };
-      gemini?: { enabled?: boolean; model?: string; timeout?: number; };
-    };
     reviewIterations?: Record<string, number>;
+    earlyExitOnAllPass?: boolean;
   };
+  display?: Partial<DisplaySettings>;
+  [key: string]: unknown;
 }
 
 // ---------------------------------------------------------------------------
@@ -187,9 +246,9 @@ export interface PlanReviewConfig {
 
 /** Options passed to reviewer implementations */
 export interface ReviewOptions {
+  timeout: number;
   context_path?: string;
   session_name?: string;
-  timeout: number;
 }
 
 /** Interface all reviewers must implement */
@@ -202,97 +261,10 @@ export interface Reviewer {
 }
 
 // ---------------------------------------------------------------------------
-// JSON Schemas
+// JSON Schemas (moved to reviewers/schemas.ts)
 // ---------------------------------------------------------------------------
-
-/** JSON schema for review structured output */
-export const REVIEW_SCHEMA: Record<string, unknown> = {
-  type: "object",
-  properties: {
-    verdict: { type: "string", enum: ["pass", "warn", "fail"] },
-    summary: { type: "string", minLength: 20 },
-    issues: {
-      type: "array",
-      items: {
-        type: "object",
-        properties: {
-          severity: { type: "string", enum: ["high", "medium", "low"] },
-          category: { type: "string" },
-          issue: { type: "string" },
-          suggested_fix: { type: "string" },
-        },
-        required: ["severity", "category", "issue", "suggested_fix"],
-        additionalProperties: false,
-      },
-    },
-    missing_sections: { type: "array", items: { type: "string" } },
-    questions: { type: "array", items: { type: "string" } },
-  },
-  required: ["verdict", "summary", "issues", "missing_sections", "questions"],
-  additionalProperties: false,
-};
-
-/** JSON schema for orchestrator structured output */
-export const ORCHESTRATOR_SCHEMA: Record<string, unknown> = {
-  type: "object",
-  properties: {
-    complexity: { type: "string", enum: ["simple", "medium", "high"] },
-    category: {
-      type: "string",
-      enum: [
-        "code",
-        "infrastructure",
-        "documentation",
-        "life",
-        "business",
-        "design",
-        "research",
-      ],
-    },
-    selectedAgents: { type: "array", items: { type: "string" } },
-    reasoning: { type: "string" },
-    skipReason: { type: "string" },
-  },
-  required: ["complexity", "category", "selectedAgents", "reasoning"],
-  additionalProperties: false,
-};
-
-// ---------------------------------------------------------------------------
-// Prompt Constants
-// ---------------------------------------------------------------------------
-
-export const REVIEW_PROMPT_PREFIX = `You are a senior staff software engineer acting as a strict plan reviewer.
-
-Review the PLAN below. Focus on:
-- missing steps, unclear assumptions, edge cases
-- security/privacy concerns
-- testing/rollout/rollback completeness
-- operational concerns (observability, failure modes)
-`;
-
-export const AGENT_REVIEW_PROMPT_PREFIX = `# SINGLE-TURN PLAN REVIEW
-
-## CRITICAL: ONE TURN ONLY
-You have exactly ONE response to complete this review. Do NOT attempt multi-step workflows, context queries, or phased analysis. Analyze the plan and output your review immediately.
-
-## YOUR TASK
-Review the plan below from your area of expertise. Then call StructuredOutput with your assessment.
-
-## REQUIRED OUTPUT (all fields must have content)
-Call StructuredOutput with:
-- **verdict**: "pass" (no concerns), "warn" (some concerns), or "fail" (critical issues)
-- **summary**: 2-3 sentences with your overall assessment and key findings (REQUIRED)
-- **issues**: Array of concerns found. Format each as:
-  {"severity": "high/medium/low", "category": "...", "issue": "...", "suggested_fix": "..."}
-- **missing_sections**: Topics the plan should address but doesn't
-- **questions**: Things that need clarification before implementation
-
-## IMPORTANT RULES
-1. A "warn" verdict MUST include at least one issue explaining why
-2. Summary MUST explain your reasoning, not just "looks good" or empty
-3. Focus on your expertise area (architecture, security, performance, etc.)
-4. Output StructuredOutput NOW - no other tools, no questions, no delays
-`;
+// Re-export for backwards compatibility
+export { REVIEW_SCHEMA, ORCHESTRATOR_SCHEMA, REVIEW_PROMPT_PREFIX, AGENT_REVIEW_PROMPT_PREFIX } from "./reviewers/schemas.js";
 
 // ---------------------------------------------------------------------------
 // Display Defaults

package/dist/templates/cc-native/_cc-native/plan-review.config.json

@@ -1,18 +1,18 @@
 {
-  "planReview": {
-    "enabled": true,
-    "reviewers": {
-      "codex": {
+  "models": {
+    "providers": {
+      "claude": {
         "enabled": true,
-        "model": "gpt-5.1-codex-mini",
-        "timeout": 120
+        "models": ["sonnet"]
       },
-      "gemini": {
-        "enabled": false,
-        "model": "",
-        "timeout": 120
+      "codex": {
+        "enabled": true,
+        "models": ["gpt-5.1-codex-mini"]
       }
-    },
+    }
+  },
+  "planReview": {
+    "enabled": true,
     "display": {
       "maxIssues": 12,
       "maxMissingSections": 12,
@@ -23,6 +23,7 @@
     "enabled": true,
     "timeout": 180,
     "warnThreshold": 0.01,
+    "maxIssuesPerAgent": 3,
     "orchestrator": {
       "enabled": true,
       "model": "opus",
@@ -40,8 +41,8 @@
     },
     "reviewIterations": {
       "simple": 1,
-      "medium": 1,
-      "high": 2
+      "medium": 3,
+      "high": 5
     },
     "highIssueThreshold": 2,
     "earlyExitOnAllPass": true,
@@ -71,5 +72,13 @@
   "planContext": {
     "enabled": true,
     "offerClarifyingQuestions": true
+  },
+  "stuckDetection": {
+    "enabled": true,
+    "errorThreshold": 3,
+    "fileEditThreshold": 4,
+    "testFailureThreshold": 3,
+    "cooldown": 10,
+    "maxSuggestions": 3
   }
 }

package/oclif.manifest.json

@@ -416,5 +416,5 @@
       ]
     }
   },
-  "version": "0.11.0"
+  "version": "0.12.0"
 }

package/package.json

@@ -1,10 +1,10 @@
 {
   "name": "aiwcli",
   "description": "AI Workflow CLI - Command-line interface for AI-powered workflows",
-  "version": "0.11.0",
+  "version": "0.12.0",
   "author": "jofu-tofu",
   "bin": {
-    "aiw": "./bin/run.js"
+    "aiw": "bin/run.js"
   },
   "bugs": {
     "url": "https://github.com/jofu-tofu/AI-Workflow-CLI/issues"
@@ -21,7 +21,6 @@
   },
   "devDependencies": {
     "@eslint/compat": "^1",
-    "@oclif/prettier-config": "^0.2.1",
     "@oclif/test": "^4",
     "@types/chai": "^4",
     "@types/mocha": "^10",