@xdevops/issue-auto-finish 1.0.92 → 1.0.94

package/dist/{chunk-4XMYOXGZ.js → chunk-36G3DPO3.js}

@@ -12,8 +12,8 @@ import {
 } from "./chunk-GF2RRYHB.js";
 
 // src/ai-runner/PtyRunner.ts
-import fs2 from "fs";
-import path2 from "path";
+import fs4 from "fs";
+import path3 from "path";
 
 // src/ai-runner/PlanFileResolver.ts
 import fs from "fs";
@@ -24,6 +24,9 @@ var PLAN_DIRS = {
   "claude-internal": path.join(os.homedir(), ".claude-internal", "plans"),
   "codebuddy": path.join(os.homedir(), ".codebuddy", "plans")
 };
+var PLAN_METADATA_PATTERNS = [
+  /^00-plan-status\.md$/
+];
 var PlanFileResolver = class _PlanFileResolver {
   plansDir;
   beforeFiles = /* @__PURE__ */ new Map();
@@ -82,6 +85,7 @@ var PlanFileResolver = class _PlanFileResolver {
       });
       return this.fallbackByMtime(afterFiles, contentHint);
     }
+    candidates.sort((a, b) => b.mtime - a.mtime);
     if (candidates.length === 1) {
       return this.readCandidate(candidates[0].path, candidates[0].mtime);
     }
@@ -89,7 +93,6 @@ var PlanFileResolver = class _PlanFileResolver {
       const matched = this.matchByContent(candidates, contentHint);
       if (matched) return matched;
     }
-    candidates.sort((a, b) => b.mtime - a.mtime);
     logger2.info("Multiple new plan files found, using most recent", {
       count: candidates.length,
       selected: path.basename(candidates[0].path)
@@ -128,12 +131,16 @@ var PlanFileResolver = class _PlanFileResolver {
   findNewFiles(afterFiles) {
     const candidates = [];
     for (const [filePath, mtime] of afterFiles) {
-      if (!this.beforeFiles.has(filePath)) {
+      if (!this.beforeFiles.has(filePath) && !this.isMetadataFile(filePath)) {
         candidates.push({ path: filePath, mtime });
       }
     }
     return candidates;
   }
+  isMetadataFile(filePath) {
+    const basename = path.basename(filePath);
+    return PLAN_METADATA_PATTERNS.some((pattern) => pattern.test(basename));
+  }
   /**
    * Fallback: if no new files found (rare case — plan might have overwritten
    * an existing file), find the most recently modified file.
@@ -164,21 +171,27 @@ var PlanFileResolver = class _PlanFileResolver {
     return this.readCandidate(newestPath, newestMtime);
   }
   matchByContent(candidates, contentHint) {
+    const matches = [];
     for (const candidate of candidates) {
       try {
         const content = fs.readFileSync(candidate.path, "utf-8");
         if (this.contentMatches(content, contentHint)) {
-          logger2.info("Plan file matched by content", {
-            file: path.basename(candidate.path),
-            hint: contentHint.slice(0, 50)
-          });
-          return { sourcePath: candidate.path, content };
+          matches.push({ sourcePath: candidate.path, content });
         }
       } catch {
         continue;
       }
     }
-    return null;
+    if (matches.length === 0) return null;
+    matches.sort((a, b) => b.content.length - a.content.length);
+    const best = matches[0];
+    logger2.info("Plan file matched by content", {
+      file: path.basename(best.sourcePath),
+      hint: contentHint.slice(0, 50),
+      matchCount: matches.length,
+      size: best.content.length
+    });
+    return best;
   }
   contentMatches(content, hint) {
     const parts = hint.split("|");
@@ -200,8 +213,711 @@ var PlanFileResolver = class _PlanFileResolver {
   }
 };
 
+// src/ai-runner/DialogClassifier.ts
+var logger3 = logger.child("DialogClassifier");
+var HOOK_EVENT_TTL_MS = 5e3;
+var PERMISSION_SUPPRESS_MS = 2e3;
+var ASK_USER_SUPPRESS_MS = 3e3;
+var DialogClassifier = class {
+  recentEvents = [];
+  handledIds = /* @__PURE__ */ new Set();
+  ingestHookEvent(event) {
+    this.recentEvents.push({ event, receivedAt: Date.now() });
+    this.pruneExpired();
+    if (event.event === "ask_user_question") {
+      logger3.info("Received ask_user_question hook event", {
+        question: event.question.slice(0, 80),
+        optionCount: event.options.length
+      });
+    } else if (event.event === "notification") {
+      logger3.debug("Received notification hook event", {
+        type: event.notification_type
+      });
+    }
+  }
+  /**
+   * Check if there's a pending AskUserQuestion from hooks that hasn't been
+   * handled yet. Returns structured data or null.
+   */
+  consumePendingAskUser() {
+    const now = Date.now();
+    for (let i = this.recentEvents.length - 1; i >= 0; i--) {
+      const { event, receivedAt } = this.recentEvents[i];
+      if (event.event !== "ask_user_question") continue;
+      if (now - receivedAt > HOOK_EVENT_TTL_MS) continue;
+      const eventId = `ask_user_${event.ts}`;
+      if (this.handledIds.has(eventId)) continue;
+      this.handledIds.add(eventId);
+      return {
+        question: event.question,
+        options: mapHookOptions(event.options)
+      };
+    }
+    return null;
+  }
+  /**
+   * Whether a recent permission_prompt notification exists, indicating
+   * that regex-detected dialogs are likely false positives.
+   */
+  hasRecentPermissionPrompt() {
+    const now = Date.now();
+    return this.recentEvents.some(
+      ({ event, receivedAt }) => event.event === "notification" && event.notification_type === "permission_prompt" && now - receivedAt < PERMISSION_SUPPRESS_MS
+    );
+  }
+  /**
+   * Whether a recent ask_user_question hook event exists, indicating
+   * that regex detection should be suppressed to avoid duplicate forwarding.
+   */
+  hasRecentAskUser() {
+    const now = Date.now();
+    return this.recentEvents.some(
+      ({ event, receivedAt }) => event.event === "ask_user_question" && now - receivedAt < ASK_USER_SUPPRESS_MS
+    );
+  }
+  /**
+   * Whether regex-based dialog detection should be suppressed
+   * (either due to recent hook-based AskUser or permission_prompt).
+   */
+  shouldSuppressRegex() {
+    return this.hasRecentAskUser() || this.hasRecentPermissionPrompt();
+  }
+  reset() {
+    this.recentEvents.length = 0;
+    this.handledIds.clear();
+  }
+  pruneExpired() {
+    const cutoff = Date.now() - HOOK_EVENT_TTL_MS;
+    this.recentEvents = this.recentEvents.filter((e) => e.receivedAt > cutoff);
+  }
+};
+function mapHookOptions(hookOptions) {
+  return hookOptions.map((o, i) => ({
+    index: o.index ?? i + 1,
+    label: o.label
+  }));
+}
+
+// src/hooks/HookEventWatcher.ts
+import fs2 from "fs";
+var logger4 = logger.child("HookEventWatcher");
+var HookEventWatcher = class {
+  eventsFile;
+  watcher = null;
+  pollTimer = null;
+  offset = 0;
+  listeners = [];
+  started = false;
+  constructor(eventsFile) {
+    this.eventsFile = eventsFile;
+  }
+  start() {
+    if (this.started) return;
+    this.started = true;
+    this.offset = this.getCurrentSize();
+    try {
+      this.watcher = fs2.watch(this.eventsFile, () => this.readNewEvents());
+    } catch {
+      logger4.debug("fs.watch unavailable, using poll-only mode");
+    }
+    this.pollTimer = setInterval(() => this.readNewEvents(), 1e3);
+  }
+  stop() {
+    if (!this.started) return;
+    this.started = false;
+    this.watcher?.close();
+    this.watcher = null;
+    if (this.pollTimer) {
+      clearInterval(this.pollTimer);
+      this.pollTimer = null;
+    }
+    this.listeners = [];
+  }
+  onEvent(callback) {
+    this.listeners.push(callback);
+    return {
+      dispose: () => {
+        this.listeners = this.listeners.filter((l) => l !== callback);
+      }
+    };
+  }
+  /**
+   * 等待指定类型的事件，带超时。
+   * 对于 'stop' 事件，只有 blocked=false 时才 resolve。
+   */
+  waitForEvent(eventType, timeoutMs) {
+    return new Promise((resolve, reject) => {
+      const timer = setTimeout(() => {
+        sub.dispose();
+        reject(new Error(`Timeout waiting for hook event "${eventType}" after ${timeoutMs}ms`));
+      }, timeoutMs);
+      const sub = this.onEvent((ev) => {
+        if (ev.event !== eventType) return;
+        if (ev.event === "stop" && ev.blocked) return;
+        clearTimeout(timer);
+        sub.dispose();
+        resolve(ev);
+      });
+    });
+  }
+  /** 获取已记录的所有产物写入事件摘要 */
+  getArtifactSummary() {
+    const events = this.readAll().filter(
+      (e) => e.event === "artifact_write"
+    );
+    if (events.length === 0) return "";
+    return events.map((e) => `${e.file} (${e.bytes} bytes)`).join(", ");
+  }
+  // ---------------------------------------------------------------------------
+  // Private
+  // ---------------------------------------------------------------------------
+  readNewEvents() {
+    if (!this.started) return;
+    const size = this.getCurrentSize();
+    if (size <= this.offset) return;
+    try {
+      const fd = fs2.openSync(this.eventsFile, "r");
+      try {
+        const buf = Buffer.alloc(size - this.offset);
+        fs2.readSync(fd, buf, 0, buf.length, this.offset);
+        this.offset = size;
+        const chunk = buf.toString("utf-8");
+        for (const line of chunk.split("\n")) {
+          const trimmed = line.trim();
+          if (!trimmed) continue;
+          try {
+            const event = JSON.parse(trimmed);
+            this.emit(event);
+          } catch {
+            logger4.debug("Skipping malformed event line", { line: trimmed });
+          }
+        }
+      } finally {
+        fs2.closeSync(fd);
+      }
+    } catch (err) {
+      logger4.debug("Error reading events file", { error: err.message });
+    }
+  }
+  readAll() {
+    if (!fs2.existsSync(this.eventsFile)) return [];
+    try {
+      const content = fs2.readFileSync(this.eventsFile, "utf-8").trim();
+      if (!content) return [];
+      return content.split("\n").reduce((acc, line) => {
+        const trimmed = line.trim();
+        if (!trimmed) return acc;
+        try {
+          acc.push(JSON.parse(trimmed));
+        } catch {
+        }
+        return acc;
+      }, []);
+    } catch {
+      return [];
+    }
+  }
+  emit(event) {
+    for (const listener of this.listeners) {
+      try {
+        listener(event);
+      } catch (err) {
+        logger4.warn("Event listener error", { error: err.message });
+      }
+    }
+  }
+  getCurrentSize() {
+    try {
+      return fs2.statSync(this.eventsFile).size;
+    } catch {
+      return 0;
+    }
+  }
+};
+
+// src/hooks/HookInjector.ts
+import fs3 from "fs";
+import path2 from "path";
+var logger5 = logger.child("HookInjector");
+var HOOKS_DIR = ".claude-plan/.hooks";
+var EVENTS_FILE_NAME = ".hook-events.jsonl";
+var MANIFEST_FILE_NAME = ".artifact-manifest.jsonl";
+var CONTEXT_FILE_NAME = ".hook-context.json";
+var HookInjector = class {
+  inject(ctx) {
+    this.writeHookScripts(ctx);
+    this.writeContextFile(ctx);
+    this.writeSettingsLocal(ctx);
+    this.initEventsFile(ctx);
+    logger5.info("Hooks injected", {
+      workDir: ctx.workDir,
+      issueIid: ctx.issueIid,
+      phase: ctx.phaseName,
+      artifacts: ctx.expectedArtifacts
+    });
+  }
+  /**
+   * 阶段切换时更新 hooks 配置（重写脚本 + settings.local.json）。
+   * 保留 events/manifest 文件（不截断），仅更新脚本和配置。
+   */
+  updateForPhase(ctx) {
+    this.writeHookScripts(ctx);
+    this.writeContextFile(ctx);
+    this.writeSettingsLocal(ctx);
+    logger5.info("Hooks updated for phase", {
+      workDir: ctx.workDir,
+      issueIid: ctx.issueIid,
+      phase: ctx.phaseName
+    });
+  }
+  readManifest(workDir) {
+    const manifestPath = path2.join(workDir, ".claude-plan", MANIFEST_FILE_NAME);
+    return readJsonl(manifestPath);
+  }
+  readEvents(workDir) {
+    const eventsPath = path2.join(workDir, ".claude-plan", EVENTS_FILE_NAME);
+    return readJsonl(eventsPath);
+  }
+  getEventsFilePath(workDir) {
+    return path2.join(workDir, ".claude-plan", EVENTS_FILE_NAME);
+  }
+  getManifestFilePath(workDir) {
+    return path2.join(workDir, ".claude-plan", MANIFEST_FILE_NAME);
+  }
+  cleanup(workDir) {
+    const hooksDir = path2.join(workDir, HOOKS_DIR);
+    try {
+      if (fs3.existsSync(hooksDir)) {
+        fs3.rmSync(hooksDir, { recursive: true });
+      }
+    } catch (err) {
+      logger5.warn("Failed to cleanup hooks", { error: err.message });
+    }
+  }
+  // ---------------------------------------------------------------------------
+  // Private
+  // ---------------------------------------------------------------------------
+  writeHookScripts(ctx) {
+    const hooksDir = path2.join(ctx.workDir, HOOKS_DIR);
+    fs3.mkdirSync(hooksDir, { recursive: true });
+    const eventsFile = path2.join(ctx.workDir, ".claude-plan", EVENTS_FILE_NAME);
+    const manifestFile = path2.join(ctx.workDir, ".claude-plan", MANIFEST_FILE_NAME);
+    const contextFile = path2.join(ctx.workDir, ".claude-plan", CONTEXT_FILE_NAME);
+    const expected = ctx.expectedArtifacts.join(",");
+    const phaseExpected = (ctx.phaseExpectedArtifacts ?? ctx.expectedArtifacts).join(",");
+    const scripts = [
+      { name: "session-start.sh", content: buildSessionStartScript(eventsFile) },
+      { name: "compact-restore.sh", content: buildCompactRestoreScript(eventsFile, contextFile) },
+      { name: "post-tool-use.sh", content: buildPostToolUseScript(eventsFile, manifestFile, expected) },
+      { name: "post-artifact.sh", content: buildPostArtifactScript(manifestFile, expected) },
+      { name: "exit-plan-mode.sh", content: buildExitPlanModeScript(eventsFile, ctx.planDir, ctx.phaseExpectedArtifacts?.[0] ?? ctx.expectedArtifacts[0]) },
+      { name: "permission.sh", content: buildPermissionScript(eventsFile) },
+      { name: "protect-files.sh", content: buildProtectFilesScript(eventsFile, ctx.phaseName, ctx.planDir) },
+      { name: "stop.sh", content: buildStopScript(eventsFile, ctx.planDir, phaseExpected) },
+      { name: "ask-user-hook.sh", content: buildAskUserHookScript(eventsFile) },
+      { name: "notification.sh", content: buildNotificationScript(eventsFile) }
+    ];
+    for (const { name, content } of scripts) {
+      const scriptPath = path2.join(hooksDir, name);
+      fs3.writeFileSync(scriptPath, content, { mode: 493 });
+    }
+  }
+  writeContextFile(ctx) {
+    const contextPath = path2.join(ctx.workDir, ".claude-plan", CONTEXT_FILE_NAME);
+    const context = {
+      issueIid: ctx.issueIid,
+      issueTitle: ctx.issueTitle ?? "",
+      issueDescription: ctx.issueDescription ?? "",
+      phaseName: ctx.phaseName ?? "",
+      expectedArtifacts: ctx.expectedArtifacts,
+      planDir: ctx.planDir
+    };
+    fs3.writeFileSync(contextPath, JSON.stringify(context, null, 2), "utf-8");
+  }
+  writeSettingsLocal(ctx) {
+    const claudeDir = path2.join(ctx.workDir, ".claude");
+    fs3.mkdirSync(claudeDir, { recursive: true });
+    const settingsPath = path2.join(claudeDir, "settings.local.json");
+    let existing = {};
+    if (fs3.existsSync(settingsPath)) {
+      try {
+        existing = JSON.parse(fs3.readFileSync(settingsPath, "utf-8"));
+      } catch {
+        logger5.warn("Failed to parse existing settings.local.json, overwriting");
+      }
+    }
+    const hooksDir = path2.join(ctx.workDir, HOOKS_DIR);
+    const hooks = buildHooksConfig(hooksDir, ctx);
+    const merged = { ...existing, hooks };
+    fs3.writeFileSync(settingsPath, JSON.stringify(merged, null, 2), "utf-8");
+  }
+  initEventsFile(ctx) {
+    const eventsPath = path2.join(ctx.workDir, ".claude-plan", EVENTS_FILE_NAME);
+    const manifestPath = path2.join(ctx.workDir, ".claude-plan", MANIFEST_FILE_NAME);
+    fs3.writeFileSync(eventsPath, "", "utf-8");
+    fs3.writeFileSync(manifestPath, "", "utf-8");
+  }
+};
+function buildHooksConfig(hooksDir, ctx) {
+  const isPlanPhase = ctx.phaseName === "plan";
+  const artifactIfPatterns = buildArtifactIfPatterns(ctx.expectedArtifacts);
+  const config = {
+    SessionStart: [
+      {
+        hooks: [{
+          type: "command",
+          command: path2.join(hooksDir, "session-start.sh"),
+          timeout: 5
+        }]
+      },
+      {
+        matcher: "compact",
+        hooks: [{
+          type: "command",
+          command: path2.join(hooksDir, "compact-restore.sh"),
+          timeout: 5
+        }]
+      }
+    ],
+    PreToolUse: [
+      {
+        matcher: "AskUserQuestion",
+        hooks: [{
+          type: "command",
+          command: path2.join(hooksDir, "ask-user-hook.sh"),
+          timeout: 5
+        }]
+      },
+      {
+        matcher: "Edit|Write",
+        hooks: [{
+          type: "command",
+          command: path2.join(hooksDir, "protect-files.sh"),
+          timeout: 5,
+          ...buildProtectIfClause(ctx.phaseName)
+        }]
+      }
+    ],
+    PostToolUse: buildPostToolUseConfig(hooksDir, artifactIfPatterns),
+    PermissionRequest: buildPermissionRequestConfig(hooksDir, isPlanPhase),
+    Notification: [{
+      hooks: [{
+        type: "command",
+        command: path2.join(hooksDir, "notification.sh"),
+        timeout: 5
+      }]
+    }],
+    Stop: [{
+      hooks: [{
+        type: "command",
+        command: path2.join(hooksDir, "stop.sh"),
+        timeout: 15
+      }]
+    }]
+  };
+  return config;
+}
+function buildPermissionRequestConfig(hooksDir, isPlanPhase) {
+  const groups = [];
+  if (isPlanPhase) {
+    groups.push({
+      matcher: "ExitPlanMode",
+      hooks: [{
+        type: "command",
+        command: path2.join(hooksDir, "exit-plan-mode.sh"),
+        timeout: 5
+      }]
+    });
+  }
+  groups.push({
+    matcher: "Bash|Edit|Write|Read|Glob|Grep|WebFetch|WebSearch|mcp__.*",
+    hooks: [{
+      type: "command",
+      command: path2.join(hooksDir, "permission.sh"),
+      timeout: 5
+    }]
+  });
+  return groups;
+}
+function buildPostToolUseConfig(hooksDir, artifactIfPatterns) {
+  const groups = [];
+  if (artifactIfPatterns) {
+    groups.push({
+      matcher: "Write|Edit",
+      hooks: [{
+        type: "command",
+        command: path2.join(hooksDir, "post-artifact.sh"),
+        timeout: 10,
+        if: artifactIfPatterns
+      }]
+    });
+  }
+  groups.push({
+    matcher: "Write|Edit",
+    hooks: [{
+      type: "command",
+      command: path2.join(hooksDir, "post-tool-use.sh"),
+      timeout: 10
+    }]
+  });
+  return groups;
+}
+function buildArtifactIfPatterns(artifacts) {
+  if (artifacts.length === 0) return void 0;
+  return artifacts.flatMap((f) => [`Write(*${f})`, `Edit(*${f})`]).join("|");
+}
+function buildProtectIfClause(_phaseName) {
+  const alwaysProtected = [".env", ".env.*", "package-lock.json", "pnpm-lock.yaml"];
+  const ifValue = alwaysProtected.flatMap((f) => [`Edit(*${f})`, `Write(*${f})`]).join("|");
+  return { if: ifValue };
+}
+function buildSessionStartScript(eventsFile) {
+  return `#!/bin/bash
+set -euo pipefail
+INPUT=$(cat)
+SESSION_ID=$(echo "$INPUT" | jq -r '.session_id // empty')
+printf '{"ts":"%s","event":"session_start","session_id":"%s"}\\n' \\
+  "$(date -u +%FT%TZ)" "$SESSION_ID" >> ${quote(eventsFile)}
+exit 0
+`;
+}
+function buildCompactRestoreScript(eventsFile, contextFile) {
+  return `#!/bin/bash
+set -euo pipefail
+
+CONTEXT_FILE=${quote(contextFile)}
+if [ ! -f "$CONTEXT_FILE" ]; then
+  exit 0
+fi
+
+ISSUE_IID=$(jq -r '.issueIid // empty' < "$CONTEXT_FILE")
+ISSUE_TITLE=$(jq -r '.issueTitle // empty' < "$CONTEXT_FILE")
+ISSUE_DESC=$(jq -r '.issueDescription // empty' < "$CONTEXT_FILE")
+PHASE=$(jq -r '.phaseName // empty' < "$CONTEXT_FILE")
+PLAN_DIR=$(jq -r '.planDir // empty' < "$CONTEXT_FILE")
+ARTIFACTS=$(jq -r '.expectedArtifacts | join(", ") // empty' < "$CONTEXT_FILE")
+
+READY=""
+MISSING=""
+for f in $(jq -r '.expectedArtifacts[]' < "$CONTEXT_FILE" 2>/dev/null); do
+  FPATH="$PLAN_DIR/$f"
+  if [ -f "$FPATH" ] && [ "$(wc -c < "$FPATH")" -ge 50 ]; then
+    READY="$READY $f"
+  else
+    MISSING="$MISSING $f"
+  fi
+done
+READY=$(echo "$READY" | xargs)
+MISSING=$(echo "$MISSING" | xargs)
+
+printf '{"ts":"%s","event":"compact_restore"}\\n' "$(date -u +%FT%TZ)" >> ${quote(eventsFile)}
+
+cat <<CONTEXT
+[\u4E0A\u4E0B\u6587\u6062\u590D \u2014 compaction \u540E\u81EA\u52A8\u6CE8\u5165]
+Issue #$ISSUE_IID: $ISSUE_TITLE
+\u5F53\u524D\u9636\u6BB5: $PHASE
+\u9884\u671F\u4EA7\u7269: $ARTIFACTS
+\u5DF2\u5C31\u7EEA: \${READY:-\u65E0}
+\u672A\u5B8C\u6210: \${MISSING:-\u65E0}
+
+\u9700\u6C42\u63CF\u8FF0:
+$ISSUE_DESC
+CONTEXT
+exit 0
+`;
+}
+function buildPostToolUseScript(eventsFile, manifestFile, expected) {
+  return `#!/bin/bash
+set -euo pipefail
+INPUT=$(cat)
+FILE_PATH=$(echo "$INPUT" | jq -r '.tool_input.file_path // empty')
+[ -z "$FILE_PATH" ] && exit 0
+
+EXPECTED=${quote(expected)}
+BASENAME=$(basename "$FILE_PATH")
+
+if echo "$EXPECTED" | tr ',' '\\n' | grep -qx "$BASENAME"; then
+  BYTES=$(wc -c < "$FILE_PATH" 2>/dev/null || echo 0)
+  printf '{"ts":"%s","event":"artifact_write","file":"%s","path":"%s","bytes":%s}\\n' \\
+    "$(date -u +%FT%TZ)" "$BASENAME" "$FILE_PATH" "$BYTES" >> ${quote(manifestFile)}
+fi
+
+printf '{"ts":"%s","event":"artifact_write","file":"%s","path":"%s","bytes":0}\\n' \\
+  "$(date -u +%FT%TZ)" "$BASENAME" "$FILE_PATH" >> ${quote(eventsFile)}
+exit 0
+`;
+}
+function buildPostArtifactScript(manifestFile, expected) {
+  return `#!/bin/bash
+set -euo pipefail
+INPUT=$(cat)
+FILE_PATH=$(echo "$INPUT" | jq -r '.tool_input.file_path // empty')
+[ -z "$FILE_PATH" ] && exit 0
+
+EXPECTED=${quote(expected)}
+BASENAME=$(basename "$FILE_PATH")
+
+if echo "$EXPECTED" | tr ',' '\\n' | grep -qx "$BASENAME"; then
+  BYTES=$(wc -c < "$FILE_PATH" 2>/dev/null || echo 0)
+  printf '{"ts":"%s","event":"write","file":"%s","path":"%s","bytes":%s}\\n' \\
+    "$(date -u +%FT%TZ)" "$BASENAME" "$FILE_PATH" "$BYTES" >> ${quote(manifestFile)}
+fi
+exit 0
+`;
+}
+function buildExitPlanModeScript(eventsFile, planDir, planArtifact) {
+  return `#!/bin/bash
+set -euo pipefail
+INPUT=$(cat)
+
+PLAN_DIR=${quote(planDir)}
+PLAN_ARTIFACT=${quote(planArtifact ?? "01-plan.md")}
+
+PLAN_CONTENT=$(echo "$INPUT" | jq -r '.tool_input.plan // empty')
+if [ -n "$PLAN_CONTENT" ]; then
+  mkdir -p "$PLAN_DIR"
+  printf '%s' "$PLAN_CONTENT" > "$PLAN_DIR/$PLAN_ARTIFACT"
+  BYTES=$(wc -c < "$PLAN_DIR/$PLAN_ARTIFACT")
+  printf '{"ts":"%s","event":"plan_captured","file":"%s","path":"%s/%s","bytes":%s}\\n' \\
+    "$(date -u +%FT%TZ)" "$PLAN_ARTIFACT" "$PLAN_DIR" "$PLAN_ARTIFACT" "$BYTES" >> ${quote(eventsFile)}
+fi
+
+printf '{"ts":"%s","event":"exit_plan_mode"}\\n' "$(date -u +%FT%TZ)" >> ${quote(eventsFile)}
+
+echo '{"hookSpecificOutput":{"hookEventName":"PermissionRequest","decision":{"behavior":"allow"}}}'
+exit 0
+`;
+}
+function buildPermissionScript(eventsFile) {
+  return `#!/bin/bash
+set -euo pipefail
+INPUT=$(cat)
+TOOL=$(echo "$INPUT" | jq -r '.tool_name // empty')
+printf '{"ts":"%s","event":"permission_request","tool":"%s"}\\n' \\
+  "$(date -u +%FT%TZ)" "$TOOL" >> ${quote(eventsFile)}
+echo '{"hookSpecificOutput":{"hookEventName":"PermissionRequest","decision":{"behavior":"allow"}}}'
+exit 0
+`;
+}
+function buildProtectFilesScript(eventsFile, _phaseName, _planDir) {
+  return `#!/bin/bash
+set -euo pipefail
+INPUT=$(cat)
+TOOL=$(echo "$INPUT" | jq -r '.tool_name // empty')
+FILE_PATH=$(echo "$INPUT" | jq -r '.tool_input.file_path // empty')
+[ -z "$FILE_PATH" ] && exit 0
+
+BASENAME=$(basename "$FILE_PATH")
+
+blocked_reason() {
+  printf '{"ts":"%s","event":"protect_blocked","tool":"%s","file":"%s"}\\n' \\
+    "$(date -u +%FT%TZ)" "$TOOL" "$BASENAME" >> ${quote(eventsFile)}
+  echo "$1" >&2
+  exit 2
+}
+
+case "$BASENAME" in
+  .env|.env.*)
+    blocked_reason "\u7981\u6B62\u4FEE\u6539\u73AF\u5883\u914D\u7F6E\u6587\u4EF6 $BASENAME\uFF0C\u8BF7\u901A\u8FC7 .env.example \u6216\u6587\u6863\u8BF4\u660E\u914D\u7F6E\u53D8\u66F4\u3002"
+    ;;
+  package-lock.json|pnpm-lock.yaml)
+    blocked_reason "\u7981\u6B62\u76F4\u63A5\u4FEE\u6539\u9501\u6587\u4EF6 $BASENAME\uFF0C\u8BF7\u901A\u8FC7 npm install / pnpm install \u66F4\u65B0\u4F9D\u8D56\u3002"
+    ;;
+esac
+
+exit 0
+`;
+}
+function buildStopScript(eventsFile, planDir, phaseExpected) {
+  return `#!/bin/bash
+set -euo pipefail
+INPUT=$(cat)
+STOP_ACTIVE=$(echo "$INPUT" | jq -r '.stop_hook_active // false')
+
+PLAN_DIR=${quote(planDir)}
+MIN_BYTES=50
+PHASE_EXPECTED=${quote(phaseExpected)}
+
+MISSING=""
+READY=""
+for f in $(echo "$PHASE_EXPECTED" | tr ',' ' '); do
+  [ -z "$f" ] && continue
+  FPATH="$PLAN_DIR/$f"
+  if [ -f "$FPATH" ] && [ "$(wc -c < "$FPATH")" -ge "$MIN_BYTES" ]; then
+    BYTES=$(wc -c < "$FPATH")
+    READY="$READY $f(\${BYTES} bytes)"
+  else
+    MISSING="$MISSING $f"
+  fi
+done
+
+MISSING=$(echo "$MISSING" | xargs)
+READY=$(echo "$READY" | xargs)
+
+if [ -n "$MISSING" ] && [ "$STOP_ACTIVE" != "true" ]; then
+  printf '{"ts":"%s","event":"stop","blocked":true,"missing":"%s"}\\n' \\
+    "$(date -u +%FT%TZ)" "$MISSING" >> ${quote(eventsFile)}
+
+  REASON="\u4EA7\u7269\u672A\u5C31\u7EEA: $MISSING\u3002\u8BF7\u5199\u5165 $PLAN_DIR/ \u4E0B\u7684\u5BF9\u5E94\u6587\u4EF6\u3002\u5DF2\u5C31\u7EEA: \${READY:-\u65E0}"
+
+  printf '{"decision":"block","reason":"%s"}' "$REASON"
+  exit 0
+fi
+
+printf '{"ts":"%s","event":"stop","blocked":false,"missing":"%s"}\\n' \\
+  "$(date -u +%FT%TZ)" "\${MISSING:-none}" >> ${quote(eventsFile)}
+exit 0
+`;
+}
+function buildAskUserHookScript(eventsFile) {
+  return `#!/bin/bash
+set -euo pipefail
+INPUT=$(cat)
+QUESTION=$(echo "$INPUT" | jq -r '.tool_input.question // empty')
+OPTIONS=$(echo "$INPUT" | jq -c '[.tool_input.options[]? | {index: .index, label: .label}] // []' 2>/dev/null || echo '[]')
+[ -z "$QUESTION" ] && exit 0
+printf '{"ts":"%s","event":"ask_user_question","question":"%s","options":%s}\\n' \\
+  "$(date -u +%FT%TZ)" "$(echo "$QUESTION" | head -c 500 | tr '"' "'")" "$OPTIONS" >> ${quote(eventsFile)}
+exit 0
+`;
+}
+function buildNotificationScript(eventsFile) {
+  return `#!/bin/bash
+set -euo pipefail
+INPUT=$(cat)
+NTYPE=$(echo "$INPUT" | jq -r '.notification_type // empty')
+MSG=$(echo "$INPUT" | jq -r '.message // empty' | head -c 200 | tr '"' "'")
+[ -z "$NTYPE" ] && exit 0
+printf '{"ts":"%s","event":"notification","notification_type":"%s","message":"%s"}\\n' \\
+  "$(date -u +%FT%TZ)" "$NTYPE" "$MSG" >> ${quote(eventsFile)}
+exit 0
+`;
+}
+function quote(s) {
+  return `"${s.replace(/"/g, '\\"')}"`;
+}
+function readJsonl(filePath) {
+  if (!fs3.existsSync(filePath)) return [];
+  try {
+    const content = fs3.readFileSync(filePath, "utf-8").trim();
+    if (!content) return [];
+    return content.split("\n").reduce((acc, line) => {
+      const trimmed = line.trim();
+      if (!trimmed) return acc;
+      try {
+        acc.push(JSON.parse(trimmed));
+      } catch {
+        logger5.debug("Skipping malformed JSONL line", { line: trimmed });
+      }
+      return acc;
+    }, []);
+  } catch {
+    return [];
+  }
+}
+
 // src/ai-runner/PtyRunner.ts
-var logger3 = logger.child("PtyRunner");
+var logger6 = logger.child("PtyRunner");
 var ANSI_RE = /\x1b\[[?><=]*[0-9;]*[a-zA-Z~]|\x1b\][^\x07]*\x07|\x1b\(B/g;
 function stripAnsi(str) {
   return str.replace(ANSI_RE, "");
@@ -340,6 +1056,34 @@ function isTuiNoise(line) {
   if (CLAUDE_BANNER_INFO_RE.test(t)) return true;
   return false;
 }
+var InputWaitController = class {
+  constructor(totalBudgetMs) {
+    this.totalBudgetMs = totalBudgetMs;
+    this.wallClockSegmentStart = Date.now();
+  }
+  _waiting = false;
+  wallClockUsedMs = 0;
+  wallClockSegmentStart;
+  get waiting() {
+    return this._waiting;
+  }
+  pause() {
+    if (this._waiting) return;
+    this._waiting = true;
+    this.wallClockUsedMs += Date.now() - this.wallClockSegmentStart;
+  }
+  resume() {
+    if (!this._waiting) return;
+    this._waiting = false;
+    this.wallClockSegmentStart = Date.now();
+  }
+  get remainingMs() {
+    return Math.max(this.totalBudgetMs - this.wallClockUsedMs, 6e4);
+  }
+  get usedMs() {
+    return this.wallClockUsedMs;
+  }
+};
 var PtyRunner = class {
   constructor(nvmNodeVersion, terminalManager, defaultAgentMode, phaseAgentMap, globalModel, idleDetectMs = 3e4) {
     this.nvmNodeVersion = nvmNodeVersion;
@@ -357,32 +1101,32 @@ var PtyRunner = class {
   // ---- AIRunner interface ---------------------------------------------------
   async run(options) {
     if (isShuttingDown()) {
-      logger3.warn("PtyRunner skipped \u2014 service is shutting down");
+      logger6.warn("PtyRunner skipped \u2014 service is shutting down");
       return { success: false, output: "Service shutting down", exitCode: null };
     }
     const { prompt, workDir, timeoutMs, onStreamEvent, phaseName } = options;
     const agentMode = this.resolveAgentForPhase(phaseName);
     const startMode = options.mode;
     const continueSession = options.continueSession ?? false;
-    logger3.info("PtyRunner.run()", { workDir, timeoutMs, phaseName, agentMode, continueSession });
+    logger6.info("PtyRunner.run()", { workDir, timeoutMs, phaseName, agentMode, continueSession });
     const { sessionId, isNew } = this.ensureSession(workDir, agentMode, startMode);
     if (isNew) {
-      logger3.info("Waiting for AI agent prompt (new session)", { sessionId, phaseName });
+      logger6.info("Waiting for AI agent prompt (new session)", { sessionId, phaseName });
       await this.waitForPrompt(sessionId, 3e5);
     } else if (continueSession) {
-      logger3.info("Waiting for AI agent prompt (continue-session)", { sessionId, phaseName });
+      logger6.info("Waiting for AI agent prompt (continue-session)", { sessionId, phaseName });
       await this.waitForPrompt(sessionId, 3e4);
     } else {
-      logger3.info("Waiting for AI agent prompt (reused session)", { sessionId, phaseName });
+      logger6.info("Waiting for AI agent prompt (reused session)", { sessionId, phaseName });
       await this.waitForPrompt(sessionId, 1e4);
     }
     if (startMode === "plan" && this.shouldUseNativePlan(agentMode)) {
       return this.runNativePlanMode(sessionId, isNew, options, agentMode, workDir);
     }
     if (continueSession && !isNew) {
-      logger3.info("Continue-session mode: attaching detectCompletion (no /clear)", { sessionId });
+      logger6.info("Continue-session mode: attaching detectCompletion (no /clear)", { sessionId });
       const result2 = await this.detectCompletion(sessionId, options, onStreamEvent);
-      logger3.info("PtyRunner continue-session completed", {
+      logger6.info("PtyRunner continue-session completed", {
         workDir,
         agentMode,
         phaseName,
@@ -398,7 +1142,7 @@ var PtyRunner = class {
     const instruction = `Please read and follow all instructions in ${promptFile}`;
     await this.writeCommand(sessionId, instruction, agentMode);
     const result = await this.detectCompletion(sessionId, options, onStreamEvent);
-    logger3.info("PtyRunner phase completed", {
+    logger6.info("PtyRunner phase completed", {
       workDir,
       agentMode,
       phaseName,
@@ -413,7 +1157,7 @@ var PtyRunner = class {
       this.terminalManager.destroy(info.sessionId);
     }
     this.sessions.clear();
-    logger3.info("PtyRunner: all managed sessions destroyed");
+    logger6.info("PtyRunner: all managed sessions destroyed");
   }
   killByWorkDir(targetWorkDir) {
     const info = this.sessions.get(targetWorkDir);
@@ -432,7 +1176,7 @@ var PtyRunner = class {
       return false;
     }
     this.terminalManager.write(info.sessionId, "");
-    logger3.info("Interrupted PTY session for retry", {
+    logger6.info("Interrupted PTY session for retry", {
       workDir: targetWorkDir,
       sessionId: info.sessionId
     });
@@ -489,7 +1233,7 @@ var PtyRunner = class {
   ensureSession(workDir, agentMode, startMode) {
     const existing = this.sessions.get(workDir);
     if (existing && existing.agentMode !== agentMode) {
-      logger3.info("Agent switched, destroying old PTY session", {
+      logger6.info("Agent switched, destroying old PTY session", {
         workDir,
         oldAgent: existing.agentMode,
         newAgent: agentMode,
@@ -500,7 +1244,7 @@ var PtyRunner = class {
     }
     if (existing && existing.agentMode === agentMode) {
       if (this.terminalManager.get(existing.sessionId)) {
-        logger3.info("Reusing existing PTY session (same agent)", {
+        logger6.info("Reusing existing PTY session (same agent)", {
           workDir,
           agentMode,
           sessionId: existing.sessionId
@@ -511,7 +1255,7 @@ var PtyRunner = class {
     }
     const orphan = this.terminalManager.findByWorkDir(workDir);
     if (orphan) {
-      logger3.info("Destroying orphaned PTY session on workDir", {
+      logger6.info("Destroying orphaned PTY session on workDir", {
         workDir,
         sessionId: orphan.id
       });
@@ -535,7 +1279,7 @@ var PtyRunner = class {
       currentMode: profile.defaultModeName ?? "bypass",
       startedWithMode: startMode
     });
-    logger3.info("Created new PTY session", {
+    logger6.info("Created new PTY session", {
       workDir,
       agentMode,
       binary,
@@ -567,7 +1311,7 @@ var PtyRunner = class {
         if (stabilityTimer) clearTimeout(stabilityTimer);
         if (silenceTimer) clearTimeout(silenceTimer);
         subscription.dispose();
-        logger3.warn("Timed out waiting for AI agent prompt", { sessionId, timeoutMs });
+        logger6.warn("Timed out waiting for AI agent prompt", { sessionId, timeoutMs });
         resolve();
       }, timeoutMs);
       const done = (reason) => {
@@ -575,7 +1319,7 @@ var PtyRunner = class {
         if (stabilityTimer) clearTimeout(stabilityTimer);
         if (silenceTimer) clearTimeout(silenceTimer);
         subscription.dispose();
-        logger3.info("AI agent prompt detected", { sessionId, reason });
+        logger6.info("AI agent prompt detected", { sessionId, reason });
         resolve();
       };
       const resetSilenceTimer = () => {
@@ -583,7 +1327,7 @@ var PtyRunner = class {
         if (silenceTimer) clearTimeout(silenceTimer);
         silenceTimer = setTimeout(() => {
           if (promptSeen) return;
-          logger3.info("Banner shown and PTY silent \u2014 treating agent as ready", { sessionId });
+          logger6.info("Banner shown and PTY silent \u2014 treating agent as ready", { sessionId });
           done("silence-after-banner");
         }, SILENCE_READY_MS);
       };
@@ -597,11 +1341,11 @@ var PtyRunner = class {
         resetSilenceTimer();
         if (!trustDialogHandled && TRUST_DIALOG_RE.test(stripped)) {
           trustDialogHandled = true;
-          logger3.info("Trust dialog detected, auto-confirming", { sessionId });
+          logger6.info("Trust dialog detected, auto-confirming", { sessionId });
           setTimeout(() => this.terminalManager.write(sessionId, "\r"), 500);
         }
         if (PERMISSION_DIALOG_RE.test(stripped)) {
-          logger3.info("Permission dialog detected in waitForPrompt, auto-confirming", { sessionId });
+          logger6.info("Permission dialog detected in waitForPrompt, auto-confirming", { sessionId });
           setTimeout(() => this.terminalManager.write(sessionId, "\r"), 500);
         }
         if (isIdlePrompt(stripped)) {
@@ -636,7 +1380,7 @@ var PtyRunner = class {
     if (!session) return;
     const targetMode = wantPlan ? profile.planModeName : profile.defaultModeName ?? "bypass";
     if (session.currentMode === targetMode) {
-      logger3.info("PTY already in target mode", { sessionId, targetMode });
+      logger6.info("PTY already in target mode", { sessionId, targetMode });
       return;
     }
     const MAX_ATTEMPTS = 5;
@@ -648,7 +1392,7 @@ var PtyRunner = class {
       if (detected) {
         session.currentMode = detected;
         if (detected === targetMode) {
-          logger3.info("PTY mode switched", {
+          logger6.info("PTY mode switched", {
             sessionId,
             agentMode,
             targetMode,
@@ -658,7 +1402,7 @@ var PtyRunner = class {
         }
       }
     }
-    logger3.warn("Failed to switch PTY mode after max attempts", {
+    logger6.warn("Failed to switch PTY mode after max attempts", {
       sessionId,
       agentMode,
       targetMode,
@@ -712,9 +1456,9 @@ var PtyRunner = class {
     const issueIid = extractIidFromPath(workDir);
     const contentHint = issueIid ? PlanFileResolver.buildContentHint(issueIid) : void 0;
     if (continueSession) {
-      logger3.info("Native plan mode: continue-session (no /clear, no prompt)", { sessionId });
+      logger6.info("Native plan mode: continue-session (no /clear, no prompt)", { sessionId });
     } else {
-      logger3.info("Native plan mode: switching to plan", { sessionId, agentMode });
+      logger6.info("Native plan mode: switching to plan", { sessionId, agentMode });
       await this.ensurePlanMode(sessionId, agentMode, true, workDir);
       if (!isNew) {
         await this.writeCommand(sessionId, "/clear", agentMode);
@@ -734,47 +1478,62 @@ var PtyRunner = class {
       artifactCheck: planArtifactCheck
     }, options.onStreamEvent, continueSession);
     if (planResult.timedOut) {
-      logger3.warn("Native plan mode: plan phase timed out", {
+      logger6.warn("Native plan mode: plan phase timed out", {
         sessionId,
         wasActive: planResult.wasActiveAtTimeout
       });
       return this.buildRunResult(planResult, sessionId);
     }
-    logger3.info("Native plan mode: resolving plan file from CLI storage", { sessionId });
-    const resolved = resolver.resolve(contentHint);
-    if (!resolved) {
-      logger3.error("Native plan mode: no plan file found in CLI storage", { sessionId, workDir });
-      return {
-        success: false,
-        output: planResult.output,
-        errorMessage: "Plan \u9636\u6BB5\u5B8C\u6210\u4F46\u672A\u5728 CLI \u8BA1\u5212\u76EE\u5F55\u4E2D\u627E\u5230\u8BA1\u5212\u6587\u4EF6",
-        sessionId,
-        exitCode: null
-      };
-    }
     const artifactPaths = options.artifactPaths ?? [];
-    if (artifactPaths.length > 0) {
-      for (const targetPath of artifactPaths) {
-        const targetDir = path2.dirname(targetPath);
-        if (!fs2.existsSync(targetDir)) {
-          fs2.mkdirSync(targetDir, { recursive: true });
-        }
-        fs2.writeFileSync(targetPath, resolved.content, "utf-8");
-        logger3.info("Plan file copied to artifact path", {
-          source: path2.basename(resolved.sourcePath),
-          target: targetPath,
-          size: resolved.content.length
-        });
+    const MIN_PLAN_BYTES = 50;
+    const hookHandled = artifactPaths.length > 0 && artifactPaths.every((p) => {
+      try {
+        return fs4.existsSync(p) && fs4.statSync(p).size >= MIN_PLAN_BYTES;
+      } catch {
+        return false;
       }
-    } else {
-      logger3.warn("Native plan mode: no artifactPaths specified, plan file not copied", {
+    });
+    if (hookHandled) {
+      logger6.info("Native plan mode: plan captured by ExitPlanMode hook", {
         sessionId,
-        resolvedFile: resolved.sourcePath
+        artifactPaths
       });
+    } else {
+      logger6.info("Native plan mode: resolving plan file from CLI storage (fallback)", { sessionId });
+      const resolved = resolver.resolve(contentHint);
+      if (!resolved) {
+        logger6.error("Native plan mode: no plan file found in CLI storage", { sessionId, workDir });
+        return {
+          success: false,
+          output: planResult.output,
+          errorMessage: "Plan \u9636\u6BB5\u5B8C\u6210\u4F46\u672A\u5728 CLI \u8BA1\u5212\u76EE\u5F55\u4E2D\u627E\u5230\u8BA1\u5212\u6587\u4EF6",
+          sessionId,
+          exitCode: null
+        };
+      }
+      if (artifactPaths.length > 0) {
+        for (const targetPath of artifactPaths) {
+          const targetDir = path3.dirname(targetPath);
+          if (!fs4.existsSync(targetDir)) {
+            fs4.mkdirSync(targetDir, { recursive: true });
+          }
+          fs4.writeFileSync(targetPath, resolved.content, "utf-8");
+          logger6.info("Plan file copied to artifact path", {
+            source: path3.basename(resolved.sourcePath),
+            target: targetPath,
+            size: resolved.content.length
+          });
+        }
+      } else {
+        logger6.warn("Native plan mode: no artifactPaths specified, plan file not copied", {
+          sessionId,
+          resolvedFile: resolved.sourcePath
+        });
+      }
     }
-    logger3.info("Native plan mode completed (deterministic copy)", {
+    logger6.info("Native plan mode completed", {
       sessionId,
-      planSource: path2.basename(resolved.sourcePath),
+      hookHandled,
       artifactsCopied: artifactPaths.length
     });
     return this.buildRunResult(planResult, sessionId);
@@ -792,13 +1551,19 @@ var PtyRunner = class {
     };
   }
   writePromptFile(workDir, prompt) {
-    const dir = path2.join(workDir, ".claude-plan");
-    if (!fs2.existsSync(dir)) {
-      fs2.mkdirSync(dir, { recursive: true });
+    const dir = path3.join(workDir, ".claude-plan");
+    if (!fs4.existsSync(dir)) {
+      fs4.mkdirSync(dir, { recursive: true });
+    }
+    const gitignorePath = path3.join(dir, ".gitignore");
+    const entry = ".phase-prompt.md";
+    if (!fs4.existsSync(gitignorePath) || !fs4.readFileSync(gitignorePath, "utf-8").includes(entry)) {
+      fs4.appendFileSync(gitignorePath, `${entry}
+`, "utf-8");
     }
     const relPath = ".claude-plan/.phase-prompt.md";
-    const absPath = path2.join(workDir, relPath);
-    fs2.writeFileSync(absPath, prompt, "utf-8");
+    const absPath = path3.join(workDir, relPath);
+    fs4.writeFileSync(absPath, prompt, "utf-8");
     return relPath;
   }
   // ---- Completion detection -------------------------------------------------
@@ -818,6 +1583,27 @@ var PtyRunner = class {
       let pendingDialogParsed = null;
       const idleTimeoutMs = options.idleTimeoutMs ?? 6e5;
       const timeoutMs = options.timeoutMs;
+      const inputWait = new InputWaitController(timeoutMs);
+      const pauseTimersForInput = () => {
+        if (inputWait.waiting) return;
+        inputWait.pause();
+        clearTimeout(wallTimer);
+        logger6.info("Timers paused \u2014 waiting for user input", {
+          sessionId,
+          wallClockUsedMs: inputWait.usedMs
+        });
+      };
+      const resumeTimersAfterInput = () => {
+        if (!inputWait.waiting) return;
+        inputWait.resume();
+        lastOutputTime = Date.now();
+        wallTimer = scheduleWallTimer(inputWait.remainingMs);
+        logger6.info("Timers resumed after user input", {
+          sessionId,
+          remainingMs: inputWait.remainingMs,
+          wallClockUsedMs: inputWait.usedMs
+        });
+      };
       const GRACE_WINDOW_MS = options.timeoutGraceMs ?? 6e4;
       const EXTENSION_MS = options.timeoutExtensionMs ?? 6e5;
       const MAX_EXTENSIONS = options.timeoutMaxExtensions ?? 3;
@@ -830,11 +1616,12 @@ var PtyRunner = class {
       };
       const scheduleWallTimer = (delayMs) => {
         return setTimeout(() => {
+          if (inputWait.waiting) return;
           const recentMs = Date.now() - lastOutputTime;
           const isActive = hasSubstantiveOutput && recentMs < GRACE_WINDOW_MS;
           if (isActive && extensions < MAX_EXTENSIONS) {
             extensions++;
-            logger3.info("Wall-clock timeout extended (agent still active)", {
+            logger6.info("Wall-clock timeout extended (agent still active)", {
               sessionId,
               extensions,
               maxExtensions: MAX_EXTENSIONS,
@@ -853,6 +1640,7 @@ var PtyRunner = class {
       };
       let wallTimer = scheduleWallTimer(timeoutMs);
       const idleCheck = setInterval(() => {
+        if (inputWait.waiting) return;
         if (!hasSubstantiveOutput) return;
         if (Date.now() - lastOutputTime >= idleTimeoutMs) {
           finish({
@@ -863,6 +1651,52 @@ var PtyRunner = class {
           });
         }
       }, 5e3);
+      const dialogClassifier = new DialogClassifier();
+      let hookWatcher;
+      let hookSub;
+      const hookInjector = new HookInjector();
+      const eventsFilePath = hookInjector.getEventsFilePath(options.workDir);
+      if (fs4.existsSync(eventsFilePath)) {
+        hookWatcher = new HookEventWatcher(eventsFilePath);
+        hookSub = hookWatcher.onEvent((event) => {
+          dialogClassifier.ingestHookEvent(event);
+          if (event.event === "ask_user_question" && options.onInputRequired && !dialogHandled && !resolved) {
+            const askData = dialogClassifier.consumePendingAskUser();
+            if (askData) {
+              dialogHandled = true;
+              dialogBuffer.length = 0;
+              if (dialogQuiesceTimer) {
+                clearTimeout(dialogQuiesceTimer);
+                dialogQuiesceTimer = void 0;
+              }
+              pauseTimersForInput();
+              logger6.info("AskUserQuestion detected via hook (high confidence, zero delay)", {
+                sessionId,
+                question: askData.question.slice(0, 80),
+                optionCount: askData.options.length
+              });
+              options.onInputRequired({
+                type: "interactive-dialog",
+                content: askData.question,
+                options: askData.options
+              }).then((response) => {
+                resumeTimersAfterInput();
+                dialogHandled = false;
+                if (!resolved && response) {
+                  this.terminalManager.write(sessionId, response + "\r");
+                }
+              }).catch((err) => {
+                logger6.warn("onInputRequired callback failed (hook-based)", {
+                  error: err.message
+                });
+                resumeTimersAfterInput();
+                dialogHandled = false;
+              });
+            }
+          }
+        });
+        hookWatcher.start();
+      }
       const subscription = this.terminalManager.onData(sessionId, (data) => {
         if (resolved) return;
         const stripped = stripAnsi(data);
@@ -877,7 +1711,7 @@ var PtyRunner = class {
             clearTimeout(dialogQuiesceTimer);
             dialogQuiesceTimer = void 0;
             pendingDialogParsed = null;
-            logger3.info("Dialog quiesce cancelled \u2014 new substantive output arrived", { sessionId });
+            logger6.info("Dialog quiesce cancelled \u2014 new substantive output arrived", { sessionId });
           }
         }
         if (!echoConsumed && stripped.includes(".phase-prompt.md")) {
@@ -888,27 +1722,27 @@ var PtyRunner = class {
           return;
         }
         if (options.completionSignal && hasSubstantiveOutput && options.completionSignal.test(stripped)) {
-          logger3.info("Completion signal detected", { sessionId });
+          logger6.info("Completion signal detected", { sessionId });
           finish({ output: outputLines.join(""), timedOut: false });
           return;
         }
         if (hasSubstantiveOutput && WORKED_SUMMARY_RE.test(stripped)) {
           const artifactReady = options.artifactCheck ? options.artifactCheck() : true;
           if (artifactReady) {
-            logger3.info("Session-end summary detected, finishing", { sessionId });
+            logger6.info("Session-end summary detected, finishing", { sessionId });
             finish({ output: outputLines.join(""), timedOut: false });
             return;
           }
-          logger3.info("Session summary detected but artifacts not ready, continuing", { sessionId });
+          logger6.info("Session summary detected but artifacts not ready, continuing", { sessionId });
         }
         if (PERMISSION_DIALOG_RE.test(stripped)) {
-          logger3.info("Permission dialog detected, auto-confirming", { sessionId });
+          logger6.info("Permission dialog detected, auto-confirming", { sessionId });
           setTimeout(() => {
             if (!resolved) this.terminalManager.write(sessionId, "\r");
           }, 500);
           return;
         }
-        if (options.onInputRequired && !dialogHandled && isInteractiveDialog(stripped)) {
+        if (options.onInputRequired && !dialogHandled && !dialogClassifier.shouldSuppressRegex() && isInteractiveDialog(stripped)) {
           const parsed = parseInteractiveDialog(stripped);
           if (parsed) {
             const confidence = getDialogConfidence(stripped);
@@ -919,7 +1753,8 @@ var PtyRunner = class {
                 clearTimeout(dialogQuiesceTimer);
                 dialogQuiesceTimer = void 0;
               }
-              logger3.info("Interactive dialog detected (high confidence), forwarding to handler", {
+              pauseTimersForInput();
+              logger6.info("Interactive dialog detected (high confidence), forwarding to handler", {
                 sessionId,
                 question: parsed.question.slice(0, 80),
                 optionCount: parsed.options.length
@@ -929,21 +1764,23 @@ var PtyRunner = class {
                 content: parsed.question,
                 options: parsed.options
               }).then((response) => {
+                resumeTimersAfterInput();
                 dialogHandled = false;
                 if (!resolved && response) {
                   this.terminalManager.write(sessionId, response + "\r");
                 }
               }).catch((err) => {
-                logger3.warn("onInputRequired callback failed for interactive dialog", {
+                logger6.warn("onInputRequired callback failed for interactive dialog", {
                   error: err.message
                 });
+                resumeTimersAfterInput();
                 dialogHandled = false;
               });
               return;
             }
             if (!dialogQuiesceTimer) {
               pendingDialogParsed = parsed;
-              logger3.info("Interactive dialog detected (low confidence), starting quiesce", {
+              logger6.info("Interactive dialog detected (low confidence), starting quiesce", {
                 sessionId,
                 question: parsed.question.slice(0, 80),
                 optionCount: parsed.options.length
@@ -955,7 +1792,8 @@ var PtyRunner = class {
                 dialogBuffer.length = 0;
                 const dp = pendingDialogParsed;
                 pendingDialogParsed = null;
-                logger3.info("Dialog quiesce elapsed \u2014 forwarding low-confidence dialog", {
+                pauseTimersForInput();
+                logger6.info("Dialog quiesce elapsed \u2014 forwarding low-confidence dialog", {
                   sessionId,
                   question: dp.question.slice(0, 80)
                 });
@@ -964,14 +1802,16 @@ var PtyRunner = class {
                   content: dp.question,
                   options: dp.options
                 }).then((response) => {
+                  resumeTimersAfterInput();
                   dialogHandled = false;
                   if (!resolved && response) {
                     this.terminalManager.write(sessionId, response + "\r");
                   }
                 }).catch((err) => {
-                  logger3.warn("onInputRequired callback failed (quiesced dialog)", {
+                  logger6.warn("onInputRequired callback failed (quiesced dialog)", {
                     error: err.message
                   });
+                  resumeTimersAfterInput();
                   dialogHandled = false;
                 });
               }, DIALOG_QUIESCE_MS);
@@ -1005,10 +1845,10 @@ var PtyRunner = class {
         if (hasSubstantiveOutput && isIdlePrompt(stripped)) {
           if (isMixedFrame) {
           } else if (options.completionSignal) {
-            logger3.debug("Idle prompt ignored (waiting for completionSignal)", { sessionId });
+            logger6.debug("Idle prompt ignored (waiting for completionSignal)", { sessionId });
           } else if (debounceTimer && isNoise) {
           } else {
-            if (options.onInputRequired && !dialogHandled && dialogBuffer.length >= 2) {
+            if (options.onInputRequired && !dialogHandled && !dialogClassifier.shouldSuppressRegex() && dialogBuffer.length >= 2) {
               const combined = dialogBuffer.join("\n");
               if (isInteractiveDialog(combined)) {
                 const parsed = parseInteractiveDialog(combined);
@@ -1021,7 +1861,8 @@ var PtyRunner = class {
                       clearTimeout(dialogQuiesceTimer);
                       dialogQuiesceTimer = void 0;
                     }
-                    logger3.info("Interactive dialog detected via accumulated buffer (high confidence)", {
+                    pauseTimersForInput();
+                    logger6.info("Interactive dialog detected via accumulated buffer (high confidence)", {
                       sessionId,
                       question: parsed.question.slice(0, 80),
                       optionCount: parsed.options.length
@@ -1031,21 +1872,23 @@ var PtyRunner = class {
                       content: parsed.question,
                       options: parsed.options
                     }).then((response) => {
+                      resumeTimersAfterInput();
                       dialogHandled = false;
                       if (!resolved && response) {
                         this.terminalManager.write(sessionId, response + "\r");
                       }
                     }).catch((err) => {
-                      logger3.warn("onInputRequired callback failed (accumulated)", {
+                      logger6.warn("onInputRequired callback failed (accumulated)", {
                         error: err.message
                       });
+                      resumeTimersAfterInput();
                       dialogHandled = false;
                     });
                     return;
                   }
                   if (!dialogQuiesceTimer) {
                     pendingDialogParsed = parsed;
-                    logger3.info("Dialog detected via buffer (low confidence), starting quiesce", {
+                    logger6.info("Dialog detected via buffer (low confidence), starting quiesce", {
                       sessionId,
                       question: parsed.question.slice(0, 80)
                     });
@@ -1056,20 +1899,23 @@ var PtyRunner = class {
                       dialogBuffer.length = 0;
                       const dp = pendingDialogParsed;
                       pendingDialogParsed = null;
-                      logger3.info("Buffer dialog quiesce elapsed \u2014 forwarding", { sessionId });
+                      pauseTimersForInput();
+                      logger6.info("Buffer dialog quiesce elapsed \u2014 forwarding", { sessionId });
                       options.onInputRequired({
                         type: "interactive-dialog",
                         content: dp.question,
                         options: dp.options
                       }).then((response) => {
+                        resumeTimersAfterInput();
                         dialogHandled = false;
                         if (!resolved && response) {
                           this.terminalManager.write(sessionId, response + "\r");
                         }
                       }).catch((err) => {
-                        logger3.warn("onInputRequired callback failed (buffer quiesced)", {
+                        logger6.warn("onInputRequired callback failed (buffer quiesced)", {
                           error: err.message
                         });
+                        resumeTimersAfterInput();
                         dialogHandled = false;
                       });
                     }, DIALOG_QUIESCE_MS);
@@ -1088,7 +1934,7 @@ var PtyRunner = class {
                 }
                 const artifactReady = options.artifactCheck ? options.artifactCheck() : true;
                 if (!artifactReady) {
-                  logger3.info("Idle prompt detected but artifacts not ready, continuing to wait", {
+                  logger6.info("Idle prompt detected but artifacts not ready, continuing to wait", {
                     sessionId
                   });
                   scheduleDebounce();
@@ -1114,14 +1960,14 @@ var PtyRunner = class {
           }
         }
         if (!resolved) {
-          logger3.warn("PTY process exited during phase", { sessionId, exitCode, wasKilled });
+          logger6.warn("PTY process exited during phase", { sessionId, exitCode, wasKilled });
           finish({
             output: outputLines.join(""),
             timedOut: wasKilled,
             timeoutType: wasKilled ? "wall-clock" : void 0
           });
         } else {
-          logger3.info("PTY exited after phase completion (post stop-hook)", { sessionId, exitCode });
+          logger6.info("PTY exited after phase completion (post stop-hook)", { sessionId, exitCode });
         }
       });
       const cleanup = () => {
@@ -1130,6 +1976,9 @@ var PtyRunner = class {
         if (debounceTimer) clearTimeout(debounceTimer);
         if (dialogQuiesceTimer) clearTimeout(dialogQuiesceTimer);
         subscription.dispose();
+        hookSub?.dispose();
+        hookWatcher?.stop();
+        dialogClassifier.reset();
       };
     });
   }
@@ -1137,6 +1986,7 @@ var PtyRunner = class {
 
 export {
   PlanFileResolver,
+  HookInjector,
   stripAnsi,
   isIdlePrompt,
   TRUST_DIALOG_RE,
@@ -1148,6 +1998,7 @@ export {
   isInteractiveDialog,
   containsActiveWork,
   isTuiNoise,
+  InputWaitController,
   PtyRunner
 };
-//# sourceMappingURL=chunk-4XMYOXGZ.js.map
+//# sourceMappingURL=chunk-36G3DPO3.js.map