aiwcli 0.13.6 → 0.13.8

package/dist/templates/cc-native/.claude/settings.json

@@ -80,6 +80,8 @@
     "allow": [],
     "deny": []
   },
-  "env": {},
+  "env": {
+    "CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS": "1"
+  },
   "enabledPlugins": {}
 }

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

@@ -7,7 +7,8 @@
       },
       "codex": {
         "enabled": true,
-        "models": ["codex-mini-latest"]
+        "models": ["gpt-5.3-codex"],
+        "reasoningEffort": "low"
       }
     }
   },
@@ -29,6 +30,10 @@
       "model": "opus",
       "timeout": 60
     },
+    "preflight": {
+      "enabled": true,
+      "timeoutMs": 15000
+    },
     "legacyMode": false,
     "mandatoryAgents": {
       "always": ["handoff-readiness", "clarity-auditor", "skeptic"],

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

@@ -70,8 +70,8 @@ export const DEFAULT_COMPLEXITY_CATEGORIES = ["code", "infrastructure", "documen
 
 export const DEFAULT_MODELS_CONFIG: ModelsConfig = {
   providers: {
-    claude: { enabled: true, models: ["sonnet"] },
-    codex: { enabled: true, models: ["codex-mini-latest"] },
+    claude: { enabled: false, models: ["sonnet"] },
+    codex: { enabled: true, models: ["gpt-5.2"] },
   },
 };
 
@@ -149,6 +149,7 @@ export function loadModelsConfig(settings: Record<string, unknown>): ModelsConfi
     providers[name] = {
       enabled: c.enabled !== false,
       models: Array.isArray(c.models) ? (c.models as string[]).filter(Boolean) : [],
+      ...(typeof c.reasoningEffort === "string" && { reasoningEffort: c.reasoningEffort }),
     };
   }
   return { providers };

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

@@ -127,6 +127,7 @@ export interface AgentConfig {
   categories: string[];
   description: string;
   system_prompt: string; // Markdown body content for --system-prompt
+  reasoningEffort?: string; // e.g. "low", "medium", "high" — passed to codex -c model_reasoning_effort
 }
 
 /** Configuration for the plan orchestrator */
@@ -140,6 +141,7 @@ export interface OrchestratorConfig {
 export interface ProviderConfig {
   enabled: boolean;
   models: string[];
+  reasoningEffort?: string; // e.g. "low", "medium", "high" — codex model_reasoning_effort
 }
 
 /** Model provider pool configuration */
@@ -327,3 +329,24 @@ export interface IterationAdvancement {
   updatedState: IterationState;
   newGraduates: string[];
 }
+
+// ---------------------------------------------------------------------------
+// Preflight Types
+// ---------------------------------------------------------------------------
+
+/** Result from a single provider+model preflight check */
+export interface PreflightCheckResult {
+  provider: string;
+  model: string;
+  available: boolean;
+  latencyMs: number;
+  error?: string;
+}
+
+/** Aggregated preflight report across all provider+model combos */
+export interface PreflightReport {
+  checks: PreflightCheckResult[];
+  available: Map<string, Set<string>>;  // provider → set of working models
+  allFailed: boolean;
+  totalMs: number;
+}

package/dist/templates/cc-native/_cc-native/plan-review/lib/agent-selection.ts

@@ -47,38 +47,70 @@ export function resolveMandatoryAgents(
 // Model Assignment
 // ---------------------------------------------------------------------------
 
+/** Provider priority order: codex first (cheaper/faster), claude as fallback */
+const PROVIDER_PRIORITY = ["codex", "claude"];
+
 /**
- * Randomly assign enabled providers and models to agents.
- * Filters to providers whose CLI is available on PATH.
+ * Assign providers and models to agents.
+ * When preflightAvailable is provided, filters to only models that passed preflight.
+ * Providers are ordered by PROVIDER_PRIORITY (codex first, claude fallback).
+ * All agents get the first available provider; random model within that provider.
  */
 export function assignModelsToAgents(
   agents: AgentConfig[],
   modelsConfig: ModelsConfig,
+  preflightAvailable?: Map<string, Set<string>>,
 ): AgentConfig[] {
-  const enabledProviders = Object.entries(modelsConfig.providers)
+  let enabledProviders = Object.entries(modelsConfig.providers)
     .filter(([name, config]) => {
       if (!config.enabled || config.models.length === 0) return false;
       const cliName = name === "claude" ? "claude" : name;
       const found = findExecutable(cliName);
       if (!found) {
         logWarn(HOOK, `Provider '${name}' enabled but CLI '${cliName}' not found on PATH — skipping`);
+        return false;
+      }
+      return true;
+    })
+    .map(([name, config]) => {
+      // Filter models by preflight results when available
+      if (preflightAvailable) {
+        const passedModels = preflightAvailable.get(name);
+        if (!passedModels || passedModels.size === 0) {
+          logWarn(HOOK, `Provider '${name}' has no models that passed preflight — skipping`);
+          return null;
+        }
+        const filteredModels = config.models.filter(m => passedModels.has(m));
+        if (filteredModels.length === 0) {
+          logWarn(HOOK, `Provider '${name}': none of its configured models passed preflight — skipping`);
+          return null;
+        }
+        return [name, { ...config, models: filteredModels }] as [string, typeof config];
       }
-      return Boolean(found);
-    });
+      return [name, config] as [string, typeof config];
+    })
+    .filter((entry): entry is [string, { enabled: boolean; models: string[]; reasoningEffort?: string }] => entry !== null);
+
+  // Sort by provider priority (codex first)
+  enabledProviders.sort((a, b) => {
+    const aIdx = PROVIDER_PRIORITY.indexOf(a[0]);
+    const bIdx = PROVIDER_PRIORITY.indexOf(b[0]);
+    return (aIdx === -1 ? 999 : aIdx) - (bIdx === -1 ? 999 : bIdx);
+  });
 
   if (enabledProviders.length === 0) {
     logWarn(HOOK, "No providers with available CLI found, falling back to Claude with agent defaults");
     return agents.map(a => ({ ...a, provider: "claude" }));
   }
 
+  // Assign all agents to the first (highest-priority) available provider
+  const [providerName, providerConfig] = enabledProviders[0]!;
+  logInfo(HOOK, `Using provider: ${providerName} (models: ${providerConfig.models.join(", ")})`);
+
   return agents.map(agent => {
-    const idx = Math.floor(Math.random() * enabledProviders.length);
-    const entry = enabledProviders[idx];
-    if (!entry) return { ...agent, provider: "claude" };
-    const [providerName, providerConfig] = entry;
     const modelIdx = Math.floor(Math.random() * providerConfig.models.length);
     const model = providerConfig.models[modelIdx] ?? providerConfig.models[0] ?? agent.model;
-    return { ...agent, provider: providerName, model };
+    return { ...agent, provider: providerName, model, reasoningEffort: providerConfig.reasoningEffort };
   });
 }
 

package/dist/templates/cc-native/_cc-native/plan-review/lib/preflight.ts

@@ -0,0 +1,162 @@
+/**
+ * Preflight health checks for plan review agents.
+ * Validates provider+model combos work before committing agents to them.
+ * Runs minimal "ping" requests in parallel per unique provider:model combo.
+ */
+
+import { logInfo, logWarn, logDebug } from "../../../_shared/lib-ts/base/logger.js";
+import { findExecutable, execFileAsync, getInternalSubprocessEnv } from "../../../_shared/lib-ts/base/subprocess-utils.js";
+import type { ModelsConfig, PreflightCheckResult, PreflightReport } from "../../lib-ts/types.js";
+import { claudePreflightArgs, CLAUDE_PREFLIGHT_INPUT } from "./reviewers/providers/claude-agent.js";
+import { codexPreflightArgs, CODEX_PREFLIGHT_INPUT } from "./reviewers/providers/codex-agent.js";
+
+const HOOK = "preflight";
+const DEFAULT_TIMEOUT_MS = 15000;
+
+// ---------------------------------------------------------------------------
+// Provider Registry
+// ---------------------------------------------------------------------------
+
+interface PreflightCommandConfig {
+  cliName: string;
+  buildArgs: (model: string) => string[];
+  input: string;
+}
+
+const PREFLIGHT_COMMANDS: Record<string, PreflightCommandConfig> = {
+  claude: { cliName: "claude", buildArgs: claudePreflightArgs, input: CLAUDE_PREFLIGHT_INPUT },
+  codex:  { cliName: "codex",  buildArgs: codexPreflightArgs,  input: CODEX_PREFLIGHT_INPUT },
+};
+
+// ---------------------------------------------------------------------------
+// Error Classification
+// ---------------------------------------------------------------------------
+
+function classifyError(stderr: string, exitCode: number | null, killed: boolean, signal: string | null): string {
+  if (killed || signal === "SIGTERM") return "Preflight timed out";
+  if (/model.*not found|not available/i.test(stderr)) return "Model not available for this account";
+  if (/rate limit|429/i.test(stderr)) return "Rate limited";
+  if (/auth|api key|401/i.test(stderr)) return "Authentication failed";
+  if (/quota|billing/i.test(stderr)) return "Quota/billing issue";
+  return `Exit code ${exitCode}`;
+}
+
+// ---------------------------------------------------------------------------
+// Single Check
+// ---------------------------------------------------------------------------
+
+async function checkProviderModel(
+  provider: string,
+  model: string,
+  timeoutMs: number,
+): Promise<PreflightCheckResult> {
+  const config = PREFLIGHT_COMMANDS[provider];
+  if (!config) {
+    return { provider, model, available: false, latencyMs: 0, error: `Unknown provider: ${provider}` };
+  }
+
+  const cliPath = findExecutable(config.cliName);
+  if (!cliPath) {
+    return { provider, model, available: false, latencyMs: 0, error: `CLI '${config.cliName}' not found on PATH` };
+  }
+
+  const start = Date.now();
+  try {
+    const env = getInternalSubprocessEnv();
+    const result = await execFileAsync(cliPath, config.buildArgs(model), {
+      input: config.input,
+      timeout: timeoutMs,
+      env: env as Record<string, string>,
+      maxBuffer: 1 * 1024 * 1024,
+      shell: process.platform === "win32",
+    });
+
+    const latencyMs = Date.now() - start;
+
+    if (result.killed || result.signal === "SIGTERM") {
+      return { provider, model, available: false, latencyMs, error: "Preflight timed out" };
+    }
+
+    if (result.exitCode !== 0) {
+      const error = classifyError(result.stderr, result.exitCode, result.killed, result.signal);
+      logWarn(HOOK, `${provider}:${model} failed: ${error} (stderr: ${result.stderr.slice(-200)})`);
+      return { provider, model, available: false, latencyMs, error };
+    }
+
+    logDebug(HOOK, `${provider}:${model} passed (${latencyMs}ms)`);
+    return { provider, model, available: true, latencyMs };
+  } catch (err) {
+    const latencyMs = Date.now() - start;
+    const error = err instanceof Error ? err.message : String(err);
+    logWarn(HOOK, `${provider}:${model} exception: ${error}`);
+    return { provider, model, available: false, latencyMs, error };
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Run All Checks
+// ---------------------------------------------------------------------------
+
+export async function runPreflight(
+  modelsConfig: ModelsConfig,
+  timeoutMs?: number,
+): Promise<PreflightReport> {
+  const effectiveTimeout = timeoutMs ?? DEFAULT_TIMEOUT_MS;
+  const start = Date.now();
+
+  // Collect unique provider:model combos from enabled providers
+  const checks: Array<{ provider: string; model: string }> = [];
+  const seen = new Set<string>();
+
+  for (const [provider, config] of Object.entries(modelsConfig.providers)) {
+    if (!config.enabled || config.models.length === 0) continue;
+    if (!PREFLIGHT_COMMANDS[provider]) {
+      logWarn(HOOK, `No preflight command for provider '${provider}', skipping`);
+      continue;
+    }
+    for (const model of config.models) {
+      const key = `${provider}:${model}`;
+      if (!seen.has(key)) {
+        seen.add(key);
+        checks.push({ provider, model });
+      }
+    }
+  }
+
+  if (checks.length === 0) {
+    logWarn(HOOK, "No provider:model combos to check");
+    return { checks: [], available: new Map(), allFailed: true, totalMs: Date.now() - start };
+  }
+
+  logInfo(HOOK, `Checking ${checks.length} provider:model combo(s): ${checks.map(c => `${c.provider}:${c.model}`).join(", ")}`);
+
+  // Run all checks in parallel
+  const results = await Promise.all(
+    checks.map(({ provider, model }) => checkProviderModel(provider, model, effectiveTimeout)),
+  );
+
+  // Build available map
+  const available = new Map<string, Set<string>>();
+  for (const r of results) {
+    if (r.available) {
+      if (!available.has(r.provider)) available.set(r.provider, new Set());
+      available.get(r.provider)!.add(r.model);
+    }
+  }
+
+  const allFailed = available.size === 0;
+  const totalMs = Date.now() - start;
+
+  // Log summary
+  const passed = results.filter(r => r.available).length;
+  const failed = results.filter(r => !r.available).length;
+  logInfo(HOOK, `Preflight complete: ${passed} passed, ${failed} failed (${totalMs}ms)`);
+
+  for (const r of results) {
+    if (!r.available) {
+      logWarn(HOOK, `  FAIL ${r.provider}:${r.model} — ${r.error}`);
+    }
+  }
+
+  return { checks: results, available, allFailed, totalMs };
+}

package/dist/templates/cc-native/_cc-native/plan-review/lib/review-pipeline.ts

@@ -8,6 +8,7 @@ import * as fs from "node:fs";
 import * as path from "node:path";
 
 import { resolveMandatoryAgents, assignModelsToAgents, selectAgents } from "./agent-selection.js";
+import { runPreflight } from "./preflight.js";
 import { computeCorroboratedDecision } from "./corroboration.js";
 import { computePassEligible, extractTopIssuesForTracker, advanceIterationState } from "./graduation.js";
 import { runOrchestrator } from "./orchestrator.js";
@@ -225,6 +226,28 @@ export async function runReviewPipeline(input: PipelineInput): Promise<PipelineR
   const agentResults: Record<string, ReviewerResult> = {};
   let detectedComplexity = "medium";
 
+  // Preflight: validate provider+model combos before committing agents or orchestrator
+  const preflightEnabled = (agentSettings.preflight as Record<string, unknown>)?.enabled ?? true;
+  let preflightAvailable: Map<string, Set<string>> | undefined;
+
+  if (preflightEnabled && agentReviewEnabled) {
+    logInfo(HOOK, "=== PREFLIGHT: Checking provider availability ===");
+    const preflightTimeoutMs = (agentSettings.preflight as Record<string, unknown>)?.timeoutMs as number | undefined;
+    const modelsConfig = loadModelsConfig(settings);
+    const preflightReport = await runPreflight(modelsConfig, preflightTimeoutMs);
+
+    if (preflightReport.allFailed) {
+      logWarn(HOOK, "All providers failed preflight checks");
+      // Preflight failures skip review rather than block because an unavailable
+      // reviewer is worse than no reviewer. A permanently broken config will
+      // silently pass all plans — mitigated by the log warnings above.
+      eprint("[plan-review] All AI providers unavailable. Skipping review.");
+      return { action: "skip", reason: "No AI providers passed preflight. Check CLI, API keys, model access, and quota." };
+    }
+
+    preflightAvailable = preflightReport.available;
+  }
+
   // 7. PHASE 1: Orchestrator
   const graduatedSet = new Set(iterationState.graduated);
   if (graduatedSet.size > 0) {
@@ -254,10 +277,20 @@ export async function runReviewPipeline(input: PipelineInput): Promise<PipelineR
   const phase1Promises: Array<{ name: string; promise: Promise<ReviewerResult | OrchestratorResult> }> = [];
 
   if (orchestratorConfig.enabled && enabledAgents.length > 0 && !legacyMode) {
-    phase1Promises.push({
-      name: "orchestrator",
-      promise: runOrchestrator(plan, enabledAgents, orchestratorConfig, agentSettings, alwaysMandatory),
-    });
+    // Guard orchestrator against preflight failures (always uses claude provider)
+    const orchProvider = "claude";
+    const orchModel = orchestratorConfig.model;
+    const orchPassed = !preflightAvailable ||
+      (preflightAvailable.has(orchProvider) && preflightAvailable.get(orchProvider)!.has(orchModel));
+
+    if (!orchPassed) {
+      logWarn(HOOK, `Orchestrator model ${orchProvider}:${orchModel} failed preflight, skipping`);
+    } else {
+      phase1Promises.push({
+        name: "orchestrator",
+        promise: runOrchestrator(plan, enabledAgents, orchestratorConfig, agentSettings, alwaysMandatory),
+      });
+    }
   }
 
   logInfo(HOOK, `=== PHASE 1: Running ${phase1Promises.length} tasks in parallel ===`);
@@ -318,9 +351,9 @@ export async function runReviewPipeline(input: PipelineInput): Promise<PipelineR
     iterationState.max = reviewIterations[detectedComplexity] ?? iterationState.max;
     logDebug(HOOK, `Iteration state: ${iterationState.current}/${iterationState.max} (${detectedComplexity})`);
 
-    // Assign random providers + models
+    // Assign providers + models (filtered by preflight results if available)
     const modelsConfig = loadModelsConfig(settings);
-    selectedAgents = assignModelsToAgents(selectedAgents, modelsConfig);
+    selectedAgents = assignModelsToAgents(selectedAgents, modelsConfig, preflightAvailable);
     logInfo(HOOK, `Model assignments: ${selectedAgents.map(a => `${a.name}→${a.provider}:${a.model}`).join(", ")}`);
 
     // 9. PHASE 3: Run agents

package/dist/templates/cc-native/_cc-native/plan-review/lib/reviewers/providers/claude-agent.ts

@@ -15,6 +15,27 @@ import { makeResult } from "../types.js";
  * Claude CLI-based agent reviewer.
  * Extends BaseCliAgent with Claude-specific prompt and argument handling.
  */
+// ---------------------------------------------------------------------------
+// Preflight (standalone — no instance needed)
+// ---------------------------------------------------------------------------
+
+export const CLAUDE_PREFLIGHT_INPUT = "Respond with exactly: ok";
+
+export function claudePreflightArgs(model: string): string[] {
+  return [
+    "--model", model,
+    "--max-turns", "1",
+    "--output-format", "json",
+    "--setting-sources", process.platform === "win32" ? '""' : "",
+    "-p",
+    "--no-session-persistence",
+  ];
+}
+
+// ---------------------------------------------------------------------------
+// Agent Class
+// ---------------------------------------------------------------------------
+
 export class ClaudeAgent extends BaseCliAgent<ReviewerResult> {
   protected buildCliArgs(): string[] {
     const schemaJson = JSON.stringify(this.schema);

package/dist/templates/cc-native/_cc-native/plan-review/lib/reviewers/providers/codex-agent.ts

@@ -16,6 +16,20 @@ import { BaseCliAgent, type ExecResult } from "../base/base-agent.js";
 import { AGENT_REVIEW_PROMPT_PREFIX } from "../schemas.js";
 import { makeResult } from "../types.js";
 
+// ---------------------------------------------------------------------------
+// Preflight (standalone — no instance needed)
+// ---------------------------------------------------------------------------
+
+export const CODEX_PREFLIGHT_INPUT = "Respond with exactly: ok";
+
+export function codexPreflightArgs(model: string): string[] {
+  return ["exec", "--sandbox", "read-only", "--model", model, "-"];
+}
+
+// ---------------------------------------------------------------------------
+// Agent Class
+// ---------------------------------------------------------------------------
+
 /** Temp directory for Codex schema/output files */
 const _tmpDir: string | null = null;
 
@@ -40,6 +54,7 @@ export class CodexAgent extends BaseCliAgent<ReviewerResult> {
 
     const cmdArgs = ["exec", "--sandbox", "read-only"];
     if (this.agent.model) cmdArgs.push("--model", this.agent.model);
+    if (this.agent.reasoningEffort) cmdArgs.push("-c", `model_reasoning_effort="${this.agent.reasoningEffort}"`);
     cmdArgs.push("--output-schema", normalizedSchema, "-o", normalizedOut, "-");
 
     return cmdArgs;

package/oclif.manifest.json

@@ -416,5 +416,5 @@
       ]
     }
   },
-  "version": "0.13.6"
+  "version": "0.13.8"
 }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "aiwcli",
   "description": "AI Workflow CLI - Command-line interface for AI-powered workflows",
-  "version": "0.13.6",
+  "version": "0.13.8",
   "author": "jofu-tofu",
   "bin": {
     "aiw": "bin/run.js"