aiwcli 0.15.5 → 0.15.7

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

@@ -0,0 +1,344 @@
+/**
+ * Tests for preflight health checks.
+ * Tests pure functions (collectPreflightChecks, buildPreflightReport) directly.
+ * Tests classifyError from shared preflight module directly.
+ * Slim integration tests for runPreflight mock only checkProviderModel (network boundary).
+ */
+
+import { describe, it, expect, mock, beforeEach } from "bun:test";
+
+import type { ModelsConfig, PreflightCheckResult, PreflightReport } from "../../../lib-ts/types.js";
+
+// ---------------------------------------------------------------------------
+// Mock logger for noise suppression only (no assertions on logger calls)
+// ---------------------------------------------------------------------------
+
+mock.module("../../../../_core/lib-ts/runtime/logger.js", () => ({
+  hookLog() {},
+  logDebug() {},
+  logInfo() {},
+  logWarn() {},
+  logError() {},
+  logBlocking() {},
+  logDiagnostic() {},
+  logHookError() {},
+  setSessionId() {},
+  setContextPath() {},
+  getContextPath: () => null,
+}));
+
+// ---------------------------------------------------------------------------
+// Import pure functions under test (no mocks needed)
+// ---------------------------------------------------------------------------
+
+const { collectPreflightChecks, buildPreflightReport } = await import("../preflight.js");
+const { classifyError } = await import("../../../../_core/lib-ts/runtime/preflight.js");
+
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+
+function makeModelsConfig(providers: Record<string, { enabled: boolean; models: string[] }>): ModelsConfig {
+  return { providers };
+}
+
+// ---------------------------------------------------------------------------
+// collectPreflightChecks — pure, zero mocks
+// ---------------------------------------------------------------------------
+
+describe("preflight", () => {
+describe("collectPreflightChecks", () => {
+  const knownProviders = new Set(["claude", "codex"]);
+
+  it("collects enabled providers with known names", () => {
+    const config = makeModelsConfig({
+      claude: { enabled: true, models: ["sonnet"] },
+      codex: { enabled: true, models: ["codex-mini-latest"] },
+    });
+
+    const { checks, skippedProviders } = collectPreflightChecks(config, knownProviders);
+
+    expect(checks).toEqual([
+      { provider: "claude", model: "sonnet" },
+      { provider: "codex", model: "codex-mini-latest" },
+    ]);
+    expect(skippedProviders).toEqual([]);
+  });
+
+  it("skips disabled providers", () => {
+    const config = makeModelsConfig({
+      claude: { enabled: false, models: ["sonnet"] },
+      codex: { enabled: true, models: ["codex-mini-latest"] },
+    });
+
+    const { checks } = collectPreflightChecks(config, knownProviders);
+
+    expect(checks).toEqual([{ provider: "codex", model: "codex-mini-latest" }]);
+  });
+
+  it("skips providers with empty model lists", () => {
+    const config = makeModelsConfig({
+      claude: { enabled: true, models: [] },
+    });
+
+    const { checks } = collectPreflightChecks(config, knownProviders);
+
+    expect(checks).toEqual([]);
+  });
+
+  it("reports unknown providers in skippedProviders", () => {
+    const config = makeModelsConfig({
+      unknown_provider: { enabled: true, models: ["some-model"] },
+    });
+
+    const { checks, skippedProviders } = collectPreflightChecks(config, knownProviders);
+
+    expect(checks).toEqual([]);
+    expect(skippedProviders).toEqual(["unknown_provider"]);
+  });
+
+  it("deduplicates same provider:model combo", () => {
+    const config = makeModelsConfig({
+      claude: { enabled: true, models: ["sonnet", "sonnet"] },
+    });
+
+    const { checks } = collectPreflightChecks(config, knownProviders);
+
+    expect(checks).toEqual([{ provider: "claude", model: "sonnet" }]);
+  });
+
+  it("collects multiple models per provider", () => {
+    const config = makeModelsConfig({
+      claude: { enabled: true, models: ["sonnet", "opus"] },
+    });
+
+    const { checks } = collectPreflightChecks(config, knownProviders);
+
+    expect(checks).toEqual([
+      { provider: "claude", model: "sonnet" },
+      { provider: "claude", model: "opus" },
+    ]);
+  });
+
+  it("returns empty checks when no providers are enabled", () => {
+    const config = makeModelsConfig({
+      claude: { enabled: false, models: ["sonnet"] },
+    });
+
+    const { checks, skippedProviders } = collectPreflightChecks(config, knownProviders);
+
+    expect(checks).toEqual([]);
+    expect(skippedProviders).toEqual([]);
+  });
+});
+
+// ---------------------------------------------------------------------------
+// buildPreflightReport — pure, zero mocks
+// ---------------------------------------------------------------------------
+
+describe("buildPreflightReport", () => {
+  it("builds available map from passing results", () => {
+    const results = [
+      { provider: "claude", model: "sonnet", available: true, latencyMs: 50 },
+      { provider: "codex", model: "codex-mini-latest", available: true, latencyMs: 30 },
+    ];
+
+    const report = buildPreflightReport(results, 100);
+
+    expect(report.allFailed).toBe(false);
+    expect(report.available.size).toBe(2);
+    expect(report.available.get("claude")?.has("sonnet")).toBe(true);
+    expect(report.available.get("codex")?.has("codex-mini-latest")).toBe(true);
+    expect(report.totalMs).toBe(100);
+  });
+
+  it("reports allFailed when all results fail", () => {
+    const results = [
+      { provider: "claude", model: "sonnet", available: false, error: "Auth failed", latencyMs: 10 },
+      { provider: "codex", model: "codex-mini", available: false, error: "Timeout", latencyMs: 15_000 },
+    ];
+
+    const report = buildPreflightReport(results, 15_000);
+
+    expect(report.allFailed).toBe(true);
+    expect(report.available.size).toBe(0);
+  });
+
+  it("reports allFailed=true for empty results", () => {
+    const report = buildPreflightReport([], 5);
+
+    expect(report.allFailed).toBe(true);
+    expect(report.available.size).toBe(0);
+    expect(report.checks).toEqual([]);
+  });
+
+  it("groups multiple models under same provider", () => {
+    const results = [
+      { provider: "claude", model: "sonnet", available: true, latencyMs: 50 },
+      { provider: "claude", model: "opus", available: true, latencyMs: 80 },
+    ];
+
+    const report = buildPreflightReport(results, 80);
+
+    expect(report.available.get("claude")?.size).toBe(2);
+    expect(report.available.get("claude")?.has("sonnet")).toBe(true);
+    expect(report.available.get("claude")?.has("opus")).toBe(true);
+  });
+
+  it("excludes failed models from available map", () => {
+    const results = [
+      { provider: "claude", model: "sonnet", available: true, latencyMs: 50 },
+      { provider: "claude", model: "opus", available: false, error: "Rate limited", latencyMs: 10 },
+    ];
+
+    const report = buildPreflightReport(results, 50);
+
+    expect(report.allFailed).toBe(false);
+    expect(report.available.get("claude")?.has("sonnet")).toBe(true);
+    expect(report.available.get("claude")?.has("opus")).toBe(false);
+  });
+
+  it("preserves check results in output", () => {
+    const results = [
+      { provider: "claude", model: "sonnet", available: true, latencyMs: 42 },
+    ];
+
+    const report = buildPreflightReport(results, 42);
+
+    expect(report.checks.length).toBe(1);
+    expect(report.checks[0]!.provider).toBe("claude");
+    expect(report.checks[0]!.model).toBe("sonnet");
+    expect(report.checks[0]!.available).toBe(true);
+    expect(report.checks[0]!.latencyMs).toBe(42);
+  });
+});
+
+// ---------------------------------------------------------------------------
+// classifyError — pure, zero mocks (from shared _core/lib-ts/runtime/preflight.ts)
+// ---------------------------------------------------------------------------
+
+describe("classifyError", () => {
+  it("classifies timeout (killed + SIGTERM)", () => {
+    expect(classifyError("", null, true, "SIGTERM")).toBe("Preflight timed out");
+  });
+
+  it("classifies timeout (killed without signal)", () => {
+    expect(classifyError("", null, true, null)).toBe("Preflight timed out");
+  });
+
+  it("classifies model not found", () => {
+    expect(classifyError("model not found", 1, false, null)).toBe("Model not available for this account");
+  });
+
+  it("classifies not available", () => {
+    expect(classifyError("not available for your plan", 1, false, null)).toBe("Model not available for this account");
+  });
+
+  it("classifies rate limit by text", () => {
+    expect(classifyError("rate limit exceeded", 1, false, null)).toBe("Rate limited");
+  });
+
+  it("classifies rate limit by 429", () => {
+    expect(classifyError("error 429", 1, false, null)).toBe("Rate limited");
+  });
+
+  it("classifies auth errors", () => {
+    expect(classifyError("invalid api key", 1, false, null)).toBe("Authentication failed");
+  });
+
+  it("classifies 401 as auth", () => {
+    expect(classifyError("HTTP 401 Unauthorized", 1, false, null)).toBe("Authentication failed");
+  });
+
+  it("classifies quota errors", () => {
+    expect(classifyError("billing quota exceeded", 1, false, null)).toBe("Quota/billing issue");
+  });
+
+  it("falls back to exit code for unknown errors", () => {
+    expect(classifyError("something unexpected", 42, false, null)).toBe("Exit code 42");
+  });
+});
+
+// ---------------------------------------------------------------------------
+// runPreflight — slim integration (mock only checkProviderModel)
+// ---------------------------------------------------------------------------
+
+describe("runPreflight", () => {
+  // Mock the network boundary: checkProviderModel and subprocess-utils
+  const mockCheckProviderModel = mock(
+    async (provider: string, model: string) =>
+      ({ provider, model, available: true, latencyMs: 10 }) as PreflightCheckResult,
+  );
+
+  const mockFindExecutable = mock(() => "/usr/bin/mock-cli" as string | null);
+
+  // Re-mock the modules to inject our mock for integration tests
+  mock.module("../../../../_core/lib-ts/runtime/preflight.js", () => ({
+    checkProviderModel: mockCheckProviderModel,
+    classifyError,
+  }));
+
+  mock.module("../../../../_core/lib-ts/runtime/subprocess-utils.js", () => ({
+    findExecutable: mockFindExecutable,
+    execFileAsync: mock(() => Promise.resolve({ stdout: "ok", stderr: "", exitCode: 0, killed: false, signal: null })),
+    isInternalCall: () => false,
+    getInternalSubprocessEnv: () => ({}),
+    normalizePathForCli: (p: string) => p,
+    shellQuoteWin: (arg: string) => arg,
+    isExecSyncError: () => false,
+  }));
+
+  // Re-import to pick up the mocked checkProviderModel
+  let runPreflight: (config: ModelsConfig, timeoutMs?: number) => Promise<PreflightReport>;
+
+  beforeEach(async () => {
+    mockCheckProviderModel.mockReset();
+    mockCheckProviderModel.mockImplementation(
+      async (provider: string, model: string) =>
+        ({ provider, model, available: true, latencyMs: 10 }) as PreflightCheckResult,
+    );
+    // Force fresh import to pick up mocks
+    const mod = await import("../preflight.js");
+    runPreflight = mod.runPreflight;
+  });
+
+  it("returns available report when checks pass", async () => {
+    const config = makeModelsConfig({
+      claude: { enabled: true, models: ["sonnet"] },
+      codex: { enabled: true, models: ["codex-mini-latest"] },
+    });
+
+    const report = await runPreflight(config);
+
+    expect(report.allFailed).toBe(false);
+    expect(report.available.size).toBe(2);
+  });
+
+  it("reports allFailed when all checks fail", async () => {
+    mockCheckProviderModel.mockImplementation(
+      async (provider: string, model: string) =>
+        ({ provider, model, available: false, latencyMs: 10, error: "Auth failed" }) as PreflightCheckResult,
+    );
+
+    const config = makeModelsConfig({
+      claude: { enabled: true, models: ["sonnet"] },
+    });
+
+    const report = await runPreflight(config);
+
+    expect(report.allFailed).toBe(true);
+    expect(report.available.size).toBe(0);
+  });
+
+  it("returns empty checks when no providers enabled", async () => {
+    const config = makeModelsConfig({
+      claude: { enabled: false, models: ["sonnet"] },
+    });
+
+    const report = await runPreflight(config);
+
+    expect(report.allFailed).toBe(true);
+    expect(report.checks.length).toBe(0);
+  });
+});
+});

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

@@ -3,8 +3,8 @@
  * Extracted from cc-native-plan-review.ts.
  */
 
-import { logDebug, logInfo, logWarn } from "../../../_shared/lib-ts/base/logger.js";
-import { findExecutable } from "../../../_shared/lib-ts/base/subprocess-utils.js";
+import { logDebug, logInfo, logWarn } from "../../../_core/lib-ts/runtime/logger.js";
+import { findExecutable } from "../../../_core/lib-ts/runtime/subprocess-utils.js";
 import type {
   AgentConfig,
   AgentReviewSettings,
@@ -51,22 +51,21 @@ export function resolveMandatoryAgents(
 /** Provider priority order: codex first (cheaper/faster), claude as fallback */
 const PROVIDER_PRIORITY = ["codex", "claude"];
 
-/**
- * Assign providers and models to agents.
- * When preflightAvailable is provided, filters to only models that passed preflight.
- * Providers are ordered by PROVIDER_PRIORITY (codex first, claude fallback).
- * All agents get the first available provider; random model within that provider.
- */
-export function assignModelsToAgents(
-  agents: AgentConfig[],
+// ---------------------------------------------------------------------------
+// Pure Provider Resolution (extracted for direct testing)
+// ---------------------------------------------------------------------------
+
+/** @internal */
+export function resolveEnabledProviders(
   modelsConfig: ModelsConfig,
+  isCliAvailable: (cliName: string) => boolean,
   preflightAvailable?: Map<string, Set<string>>,
-): AgentConfig[] {
-  let enabledProviders = Object.entries(modelsConfig.providers)
+): Array<[string, { enabled: boolean; models: string[] }]> {
+  const result = Object.entries(modelsConfig.providers)
     .filter(([name, config]) => {
       if (!config.enabled || config.models.length === 0) return false;
       const cliName = name === "claude" ? "claude" : name;
-      const found = findExecutable(cliName);
+      const found = isCliAvailable(cliName);
       if (!found) {
         logWarn(HOOK, `Provider '${name}' enabled but CLI '${cliName}' not found on PATH — skipping`);
         return false;
@@ -93,12 +92,35 @@ export function assignModelsToAgents(
     .filter((entry): entry is [string, { enabled: boolean; models: string[] }] => entry !== null);
 
   // Sort by provider priority (codex first)
-  enabledProviders.sort((a, b) => {
+  result.sort((a, b) => {
     const aIdx = PROVIDER_PRIORITY.indexOf(a[0]);
     const bIdx = PROVIDER_PRIORITY.indexOf(b[0]);
     return (aIdx === -1 ? 999 : aIdx) - (bIdx === -1 ? 999 : bIdx);
   });
 
+  return result;
+}
+
+/**
+ * Assign providers and models to agents.
+ * When preflightAvailable is provided, filters to only models that passed preflight.
+ * Providers are ordered by PROVIDER_PRIORITY (codex first, claude fallback).
+ * All agents get the first available provider; random model within that provider.
+ */
+export function assignModelsToAgents(
+  agents: AgentConfig[],
+  modelsConfig: ModelsConfig,
+  preflightAvailable?: Map<string, Set<string>>,
+  options?: {
+    isCliAvailable?: (name: string) => boolean;
+    randomFn?: () => number;
+  },
+): AgentConfig[] {
+  const isCliAvailable = options?.isCliAvailable ?? ((name: string) => Boolean(findExecutable(name)));
+  const randomFn = options?.randomFn ?? Math.random;
+
+  const enabledProviders = resolveEnabledProviders(modelsConfig, isCliAvailable, preflightAvailable);
+
   if (enabledProviders.length === 0) {
     logWarn(HOOK, "No providers with available CLI found, falling back to Claude with agent defaults");
     return agents.map(a => ({ ...a, provider: "claude" }));
@@ -109,7 +131,7 @@ export function assignModelsToAgents(
   logInfo(HOOK, `Using provider: ${providerName} (models: ${providerConfig.models.join(", ")})`);
 
   return agents.map(agent => {
-    const modelIdx = Math.floor(Math.random() * providerConfig.models.length);
+    const modelIdx = Math.floor(randomFn() * providerConfig.models.length);
     const model = providerConfig.models[modelIdx] ?? providerConfig.models[0] ?? agent.model;
     return { ...agent, provider: providerName, model };
   });

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

@@ -1,35 +1,23 @@
 /**
  * Corroboration-based verdict computation for plan review.
  *
- * Uses agent-agreement thresholding: a dimension blocks only when a sufficient
- * number of *distinct agents* independently flag it. This measures true
- * corroboration (multiple independent reviewers converge) rather than issue
- * density (one verbose agent floods a dimension).
+ * Replaces the old per-verdict aggregation with proportional thresholding:
+ * high-severity issues in a dimension only block when the total count
+ * exceeds 2× the number of distinct agents contributing to that dimension.
  *
- * **Algorithm:**
- * For each dimension, compute: `effective_threshold = max(minAgreement, ceil(minRatio × totalAgents))`
- * Block when `distinct_agents_in_dimension >= effective_threshold`.
- *
- * **Default config:** `minAgreement=2, minRatio=0.40`
- * - At 6 agents: threshold=3 (50% must agree)
- * - At 10 agents: threshold=4 (40% must agree)
- * - At 20 agents: threshold=8 (40% must agree)
- *
- * **Why agent-agreement over issue-density:**
- * The previous system (issues >= 2×agents_in_dimension) allowed a single agent
- * to self-corroborate by raising 2+ issues, and made blocking harder as more
- * agents covered a dimension (inverted scaling). Agent-agreement fixes both:
- * a single agent can never self-corroborate, and more agents agreeing is a
- * stronger signal, not a weaker one.
+ * **Why proportional thresholding:**
+ * The agent pool has dimensional imbalance (e.g., 10 completeness agents vs
+ * 1 maintainability agent). A fixed "2+ agents agree = block" would mean
+ * any 2 completeness agents always block. Proportional scaling (issues > 2×agents)
+ * sets a fair bar regardless of how many agents focus on each dimension.
  *
  * **Convergence problem this solves:**
  * Agents with opposing philosophies (simplicity-guardian vs completeness-gaps)
  * produce contradictory high-severity issues. Because the old system treated
  * every agent's finding as independently authoritative, plans oscillated —
- * addressing one agent's feedback triggered the opposing agent. The minAgreement
- * floor prevents any single agent's philosophy from blocking alone.
+ * addressing one agent's feedback triggered the opposing agent.
  *
- * **Revert path:** Change one line in review-pipeline.ts back to
+ * **Revert path:** Change one line in cc-native-plan-review.ts back to
  * `computeReviewDecision(allVerdicts)`. Old function kept in verdict.ts.
  */
 
@@ -42,55 +30,22 @@ import type {
   SoloFinding,
 } from "../../lib-ts/types.js";
 
-/** Configuration for corroboration thresholds */
-export interface CorroborationConfig {
-  /** Minimum distinct agents that must agree to trigger blocking (default: 2) */
-  minAgreement?: number;
-  /** Minimum fraction of total agent pool that must agree (default: 0.40) */
-  minRatio?: number;
-}
-
-const DEFAULT_MIN_AGREEMENT = 2;
-const DEFAULT_MIN_RATIO = 0.40;
-
-/**
- * Compute the effective blocking threshold for a given agent pool size.
- *
- * Returns `max(minAgreement, ceil(minRatio × totalAgents))`.
- * This ensures a fixed floor (no single-agent self-corroboration) while
- * scaling proportionally at larger pool sizes.
- */
-export function getEffectiveThreshold(
-  totalAgents: number,
-  config: CorroborationConfig = {},
-): number {
-  const minAgreement = config.minAgreement ?? DEFAULT_MIN_AGREEMENT;
-  const minRatio = config.minRatio ?? DEFAULT_MIN_RATIO;
-  return Math.max(minAgreement, Math.ceil(totalAgents * minRatio));
-}
-
 /**
  * Compute a corroboration-based review decision from all reviewer results.
  *
  * Algorithm:
  * 1. Collect all high-severity issues with a `dimension` field
  * 2. Group by dimension, tracking distinct agent names per group
- * 3. Compute effective threshold: `max(minAgreement, ceil(minRatio × totalAgents))`
- * 4. For each dimension: block if `distinct_agents >= effective_threshold`
- * 5. Issues without `dimension` are unclassified (logged as warning, never block)
- * 6. Non-high issues are ignored (informational only)
+ * 3. For each dimension: block if `issues.length > 2 × agentCount`
+ * 4. Issues without `dimension` are unclassified (never block)
+ * 5. Non-high issues are ignored (informational only)
  *
  * @param allResults - Map of reviewer name → ReviewerResult (CLI + agent)
- * @param config - Optional threshold configuration
  * @returns CorroborationResult with blocking groups, solo findings, and verdict
  */
 export function computeCorroboratedDecision(
   allResults: Record<string, ReviewerResult>,
-  config: CorroborationConfig = {},
 ): CorroborationResult {
-  const totalAgents = Object.keys(allResults).length;
-  const threshold = getEffectiveThreshold(totalAgents, config);
-
   // Accumulator: dimension → { issues, agentNames }
   const dimMap = new Map<
     IssueDimension,
@@ -111,7 +66,7 @@ export function computeCorroboratedDecision(
       // Only high-severity issues participate in corroboration
       if (issue.severity !== "high") continue;
 
-      // Issues without dimension are unclassified — logged but cannot block
+      // Issues without dimension are unclassified — cannot block
       if (!issue.dimension) {
         unclassified.push({ agent: agentName, issue });
         continue;
@@ -127,22 +82,14 @@ export function computeCorroboratedDecision(
     }
   }
 
-  // Warn about unclassified issues so they don't silently disappear
-  if (unclassified.length > 0) {
-    const agents = [...new Set(unclassified.map(u => u.agent))];
-    process.stderr.write(
-      `[corroboration] WARNING: ${unclassified.length} high-severity issue(s) from [${agents.join(", ")}] lack dimension classification and cannot participate in corroboration\n`,
-    );
-  }
-
   const blocking: CorroboratedGroup[] = [];
   const solo: SoloFinding[] = [];
 
   for (const [dimension, group] of dimMap) {
     const agentCount = group.agentNames.size;
+    const threshold = 2 * agentCount;
 
-    // Block when enough distinct agents independently flag this dimension
-    if (agentCount >= threshold) {
+    if (group.issues.length >= threshold) {
       blocking.push({
         dimension,
         issues: group.issues,

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

@@ -5,7 +5,7 @@
  */
 
 import { OrchestratorClaudeAgent } from "./reviewers/providers/orchestrator-claude-agent.js";
-import { logInfo, logWarn } from "../../../_shared/lib-ts/base/logger.js";
+import { logInfo, logWarn } from "../../../_core/lib-ts/runtime/logger.js";
 import type { AgentConfig, AgentReviewSettings, OrchestratorConfig, OrchestratorResult } from "../../lib-ts/types.js";
 
 // Re-export for backward compatibility (moved to reviewers/schemas.ts)

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

@@ -3,7 +3,7 @@
  * Extracted from cc-native-plan-review.ts.
  */
 
-import { logInfo } from "../../../_shared/lib-ts/base/logger.js";
+import { logInfo } from "../../../_core/lib-ts/runtime/logger.js";
 import {
   buildInlineReviewSummary,
   extractTopIssuesText,

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

@@ -8,8 +8,8 @@ import * as path from "node:path";
 
 import { runAgentReview } from "./reviewers/index.js";
 import { QUESTIONS_SCHEMA } from "./reviewers/schemas.js";
-import { logInfo, logWarn, logError } from "../../../_shared/lib-ts/base/logger.js";
-import { findExecutable } from "../../../_shared/lib-ts/base/subprocess-utils.js";
+import { logInfo, logWarn, logError } from "../../../_core/lib-ts/runtime/logger.js";
+import { findExecutable } from "../../../_core/lib-ts/runtime/subprocess-utils.js";
 import { aggregateAgents } from "../../lib-ts/aggregate-agents.js";
 import type { AgentConfig } from "../../lib-ts/types.js";