aiwcli 0.13.8 → 0.15.1

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

@@ -178,6 +178,7 @@ export function getIterationState(
     passStreaks: {},
     lastPlanHash: "",
     lastPlanPath: "",
+    sessionId: "",
   };
 }
 

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

@@ -7,6 +7,10 @@
 // Re-export shared types used by cc-native consumers
 export type { ContextState, HookInput, HookOutput } from "../../_shared/lib-ts/types.js";
 
+// Import AgentConfig for local use and re-export
+import type { AgentConfig as _AgentConfig } from "../../_shared/lib-ts/types.js";
+export type AgentConfig = _AgentConfig;
+
 // ---------------------------------------------------------------------------
 // Verdict & Decision Types
 // ---------------------------------------------------------------------------
@@ -118,22 +122,13 @@ export interface ReviewDecisionResult {
 // Agent & Orchestrator Configuration
 // ---------------------------------------------------------------------------
 
-/** 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;
-  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
-}
+// AgentConfig re-exported from _shared/lib-ts/types.ts above
 
 /** Configuration for the plan orchestrator */
 export interface OrchestratorConfig {
   enabled: boolean;
   model: string;
+  provider?: string;
   timeout: number;
 }
 
@@ -141,7 +136,6 @@ 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 */
@@ -149,6 +143,66 @@ export interface ModelsConfig {
   providers: Record<string, ProviderConfig>;
 }
 
+// ---------------------------------------------------------------------------
+// Settings Interfaces (typed output of loadSettings())
+// ---------------------------------------------------------------------------
+
+/** Agent selection count range for a single complexity tier */
+export interface AgentSelectionRange {
+  min: number;
+  max: number;
+}
+
+/** Agent selection configuration (per-tier ranges + fallback) */
+export interface AgentSelectionConfig {
+  simple?: AgentSelectionRange;
+  medium?: AgentSelectionRange;
+  high?: AgentSelectionRange;
+  fallbackCount?: number;
+}
+
+/** Preflight health-check configuration */
+export interface PreflightSettings {
+  enabled?: boolean;
+  timeoutMs?: number;
+}
+
+/** Plan review section of merged settings (the "planReview" key) */
+export interface PlanReviewSettings {
+  enabled?: boolean;
+  reviewers?: {
+    codex?: { enabled?: boolean; model?: string; timeout?: number };
+    gemini?: { enabled?: boolean; model?: string; timeout?: number };
+  };
+  display?: Partial<DisplaySettings>;
+}
+
+/** Agent review section of merged settings (the "agentReview" key) */
+export interface AgentReviewSettings {
+  enabled?: boolean;
+  timeout?: number;
+  orchestrator?: OrchestratorConfig;
+  legacyMode?: boolean;
+  highIssueThreshold?: number;
+  maxIssuesPerAgent?: number;
+  mandatoryAgents?: string[] | Record<string, string[]>;
+  agentSelection?: AgentSelectionConfig;
+  agentDefaults?: { model?: string };
+  complexityCategories?: string[];
+  sanitization?: { maxSessionIdLength?: number; maxTitleLength?: number };
+  reviewIterations?: Record<string, number>;
+  display?: Partial<DisplaySettings>;
+  preflight?: PreflightSettings;
+  fallbackByComplexity?: Record<string, number>;
+}
+
+/** Top-level settings object returned by loadSettings() */
+export interface LoadedSettings {
+  planReview: PlanReviewSettings;
+  agentReview: AgentReviewSettings;
+  models: Record<string, unknown>;
+}
+
 // ---------------------------------------------------------------------------
 // State Interfaces
 // ---------------------------------------------------------------------------

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

@@ -7,6 +7,7 @@ import { logDebug, logInfo, logWarn } from "../../../_shared/lib-ts/base/logger.
 import { findExecutable } from "../../../_shared/lib-ts/base/subprocess-utils.js";
 import type {
   AgentConfig,
+  AgentReviewSettings,
   ModelsConfig,
   OrchestratorResult,
   AgentSelectionResult,
@@ -89,7 +90,7 @@ export function assignModelsToAgents(
       }
       return [name, config] as [string, typeof config];
     })
-    .filter((entry): entry is [string, { enabled: boolean; models: string[]; reasoningEffort?: string }] => entry !== null);
+    .filter((entry): entry is [string, { enabled: boolean; models: string[] }] => entry !== null);
 
   // Sort by provider priority (codex first)
   enabledProviders.sort((a, b) => {
@@ -110,7 +111,7 @@ export function assignModelsToAgents(
   return agents.map(agent => {
     const modelIdx = Math.floor(Math.random() * providerConfig.models.length);
     const model = providerConfig.models[modelIdx] ?? providerConfig.models[0] ?? agent.model;
-    return { ...agent, provider: providerName, model, reasoningEffort: providerConfig.reasoningEffort };
+    return { ...agent, provider: providerName, model };
   });
 }
 
@@ -122,7 +123,7 @@ export interface AgentSelectionInput {
   enabledAgents: AgentConfig[];
   orchResult: OrchestratorResult | null;
   mandatoryConfig: unknown;
-  agentSettings: Record<string, unknown>;
+  agentSettings: AgentReviewSettings;
   legacyMode: boolean;
 }
 
@@ -168,7 +169,7 @@ export function selectAgents(input: AgentSelectionInput): AgentSelectionResult {
     }
 
     // Enforce minimum agent count
-    const fallbackByComplexity = agentSettings.fallbackByComplexity ?? { simple: 0, medium: 2, high: 4 };
+    const fallbackByComplexity: Record<string, number> = agentSettings.fallbackByComplexity ?? { simple: 0, medium: 2, high: 4 };
     const minAdditional = fallbackByComplexity[detectedComplexity] ?? 5;
     if (orchSelected.length < minAdditional && nonMandatory.length > 0) {
       const remaining = nonMandatory.filter(a => !orchSelected.includes(a));

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

@@ -6,7 +6,7 @@
 
 import { OrchestratorClaudeAgent } from "./reviewers/providers/orchestrator-claude-agent.js";
 import { logInfo, logWarn } from "../../../_shared/lib-ts/base/logger.js";
-import type { AgentConfig, OrchestratorConfig, OrchestratorResult } from "../../lib-ts/types.js";
+import type { AgentConfig, AgentReviewSettings, OrchestratorConfig, OrchestratorResult } from "../../lib-ts/types.js";
 
 // Re-export for backward compatibility (moved to reviewers/schemas.ts)
 export { buildOrchestratorSchema } from "./reviewers/schemas.js";
@@ -23,7 +23,7 @@ export async function runOrchestrator(
   plan: string,
   agentLibrary: AgentConfig[],
   config: OrchestratorConfig,
-  settings: Record<string, unknown>,
+  settings: AgentReviewSettings,
   mandatoryNames?: Set<string>,
 ): Promise<OrchestratorResult> {
   logInfo("orchestrator", "Starting plan analysis...");
@@ -34,7 +34,7 @@ export async function runOrchestrator(
   const orchestratorAgent: AgentConfig = {
     name: "orchestrator",
     model: config.model,
-    provider: "claude",
+    provider: config.provider ?? "claude",
     focus: "plan analysis and agent selection",
     categories: [],
     description: "Plan orchestrator",
@@ -58,7 +58,7 @@ export async function runOrchestrator(
   } catch (error) {
     logWarn("orchestrator", `Unexpected error: ${error}`);
     const nonMandatory = agentLibrary.filter((a) => !mandatory.has(a.name));
-    const fallbackCount = ((settings.agentSelection as Record<string, unknown>)?.fallbackCount as number) ?? 2;
+    const fallbackCount = settings.agentSelection?.fallbackCount ?? 2;
     return {
       complexity: "medium",
       category: "code",

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

@@ -2,97 +2,29 @@
  * 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.
+ *
+ * Uses shared checkProviderModel() from _shared/lib-ts/base/preflight.ts.
+ * This module provides the batch orchestrator and provider registry specific
+ * to the plan review pipeline.
  */
 
-import { logInfo, logWarn, logDebug } from "../../../_shared/lib-ts/base/logger.js";
-import { findExecutable, execFileAsync, getInternalSubprocessEnv } from "../../../_shared/lib-ts/base/subprocess-utils.js";
+import { preflightCommandConfig } from "../../../_shared/lib-ts/base/cli-args.js";
+import { logInfo, logWarn } from "../../../_shared/lib-ts/base/logger.js";
+import { checkProviderModel, type PreflightCommandConfig } from "../../../_shared/lib-ts/base/preflight.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
+// Provider Registry (built from centralized cli-args)
 // ---------------------------------------------------------------------------
 
-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 },
+  claude: preflightCommandConfig("claude"),
+  codex:  preflightCommandConfig("codex"),
 };
 
-// ---------------------------------------------------------------------------
-// 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
 // ---------------------------------------------------------------------------
@@ -130,9 +62,11 @@ export async function runPreflight(
 
   logInfo(HOOK, `Checking ${checks.length} provider:model combo(s): ${checks.map(c => `${c.provider}:${c.model}`).join(", ")}`);
 
-  // Run all checks in parallel
+  // Run all checks in parallel (pass provider-specific config from registry)
   const results = await Promise.all(
-    checks.map(({ provider, model }) => checkProviderModel(provider, model, effectiveTimeout)),
+    checks.map(({ provider, model }) =>
+      checkProviderModel(provider, model, PREFLIGHT_COMMANDS[provider]!, effectiveTimeout, HOOK),
+    ),
   );
 
   // Build available map

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

@@ -43,7 +43,10 @@ import { loadSettings, loadModelsConfig, loadAgentLibrary, DEFAULT_ORCHESTRATOR
 import { DEFAULT_REVIEW_ITERATIONS, loadIterationState, saveIterationState } from "../../lib-ts/state.js";
 import type {
   AgentConfig,
+  AgentReviewSettings,
+  LoadedSettings,
   OrchestratorConfig,
+  PlanReviewSettings,
   ReviewerResult,
   CombinedReviewResult,
   OrchestratorResult,
@@ -66,7 +69,7 @@ function getActiveContextForReview(sessionId: string, projectRoot: string): Cont
     return ctx;
   }
   const allActive = getAllContexts("active", projectRoot);
-  const planning = allActive.filter(c => c.mode === "active" || c.mode === "has_plan");
+  const planning = allActive.filter(c => c.mode === "active" || c.mode === "has_staged_work");
   if (planning.length === 1) {
     logInfo(HOOK, `Found single planning context: ${planning[0]!.id}`);
     return planning[0]!;
@@ -89,9 +92,9 @@ export async function runReviewPipeline(input: PipelineInput): Promise<PipelineR
   const { sessionId, base, aiwcliDir, transcriptPath, payload } = input;
 
   // 1. Load settings
-  const settings = loadSettings(aiwcliDir);
-  const planSettings = settings.planReview ?? {};
-  const agentSettings = settings.agentReview ?? {};
+  const settings: LoadedSettings = loadSettings(aiwcliDir);
+  const planSettings: PlanReviewSettings = settings.planReview;
+  const agentSettings: AgentReviewSettings = settings.agentReview;
 
   const planReviewEnabled = planSettings.enabled ?? true;
   const agentReviewEnabled = agentSettings.enabled ?? true;
@@ -162,8 +165,8 @@ export async function runReviewPipeline(input: PipelineInput): Promise<PipelineR
   // 5. Questions gate
   if (!wasPlanQuestionsAgentAsked(sessionId, base)) {
     logInfo(HOOK, "Questions gate: plan-questions agent has not run yet, running now");
-    const timeout = typeof agentSettings.timeout === "number" ? agentSettings.timeout : 120;
-    const questionsResult = await runPlanQuestions(plan, aiwcliDir, timeout, undefined, sessionId);
+    const questionsTimeout = agentSettings.timeout ?? 120;
+    const questionsResult = await runPlanQuestions(plan, aiwcliDir, questionsTimeout, undefined, sessionId);
 
     markQuestionsAsked(sessionId, base, "agent");
 
@@ -227,12 +230,12 @@ export async function runReviewPipeline(input: PipelineInput): Promise<PipelineR
   let detectedComplexity = "medium";
 
   // Preflight: validate provider+model combos before committing agents or orchestrator
-  const preflightEnabled = (agentSettings.preflight as Record<string, unknown>)?.enabled ?? true;
+  const preflightEnabled = agentSettings.preflight?.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 preflightTimeoutMs = agentSettings.preflight?.timeoutMs;
     const modelsConfig = loadModelsConfig(settings);
     const preflightReport = await runPreflight(modelsConfig, preflightTimeoutMs);
 
@@ -257,13 +260,14 @@ export async function runReviewPipeline(input: PipelineInput): Promise<PipelineR
   const agentLibrary = agentReviewEnabled ? loadAgentLibrary(aiwcliDir, agentSettings) : [];
   const originalAgentCount = agentLibrary.length;
   const enabledAgents = agentLibrary.filter(a => !graduatedSet.has(a.name));
-  const timeout = typeof agentSettings.timeout === "number" ? agentSettings.timeout : 120;
+  const timeout = agentSettings.timeout ?? 120;
   const legacyMode = agentSettings.legacyMode === true;
 
   const orchSettings = agentSettings.orchestrator ?? DEFAULT_ORCHESTRATOR;
   const orchestratorConfig: OrchestratorConfig = {
     enabled: (orchSettings.enabled ?? true) && agentReviewEnabled,
     model: orchSettings.model ?? "haiku",
+    provider: orchSettings.provider,
     timeout: orchSettings.timeout ?? 30,
   };
 
@@ -278,7 +282,7 @@ export async function runReviewPipeline(input: PipelineInput): Promise<PipelineR
 
   if (orchestratorConfig.enabled && enabledAgents.length > 0 && !legacyMode) {
     // Guard orchestrator against preflight failures (always uses claude provider)
-    const orchProvider = "claude";
+    const orchProvider = orchestratorConfig.provider ?? "claude";
     const orchModel = orchestratorConfig.model;
     const orchPassed = !preflightAvailable ||
       (preflightAvailable.has(orchProvider) && preflightAvailable.get(orchProvider)!.has(orchModel));
@@ -395,8 +399,7 @@ export async function runReviewPipeline(input: PipelineInput): Promise<PipelineR
   }
 
   // 10. Issue truncation + verdict override
-  const maxIssuesPerAgent = typeof agentSettings.maxIssuesPerAgent === "number"
-    ? agentSettings.maxIssuesPerAgent : 3;
+  const maxIssuesPerAgent = agentSettings.maxIssuesPerAgent ?? 3;
   truncateAgentIssues(agentResults, maxIssuesPerAgent);
 
   const passEligible = computePassEligible(agentResults);
@@ -404,7 +407,7 @@ export async function runReviewPipeline(input: PipelineInput): Promise<PipelineR
     logInfo(HOOK, `Pass-eligible agents this iteration: ${passEligible.join(", ")}`);
   }
 
-  const highIssueThreshold = typeof agentSettings.highIssueThreshold === "number" ? agentSettings.highIssueThreshold : 3;
+  const highIssueThreshold = agentSettings.highIssueThreshold ?? 3;
   overrideVerdictsByThreshold(agentResults, highIssueThreshold);
 
   // PHASE 4: Generate Output

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

@@ -4,19 +4,24 @@
  * See cc-native-plan-review-spec.md §4.10
  */
 
+import type { ExecutionBackend } from "../../../../_shared/lib-ts/agent-exec/execution-backend.js";
+import { logWarn } from "../../../../_shared/lib-ts/base/logger.js";
+import { debugLog, debugRaw } from "../../../lib-ts/debug.js";
+import type { AgentConfig, ReviewerResult, ReviewOptions } from "../../../lib-ts/types.js";
 import { ClaudeAgent } from "./providers/claude-agent.js";
 import { CodexAgent } from "./providers/codex-agent.js";
 import { GeminiAgent } from "./providers/gemini-agent.js";
 import type { Reviewer } from "./types.js";
 import { makeResult } from "./types.js";
-import { logWarn } from "../../../../_shared/lib-ts/base/logger.js";
-import type { AgentConfig, ReviewerResult, ReviewOptions } from "../../../lib-ts/types.js";
 
 /**
  * Agent reviewer — runs a CLI instance with a custom persona.
  */
 export class AgentReviewer implements Reviewer {
-  constructor(private agent: AgentConfig) {}
+  constructor(
+    private agent: AgentConfig,
+    private backend?: ExecutionBackend,
+  ) {}
 
   async review(
     plan: string,
@@ -30,6 +35,7 @@ export class AgentReviewer implements Reviewer {
       options.timeout,
       options.context_path,
       options.session_name ?? "unknown",
+      this.backend,
     );
   }
 }
@@ -46,21 +52,27 @@ export async function runAgentReview(
   timeout: number,
   contextPath?: string,
   sessionName = "unknown",
+  backend?: ExecutionBackend,
 ): Promise<ReviewerResult> {
   try {
-    let reviewer;
+    const config = {
+      agent, schema, timeout, contextPath, sessionName,
+      debugLogger: { log: debugLog, raw: debugRaw },
+    };
+
+    let reviewer: ClaudeAgent | CodexAgent | GeminiAgent;
 
     switch (agent.provider) {
       case "codex": {
-        reviewer = new CodexAgent(agent, schema, timeout, contextPath, sessionName);
+        reviewer = new CodexAgent(config, backend);
         break;
       }
       case "gemini": {
-        reviewer = new GeminiAgent(agent, schema, timeout, contextPath, sessionName);
+        reviewer = new GeminiAgent(config, backend);
         break;
       }
       default: {
-        reviewer = new ClaudeAgent(agent, schema, timeout, contextPath, sessionName);
+        reviewer = new ClaudeAgent(config, backend);
         break;
       }
     }