aiwcli 0.12.6 → 0.12.8

package/dist/templates/cc-native/_cc-native/hooks/plan_questions_early.ts

@@ -1,61 +1,61 @@
-#!/usr/bin/env bun
-/**
- * UserPromptSubmit hook — injects post-exploration clarification prompt in plan mode.
- *
- * After explore agents finish examining the codebase, injects a system-reminder
- * telling Claude to ask clarification questions via AskUserQuestion to narrow
- * the approach before drafting the plan.
- *
- * Skips if questions were already asked this session.
- */
-
-import { getProjectRoot } from "../../_shared/lib-ts/base/constants.js";
-import { loadHookInput, runHook, logDebug, logInfo, emitContext } from "../../_shared/lib-ts/base/hook-utils.js";
-import { wasEarlyQuestionsAsked } from "../lib-ts/cc-native-state.js";
-
-const PHASE_A_PROMPT = `## Plan Mode: Narrow the Approach After Exploration
-
-After exploring the codebase, use AskUserQuestion — one call, 3-4 questions — before drafting the plan.
-
-### Why This Matters
-Once you've explored the codebase, you'll understand what exists — but not which direction the user prefers. That's a branch point: multiple viable approaches, and the user's priorities determine which is best. Questions asked after exploration have maximum steering value: they narrow your path before you commit to an implementation direction.
-
-### What to Ask About
-Only ask about decisions that exploration will surface but can't resolve — where human judgment is needed to choose between viable options:
-
-- **Approach selection:** If exploration reveals 2-3 viable implementation paths, ask which the user prefers. Present each option with its trade-offs as concrete choices.
-- **Scope boundaries:** What's in scope vs. out of scope for this change? Which areas of the codebase should be left untouched? How far should the change ripple?
-- **Trade-off preferences:** Where exploration reveals tensions (simplicity vs. flexibility, speed vs. thoroughness, minimal change vs. full refactor), ask which side the user leans toward.
-- **Success criteria beyond the literal ask:** What would make this a 10? What non-obvious quality matters most — performance, readability, extensibility, consistency with existing patterns?
-
-### How to Select Questions
-1. Generate 5+ candidate questions across the categories above
-2. For each, evaluate: "If they answered A vs B, would I take a different approach or write different code?" If no — discard it.
-3. Keep the 3-4 where different answers lead to meaningfully different implementation strategies
-4. Frame each with 2-3 concrete options so the user can react rather than generate from scratch`;
-
-function main(): void {
-  const payload = loadHookInput();
-  if (!payload) return;
-
-  const permissionMode = payload.permission_mode ?? "";
-  if (permissionMode !== "plan") return;
-
-  const sessionId = String(payload.session_id ?? "");
-  if (!sessionId) {
-    logDebug("plan_questions_early", "No session_id, skipping");
-    return;
-  }
-
-  const projectRoot = getProjectRoot(payload.cwd);
-
-  if (wasEarlyQuestionsAsked(sessionId, projectRoot)) {
-    logDebug("plan_questions_early", "Early questions already asked, skipping Phase A prompt");
-    return;
-  }
-
-  logInfo("plan_questions_early", "Plan mode detected, injecting Phase A prompt");
-  emitContext(PHASE_A_PROMPT);
-}
-
-runHook(main, "plan_questions_early");
+#!/usr/bin/env bun
+/**
+ * UserPromptSubmit hook — injects post-exploration clarification prompt in plan mode.
+ *
+ * After explore agents finish examining the codebase, injects a system-reminder
+ * telling Claude to ask clarification questions via AskUserQuestion to narrow
+ * the approach before drafting the plan.
+ *
+ * Skips if questions were already asked this session.
+ */
+
+import { getProjectRoot } from "../../_shared/lib-ts/base/constants.js";
+import { loadHookInput, runHook, logDebug, logInfo, emitContext } from "../../_shared/lib-ts/base/hook-utils.js";
+import { wasEarlyQuestionsAsked } from "../lib-ts/cc-native-state.js";
+
+const PHASE_A_PROMPT = `## Plan Mode: Narrow the Approach After Exploration
+
+After exploring the codebase, use AskUserQuestion — one call, 3-4 questions — before drafting the plan.
+
+### Why This Matters
+Once you've explored the codebase, you'll understand what exists — but not which direction the user prefers. That's a branch point: multiple viable approaches, and the user's priorities determine which is best. Questions asked after exploration have maximum steering value: they narrow your path before you commit to an implementation direction.
+
+### What to Ask About
+Only ask about decisions that exploration will surface but can't resolve — where human judgment is needed to choose between viable options:
+
+- **Approach selection:** If exploration reveals 2-3 viable implementation paths, ask which the user prefers. Present each option with its trade-offs as concrete choices.
+- **Scope boundaries:** What's in scope vs. out of scope for this change? Which areas of the codebase should be left untouched? How far should the change ripple?
+- **Trade-off preferences:** Where exploration reveals tensions (simplicity vs. flexibility, speed vs. thoroughness, minimal change vs. full refactor), ask which side the user leans toward.
+- **Success criteria beyond the literal ask:** What would make this a 10? What non-obvious quality matters most — performance, readability, extensibility, consistency with existing patterns?
+
+### How to Select Questions
+1. Generate 5+ candidate questions across the categories above
+2. For each, evaluate: "If they answered A vs B, would I take a different approach or write different code?" If no — discard it.
+3. Keep the 3-4 where different answers lead to meaningfully different implementation strategies
+4. Frame each with 2-3 concrete options so the user can react rather than generate from scratch`;
+
+function main(): void {
+  const payload = loadHookInput();
+  if (!payload) return;
+
+  const permissionMode = payload.permission_mode ?? "";
+  if (permissionMode !== "plan") return;
+
+  const sessionId = String(payload.session_id ?? "");
+  if (!sessionId) {
+    logDebug("plan_questions_early", "No session_id, skipping");
+    return;
+  }
+
+  const projectRoot = getProjectRoot(payload.cwd);
+
+  if (wasEarlyQuestionsAsked(sessionId, projectRoot)) {
+    logDebug("plan_questions_early", "Early questions already asked, skipping Phase A prompt");
+    return;
+  }
+
+  logInfo("plan_questions_early", "Plan mode detected, injecting Phase A prompt");
+  emitContext(PHASE_A_PROMPT);
+}
+
+runHook(main, "plan_questions_early");

package/dist/templates/cc-native/_cc-native/hooks/validate_task_prompt.ts

@@ -0,0 +1,76 @@
+#!/usr/bin/env bun
+/**
+ * PreToolUse:Task Hook: Prompt Validation Gate
+ *
+ * Validates that Task tool calls have self-contained, goal-oriented prompts.
+ * Short-circuits immediately for resume calls (no prompt to validate).
+ *
+ * Design:
+ * - Resume calls (tool_input.resume present) → allow through, no inference
+ * - Missing/empty prompt → allow through (fail open)
+ * - Non-empty prompt → run AI validation via inference(), block if ok:false
+ */
+
+import {
+  loadHookInput,
+  runHook,
+  logInfo,
+  logDebug,
+  logWarn,
+  emitContextAndBlock,
+  getToolInput,
+} from "../../_shared/lib-ts/base/hook-utils.js";
+import { isInternalCall } from "../../_shared/lib-ts/base/subprocess-utils.js";
+import { inference } from "../../_shared/lib-ts/base/inference.js";
+
+const VALIDATION_SYSTEM_PROMPT = `The sub-agent receives ONLY the prompt text — no conversation history, no prior context.
+
+Check 1 — Dangling References: Does the prompt use pronouns or demonstratives that ONLY make sense with prior conversation? Violations: 'the file we looked at', 'as discussed above', 'that approach we chose', 'the error from earlier', 'fix the issue mentioned above'. NOT violations: relative paths ('_output/', 'src/lib/'), search terms ('context-manager', 'auth module'), directory exploration ('find files matching X'), tool names, or any concrete noun — even if imprecise. Only flag references that are truly UNRESOLVABLE without conversation history.
+
+Check 2 — Implicit Contract: Does the prompt have ANY discernible goal? 'Explore the _output directory and find context files' IS a clear goal. 'Search for hooks that handle Task events' IS a clear goal. 'Read and summarize all files in X' IS a clear goal. Only flag if the prompt is truly goalless — e.g., a sentence fragment with no verb, or pure context with no request.
+
+If both checks pass, return ok:true. When in doubt, pass — false negatives (letting a vague prompt through) are far less costly than false positives (blocking legitimate work).
+
+When returning ok:false, end your response with: 'Retry: Re-invoke the Task tool with a revised prompt that resolves the issues above.'`;
+
+function main(): void {
+  if (isInternalCall()) return;
+
+  const payload = loadHookInput();
+  if (!payload) return;
+
+  const toolInput = getToolInput(payload);
+
+  // Resume calls: tool_input contains `resume: "<agent-id>"` (may also have prompt/description).
+  // The resume field being present is the authoritative discriminator — skip all validation.
+  if (toolInput?.resume) {
+    logInfo("validate_task_prompt", `Resume call detected (agent: ${toolInput.resume}) — skipping validation`);
+    return;
+  }
+
+  const prompt: string = toolInput?.prompt ?? "";
+  if (!prompt.trim()) {
+    logDebug("validate_task_prompt", "No prompt field — allowing through (fail open)");
+    return;
+  }
+
+  logInfo("validate_task_prompt", `Validating Task prompt (${prompt.length} chars)`);
+  const result = inference(VALIDATION_SYSTEM_PROMPT, prompt, "fast");
+
+  if (!result.success) {
+    logWarn("validate_task_prompt", `inference() failed (${result.error}) — failing open`);
+    return;
+  }
+
+  const output = result.output;
+  if (output.includes("ok:false")) {
+    // Extract the Retry line if present; fall back to full output
+    const retryMatch = output.match(/Retry:.*$/m);
+    const retryMessage = retryMatch ? retryMatch[0] : "Retry: Re-invoke the Task tool with a revised, self-contained prompt.";
+    logInfo("validate_task_prompt", "Blocking Task — prompt failed validation");
+    emitContextAndBlock(output, retryMessage);
+  }
+  // ok:true or anything else → allow through (no output = no block)
+}
+
+runHook(main, "validate_task_prompt");

package/dist/templates/cc-native/_cc-native/lib-ts/aggregate-agents.ts

@@ -1,6 +1,11 @@
 /**
  * Agent frontmatter parser — discovers and loads agent configs from markdown files.
  * See cc-native-plan-review-spec.md §4.14
+ *
+ * NOTE: This file intentionally stays in lib-ts/ rather than plan-review/lib/.
+ * Both settings.ts (shared cc-native infra) and plan-questions.ts (plan-review) import it.
+ * Moving it to plan-review/ would create a forbidden backward dependency: lib-ts → plan-review.
+ * Do not move this file without first moving settings.ts out of lib-ts/.
  */
 
 import * as fs from "node:fs";
@@ -92,11 +97,13 @@ export function extractBody(content: string): string {
  * Discover and load all agent configs from a directory of markdown files.
  * Skips the plan-orchestrator agent. Defaults categories to ["code"].
  *
- * @param agentsDir - Path to agents directory (default: _cc-native/agents/)
+ * @param agentsDir - Path to agents directory. Callers must pass an explicit path.
+ *   Known call sites: settings.ts → plan-review/agents/plan-review,
+ *   plan-questions.ts → plan-review/agents/plan-questions
  * @returns Array of AgentConfig objects
  */
 export function aggregateAgents(agentsDir?: string): AgentConfig[] {
-  const dir = agentsDir ?? path.join("_cc-native", "agents");
+  const dir = agentsDir ?? path.join("_cc-native", "plan-review", "agents");
 
   if (!fs.existsSync(dir)) {
     logWarn("aggregate", `Agents directory not found: ${dir}`);