aiwcli 0.14.0 → 0.15.1

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

@@ -11,8 +11,12 @@ import { loadConfig, getDisplaySettings } from "./config.js";
 import { DEFAULT_REVIEW_ITERATIONS } from "./state.js";
 import type {
   AgentConfig,
-  ProviderConfig,
+  AgentReviewSettings,
+  AgentSelectionConfig,
+  LoadedSettings,
   ModelsConfig,
+  PlanReviewSettings,
+  ProviderConfig,
 } from "./types.js";
 import { DEFAULT_DISPLAY, DEFAULT_SANITIZATION } from "./types.js";
 import { logInfo } from "../../_shared/lib-ts/base/logger.js";
@@ -57,10 +61,10 @@ export const DEFAULT_AGENTS: Array<{ name: string; model: string; provider: stri
   { ...AGENT_DEFAULTS, name: "constraint-validator", focus: "constraint identification and satisfaction", categories: ALL_CATEGORIES },
 ];
 
-export const DEFAULT_ORCHESTRATOR: { enabled: boolean; model: string; timeout: number } = { enabled: true, model: "opus", timeout: 60 };
+export const DEFAULT_ORCHESTRATOR = { enabled: true, model: CODEX_MODELS.codex, provider: "codex", timeout: 60 } as const;
 export const DEFAULT_AGENT_MODEL = "sonnet";
 
-export const DEFAULT_AGENT_SELECTION: Record<string, unknown> = {
+export const DEFAULT_AGENT_SELECTION: AgentSelectionConfig = {
   simple: { min: 3, max: 3 },
   medium: { min: 5, max: 5 },
   high: { min: 7, max: 7 },
@@ -80,58 +84,131 @@ export const DEFAULT_MODELS_CONFIG: ModelsConfig = {
 // Settings Loading
 // ---------------------------------------------------------------------------
 
-export function loadSettings(projDir: string): Record<string, unknown> {
-  const defaults: Record<string, unknown> = {
-    planReview: {
-      enabled: true,
-      reviewers: {
-        codex: { enabled: true, model: "", timeout: 120 },
-        gemini: { enabled: false, model: "", timeout: 120 },
-      },
-      display: { ...DEFAULT_DISPLAY },
-    },
-    agentReview: {
-      enabled: true,
-      orchestrator: { ...DEFAULT_ORCHESTRATOR },
-      timeout: 180,
-      highIssueThreshold: 3,
-      legacyMode: false,
-      display: { ...DEFAULT_DISPLAY },
-      agentSelection: { ...DEFAULT_AGENT_SELECTION },
-      agentDefaults: { model: DEFAULT_AGENT_MODEL },
-      complexityCategories: [...DEFAULT_COMPLEXITY_CATEGORIES],
-      sanitization: { ...DEFAULT_SANITIZATION },
+function asRecord(value: unknown): Record<string, unknown> | undefined {
+  return value && typeof value === "object" && !Array.isArray(value)
+    ? value as Record<string, unknown>
+    : undefined;
+}
+
+function asStringArray(value: unknown): string[] | undefined {
+  if (!Array.isArray(value)) return undefined;
+  const filtered = value.filter((item): item is string => typeof item === "string" && item.trim().length > 0);
+  return filtered.length > 0 ? filtered : undefined;
+}
+
+export function loadSettings(projDir: string): LoadedSettings {
+  const defaultPlan: PlanReviewSettings = {
+    enabled: true,
+    reviewers: {
+      codex: { enabled: true, model: "", timeout: 120 },
+      gemini: { enabled: false, model: "", timeout: 120 },
     },
+    display: { ...DEFAULT_DISPLAY },
+  };
+
+  const defaultAgent: AgentReviewSettings = {
+    enabled: true,
+    orchestrator: { ...DEFAULT_ORCHESTRATOR },
+    timeout: 180,
+    highIssueThreshold: 3,
+    legacyMode: false,
+    display: { ...DEFAULT_DISPLAY },
+    agentSelection: { ...DEFAULT_AGENT_SELECTION },
+    agentDefaults: { model: DEFAULT_AGENT_MODEL },
+    complexityCategories: [...DEFAULT_COMPLEXITY_CATEGORIES],
+    sanitization: { ...DEFAULT_SANITIZATION },
   };
 
   const config = loadConfig(projDir);
-  if (!config || Object.keys(config).length === 0) return { ...defaults, models: {} };
+  if (!config || Object.keys(config).length === 0) {
+    return { planReview: defaultPlan, agentReview: defaultAgent, models: {} };
+  }
+
+  // Cast raw config to access arbitrary keys from JSON
+  const raw = config as Record<string, unknown>;
 
   // Merge planReview
-  const planReview = config.planReview ?? {};
-  const mergedPlan = { ...defaults.planReview, ...planReview };
-  if (planReview.reviewers) {
-    mergedPlan.reviewers = { ...defaults.planReview.reviewers, ...planReview.reviewers };
+  const planReviewRaw = (asRecord(raw.planReview) ?? {}) as Partial<PlanReviewSettings>;
+  const mergedPlan: PlanReviewSettings = { ...defaultPlan, ...planReviewRaw };
+  if (planReviewRaw.reviewers) {
+    mergedPlan.reviewers = { ...defaultPlan.reviewers, ...planReviewRaw.reviewers };
   }
   mergedPlan.display = getDisplaySettings(config, "planReview");
 
   // Merge agentReview
-  const agentReview = (config as Record<string, unknown>).agentReview ?? {};
-  const mergedAgent = { ...defaults.agentReview, ...agentReview };
+  const agentReviewRawRecord = asRecord(raw.agentReview);
+  const agentReviewRaw = (agentReviewRawRecord ?? {}) as Partial<AgentReviewSettings>;
+  const mergedAgent: AgentReviewSettings = { ...defaultAgent, ...agentReviewRaw };
   if (!mergedAgent.orchestrator || typeof mergedAgent.orchestrator !== "object") {
     mergedAgent.orchestrator = { ...DEFAULT_ORCHESTRATOR };
   } else {
     mergedAgent.orchestrator = { ...DEFAULT_ORCHESTRATOR, ...mergedAgent.orchestrator };
   }
   mergedAgent.display = getDisplaySettings(config, "agentReview");
-  const configRecord = config as Record<string, unknown>;
-  mergedAgent.agentSelection = { ...DEFAULT_AGENT_SELECTION, ...(configRecord.agentSelection as Record<string, unknown>) };
-  mergedAgent.agentDefaults = { model: DEFAULT_AGENT_MODEL, ...(configRecord.agentDefaults as Record<string, unknown>) };
-  mergedAgent.complexityCategories = (configRecord.complexityCategories as string[]) ?? [...DEFAULT_COMPLEXITY_CATEGORIES];
-  mergedAgent.sanitization = { ...DEFAULT_SANITIZATION, ...(configRecord.sanitization as Record<string, unknown>) };
-  mergedAgent.reviewIterations = { ...DEFAULT_REVIEW_ITERATIONS, ...agentReview.reviewIterations };
-
-  const modelsRaw = (config as Record<string, unknown>).models ?? {};
+
+  const nestedAgentSelection = asRecord(agentReviewRawRecord?.agentSelection) as AgentSelectionConfig | undefined;
+  const topLevelAgentSelection = asRecord(raw.agentSelection) as AgentSelectionConfig | undefined;
+  mergedAgent.agentSelection = {
+    ...DEFAULT_AGENT_SELECTION,
+    ...nestedAgentSelection,
+    ...topLevelAgentSelection,
+  };
+
+  const nestedAgentDefaults = asRecord(agentReviewRawRecord?.agentDefaults) as { model?: string } | undefined;
+  const topLevelAgentDefaults = asRecord(raw.agentDefaults) as { model?: string } | undefined;
+  mergedAgent.agentDefaults = {
+    model: DEFAULT_AGENT_MODEL,
+    ...nestedAgentDefaults,
+    ...topLevelAgentDefaults,
+  };
+
+  const nestedComplexityCategories = asStringArray(agentReviewRawRecord?.complexityCategories);
+  const topLevelComplexityCategories = asStringArray(raw.complexityCategories);
+  mergedAgent.complexityCategories = topLevelComplexityCategories
+    ?? nestedComplexityCategories
+    ?? [...DEFAULT_COMPLEXITY_CATEGORIES];
+
+  const nestedSanitization = asRecord(agentReviewRawRecord?.sanitization);
+  const topLevelSanitization = asRecord(raw.sanitization);
+  mergedAgent.sanitization = {
+    ...DEFAULT_SANITIZATION,
+    ...nestedSanitization,
+    ...topLevelSanitization,
+  };
+
+  const nestedFallbackByComplexity = asRecord(agentReviewRawRecord?.fallbackByComplexity) as Record<string, number> | undefined;
+  const topLevelFallbackByComplexity = asRecord(raw.fallbackByComplexity) as Record<string, number> | undefined;
+  if (nestedFallbackByComplexity || topLevelFallbackByComplexity) {
+    mergedAgent.fallbackByComplexity = {
+      ...(nestedFallbackByComplexity ?? {}),
+      ...(topLevelFallbackByComplexity ?? {}),
+    };
+  }
+
+  const nestedMandatoryAgents = agentReviewRawRecord?.mandatoryAgents as AgentReviewSettings["mandatoryAgents"] | undefined;
+  const topLevelMandatoryAgents = raw.mandatoryAgents as AgentReviewSettings["mandatoryAgents"] | undefined;
+  if (nestedMandatoryAgents !== undefined || topLevelMandatoryAgents !== undefined) {
+    mergedAgent.mandatoryAgents = topLevelMandatoryAgents ?? nestedMandatoryAgents;
+  }
+
+  const nestedPreflight = asRecord(agentReviewRawRecord?.preflight);
+  const topLevelPreflight = asRecord(raw.preflight);
+  if (nestedPreflight || topLevelPreflight) {
+    mergedAgent.preflight = {
+      ...(nestedPreflight ?? {}),
+      ...(topLevelPreflight ?? {}),
+    };
+  }
+
+  const nestedReviewIterations = asRecord(agentReviewRawRecord?.reviewIterations) as Record<string, number> | undefined;
+  const topLevelReviewIterations = asRecord(raw.reviewIterations) as Record<string, number> | undefined;
+  mergedAgent.reviewIterations = {
+    ...DEFAULT_REVIEW_ITERATIONS,
+    ...(nestedReviewIterations ?? {}),
+    ...(topLevelReviewIterations ?? {}),
+  };
+
+  const modelsRaw = (raw.models ?? {}) as Record<string, unknown>;
   return { planReview: mergedPlan, agentReview: mergedAgent, models: modelsRaw };
 }
 
@@ -139,7 +216,7 @@ export function loadSettings(projDir: string): Record<string, unknown> {
 // Models Config
 // ---------------------------------------------------------------------------
 
-export function loadModelsConfig(settings: Record<string, unknown>): ModelsConfig {
+export function loadModelsConfig(settings: LoadedSettings): ModelsConfig {
   const raw = settings.models as Record<string, unknown> | undefined;
   if (!raw?.providers || typeof raw.providers !== "object") {
     return DEFAULT_MODELS_CONFIG;
@@ -150,7 +227,6 @@ 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 };
@@ -162,7 +238,7 @@ export function loadModelsConfig(settings: Record<string, unknown>): ModelsConfi
 
 export function loadAgentLibrary(
   projDir: string,
-  settings?: Record<string, unknown>,
+  settings?: AgentReviewSettings,
 ): AgentConfig[] {
   const agentsData = aggregateAgents(path.join(projDir, "_cc-native", "plan-review", "agents", "plan-review"));
   const defaultModel = settings?.agentDefaults?.model ?? DEFAULT_AGENT_MODEL;

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

@@ -128,6 +128,7 @@ export interface ReviewDecisionResult {
 export interface OrchestratorConfig {
   enabled: boolean;
   model: string;
+  provider?: string;
   timeout: number;
 }
 
@@ -142,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/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/providers/orchestrator-claude-agent.ts

@@ -3,13 +3,13 @@
  * Analyzes plan complexity and selects reviewer agents via Claude CLI.
  */
 
-import { buildCliInvocation, reviewSpec } from "../../../../../_shared/lib-ts/base/cli-args.js";
+import { buildCliInvocation, reviewSpec, type CliProvider } from "../../../../../_shared/lib-ts/base/cli-args.js";
 import type { ExecutionBackend } from "../../../../../_shared/lib-ts/agent-exec/execution-backend.js";
 import type { ExecutionResult } from "../../../../../_shared/lib-ts/agent-exec/execution-backend.js";
+import { parseStructuredOutput } from "../../../../../_shared/lib-ts/agent-exec/structured-output.js";
 import { logDebug } from "../../../../../_shared/lib-ts/base/logger.js";
 import { debugLog, debugRaw } from "../../../../lib-ts/debug.js";
-import { parseCliOutput } from "../../../../lib-ts/cli-output-parser.js";
-import type { AgentConfig, OrchestratorResult, ComplexityCategory } from "../../../../lib-ts/types.js";
+import type { AgentConfig, AgentReviewSettings, AgentSelectionConfig, OrchestratorResult, ComplexityCategory } from "../../../../lib-ts/types.js";
 import { BaseCliAgent } from "../base/base-agent.js";
 import { buildOrchestratorSchema, ORCHESTRATOR_SCHEMA } from "../schemas.js";
 
@@ -27,7 +27,7 @@ const DEFAULT_COMPLEXITY_CATEGORIES = [
   "research",
 ];
 
-const DEFAULT_AGENT_SELECTION: Record<string, unknown> = {
+const DEFAULT_AGENT_SELECTION: AgentSelectionConfig = {
   simple: { min: 3, max: 3 },
   medium: { min: 8, max: 8 },
   high: { min: 12, max: 12 },
@@ -43,14 +43,14 @@ export class OrchestratorClaudeAgent extends BaseCliAgent<OrchestratorResult> {
   private fallbackCount: number;
   private mandatoryCount: number;
   private nonMandatory: AgentConfig[];
-  private settings: Record<string, unknown>;
+  private settings: AgentReviewSettings;
   private validNames: string[];
 
   constructor(
     agent: AgentConfig,
     agentLibrary: AgentConfig[],
     mandatoryNames: Set<string>,
-    settings: Record<string, unknown>,
+    settings: AgentReviewSettings,
     timeout: number,
     contextPath?: string,
     sessionName?: string,
@@ -61,7 +61,7 @@ export class OrchestratorClaudeAgent extends BaseCliAgent<OrchestratorResult> {
       (a) => !mandatoryNames.has(a.name),
     );
     const validNames = nonMandatory.map((a) => a.name);
-    const categories = (settings.complexityCategories as string[]) ?? DEFAULT_COMPLEXITY_CATEGORIES;
+    const categories = settings.complexityCategories ?? DEFAULT_COMPLEXITY_CATEGORIES;
 
     const schema = validNames.length > 0
       ? buildOrchestratorSchema(validNames, categories)
@@ -77,8 +77,8 @@ export class OrchestratorClaudeAgent extends BaseCliAgent<OrchestratorResult> {
     this.categories = categories;
     this.settings = settings;
 
-    const selection = (settings.agentSelection as Record<string, unknown>) ?? DEFAULT_AGENT_SELECTION;
-    this.fallbackCount = (selection.fallbackCount as number) ?? 2;
+    const selection = settings.agentSelection ?? DEFAULT_AGENT_SELECTION;
+    this.fallbackCount = selection.fallbackCount ?? DEFAULT_AGENT_SELECTION.fallbackCount;
     this.mandatoryCount = agentLibrary.filter((a) => mandatoryNames.has(a.name)).length;
 
     logDebug("orchestrator", `Mandatory agents (always run): ${[...mandatoryNames].sort().join(", ")}`);
@@ -97,12 +97,12 @@ When selecting agents:
 - Fewer agents for simple plans, more for complex plans`;
 
     return buildCliInvocation(
-      reviewSpec("claude", this.agent.model, this.schema, systemPrompt),
+      reviewSpec((this.agent.provider ?? "claude") as CliProvider, this.agent.model, this.schema, systemPrompt),
     ).args;
   }
 
   protected buildPrompt(plan: string): string {
-    const selection = (this.settings.agentSelection as Record<string, unknown>) ?? DEFAULT_AGENT_SELECTION;
+    const selection = this.settings.agentSelection ?? DEFAULT_AGENT_SELECTION;
 
     const agentList = this.nonMandatory
       .map(
@@ -112,9 +112,9 @@ When selecting agents:
       .join("\n");
     const categoryList = this.categories.join("/");
 
-    const simpleAdditional = Math.max(0, ((selection.simple as Record<string, number> | undefined)?.max ?? 3) - this.mandatoryCount);
-    const mediumAdditional = Math.max(0, ((selection.medium as Record<string, number> | undefined)?.max ?? 8) - this.mandatoryCount);
-    const highAdditional = Math.max(0, ((selection.high as Record<string, number> | undefined)?.max ?? 12) - this.mandatoryCount);
+    const simpleAdditional = Math.max(0, (selection.simple?.max ?? 3) - this.mandatoryCount);
+    const mediumAdditional = Math.max(0, (selection.medium?.max ?? 8) - this.mandatoryCount);
+    const highAdditional = Math.max(0, (selection.high?.max ?? 12) - this.mandatoryCount);
 
     return `Analyze this plan and select appropriate reviewer agents.
 
@@ -149,26 +149,54 @@ Call StructuredOutput now with: complexity, category, selectedAgents, reasoning`
         ? rawComplexity
         : "medium";
 
-    let category = (obj.category as string) ?? "code";
-    if (!this.categories.includes(category)) category = "code";
+    const defaultCategory = this.categories.includes("code")
+      ? "code"
+      : (this.categories[0] ?? "code");
+    let category = defaultCategory;
+    if (typeof obj.category === "string" && this.categories.includes(obj.category)) {
+      category = obj.category;
+    }
+
+    const rawSelected = Array.isArray(obj.selectedAgents)
+      ? obj.selectedAgents
+      : (Array.isArray(obj.selected_agents) ? obj.selected_agents : []);
+
+    const validNames = new Set(this.validNames);
+    const selectedAgents: string[] = [];
+    const unknownNames: string[] = [];
+    const seen = new Set<string>();
+    for (const value of rawSelected) {
+      if (typeof value !== "string") continue;
+      if (!validNames.has(value)) {
+        unknownNames.push(value);
+        continue;
+      }
+      if (!seen.has(value)) {
+        selectedAgents.push(value);
+        seen.add(value);
+      }
+    }
 
-    let {selectedAgents} = obj;
-    if (!Array.isArray(selectedAgents)) selectedAgents = [];
+    if (unknownNames.length > 0) {
+      logDebug("orchestrator", `Ignoring unknown orchestrator selections: ${unknownNames.join(", ")}`);
+    }
 
     const reasoning = String(obj.reasoning ?? "").trim() || "No reasoning provided";
-    const skipReason = obj.skipReason as string | undefined;
+    const skipReasonRaw = typeof obj.skipReason === "string"
+      ? obj.skipReason
+      : (typeof obj.skip_reason === "string" ? obj.skip_reason : undefined);
 
     return {
       complexity,
       category,
-      selected_agents: selectedAgents as string[],
+      selected_agents: selectedAgents,
       reasoning,
-      skip_reason: skipReason || undefined,
+      skip_reason: skipReasonRaw || undefined,
     };
   }
 
   protected getCliName(): string {
-    return "claude";
+    return this.agent.provider ?? "claude";
   }
 
   protected makeErrorResult(type: "skip" | "error", message: string): OrchestratorResult {
@@ -179,7 +207,10 @@ Call StructuredOutput now with: complexity, category, selectedAgents, reasoning`
   }
 
   protected parseOutput(raw: string, _result: ExecutionResult): Record<string, unknown> | null {
-    return parseCliOutput(raw);
+    return parseStructuredOutput(raw, {
+      requireFields: ["complexity", "category", "reasoning"],
+      loggerTag: "orchestrator_parser",
+    });
   }
 
   private makeFallback(reasoning: string, error: string): OrchestratorResult {

package/oclif.manifest.json

@@ -434,5 +434,5 @@
       ]
     }
   },
-  "version": "0.14.0"
+  "version": "0.15.1"
 }