aiwcli 0.12.3 → 0.12.7

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

@@ -1,119 +1,119 @@
-/**
- * Corroboration-based verdict computation for plan review.
- *
- * 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.
- *
- * **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.
- *
- * **Revert path:** Change one line in cc-native-plan-review.ts back to
- * `computeReviewDecision(allVerdicts)`. Old function kept in verdict.ts.
- */
-
-import type {
-  ReviewerResult,
-  ReviewIssue,
-  IssueDimension,
-  CorroborationResult,
-  CorroboratedGroup,
-  SoloFinding,
-} from "./types.js";
-
-/**
- * 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. 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)
- * @returns CorroborationResult with blocking groups, solo findings, and verdict
- */
-export function computeCorroboratedDecision(
-  allResults: Record<string, ReviewerResult>,
-): CorroborationResult {
-  // Accumulator: dimension → { issues, agentNames }
-  const dimMap = new Map<
-    IssueDimension,
-    {
-      issues: Array<{ agent: string; issue: ReviewIssue }>;
-      agentNames: Set<string>;
-    }
-  >();
-
-  const unclassified: Array<{ agent: string; issue: ReviewIssue }> = [];
-
-  for (const [agentName, result] of Object.entries(allResults)) {
-    if (!result.data) continue;
-    const issues = result.data.issues as ReviewIssue[] | undefined;
-    if (!Array.isArray(issues)) continue;
-
-    for (const issue of issues) {
-      // Only high-severity issues participate in corroboration
-      if (issue.severity !== "high") continue;
-
-      // Issues without dimension are unclassified — cannot block
-      if (!issue.dimension) {
-        unclassified.push({ agent: agentName, issue });
-        continue;
-      }
-
-      let group = dimMap.get(issue.dimension);
-      if (!group) {
-        group = { issues: [], agentNames: new Set() };
-        dimMap.set(issue.dimension, group);
-      }
-      group.issues.push({ agent: agentName, issue });
-      group.agentNames.add(agentName);
-    }
-  }
-
-  const blocking: CorroboratedGroup[] = [];
-  const solo: SoloFinding[] = [];
-
-  for (const [dimension, group] of dimMap) {
-    const agentCount = group.agentNames.size;
-    const threshold = 2 * agentCount;
-
-    if (group.issues.length >= threshold) {
-      blocking.push({
-        dimension,
-        issues: group.issues,
-        agentCount,
-        threshold,
-      });
-    } else {
-      solo.push({
-        dimension,
-        issues: group.issues,
-        agentCount,
-        threshold,
-      });
-    }
-  }
-
-  return {
-    blocking,
-    solo,
-    unclassified,
-    verdict: blocking.length > 0
-      ? "fail"
-      : solo.length > 0
-        ? "warn"
-        : "pass",
-  };
-}
+/**
+ * Corroboration-based verdict computation for plan review.
+ *
+ * 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.
+ *
+ * **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.
+ *
+ * **Revert path:** Change one line in cc-native-plan-review.ts back to
+ * `computeReviewDecision(allVerdicts)`. Old function kept in verdict.ts.
+ */
+
+import type {
+  ReviewerResult,
+  ReviewIssue,
+  IssueDimension,
+  CorroborationResult,
+  CorroboratedGroup,
+  SoloFinding,
+} from "./types.js";
+
+/**
+ * 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. 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)
+ * @returns CorroborationResult with blocking groups, solo findings, and verdict
+ */
+export function computeCorroboratedDecision(
+  allResults: Record<string, ReviewerResult>,
+): CorroborationResult {
+  // Accumulator: dimension → { issues, agentNames }
+  const dimMap = new Map<
+    IssueDimension,
+    {
+      issues: Array<{ agent: string; issue: ReviewIssue }>;
+      agentNames: Set<string>;
+    }
+  >();
+
+  const unclassified: Array<{ agent: string; issue: ReviewIssue }> = [];
+
+  for (const [agentName, result] of Object.entries(allResults)) {
+    if (!result.data) continue;
+    const issues = result.data.issues as ReviewIssue[] | undefined;
+    if (!Array.isArray(issues)) continue;
+
+    for (const issue of issues) {
+      // Only high-severity issues participate in corroboration
+      if (issue.severity !== "high") continue;
+
+      // Issues without dimension are unclassified — cannot block
+      if (!issue.dimension) {
+        unclassified.push({ agent: agentName, issue });
+        continue;
+      }
+
+      let group = dimMap.get(issue.dimension);
+      if (!group) {
+        group = { issues: [], agentNames: new Set() };
+        dimMap.set(issue.dimension, group);
+      }
+      group.issues.push({ agent: agentName, issue });
+      group.agentNames.add(agentName);
+    }
+  }
+
+  const blocking: CorroboratedGroup[] = [];
+  const solo: SoloFinding[] = [];
+
+  for (const [dimension, group] of dimMap) {
+    const agentCount = group.agentNames.size;
+    const threshold = 2 * agentCount;
+
+    if (group.issues.length >= threshold) {
+      blocking.push({
+        dimension,
+        issues: group.issues,
+        agentCount,
+        threshold,
+      });
+    } else {
+      solo.push({
+        dimension,
+        issues: group.issues,
+        agentCount,
+        threshold,
+      });
+    }
+  }
+
+  return {
+    blocking,
+    solo,
+    unclassified,
+    verdict: blocking.length > 0
+      ? "fail"
+      : solo.length > 0
+        ? "warn"
+        : "pass",
+  };
+}

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

@@ -1,80 +1,80 @@
-/**
- * Per-context debug logging for cc-native hooks.
- * Thin delegation layer over the unified logger.
- * See cc-native-plan-review-spec.md §4.13
- *
- * Can be disabled via CCNATIVE_DEBUG_DISABLE=1 environment variable.
- */
-
-import * as fs from "node:fs";
+/**
+ * Per-context debug logging for cc-native hooks.
+ * Thin delegation layer over the unified logger.
+ * See cc-native-plan-review-spec.md §4.13
+ *
+ * Can be disabled via CCNATIVE_DEBUG_DISABLE=1 environment variable.
+ */
+
+import * as fs from "node:fs";
 import * as path from "node:path";
-
-import { hookLog } from "../../_shared/lib-ts/base/logger.js";
-
-/** Feature flag — set CCNATIVE_DEBUG_DISABLE=1 to turn off */
-const DEBUG_ENABLED = !["1", "true", "yes"].includes(
-  (process.env.CCNATIVE_DEBUG_DISABLE ?? "").toLowerCase(),
-);
-
-/**
- * Get or create debug directory within context folder.
- */
-export function getDebugDir(contextPath: string): string {
-  const debugDir = path.join(contextPath, "debug");
-  fs.mkdirSync(debugDir, { recursive: true });
-  return debugDir;
-}
-
-/**
- * Write a debug log entry. Delegates to unified logger.
- */
-export function debugLog(
-  contextPath: string,
-  sessionName: string,
-  component: string,
-  message: string,
-  data?: unknown,
-): void {
-  if (!DEBUG_ENABLED) return;
-
-  hookLog("debug", sessionName, message, {
-    component,
-    data,
-  });
-}
-
-/**
- * Log raw output (stdout, stderr, etc). Delegates to unified logger.
- */
-export function debugRaw(
-  contextPath: string,
-  sessionName: string,
-  component: string,
-  label: string,
-  raw: string,
-  maxLen = 10_000,
-): void {
-  if (!DEBUG_ENABLED) return;
-
-  const truncated = raw.length > maxLen ? raw.slice(0, maxLen) : raw;
-  const suffix =
-    raw.length > maxLen ? ` [TRUNCATED from ${raw.length} chars]` : "";
-
-  hookLog("debug", sessionName, `${label}${suffix}: ${truncated}`, {
-    component,
-  });
-}
-
-/**
- * Remove debug folder during context archive.
- */
-export function cleanupDebugFolder(contextPath: string): void {
-  try {
-    const debugDir = path.join(contextPath, "debug");
-    if (fs.existsSync(debugDir)) {
-      fs.rmSync(debugDir, { recursive: true, force: true });
-    }
-  } catch {
-    // Best effort cleanup
-  }
-}
+
+import { hookLog } from "../../_shared/lib-ts/base/logger.js";
+
+/** Feature flag — set CCNATIVE_DEBUG_DISABLE=1 to turn off */
+const DEBUG_ENABLED = !["1", "true", "yes"].includes(
+  (process.env.CCNATIVE_DEBUG_DISABLE ?? "").toLowerCase(),
+);
+
+/**
+ * Get or create debug directory within context folder.
+ */
+export function getDebugDir(contextPath: string): string {
+  const debugDir = path.join(contextPath, "debug");
+  fs.mkdirSync(debugDir, { recursive: true });
+  return debugDir;
+}
+
+/**
+ * Write a debug log entry. Delegates to unified logger.
+ */
+export function debugLog(
+  contextPath: string,
+  sessionName: string,
+  component: string,
+  message: string,
+  data?: unknown,
+): void {
+  if (!DEBUG_ENABLED) return;
+
+  hookLog("debug", sessionName, message, {
+    component,
+    data,
+  });
+}
+
+/**
+ * Log raw output (stdout, stderr, etc). Delegates to unified logger.
+ */
+export function debugRaw(
+  contextPath: string,
+  sessionName: string,
+  component: string,
+  label: string,
+  raw: string,
+  maxLen = 10_000,
+): void {
+  if (!DEBUG_ENABLED) return;
+
+  const truncated = raw.length > maxLen ? raw.slice(0, maxLen) : raw;
+  const suffix =
+    raw.length > maxLen ? ` [TRUNCATED from ${raw.length} chars]` : "";
+
+  hookLog("debug", sessionName, `${label}${suffix}: ${truncated}`, {
+    component,
+  });
+}
+
+/**
+ * Remove debug folder during context archive.
+ */
+export function cleanupDebugFolder(contextPath: string): void {
+  try {
+    const debugDir = path.join(contextPath, "debug");
+    if (fs.existsSync(debugDir)) {
+      fs.rmSync(debugDir, { recursive: true, force: true });
+    }
+  } catch {
+    // Best effort cleanup
+  }
+}

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

@@ -1,132 +1,132 @@
-/**
- * Graduation logic: pass eligibility, pass streaks, graduation threshold, iteration advancement.
- * Extracted from cc-native-plan-review.ts.
- */
-
-import type {
-  IterationState,
-  ReviewerResult,
-  CombinedReviewResult,
-  IterationAdvancement,
-} from "./types.js";
-
-// ---------------------------------------------------------------------------
-// Pass Eligibility
-// ---------------------------------------------------------------------------
-
-/**
- * Determine which agents are pass-eligible this iteration.
- * Criteria: verdict === "pass" OR zero high-severity issues.
- * Agents with "skip"/"error" are NOT eligible (no signal).
- */
-export function computePassEligible(agentResults: Record<string, ReviewerResult>): string[] {
-  const eligible: string[] = [];
-  for (const [name, result] of Object.entries(agentResults)) {
-    if (result.verdict === "skip" || result.verdict === "error") continue;
-    if (result.verdict === "pass") { eligible.push(name); continue; }
-    const issues = Array.isArray(result.data?.issues)
-      ? (result.data.issues as Array<{ severity?: string }>) : [];
-    if (issues.filter(i => i.severity === "high").length === 0) {
-      eligible.push(name);
-    }
-  }
-  return eligible;
-}
-
-// ---------------------------------------------------------------------------
-// Tracker Issue Extraction
-// ---------------------------------------------------------------------------
-
-/**
- * Extract top high-severity issues for the review tracker.
- */
-export function extractTopIssuesForTracker(
-  combined: CombinedReviewResult,
-  maxCount = 5,
-): string[] {
-  const allReviewers = Object.values(combined.agents);
-  const issues: string[] = [];
-  for (const r of allReviewers) {
-    if (!r.data) continue;
-    const issueList = r.data.issues as Array<Record<string, unknown>> | undefined;
-    if (!issueList) continue;
-    for (const issue of issueList) {
-      if (issue.severity === "high") {
-        const text = String(issue.issue ?? "").trim();
-        if (text) {
-          issues.push(`[${r.name}] ${text}`);
-        }
-      }
-    }
-    if (issues.length >= maxCount) break;
-  }
-  return issues.slice(0, maxCount);
-}
-
-// ---------------------------------------------------------------------------
-// Iteration Advancement
-// ---------------------------------------------------------------------------
-
-const GRADUATION_THRESHOLD = 2;
-
-/**
- * Advance iteration state after a review cycle. Returns a new state copy
- * (does not mutate input).
- *
- * - On pass/warrant: sets current past max (stop iterating)
- * - On deny: increments current toward max (safety valve)
- * - Updates pass streaks and graduates agents that reached threshold
- */
-export function advanceIterationState(
-  state: IterationState,
-  planHash: string,
-  planPath: string,
-  verdict: string,
-  shouldDeny: boolean,
-  passEligible: string[],
-  agentResults: Record<string, ReviewerResult>,
-  graduationThreshold = GRADUATION_THRESHOLD,
-): IterationAdvancement {
-  const updated: IterationState = {
-    ...state,
-    history: [...state.history, { hash: planHash, verdict, timestamp: new Date().toISOString() }],
-    lastPlanHash: planHash,
-    lastPlanPath: planPath,
-    graduated: [...state.graduated],
-    passStreaks: { ...(state.passStreaks ?? {}) },
-  };
-
-  if (!shouldDeny) {
-    // Pass/warrant: stop iterating
-    updated.current = updated.max + 1;
-  } else {
-    // Deny: advance toward max
-    updated.current = state.current + 1;
-  }
-
-  // Update pass streaks — only for agents that actually ran this iteration
-  const passEligibleSet = new Set(passEligible);
-  const graduatedSet = new Set(updated.graduated);
-
-  for (const name of Object.keys(agentResults)) {
-    if (graduatedSet.has(name)) continue;
-    if (passEligibleSet.has(name)) {
-      updated.passStreaks[name] = (updated.passStreaks[name] ?? 0) + 1;
-    } else {
-      updated.passStreaks[name] = 0;
-    }
-  }
-
-  // Graduate agents that reached threshold
-  const newGraduates: string[] = [];
-  for (const [name, streak] of Object.entries(updated.passStreaks)) {
-    if (streak >= graduationThreshold && !graduatedSet.has(name)) {
-      newGraduates.push(name);
-    }
-  }
-  if (newGraduates.length > 0) {
-    updated.graduated = [...updated.graduated, ...newGraduates];
-  }
-
-  return { updatedState: updated, newGraduates };
-}
+/**
+ * Graduation logic: pass eligibility, pass streaks, graduation threshold, iteration advancement.
+ * Extracted from cc-native-plan-review.ts.
+ */
+
+import type {
+  IterationState,
+  ReviewerResult,
+  CombinedReviewResult,
+  IterationAdvancement,
+} from "./types.js";
+
+// ---------------------------------------------------------------------------
+// Pass Eligibility
+// ---------------------------------------------------------------------------
+
+/**
+ * Determine which agents are pass-eligible this iteration.
+ * Criteria: verdict === "pass" OR zero high-severity issues.
+ * Agents with "skip"/"error" are NOT eligible (no signal).
+ */
+export function computePassEligible(agentResults: Record<string, ReviewerResult>): string[] {
+  const eligible: string[] = [];
+  for (const [name, result] of Object.entries(agentResults)) {
+    if (result.verdict === "skip" || result.verdict === "error") continue;
+    if (result.verdict === "pass") { eligible.push(name); continue; }
+    const issues = Array.isArray(result.data?.issues)
+      ? (result.data.issues as Array<{ severity?: string }>) : [];
+    if (issues.filter(i => i.severity === "high").length === 0) {
+      eligible.push(name);
+    }
+  }
+  return eligible;
+}
+
+// ---------------------------------------------------------------------------
+// Tracker Issue Extraction
+// ---------------------------------------------------------------------------
+
+/**
+ * Extract top high-severity issues for the review tracker.
+ */
+export function extractTopIssuesForTracker(
+  combined: CombinedReviewResult,
+  maxCount = 5,
+): string[] {
+  const allReviewers = Object.values(combined.agents);
+  const issues: string[] = [];
+  for (const r of allReviewers) {
+    if (!r.data) continue;
+    const issueList = r.data.issues as Array<Record<string, unknown>> | undefined;
+    if (!issueList) continue;
+    for (const issue of issueList) {
+      if (issue.severity === "high") {
+        const text = String(issue.issue ?? "").trim();
+        if (text) {
+          issues.push(`[${r.name}] ${text}`);
+        }
+      }
+    }
+    if (issues.length >= maxCount) break;
+  }
+  return issues.slice(0, maxCount);
+}
+
+// ---------------------------------------------------------------------------
+// Iteration Advancement
+// ---------------------------------------------------------------------------
+
+const GRADUATION_THRESHOLD = 2;
+
+/**
+ * Advance iteration state after a review cycle. Returns a new state copy
+ * (does not mutate input).
+ *
+ * - On pass/warrant: sets current past max (stop iterating)
+ * - On deny: increments current toward max (safety valve)
+ * - Updates pass streaks and graduates agents that reached threshold
+ */
+export function advanceIterationState(
+  state: IterationState,
+  planHash: string,
+  planPath: string,
+  verdict: string,
+  shouldDeny: boolean,
+  passEligible: string[],
+  agentResults: Record<string, ReviewerResult>,
+  graduationThreshold = GRADUATION_THRESHOLD,
+): IterationAdvancement {
+  const updated: IterationState = {
+    ...state,
+    history: [...state.history, { hash: planHash, verdict, timestamp: new Date().toISOString() }],
+    lastPlanHash: planHash,
+    lastPlanPath: planPath,
+    graduated: [...state.graduated],
+    passStreaks: { ...(state.passStreaks ?? {}) },
+  };
+
+  if (!shouldDeny) {
+    // Pass/warrant: stop iterating
+    updated.current = updated.max + 1;
+  } else {
+    // Deny: advance toward max
+    updated.current = state.current + 1;
+  }
+
+  // Update pass streaks — only for agents that actually ran this iteration
+  const passEligibleSet = new Set(passEligible);
+  const graduatedSet = new Set(updated.graduated);
+
+  for (const name of Object.keys(agentResults)) {
+    if (graduatedSet.has(name)) continue;
+    if (passEligibleSet.has(name)) {
+      updated.passStreaks[name] = (updated.passStreaks[name] ?? 0) + 1;
+    } else {
+      updated.passStreaks[name] = 0;
+    }
+  }
+
+  // Graduate agents that reached threshold
+  const newGraduates: string[] = [];
+  for (const [name, streak] of Object.entries(updated.passStreaks)) {
+    if (streak >= graduationThreshold && !graduatedSet.has(name)) {
+      newGraduates.push(name);
+    }
+  }
+  if (newGraduates.length > 0) {
+    updated.graduated = [...updated.graduated, ...newGraduates];
+  }
+
+  return { updatedState: updated, newGraduates };
+}