aiwcli 0.12.1 → 0.12.2

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

@@ -4,6 +4,9 @@
  * See cc-native-plan-review-spec.md §4.5
  */
 
+import { getContextBySessionId, saveState } from "../../_shared/lib-ts/context/context-store.js";
+import { logInfo, logWarn } from "../../_shared/lib-ts/base/logger.js";
+import { nowIso } from "../../_shared/lib-ts/base/utils.js";
 import type {
   CcNativeState,
   PlanReviewState,
@@ -11,9 +14,6 @@ import type {
   IterationState,
   StuckDetectionState,
 } from "./types.js";
-import { logInfo, logWarn } from "../../_shared/lib-ts/base/logger.js";
-import { nowIso } from "../../_shared/lib-ts/base/utils.js";
-import { getContextBySessionId, saveState } from "../../_shared/lib-ts/context/context-store.js";
 import type { ContextState } from "../../_shared/lib-ts/types.js";
 
 /**
@@ -62,8 +62,8 @@ export function saveCcNativeState(
       saveState(state.id, state, projectRoot);
       return true;
     }
-  } catch (error: unknown) {
-    logWarn("utils", `Failed to save cc_native state: ${error}`);
+  } catch (e: unknown) {
+    logWarn("utils", `Failed to save cc_native state: ${e}`);
   }
   return false;
 }
@@ -145,9 +145,9 @@ export function markPlanReviewed(
         max: iterationState.max ?? 1,
         complexity: iterationState.complexity ?? "unknown",
       };
-      const {history} = iterationState;
+      const history = iterationState.history;
       if (history && history.length > 0) {
-        const lastEntry = history.at(-1);
+        const lastEntry = history[history.length - 1];
         if (lastEntry) {
           reviewData.iteration.latest_verdict = lastEntry.verdict ?? "unknown";
         }
@@ -167,8 +167,8 @@ export function markPlanReviewed(
         `Failed to save plan review state for session ${sessionId}`,
       );
     }
-  } catch (error: unknown) {
-    logWarn(hookName, `Failed to mark plan reviewed: ${error}`);
+  } catch (e: unknown) {
+    logWarn(hookName, `Failed to mark plan reviewed: ${e}`);
   }
 }
 
@@ -255,8 +255,31 @@ export function markQuestionsAsked(
     ccNative.questions_asked.asked_at = timestamp;
 
     return saveCcNativeState(sessionId, projectRoot, ccNative);
-  } catch (error: unknown) {
-    logWarn("utils", `Failed to mark questions asked: ${error}`);
+  } catch (e: unknown) {
+    logWarn("utils", `Failed to mark questions asked: ${e}`);
+    return false;
+  }
+}
+
+/**
+ * Reset plan questions agent flag so a new plan gets fresh questions.
+ * Called when plan file path changes (new plan topic detected).
+ */
+export function resetPlanQuestionsAsked(
+  sessionId: string,
+  projectRoot: string,
+): boolean {
+  try {
+    const ccNative = getCcNativeState(sessionId, projectRoot) ?? {};
+    if (ccNative.questions_asked) {
+      ccNative.questions_asked.plan_questions_agent_asked = {
+        asked: false,
+        asked_at: "",
+      };
+    }
+    return saveCcNativeState(sessionId, projectRoot, ccNative);
+  } catch (e: unknown) {
+    logWarn("utils", `Failed to reset plan questions asked: ${e}`);
     return false;
   }
 }
@@ -288,8 +311,8 @@ export function updateStuckDetectionState(
     const ccNative = getCcNativeState(sessionId, projectRoot) ?? {};
     ccNative.stuck_detection = stuckState;
     return saveCcNativeState(sessionId, projectRoot, ccNative);
-  } catch (error: unknown) {
-    logWarn("utils", `Failed to update stuck detection state: ${error}`);
+  } catch (e: unknown) {
+    logWarn("utils", `Failed to update stuck detection state: ${e}`);
     return false;
   }
 }

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

@@ -0,0 +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 };
+}

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

@@ -36,7 +36,6 @@ export async function runOrchestrator(
     model: config.model,
     provider: "claude",
     focus: "plan analysis and agent selection",
-    enabled: config.enabled,
     categories: [],
     description: "Plan orchestrator",
     system_prompt: "",
@@ -58,7 +57,7 @@ export async function runOrchestrator(
     return result;
   } catch (error) {
     logWarn("orchestrator", `Unexpected error: ${error}`);
-    const nonMandatory = agentLibrary.filter((a) => a.enabled && !mandatory.has(a.name));
+    const nonMandatory = agentLibrary.filter((a) => !mandatory.has(a.name));
     const fallbackCount = ((settings.agentSelection as Record<string, unknown>)?.fallbackCount as number) ?? 2;
     return {
       complexity: "medium",

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

@@ -0,0 +1,130 @@
+/**
+ * Output construction: issue truncation, verdict override, message building.
+ * Extracted from cc-native-plan-review.ts.
+ */
+
+import { logInfo } from "../../_shared/lib-ts/base/logger.js";
+
+import type {
+  ReviewerResult,
+  CombinedReviewResult,
+  CorroborationResult,
+  IterationState,
+} from "./types.js";
+import {
+  buildInlineReviewSummary,
+  extractTopIssuesText,
+} from "./artifacts/format.js";
+import { extractTopIssuesForTracker } from "./graduation.js";
+
+const HOOK = "output-builder";
+
+const REVIEWER_CAVEAT = "Reviewers have limited context compared to your full session — use your judgment to adopt valid points and dismiss genuine false positives. However, treat false positives as a clarity signal: if a reviewer misunderstood your plan, an agent executing it will likely hit the same confusion. Revise those sections to be unambiguous so no future reader — human or AI — makes the same mistake.";
+const RESUBMIT_INSTRUCTION = "IMPORTANT: After revising the plan file, you MUST call ExitPlanMode again to trigger re-review. Do not end your turn or ask the user without calling ExitPlanMode.";
+
+// ---------------------------------------------------------------------------
+// Issue Truncation
+// ---------------------------------------------------------------------------
+
+/**
+ * Truncate per-agent issues to top N by severity.
+ * @mutates agentResults[name].data.issues in place.
+ */
+export function truncateAgentIssues(
+  agentResults: Record<string, ReviewerResult>,
+  maxPerAgent: number,
+): void {
+  for (const r of Object.values(agentResults)) {
+    if (!Array.isArray(r.data?.issues)) continue;
+    const issues = r.data.issues as Array<{ severity?: string }>;
+    if (issues.length <= maxPerAgent) continue;
+    const severityOrder: Record<string, number> = { high: 0, medium: 1, low: 2 };
+    issues.sort((a, b) => (severityOrder[a.severity ?? "low"] ?? 2) - (severityOrder[b.severity ?? "low"] ?? 2));
+    const originalCount = issues.length;
+    r.data.issues = issues.slice(0, maxPerAgent);
+    logInfo(HOOK, `${r.name}: truncated issues ${originalCount} → ${maxPerAgent}`);
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Verdict Override
+// ---------------------------------------------------------------------------
+
+/**
+ * Override verdict to "fail" for agents exceeding high-issue threshold.
+ * @mutates agentResults[name].verdict in place.
+ */
+export function overrideVerdictsByThreshold(
+  agentResults: Record<string, ReviewerResult>,
+  threshold: number,
+): void {
+  for (const r of Object.values(agentResults)) {
+    if (!r.verdict || r.verdict === "skip" || r.verdict === "error") continue;
+    const issues = Array.isArray(r.data?.issues) ? r.data.issues as Array<{ severity?: string }> : [];
+    const agentHigh = issues.filter(i => i.severity === "high").length;
+    if (agentHigh >= threshold) {
+      logInfo(HOOK, `${r.name}: verdict overridden to 'fail' (${agentHigh} high issues >= ${threshold})`);
+      r.verdict = "fail";
+    }
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Output Building
+// ---------------------------------------------------------------------------
+
+export interface ReviewOutputParams {
+  combinedResult: CombinedReviewResult;
+  corroborationResult: CorroborationResult;
+  iterationState: IterationState;
+  reviewFile: string;
+  highIssuesPath: string;
+}
+
+export interface ReviewOutput {
+  contextText: string;
+  blockReason: string;
+  shouldDeny: boolean;
+}
+
+/**
+ * Build the final review output: context text and block reason.
+ */
+export function buildReviewOutput(params: ReviewOutputParams): ReviewOutput {
+  const { combinedResult, corroborationResult, iterationState } = params;
+
+  const shouldDeny = corroborationResult.blocking.length > 0;
+  const reviewScore = shouldDeny ? 1.0 : 0.0;
+  const overall = corroborationResult.verdict;
+
+  // Build inline summary
+  const inlineSummary = buildInlineReviewSummary(combinedResult, 5, 800, corroborationResult);
+  const contextParts = [inlineSummary];
+
+  // Top issues
+  const topIssuesList = extractTopIssuesForTracker(combinedResult, 5);
+  if (topIssuesList.length > 0) {
+    contextParts.push(`\nTop high-severity issues:\n${topIssuesList.map(i => `- ${i}`).join("\n")}`);
+  }
+  contextParts.push(`\nFull review: \`${params.reviewFile}\`\n`);
+
+  const contextText = contextParts.join("");
+  const iterInfo = ` (iteration ${iterationState.current}/${iterationState.max}, score=${reviewScore.toFixed(2)})`;
+
+  let blockReason: string;
+  if (shouldDeny) {
+    const topIssuesText = extractTopIssuesText(combinedResult, 3, "high");
+    blockReason = `Plan review FAILED${iterInfo}. ` +
+      `Critical issues: ${topIssuesText}. ` +
+      `IMPORTANT: Read \`${params.highIssuesPath}\` for ALL high-severity issues — ` +
+      `this file contains only the most critical findings, no noise. ` +
+      `${REVIEWER_CAVEAT} ` +
+      `Revise the plan to address these issues, then call ExitPlanMode again. ` +
+      RESUBMIT_INSTRUCTION;
+  } else {
+    blockReason = `Plan review ${overall.toUpperCase()}${iterInfo}. Review complete. ${REVIEWER_CAVEAT}`;
+  }
+
+  return { contextText, blockReason, shouldDeny };
+}
+

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

@@ -0,0 +1,80 @@
+/**
+ * Plan file discovery: find, read, and hash the plan file.
+ * Extracted from cc-native-plan-review.ts.
+ */
+
+import * as fs from "node:fs";
+import * as path from "node:path";
+import * as os from "node:os";
+import * as crypto from "node:crypto";
+
+import { logInfo, logDebug } from "../../_shared/lib-ts/base/logger.js";
+import { findPlanPathInTranscript } from "../../_shared/lib-ts/context/plan-manager.js";
+
+import type { DiscoveredPlan } from "./types.js";
+
+const HOOK = "plan-discovery";
+
+/**
+ * Find the most recently modified plan file in ~/.claude/plans/.
+ */
+export function findPlanFile(): string | null {
+  const plansDir = path.join(os.homedir(), ".claude", "plans");
+  if (!fs.existsSync(plansDir)) return null;
+  const files = fs.readdirSync(plansDir)
+    .filter(f => f.endsWith(".md"))
+    .map(f => {
+      const p = path.join(plansDir, f);
+      return { path: p, mtime: fs.statSync(p).mtimeMs };
+    })
+    .sort((a, b) => b.mtime - a.mtime);
+  return files.length > 0 ? files[0]!.path : null;
+}
+
+/**
+ * Compute a short SHA-256 hash of plan content.
+ */
+export function computePlanHash(content: string): string {
+  return crypto.createHash("sha256").update(content, "utf-8").digest("hex").slice(0, 16);
+}
+
+/**
+ * Discover the plan file, read its content, and compute its hash.
+ * Prefers transcript-based discovery (session-accurate), falls back to mtime scan.
+ */
+export function discoverPlan(transcriptPath?: string): DiscoveredPlan | null {
+  let planPath: string | null = null;
+
+  if (transcriptPath) {
+    planPath = findPlanPathInTranscript(transcriptPath);
+    if (planPath) {
+      logInfo(HOOK, `Found plan via transcript: ${planPath}`);
+    } else {
+      logDebug(HOOK, "No plan Write found in transcript, falling back to mtime scan");
+    }
+  }
+
+  if (!planPath) {
+    planPath = findPlanFile();
+  }
+
+  if (!planPath) return null;
+
+  let content: string;
+  try {
+    content = fs.readFileSync(planPath, "utf-8").trim();
+  } catch {
+    return null;
+  }
+
+  if (!content) return null;
+
+  logInfo(HOOK, `Found plan at: ${planPath}`);
+  logDebug(HOOK, `Plan length: ${content.length} chars`);
+
+  return {
+    path: planPath,
+    content,
+    hash: computePlanHash(content),
+  };
+}