aiwcli 0.14.0 → 0.15.2

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

@@ -1,144 +1,20 @@
 /**
- * Unified Claude CLI output parser.
- * Deduplicates identical logic from orchestrator.ts and reviewers/agent.ts.
- * See cc-native-plan-review-spec.md §4.6
+ * CC-native wrapper around shared structured-output parsing.
+ * Keeps existing import surface stable for provider implementations.
  */
 
-import { parseJsonMaybe } from "./json-parser.js";
-import { logDebug, logError, logWarn } from "../../_shared/lib-ts/base/logger.js";
+import { parseStructuredOutput } from "../../_shared/lib-ts/agent-exec/structured-output.js";
 
 /**
- * Parse Claude CLI JSON output, handling various formats.
- *
- * Claude CLI can output in several formats:
- * - Direct structured_output dict
- * - Assistant message with StructuredOutput tool use
- * - List of events with assistant messages
- * - Raw text with embedded JSON (heuristic fallback)
- *
- * @param raw - Raw stdout from Claude CLI
- * @param requireFields - Optional fields to validate in heuristic fallback
- * @returns Parsed JSON dict or null if parsing failed
+ * Parse CLI JSON output into a structured object.
+ * Delegates to shared parser with cc-native logging tag.
  */
 export function parseCliOutput(
   raw: string,
   requireFields?: string[],
 ): null | Record<string, unknown> {
-  try {
-    const result: unknown = JSON.parse(raw);
-
-    if (result !== null && typeof result === "object" && !Array.isArray(result)) {
-      const dict = result as Record<string, unknown>;
-
-      // Strategy 1: Direct structured_output key
-      if ("structured_output" in dict) {
-        logDebug("cli_parser", "Found structured_output in root dict");
-        return dict.structured_output as Record<string, unknown>;
-      }
-
-      // Strategy 1.5: Session result envelope (type: "result")
-      // When the model fails to call StructuredOutput, the CLI returns a
-      // session metadata object with type/subtype/duration_ms/usage/etc.
-      // but no structured_output key. Check for the `result` text field
-      // (model may have written review as text) and for error states.
-      if (dict.type === "result" || ("duration_ms" in dict && "session_id" in dict)) {
-        if (dict.is_error === true || (Array.isArray(dict.errors) && (dict.errors as unknown[]).length > 0)) {
-          logWarn("cli_parser", `CLI returned error result: ${JSON.stringify(dict.errors ?? "is_error=true")}`);
-          return null;
-        }
-        if (typeof dict.result === "string" && dict.result) {
-          logDebug("cli_parser", "Found result text in session envelope, attempting JSON extraction");
-          const extracted = parseJsonMaybe(dict.result as string, requireFields);
-          if (extracted) return extracted;
-          logWarn("cli_parser", "Session envelope result text contained no extractable JSON");
-        }
-        logDebug("cli_parser", "Session result envelope with no structured_output or extractable result");
-        return null;
-      }
-
-      // Strategy 2: Assistant message with StructuredOutput tool use
-      if (dict.type === "assistant") {
-        const message = dict.message as Record<string, unknown> | undefined;
-        const content = message?.content;
-        if (Array.isArray(content)) {
-          for (const item of content) {
-            if (
-              item !== null &&
-              typeof item === "object" &&
-              (item as Record<string, unknown>).name === "StructuredOutput"
-            ) {
-              logDebug(
-                "cli_parser",
-                "Found StructuredOutput in assistant message content",
-              );
-              return (item as Record<string, unknown>).input as Record<
-                string,
-                unknown
-              >;
-            }
-          }
-        }
-
-        logDebug(
-          "cli_parser",
-          "Assistant message found but no StructuredOutput tool use in content",
-        );
-      }
-    } else if (Array.isArray(result)) {
-      // Strategy 3: List of events with assistant messages
-      logDebug(
-        "cli_parser",
-        `Received list of ${(result as unknown[]).length} events, searching for assistant message`,
-      );
-      for (let i = 0; i < (result as unknown[]).length; i++) {
-        const event = (result as unknown[])[i];
-        if (event === null || typeof event !== "object") continue;
-
-        const dict = event as Record<string, unknown>;
-        if (dict.type === "assistant") {
-          const message = dict.message as Record<string, unknown> | undefined;
-          const content = message?.content;
-          if (Array.isArray(content)) {
-            for (const item of content) {
-              if (
-                item !== null &&
-                typeof item === "object" &&
-                (item as Record<string, unknown>).name === "StructuredOutput"
-              ) {
-                logDebug(
-                  "cli_parser",
-                  `Found StructuredOutput in event[${i}] assistant message`,
-                );
-                return (item as Record<string, unknown>).input as Record<
-                  string,
-                  unknown
-                >;
-              }
-            }
-          }
-        }
-      }
-
-      logDebug(
-        "cli_parser",
-        "No StructuredOutput found in any assistant message in event list",
-      );
-    }
-  } catch (error: unknown) {
-    if (error instanceof SyntaxError) {
-      logWarn("cli_parser", `JSON decode error: ${error.message}`);
-    } else {
-      logError(
-        "cli_parser",
-        `Unexpected error during structured parsing: ${error}`,
-      );
-    }
-  }
-
-  // Strategy 4: Heuristic {…} extraction fallback
-  logDebug(
-    "cli_parser",
-    "No structured output found, falling back to heuristic JSON extraction",
-  );
-  return parseJsonMaybe(raw, requireFields);
+  return parseStructuredOutput(raw, {
+    requireFields,
+    loggerTag: "cli_parser",
+  });
 }

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