aiwcli 0.15.5 → 0.17.0

package/dist/templates/cc-native/_cc-native/{plan-review/lib → lib-ts}/verdict.ts

@@ -1,72 +1,72 @@
-/**
- * Pure verdict aggregation logic.
- * See cc-native-plan-review-spec.md §4.2
- */
-
-import type { ReviewDecisionResult, Verdict } from "../../lib-ts/types.js";
-
-/**
- * Return the worst verdict from a list.
- * Order: pass < warn < fail. skip→pass, error→warn.
- */
-export function worstVerdict(verdicts: Verdict[]): Verdict {
-  const order: Record<Verdict, number> = {
-    pass: 0,
-    warn: 1,
-    fail: 2,
-    skip: 0,
-    error: 1,
-  };
-
-  let worst: Verdict = "pass";
-  for (const v of verdicts) {
-    if ((order[v] ?? 1) > (order[worst] ?? 0)) {
-      worst = v;
-    }
-  }
-
-  // Normalize error → warn
-  if (worst === "error") return "warn";
-  return worst;
-}
-
-/**
- * Verdict aggregation: fail veto triggers a block.
- *
- * Priority order:
- * 1. Fail Veto: Any fail → deny (ISO 61508 zero-tolerance)
- * 2. Acceptable: warns are informational only
- *
- * Error exclusion: Detectors that produce no signal (error/skip) are excluded
- * from the denominator.
- *
- * @param allVerdicts - List of verdict strings from all reviewers
- * @returns ReviewDecisionResult with should_deny, reason, and score
- */
-export function computeReviewDecision(
-  allVerdicts: Verdict[],
-): ReviewDecisionResult {
-  // Exclude non-signal verdicts
-  const signalVerdicts = allVerdicts.filter(
-    (v) => v === "pass" || v === "warn" || v === "fail",
-  );
-
-  if (signalVerdicts.length === 0) {
-    return { should_deny: false, reason: "no_signal", score: 0 };
-  }
-
-  // Fail blocks unconditionally
-  const failCount = signalVerdicts.filter((v) => v === "fail").length;
-  if (failCount > 0) {
-    return { should_deny: true, reason: "fail_veto", score: 1 };
-  }
-
-  // Warn also blocks — reviewers flagged concerns worth addressing
-  const warnCount = signalVerdicts.filter((v) => v === "warn").length;
-  const warnRatio = warnCount / signalVerdicts.length;
-  if (warnCount > 0) {
-    return { should_deny: true, reason: "warn_block", score: warnRatio };
-  }
-
-  return { should_deny: false, reason: "acceptable", score: 0 };
-}
+/**
+ * Pure verdict aggregation logic.
+ * See cc-native-plan-review-spec.md §4.2
+ */
+
+import type { ReviewDecisionResult, Verdict } from "./types.js";
+
+/**
+ * Return the worst verdict from a list.
+ * Order: pass < warn < fail. skip→pass, error→warn.
+ */
+export function worstVerdict(verdicts: Verdict[]): Verdict {
+  const order: Record<Verdict, number> = {
+    pass: 0,
+    warn: 1,
+    fail: 2,
+    skip: 0,
+    error: 1,
+  };
+
+  let worst: Verdict = "pass";
+  for (const v of verdicts) {
+    if ((order[v] ?? 1) > (order[worst] ?? 0)) {
+      worst = v;
+    }
+  }
+
+  // Normalize error → warn
+  if (worst === "error") return "warn";
+  return worst;
+}
+
+/**
+ * Verdict aggregation: fail veto triggers a block.
+ *
+ * Priority order:
+ * 1. Fail Veto: Any fail → deny (ISO 61508 zero-tolerance)
+ * 2. Acceptable: warns are informational only
+ *
+ * Error exclusion: Detectors that produce no signal (error/skip) are excluded
+ * from the denominator.
+ *
+ * @param allVerdicts - List of verdict strings from all reviewers
+ * @returns ReviewDecisionResult with should_deny, reason, and score
+ */
+export function computeReviewDecision(
+  allVerdicts: Verdict[],
+): ReviewDecisionResult {
+  // Exclude non-signal verdicts
+  const signalVerdicts = allVerdicts.filter(
+    (v) => v === "pass" || v === "warn" || v === "fail",
+  );
+
+  if (signalVerdicts.length === 0) {
+    return { should_deny: false, reason: "no_signal", score: 0.0 };
+  }
+
+  // Fail blocks unconditionally
+  const failCount = signalVerdicts.filter((v) => v === "fail").length;
+  if (failCount > 0) {
+    return { should_deny: true, reason: "fail_veto", score: 1.0 };
+  }
+
+  // Warn also blocks — reviewers flagged concerns worth addressing
+  const warnCount = signalVerdicts.filter((v) => v === "warn").length;
+  const warnRatio = warnCount / signalVerdicts.length;
+  if (warnCount > 0) {
+    return { should_deny: true, reason: "warn_block", score: warnRatio };
+  }
+
+  return { should_deny: false, reason: "acceptable", score: 0.0 };
+}

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

@@ -67,8 +67,9 @@ Hooks that invoke this system (all in `../_cc-native/hooks/`):
 | Module | Key Exports |
 |--------|-------------|
 | `review-pipeline.ts` | `runReviewPipeline(input)` — main entry point |
-| `agent-selection.ts` | `resolveMandatoryAgents()`, `selectAgents()`, `assignModelsToAgents()` |
+| `agent-selection.ts` | `resolveMandatoryAgents()`, `selectAgents()`, `assignModelsToAgents(agents, config, available?, options?)`, `resolveEnabledProviders()` (@internal). `assignModelsToAgents` accepts optional `{ isCliAvailable, randomFn }` for DI. |
 | `corroboration.ts` | `computeCorroboratedDecision()` |
+| `preflight.ts` | `runPreflight()`, `collectPreflightChecks()` (@internal), `buildPreflightReport()` (@internal), `KNOWN_PROVIDERS` |
 | `graduation.ts` | `computePassEligible()`, `extractTopIssuesForTracker()`, `advanceIterationState()` |
 | `orchestrator.ts` | `runOrchestrator()`, `buildOrchestratorSchema()` (re-exported) |
 | `output-builder.ts` | `buildReviewOutput()`, `truncateAgentIssues()`, `overrideVerdictsByThreshold()` |
@@ -79,6 +80,7 @@ Hooks that invoke this system (all in `../_cc-native/hooks/`):
 ## Dependencies
 
 **Reads from shared lib-ts (stays in lib-ts, not part of plan-review):**
+- `_core/lib-ts/runtime/cli-args.ts` — centralized CLI arg construction (`buildCliInvocation`, `reviewSpec`, `preflightCommandConfig`). All provider agents and preflight delegate flag construction here.
 - `../../lib-ts/types.ts` — all shared types (AgentConfig, ReviewerResult, etc.)
 - `../../lib-ts/settings.ts` — config loading
 - `../../lib-ts/plan-discovery.ts` — plan file discovery
@@ -142,9 +144,44 @@ weight: 1.0
 
 `mandatory: true` agents always run. `mandatory: false` agents are selected by the orchestrator based on plan complexity.
 
+## Model & Provider Configuration
+
+Model assignment flows through a multi-layer pipeline:
+
+1. **Config source:** `cc-native.config.json` → `models.providers` section
+2. **Defaults:** `lib-ts/settings.ts` → `DEFAULT_MODELS_CONFIG`
+3. **Loading:** `loadModelsConfig()` parses config into `ModelsConfig` (including `reasoning_effort`)
+4. **Assignment:** `assignModelsToAgents()` assigns provider, model, and `reasoning_effort` from the selected `ProviderConfig` to each `AgentConfig`
+5. **Invocation:** Provider agents (e.g. `CodexAgent.buildCliArgs()`) emit CLI flags
+
+**Current defaults:**
+- Codex: model `gpt-5.4`, `reasoning_effort: "low"` → `codex exec --model gpt-5.4 -c model_reasoning_effort="low"`
+- Claude: model `sonnet` → `claude --model sonnet`
+
+**Provider priority:** `["codex", "claude"]` — Codex is preferred (cheaper/faster), Claude is fallback.
+
+**`reasoning_effort` field:** Configured per-provider in `ProviderConfig`. Passed through `assignModelsToAgents()` to `AgentConfig.reasoning_effort`. `CodexAgent` emits it as `-c model_reasoning_effort="<value>"`. When absent, the flag is omitted and the CLI default applies.
+
+### Verifying model/config changes
+
+**Always test model or config changes against the real CLI.** Use `codex exec` directly to confirm the model name and flags are accepted before committing:
+
+```bash
+# Verify model + reasoning_effort works
+codex exec --model gpt-5.4 -c 'model_reasoning_effort="low"' --sandbox read-only --ephemeral \
+  -o /tmp/test-out.txt "Say hello" 2>&1 | head -20
+
+# Check the output header for: model, reasoning effort, provider
+# A 400 error like "model is not supported" means the model name is wrong
+```
+
+Invalid model names fail at runtime with no compile-time safety net. The CLI header prints the resolved `model:` and `reasoning effort:` — always verify these match expectations.
+
 ## Design Decisions
 
 - **Thin hook, fat pipeline:** The hook is ~70 lines and delegates everything to `review-pipeline.ts`. This enables testing the pipeline without hook machinery.
 - **Parallel reviews:** All selected agents run simultaneously via `Promise.all()`. Review time is bounded by the slowest agent, not total agents.
 - **Questions gate first:** Questions must be asked before review. `wasQuestionsAsked()` prevents skipping the gate via repeated ExitPlanMode attempts.
 - **Co-location:** Moved from scattered `lib-ts/`, `agents/`, and `workflows/` to `plan-review/` to follow the handoff system pattern. See root CLAUDE.md "System Co-location Pattern".
+
+<!-- context-layer: last-audited=2026-03-07 | version=2 -->

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

@@ -0,0 +1,345 @@
+/**
+ * Tests for agent-selection module.
+ * Tests resolveEnabledProviders directly with simple predicates — zero mocks.
+ * Tests assignModelsToAgents with DI options (randomFn, isCliAvailable) — zero mocks.
+ * Logger mock is for noise suppression only.
+ */
+
+import { describe, it, expect, mock } from "bun:test";
+
+import type { AgentConfig, ModelsConfig } from "../../../lib-ts/types.js";
+
+// ---------------------------------------------------------------------------
+// Mock logger for noise suppression only (no assertions on logger calls)
+// ---------------------------------------------------------------------------
+
+mock.module("../../../../_core/lib-ts/runtime/logger.js", () => ({
+  logDebug() {},
+  logInfo() {},
+  logWarn() {},
+  logError() {},
+}));
+
+// Mock subprocess-utils so module load doesn't fail (not used by tests via DI)
+mock.module("../../../../_core/lib-ts/runtime/subprocess-utils.js", () => ({
+  findExecutable: () => null,
+}));
+
+const { assignModelsToAgents, resolveEnabledProviders } = await import("../agent-selection.js");
+
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+
+function makeAgent(name: string): AgentConfig {
+  return {
+    name,
+    model: "default-model",
+    provider: "",
+    focus: "test",
+    categories: [],
+    description: `Test agent ${name}`,
+    system_prompt: "",
+  };
+}
+
+function makeModelsConfig(providers: Record<string, { enabled: boolean; models: string[] }>): ModelsConfig {
+  return { providers };
+}
+
+/** CLI always available */
+const allAvailable = () => true;
+
+/** CLI never available */
+const noneAvailable = () => false;
+
+/** Only specific CLIs available */
+const onlyAvailable = (...names: string[]) => (name: string) => names.includes(name);
+
+// ---------------------------------------------------------------------------
+// resolveEnabledProviders — pure, zero mocks
+// ---------------------------------------------------------------------------
+
+describe("agent-selection", () => {
+describe("resolveEnabledProviders", () => {
+  it("returns enabled providers sorted by priority (codex first)", () => {
+    const config = makeModelsConfig({
+      claude: { enabled: true, models: ["sonnet"] },
+      codex: { enabled: true, models: ["codex-mini-latest"] },
+    });
+
+    const result = resolveEnabledProviders(config, allAvailable);
+
+    expect(result.length).toBe(2);
+    expect(result[0]![0]).toBe("codex");
+    expect(result[1]![0]).toBe("claude");
+  });
+
+  it("excludes providers whose CLI is not available", () => {
+    const config = makeModelsConfig({
+      claude: { enabled: true, models: ["sonnet"] },
+      codex: { enabled: true, models: ["codex-mini-latest"] },
+    });
+
+    const result = resolveEnabledProviders(config, onlyAvailable("claude"));
+
+    expect(result.length).toBe(1);
+    expect(result[0]![0]).toBe("claude");
+  });
+
+  it("excludes disabled providers", () => {
+    const config = makeModelsConfig({
+      claude: { enabled: false, models: ["sonnet"] },
+      codex: { enabled: true, models: ["codex-mini-latest"] },
+    });
+
+    const result = resolveEnabledProviders(config, allAvailable);
+
+    expect(result.length).toBe(1);
+    expect(result[0]![0]).toBe("codex");
+  });
+
+  it("excludes providers with empty model lists", () => {
+    const config = makeModelsConfig({
+      claude: { enabled: true, models: [] },
+      codex: { enabled: true, models: ["codex-mini-latest"] },
+    });
+
+    const result = resolveEnabledProviders(config, allAvailable);
+
+    expect(result.length).toBe(1);
+    expect(result[0]![0]).toBe("codex");
+  });
+
+  it("filters models by preflight results", () => {
+    const config = makeModelsConfig({
+      claude: { enabled: true, models: ["sonnet", "opus"] },
+    });
+
+    const preflightAvailable = new Map([
+      ["claude", new Set(["sonnet"])],
+    ]);
+
+    const result = resolveEnabledProviders(config, allAvailable, preflightAvailable);
+
+    expect(result.length).toBe(1);
+    expect(result[0]![1].models).toEqual(["sonnet"]);
+  });
+
+  it("skips provider when no models passed preflight", () => {
+    const config = makeModelsConfig({
+      claude: { enabled: true, models: ["sonnet"] },
+      codex: { enabled: true, models: ["codex-mini-latest"] },
+    });
+
+    // Only claude passed preflight
+    const preflightAvailable = new Map([
+      ["claude", new Set(["sonnet"])],
+    ]);
+
+    const result = resolveEnabledProviders(config, allAvailable, preflightAvailable);
+
+    expect(result.length).toBe(1);
+    expect(result[0]![0]).toBe("claude");
+  });
+
+  it("returns empty when no providers are available", () => {
+    const config = makeModelsConfig({
+      codex: { enabled: true, models: ["codex-mini-latest"] },
+    });
+
+    const result = resolveEnabledProviders(config, noneAvailable);
+
+    expect(result).toEqual([]);
+  });
+
+  it("puts unknown providers after known ones in priority", () => {
+    const config = makeModelsConfig({
+      gemini: { enabled: true, models: ["gemini-pro"] },
+      codex: { enabled: true, models: ["codex-mini"] },
+    });
+
+    const result = resolveEnabledProviders(config, allAvailable);
+
+    expect(result[0]![0]).toBe("codex");
+    expect(result[1]![0]).toBe("gemini");
+  });
+});
+
+// ---------------------------------------------------------------------------
+// assignModelsToAgents — uses DI, zero subprocess mocks
+// ---------------------------------------------------------------------------
+
+describe("assignModelsToAgents", () => {
+  it("assigns provider and model to agents", () => {
+    const agents = [makeAgent("a1"), makeAgent("a2")];
+    const config = makeModelsConfig({
+      claude: { enabled: true, models: ["sonnet"] },
+    });
+
+    const result = assignModelsToAgents(agents, config, undefined, {
+      isCliAvailable: allAvailable,
+      randomFn: () => 0,
+    });
+
+    expect(result.length).toBe(2);
+    expect(result[0]!.provider).toBe("claude");
+    expect(result[0]!.model).toBe("sonnet");
+    expect(result[1]!.provider).toBe("claude");
+  });
+
+  it("prefers codex over claude when both available", () => {
+    const agents = [makeAgent("a1"), makeAgent("a2"), makeAgent("a3")];
+    const config = makeModelsConfig({
+      claude: { enabled: true, models: ["sonnet"] },
+      codex: { enabled: true, models: ["codex-mini-latest"] },
+    });
+
+    const result = assignModelsToAgents(agents, config, undefined, {
+      isCliAvailable: allAvailable,
+      randomFn: () => 0,
+    });
+
+    expect(result.every(a => a.provider === "codex")).toBe(true);
+    expect(result.every(a => a.model === "codex-mini-latest")).toBe(true);
+  });
+
+  it("falls back to claude when codex CLI not found", () => {
+    const agents = [makeAgent("a1")];
+    const config = makeModelsConfig({
+      claude: { enabled: true, models: ["sonnet"] },
+      codex: { enabled: true, models: ["codex-mini-latest"] },
+    });
+
+    const result = assignModelsToAgents(agents, config, undefined, {
+      isCliAvailable: onlyAvailable("claude"),
+      randomFn: () => 0,
+    });
+
+    expect(result[0]!.provider).toBe("claude");
+    expect(result[0]!.model).toBe("sonnet");
+  });
+
+  it("filters models by preflight results", () => {
+    const agents = [makeAgent("a1")];
+    const config = makeModelsConfig({
+      claude: { enabled: true, models: ["sonnet", "opus"] },
+    });
+
+    const preflightAvailable = new Map([
+      ["claude", new Set(["sonnet"])],
+    ]);
+
+    const result = assignModelsToAgents(agents, config, preflightAvailable, {
+      isCliAvailable: allAvailable,
+      randomFn: () => 0,
+    });
+
+    expect(result[0]!.provider).toBe("claude");
+    expect(result[0]!.model).toBe("sonnet");
+  });
+
+  it("skips provider entirely when no models passed preflight", () => {
+    const agents = [makeAgent("a1")];
+    const config = makeModelsConfig({
+      claude: { enabled: true, models: ["sonnet"] },
+      codex: { enabled: true, models: ["codex-mini-latest"] },
+    });
+
+    const preflightAvailable = new Map([
+      ["claude", new Set(["sonnet"])],
+    ]);
+
+    const result = assignModelsToAgents(agents, config, preflightAvailable, {
+      isCliAvailable: allAvailable,
+      randomFn: () => 0,
+    });
+
+    expect(result[0]!.provider).toBe("claude");
+  });
+
+  it("falls back to claude defaults when all providers fail CLI check", () => {
+    const agents = [makeAgent("a1")];
+    const config = makeModelsConfig({
+      codex: { enabled: true, models: ["codex-mini-latest"] },
+    });
+
+    const result = assignModelsToAgents(agents, config, undefined, {
+      isCliAvailable: noneAvailable,
+      randomFn: () => 0,
+    });
+
+    expect(result[0]!.provider).toBe("claude");
+  });
+
+  it("skips disabled providers", () => {
+    const agents = [makeAgent("a1")];
+    const config = makeModelsConfig({
+      claude: { enabled: false, models: ["sonnet"] },
+      codex: { enabled: true, models: ["codex-mini-latest"] },
+    });
+
+    const result = assignModelsToAgents(agents, config, undefined, {
+      isCliAvailable: allAvailable,
+      randomFn: () => 0,
+    });
+
+    expect(result[0]!.provider).toBe("codex");
+  });
+
+  it("skips providers with empty model lists", () => {
+    const agents = [makeAgent("a1")];
+    const config = makeModelsConfig({
+      claude: { enabled: true, models: [] },
+      codex: { enabled: true, models: ["codex-mini-latest"] },
+    });
+
+    const result = assignModelsToAgents(agents, config, undefined, {
+      isCliAvailable: allAvailable,
+      randomFn: () => 0,
+    });
+
+    expect(result[0]!.provider).toBe("codex");
+  });
+
+  it("selects deterministic model with randomFn", () => {
+    const agents = [makeAgent("a1")];
+    const config = makeModelsConfig({
+      codex: { enabled: true, models: ["model-a", "model-b"] },
+    });
+
+    // randomFn=0 picks index 0 (model-a)
+    const result0 = assignModelsToAgents(agents, config, undefined, {
+      isCliAvailable: allAvailable,
+      randomFn: () => 0,
+    });
+    expect(result0[0]!.model).toBe("model-a");
+
+    // randomFn=0.5 picks index 1 (model-b)
+    const result1 = assignModelsToAgents(agents, config, undefined, {
+      isCliAvailable: allAvailable,
+      randomFn: () => 0.5,
+    });
+    expect(result1[0]!.model).toBe("model-b");
+  });
+
+  it("preserves agent fields other than provider and model", () => {
+    const agent = makeAgent("test-agent");
+    agent.focus = "security";
+    agent.system_prompt = "Be thorough";
+
+    const config = makeModelsConfig({
+      claude: { enabled: true, models: ["sonnet"] },
+    });
+
+    const result = assignModelsToAgents([agent], config, undefined, {
+      isCliAvailable: allAvailable,
+      randomFn: () => 0,
+    });
+
+    expect(result[0]!.name).toBe("test-agent");
+    expect(result[0]!.focus).toBe("security");
+    expect(result[0]!.system_prompt).toBe("Be thorough");
+  });
+});
+});