aiwcli 0.13.8 → 0.15.1

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

@@ -1,6 +1,23 @@
 {
+  "statusLine": {
+    "type": "command",
+    "command": "NO_COLOR= FORCE_COLOR=2 bun ~/.aiwcli/bin/resolve-run.ts .aiwcli/_shared/scripts/status_line.ts"
+  },
+  "fileSuggestion": {
+    "type": "command",
+    "command": "bun ~/.aiwcli/bin/resolve-run.ts .aiwcli/_shared/hooks-ts/file-suggestion.ts"
+  },
   "hooks": {
     "UserPromptSubmit": [
+      {
+        "hooks": [
+          {
+            "type": "command",
+            "command": "bun ~/.aiwcli/bin/resolve-run.ts .aiwcli/_shared/hooks-ts/user_prompt_submit.ts",
+            "timeout": 10000
+          }
+        ]
+      },
       {
         "hooks": [
           {
@@ -12,6 +29,56 @@
       }
     ],
     "PostToolUse": [
+      {
+        "matcher": "*",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "bun ~/.aiwcli/bin/resolve-run.ts .aiwcli/_shared/hooks-ts/context_monitor.ts",
+            "timeout": 5000
+          }
+        ]
+      },
+      {
+        "matcher": "TaskCreate",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "bun ~/.aiwcli/bin/resolve-run.ts .aiwcli/_shared/hooks-ts/task_create_capture.ts",
+            "timeout": 3000
+          }
+        ]
+      },
+      {
+        "matcher": "TaskUpdate",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "bun ~/.aiwcli/bin/resolve-run.ts .aiwcli/_shared/hooks-ts/task_update_capture.ts",
+            "timeout": 3000
+          }
+        ]
+      },
+      {
+        "matcher": "ExitPlanMode",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "bun ~/.aiwcli/bin/resolve-run.ts .aiwcli/_shared/hooks-ts/archive_plan.ts",
+            "timeout": 5000
+          }
+        ]
+      },
+      {
+        "matcher": "Write|Edit",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "bun ~/.aiwcli/bin/resolve-run.ts .aiwcli/_shared/hooks-ts/lint_after_edit.ts",
+            "timeout": 10000
+          }
+        ]
+      },
       {
         "matcher": "AskUserQuestion",
         "hooks": [
@@ -44,6 +111,51 @@
         ]
       }
     ],
+    "SessionStart": [
+      {
+        "hooks": [
+          {
+            "type": "command",
+            "command": "bun ~/.aiwcli/bin/resolve-run.ts .aiwcli/_shared/hooks-ts/session_start.ts",
+            "timeout": 5000
+          }
+        ]
+      }
+    ],
+    "SessionEnd": [
+      {
+        "hooks": [
+          {
+            "type": "command",
+            "command": "bun ~/.aiwcli/bin/resolve-run.ts .aiwcli/_shared/hooks-ts/session_end.ts",
+            "timeout": 5000
+          }
+        ]
+      }
+    ],
+    "PreCompact": [
+      {
+        "hooks": [
+          {
+            "type": "command",
+            "command": "bun ~/.aiwcli/bin/resolve-run.ts .aiwcli/_shared/hooks-ts/pre_compact.ts",
+            "timeout": 5000
+          }
+        ]
+      }
+    ],
+    "PermissionRequest": [
+      {
+        "matcher": "ExitPlanMode",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "bun ~/.aiwcli/bin/resolve-run.ts .aiwcli/_shared/hooks-ts/archive_plan.ts",
+            "timeout": 5000
+          }
+        ]
+      }
+    ],
     "PreToolUse": [
       {
         "matcher": "^TaskCreate$",
@@ -83,5 +195,13 @@
   "env": {
     "CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS": "1"
   },
-  "enabledPlugins": {}
+  "enabledPlugins": {},
+  "methods": {
+    "cc-native": {
+      "ides": [
+        "claude"
+      ],
+      "installedAt": "2026-02-21T16:59:33.520Z"
+    }
+  }
 }

package/dist/templates/cc-native/_cc-native/CLAUDE.md

@@ -0,0 +1,73 @@
+# CC-Native Method
+
+**Location:** `.aiwcli/_cc-native/` — Claude Code-specific plan review, artifacts, and agent orchestration.
+
+---
+
+## Subsystems
+
+| Directory | Purpose | CLAUDE.md |
+|-----------|---------|-----------|
+| `agents/` | Plan review agent roster and specs | `agents/CLAUDE.md` |
+| `artifacts/` | Review artifact generation and tracking | `artifacts/CLAUDE.md` |
+| `hooks/` | CC-native hook entry points (plan review triggers) | `hooks/CLAUDE.md` |
+| `lib-ts/` | Shared TypeScript library for cc-native subsystems | `lib-ts/CLAUDE.md` |
+| `lib-ts/rlm/` | Retrieval-augmented learning memory | `lib-ts/rlm/CLAUDE.md` |
+| `plan-review/` | Multi-agent plan review pipeline | `plan-review/CLAUDE.md` |
+
+---
+
+## Shared Infrastructure (`_shared/lib-ts/`)
+
+CC-native code depends heavily on shared infrastructure. Full API details: `_shared/lib-ts/CLAUDE.md`.
+
+| Module | Capability | Use When |
+|--------|-----------|----------|
+| `base/hook-utils` | Hook lifecycle (load input, run, emit context) | Writing hooks |
+| `base/logger` | Structured logging (debug/info/warn/error) | Any hook or lib module |
+| `base/constants` | Project paths, context dirs, sanitization | Resolving file locations |
+| `base/subprocess-utils` | Find executables, exec with env, shell quoting | Spawning agent CLIs |
+| `base/cli-args` | CLI invocation builder, review spec construction | Launching review agents |
+| `base/atomic-write` | Crash-safe file writes | Writing state or artifacts |
+| `base/state-io` | State read/write helpers | Context state persistence |
+| `base/inference` | Claude CLI subprocess calls | AI inference from hooks |
+| `context/context-store` | Context CRUD (get by session, list all) | Session/context binding |
+| `context/plan-manager` | Plan lifecycle (archive, hash, sign) | Plan discovery and hashing |
+| `types` | Shared type definitions (`ContextState`, etc.) | Type imports |
+
+---
+
+## Import Patterns
+
+**Import direction:** `hooks/` → `lib-ts/` → `_shared/lib-ts/`. Never the reverse.
+
+```typescript
+// From hooks/ (2 levels up to _shared):
+import { runHook, logInfo } from "../../_shared/lib-ts/base/hook-utils.js";
+import { loadConfig } from "../lib-ts/config.js";
+
+// From lib-ts/ (2 levels up to _shared):
+import { logDebug } from "../../_shared/lib-ts/base/logger.js";
+import { atomicWrite } from "../../_shared/lib-ts/base/atomic-write.js";
+
+// From plan-review/lib/ (3 levels up to _shared):
+import { logInfo } from "../../../_shared/lib-ts/base/logger.js";
+```
+
+---
+
+## Context Maintenance
+
+**After modifying files in this directory:** scan the entries above — if any claim is now
+false or incomplete, update this file before ending the task. Do not defer.
+
+**Add** an entry only if an agent would fail without knowing it, it is not obvious from
+the code, and it belongs at this scope.
+
+**Remove** any entry that fails the falsifiability test: if removing it would not change
+how an agent acts here, remove it.
+
+**Staleness anchor:** This file assumes `lib-ts/index.ts` exists. If it doesn't, this file
+is stale — update or regenerate before relying on it.
+
+<!-- context-layer: generated=2026-03-01 | last-audited=2026-03-01 | version=1 | dir-commits-at-audit=15 -->

package/dist/templates/cc-native/_cc-native/lib-ts/CLAUDE.md

@@ -0,0 +1,70 @@
+# CC-Native Library
+
+**Location:** `_cc-native/lib-ts/` — TypeScript modules for plan review, state, and agent orchestration.
+
+**Import direction:** `hooks/` → `lib-ts/` → `_shared/lib-ts/`. Never the reverse.
+
+---
+
+## Module Reference
+
+The barrel `index.ts` re-exports most modules. Three files are **not** re-exported and must be imported directly: `plan-discovery.ts`, `plan-enhancement.ts`, `settings.ts`.
+
+| File | Purpose | Key Exports |
+|------|---------|-------------|
+| `aggregate-agents.ts` | Agent frontmatter parser — loads agent configs from markdown | `aggregateAgents`, `extractBody`, `extractFrontmatter` |
+| `cc-native-state.ts` | CC-native state accessor for context `state.json` | `getCcNativeState`, `saveCcNativeState`, `isPlanAlreadyReviewed`, `markPlanReviewed`, `markQuestionsAsked` |
+| `cli-output-parser.ts` | Unified Claude CLI JSON output parser | `parseCliOutput` |
+| `config.ts` | Configuration loading from `cc-native.config.json` | `loadConfig`, `getDisplaySettings` |
+| `constants.ts` | Feature flags, security limits, path validation | `ENABLE_ROBUST_PLAN_WRITES`, `PLANS_DIR`, `validatePlanPath`, `MAX_RETRY_ATTEMPTS` |
+| `debug.ts` | Per-context debug logging (thin layer over shared logger) | `debugLog`, `debugRaw`, `getDebugDir`, `cleanupDebugFolder` |
+| `index.ts` | Barrel — re-exports public API from all modules | (see individual modules) |
+| `json-parser.ts` | JSON parsing with recovery for LLM responses | `parseJsonMaybe`, `coerceToReview` |
+| `plan-discovery.ts` | Plan file discovery, reading, and hashing | *(not re-exported)* — import directly |
+| `plan-enhancement.ts` | Plan quality guidance prompt for context emission | *(not re-exported)* — import directly |
+| `settings.ts` | Settings loading, defaults, agent library management | *(not re-exported)* — import directly |
+| `state.ts` | Iteration state management for plan review cycles | `loadState`, `saveStateToPlan`, `getIterationState`, `shouldContinueIterating` |
+| `types.ts` | All cc-native type definitions and prompt constants | `Verdict`, `ReviewData`, `AgentConfig`, `PlanReviewConfig`, `REVIEW_SCHEMA` |
+
+**Subfolder:** `rlm/` — retrieval-augmented learning memory. Has its own `rlm/CLAUDE.md`.
+
+---
+
+## Shared Dependencies
+
+These `_shared/lib-ts` modules are used across cc-native lib-ts:
+
+| Shared Module | Used By |
+|--------------|---------|
+| `base/logger` | All modules (logging) |
+| `base/atomic-write` | `state.ts` (crash-safe writes) |
+| `base/utils` | `cc-native-state.ts` (`nowIso`) |
+| `context/context-store` | `cc-native-state.ts` (state access) |
+| `context/plan-manager` | `plan-discovery.ts` (plan path lookup) |
+| `types` | `types.ts` (re-exports `ContextState`, `HookInput`, `HookOutput`) |
+
+---
+
+## Import Direction
+
+```
+hooks/                    (entry points — import from lib-ts/ and _shared/)
+  ↓
+lib-ts/                   (this directory — import from _shared/ only)
+  ↓
+_shared/lib-ts/           (cross-method infrastructure — no reverse imports)
+```
+
+Never import from `hooks/` or `plan-review/` into `lib-ts/`. The one exception noted in `aggregate-agents.ts`: it stays in `lib-ts/` because both `settings.ts` and `plan-review/` depend on it.
+
+---
+
+## Context Maintenance
+
+**After modifying files in this directory:** scan the entries above — if any claim is now
+false or incomplete, update this file before ending the task. Do not defer.
+
+**Staleness anchor:** This file assumes `index.ts` exists with 13 sibling `.ts` files. If the
+count changes, update the Module Reference table.
+
+<!-- context-layer: generated=2026-03-01 | last-audited=2026-03-01 | version=1 | dir-commits-at-audit=15 -->

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,11 +11,16 @@ 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";
+import { CODEX_MODELS } from "../../_shared/lib-ts/base/models.js";
 
 const HOOK = "settings";
 
@@ -56,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 },
@@ -71,7 +76,7 @@ export const DEFAULT_COMPLEXITY_CATEGORIES = ["code", "infrastructure", "documen
 export const DEFAULT_MODELS_CONFIG: ModelsConfig = {
   providers: {
     claude: { enabled: false, models: ["sonnet"] },
-    codex: { enabled: true, models: ["gpt-5.2"] },
+    codex: { enabled: true, models: [CODEX_MODELS.codex] },
   },
 };
 
@@ -79,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 };
 }
 
@@ -138,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;
@@ -149,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 };
@@ -161,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;