@xdevops/issue-auto-finish 1.0.87 → 1.0.89

package/dist/chunk-4XMYOXGZ.js

@@ -0,0 +1,1153 @@
+import {
+  getPtyProfile,
+  getRegistryEntry,
+  getRunnerCapabilities,
+  resolveModelForRunner
+} from "./chunk-TFEPHOVE.js";
+import {
+  isShuttingDown
+} from "./chunk-G7QI5WDI.js";
+import {
+  logger
+} from "./chunk-GF2RRYHB.js";
+
+// src/ai-runner/PtyRunner.ts
+import fs2 from "fs";
+import path2 from "path";
+
+// src/ai-runner/PlanFileResolver.ts
+import fs from "fs";
+import path from "path";
+import os from "os";
+var logger2 = logger.child("PlanFileResolver");
+var PLAN_DIRS = {
+  "claude-internal": path.join(os.homedir(), ".claude-internal", "plans"),
+  "codebuddy": path.join(os.homedir(), ".codebuddy", "plans")
+};
+var PlanFileResolver = class _PlanFileResolver {
+  plansDir;
+  beforeFiles = /* @__PURE__ */ new Map();
+  constructor(plansDir) {
+    this.plansDir = plansDir ?? path.join(os.homedir(), ".claude-internal", "plans");
+  }
+  /** Create a resolver for a specific runner mode (e.g. 'claude-internal', 'codebuddy'). */
+  static forRunner(agentMode) {
+    const dir = PLAN_DIRS[agentMode];
+    return new _PlanFileResolver(dir);
+  }
+  /** Take a snapshot of existing plan files before the plan phase starts. */
+  takeBeforeSnapshot() {
+    this.beforeFiles = this.listFiles();
+    logger2.info("Plan file snapshot taken", {
+      dir: this.plansDir,
+      fileCount: this.beforeFiles.size
+    });
+  }
+  /**
+   * Check if any new or modified plan files exist since the before-snapshot.
+   * Used as an artifact gate by detectCompletion to prevent premature
+   * completion when the agent is still exploring/thinking.
+   */
+  hasNewOrModifiedFiles() {
+    const afterFiles = this.listFiles();
+    for (const [filePath, mtime] of afterFiles) {
+      const beforeMtime = this.beforeFiles.get(filePath);
+      if (beforeMtime === void 0 || mtime > beforeMtime) return true;
+    }
+    return false;
+  }
+  /**
+   * After plan phase completes, find the newly created plan file.
+   *
+   * Strategy:
+   *   1. Diff against beforeSnapshot to find new files
+   *   2. Sort candidates by mtime (newest first)
+   *   3. If contentHint provided, prefer the file whose content matches
+   *   4. Return the best candidate
+   *
+   * @param contentHint - Optional string (e.g. issue IID or title) to validate content
+   */
+  resolve(contentHint) {
+    if (!fs.existsSync(this.plansDir)) {
+      logger2.warn("Plans directory does not exist", { dir: this.plansDir });
+      return null;
+    }
+    const afterFiles = this.listFiles();
+    const candidates = this.findNewFiles(afterFiles);
+    if (candidates.length === 0) {
+      logger2.warn("No new plan files found after plan phase", {
+        dir: this.plansDir,
+        beforeCount: this.beforeFiles.size,
+        afterCount: afterFiles.size
+      });
+      return this.fallbackByMtime(afterFiles, contentHint);
+    }
+    if (candidates.length === 1) {
+      return this.readCandidate(candidates[0].path, candidates[0].mtime);
+    }
+    if (contentHint) {
+      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)
+    });
+    return this.readCandidate(candidates[0].path, candidates[0].mtime);
+  }
+  /**
+   * Build a content hint string from issue metadata for content-based matching.
+   */
+  static buildContentHint(issueIid, issueTitle) {
+    const parts = [`#${issueIid}`, `${issueIid}`];
+    if (issueTitle) parts.push(issueTitle);
+    return parts.join("|");
+  }
+  listFiles() {
+    const result = /* @__PURE__ */ new Map();
+    if (!fs.existsSync(this.plansDir)) return result;
+    try {
+      const entries = fs.readdirSync(this.plansDir);
+      for (const entry of entries) {
+        if (!entry.endsWith(".md")) continue;
+        const fullPath = path.join(this.plansDir, entry);
+        try {
+          const stat = fs.statSync(fullPath);
+          if (stat.isFile()) {
+            result.set(fullPath, stat.mtimeMs);
+          }
+        } catch {
+        }
+      }
+    } catch (err) {
+      logger2.warn("Failed to list plans directory", { dir: this.plansDir, err });
+    }
+    return result;
+  }
+  findNewFiles(afterFiles) {
+    const candidates = [];
+    for (const [filePath, mtime] of afterFiles) {
+      if (!this.beforeFiles.has(filePath)) {
+        candidates.push({ path: filePath, mtime });
+      }
+    }
+    return candidates;
+  }
+  /**
+   * Fallback: if no new files found (rare case — plan might have overwritten
+   * an existing file), find the most recently modified file.
+   */
+  fallbackByMtime(afterFiles, contentHint) {
+    if (afterFiles.size === 0) return null;
+    const sorted = [...afterFiles.entries()].sort((a, b) => b[1] - a[1]);
+    if (contentHint) {
+      for (const [filePath] of sorted.slice(0, 5)) {
+        try {
+          const content = fs.readFileSync(filePath, "utf-8");
+          if (this.contentMatches(content, contentHint)) {
+            logger2.info("Fallback: found plan file by content match", {
+              file: path.basename(filePath)
+            });
+            return { sourcePath: filePath, content };
+          }
+        } catch {
+          continue;
+        }
+      }
+    }
+    const [newestPath, newestMtime] = sorted[0];
+    logger2.info("Fallback: using most recently modified plan file", {
+      file: path.basename(newestPath),
+      ageMs: Date.now() - newestMtime
+    });
+    return this.readCandidate(newestPath, newestMtime);
+  }
+  matchByContent(candidates, contentHint) {
+    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 };
+        }
+      } catch {
+        continue;
+      }
+    }
+    return null;
+  }
+  contentMatches(content, hint) {
+    const parts = hint.split("|");
+    return parts.some((part) => content.includes(part));
+  }
+  readCandidate(filePath, mtime) {
+    try {
+      const content = fs.readFileSync(filePath, "utf-8");
+      logger2.info("Resolved plan file", {
+        file: path.basename(filePath),
+        size: content.length,
+        ageMs: Date.now() - mtime
+      });
+      return { sourcePath: filePath, content };
+    } catch (err) {
+      logger2.error("Failed to read plan file", { filePath, err });
+      return null;
+    }
+  }
+};
+
+// src/ai-runner/PtyRunner.ts
+var logger3 = 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, "");
+}
+function extractIidFromPath(workDir) {
+  const match = workDir.match(/issue-(\d+)/);
+  return match ? parseInt(match[1], 10) : void 0;
+}
+function isIdlePrompt(stripped) {
+  const lines = stripped.split("\n").filter((l) => l.trim());
+  if (lines.length === 0) return false;
+  const last = lines[lines.length - 1].trim();
+  if (/^[❯>$%]\s*$/.test(last) || /[❯>]\s*$/.test(last)) return true;
+  if (lines.some((l) => {
+    const t = l.trim();
+    if (!/(?:^|\s)❯/.test(t)) return false;
+    if (/❯\s*$/.test(t)) return true;
+    return !/❯\s+[A-Za-z]{3,}/.test(t);
+  })) return true;
+  if (lines.some((l) => /^>/.test(l.trim())) && /⏵/.test(stripped)) return true;
+  if (/→/.test(stripped) && /\/\s*commands/.test(stripped) && !/ctrl\+c\s*to\s*stop/i.test(stripped)) {
+    return true;
+  }
+  return false;
+}
+var SPINNER_CHARS = "\u2736\u273B\u273D\u2722\u273E\u25C6\u2756\u25CF\u25D0\u25D1\u25D2\u25D3\u25CB\u280B\u2819\u2839\u2838\u283C\u2834\u2826\u2827\u2807\u280F\u2802\u2812\u2810\u2808\u2820\u2824\xB7*\u2026\u22EF\u2B21\u2B22";
+var SPINNER_RE = new RegExp(`^[${SPINNER_CHARS}\\s]+$`);
+var SPINNER_FRAGMENT_RE = new RegExp(`^[${SPINNER_CHARS}][a-zA-Z]{0,3}$`);
+var STATUS_BAR_RE = /bypass permissions|shift\+tab|ctrl\+[a-z].*(?:to |edit)|to interrupt|to cycle|⏵.*(?:bypass|permission)/;
+var THINKING_RE = /^[^\w]*\w[\w-]*…\s*$/;
+var SEPARATOR_RE = /^[─━═-]{10,}$/;
+var EFFORT_RE = /^[◐◑◒◓]\s+(?:low|medium|high)\s+·\s+\/effort$/;
+var CLAUDE_STATUS_BAR_RE = new RegExp(`^[${SPINNER_CHARS}]\\s*\\d+[smh]`);
+var CURSOR_ARTIFACT_RE = /^\d{1,3}$/;
+var CURSOR_GENERATING_RE = /^[⬡⬢]\s*Generating/;
+var CURSOR_FOOTER_RE = /^\/\s*commands\s*·\s*@\s*files\s*·\s*!\s*shell$/;
+var CURSOR_STATUS_RE = /^▶︎?\s*Auto-run/;
+var CURSOR_MODEL_RE = /^(?:Opus|Claude|GPT|Gemini|当前使用的模型)\s*/;
+var BOX_DRAWING_RE = /^[┌┐└┘│─┬┴├┤┼╭╮╰╯═║╔╗╚╝╠╣╦╩╬\s]*$/;
+var QUEUED_MSG_RE = /Press\s*up\s*to\s*edit\s*queued\s*messages/;
+var STOP_HOOK_RE = /^[^\w]*\w[\w-]*…\s*\(.*\)\s*$/;
+var WORKED_SUMMARY_RE = new RegExp(`^[${SPINNER_CHARS}]\\s*(?:\\w+\\s+for|\u5DE5\u4F5C\u4E86)\\s+\\d+[smh]`, "m");
+var CLAUDE_BANNER_RE = /^[▐▛▜▌▝▘█\s]+$/;
+var CLAUDE_BANNER_INFO_RE = /^[▐▛▜▌▝▘█]+\s+(?:Claude|Opus|Gemini|GPT|Sonnet|Haiku)/;
+var TRUST_DIALOG_RE = /trust\s*(?:the\s*files\s*in\s*)?this\s*(?:folder|workspace)|I\s*trust\s*this/i;
+var PERMISSION_DIALOG_RE = /Do\s*you\s*want\s*to\s*proceed\s*\?|(?:❯|>)\s*\d+\.\s*Yes\b|Allow\s+(?:this|the)\s+(?:action|command)\s*\?/i;
+var PLAN_CONFIRM_RE = /written\s*up\s*a\s*plan|ready\s*to\s*execute.*(?:Would|proceed)|Yes,?\s*and\s*bypass\s*permissions/i;
+var NUMBERED_OPTION_RE = /(?:❯|>)?\s*(\d+)\.\s*(.+)/;
+var INTERACTIVE_NAV_HINT_RE = /Enter\s*to\s*select|↑.*↓.*navigate|Esc\s*to\s*cancel/i;
+var CHECKBOX_HEADER_RE = /☐/;
+var HIGHLIGHTED_OPTION_RE = /❯\s*\d+\./;
+function parseInteractiveDialog(stripped) {
+  const lines = stripped.split(/[\r\n]+/).map((l) => l.trim()).filter(Boolean);
+  const options = [];
+  const questionParts = [];
+  let optionsStarted = false;
+  for (const line of lines) {
+    if (isTuiNoise(line)) continue;
+    if (INTERACTIVE_NAV_HINT_RE.test(line)) continue;
+    const m = NUMBERED_OPTION_RE.exec(line);
+    if (m) {
+      const label = m[2].trim();
+      if (label.length >= 2 && !/^\d+$/.test(label)) {
+        if (m.index > 0 && !optionsStarted) {
+          const prefix = line.slice(0, m.index).replace(/[─━═╌☐]+/g, " ").trim();
+          if (prefix.length > 0) questionParts.push(prefix);
+        }
+        optionsStarted = true;
+        options.push({ index: parseInt(m[1], 10), label });
+      }
+    } else if (!optionsStarted) {
+      if (!/^[❯>$%]\s*$/.test(line) && !/^[─━═╌]{4,}$/.test(line)) {
+        questionParts.push(line);
+      }
+    }
+  }
+  const minRequired = INTERACTIVE_NAV_HINT_RE.test(stripped) ? 1 : 2;
+  if (options.length < minRequired) return null;
+  return { question: questionParts.join(" ").trim(), options };
+}
+function getDialogConfidence(stripped) {
+  if (INTERACTIVE_NAV_HINT_RE.test(stripped)) return "high";
+  if (HIGHLIGHTED_OPTION_RE.test(stripped)) return "high";
+  if (CHECKBOX_HEADER_RE.test(stripped)) return "high";
+  return "low";
+}
+function isInteractiveDialog(stripped) {
+  if (PLAN_CONFIRM_RE.test(stripped)) return false;
+  if (PERMISSION_DIALOG_RE.test(stripped)) return false;
+  if (parseInteractiveDialog(stripped) !== null) return true;
+  if (INTERACTIVE_NAV_HINT_RE.test(stripped)) {
+    const lines = stripped.split(/[\r\n]+/).map((l) => l.trim()).filter(Boolean);
+    return lines.some((l) => !isTuiNoise(l) && NUMBERED_OPTION_RE.test(l));
+  }
+  return false;
+}
+function containsActiveWork(stripped) {
+  const lines = stripped.split(/[\r\n]+/).filter((l) => l.trim());
+  let inTipBlock = false;
+  return lines.some((line) => {
+    const t = line.trim();
+    if (t.length === 0) return false;
+    if (/Tip:/i.test(t)) {
+      inTipBlock = true;
+      return false;
+    }
+    if (inTipBlock) return false;
+    if (/ctrl\+o to expand/i.test(t)) return false;
+    if (/^⎿/.test(t)) return false;
+    if (/^[❯>$%]\s*$/.test(t) || /[❯>]\s*$/.test(t)) return false;
+    if (/^[│║┃]/.test(t) && /[│║┃]$/.test(t)) return false;
+    if (isTuiNoise(t)) return false;
+    return true;
+  });
+}
+function isTuiNoise(line) {
+  const t = line.replace(/\r/g, "").trim();
+  if (t.length === 0) return true;
+  if (SPINNER_RE.test(t)) return true;
+  if (t.length <= 4 && SPINNER_FRAGMENT_RE.test(t)) return true;
+  if (STATUS_BAR_RE.test(t)) return true;
+  if (THINKING_RE.test(t)) return true;
+  if (SEPARATOR_RE.test(t)) return true;
+  if (EFFORT_RE.test(t)) return true;
+  if (CLAUDE_STATUS_BAR_RE.test(t)) return true;
+  if (QUEUED_MSG_RE.test(t)) return true;
+  if (CURSOR_ARTIFACT_RE.test(t)) return true;
+  if (CURSOR_GENERATING_RE.test(t)) return true;
+  if (CURSOR_FOOTER_RE.test(t)) return true;
+  if (CURSOR_STATUS_RE.test(t)) return true;
+  if (CURSOR_MODEL_RE.test(t)) return true;
+  if (BOX_DRAWING_RE.test(t) && t.length > 1) return true;
+  if (STOP_HOOK_RE.test(t)) return true;
+  if (WORKED_SUMMARY_RE.test(t)) return true;
+  if (CLAUDE_BANNER_RE.test(t) && t.length > 1) return true;
+  if (CLAUDE_BANNER_INFO_RE.test(t)) return true;
+  return false;
+}
+var PtyRunner = class {
+  constructor(nvmNodeVersion, terminalManager, defaultAgentMode, phaseAgentMap, globalModel, idleDetectMs = 3e4) {
+    this.nvmNodeVersion = nvmNodeVersion;
+    this.terminalManager = terminalManager;
+    this.defaultAgentMode = defaultAgentMode;
+    this.phaseAgentMap = phaseAgentMap;
+    this.globalModel = globalModel;
+    this.idleDetectMs = idleDetectMs;
+  }
+  /** workDir → active session info (sessionId + current agent type) */
+  sessions = /* @__PURE__ */ new Map();
+  /** Sessions that were forcefully killed (via killByWorkDir/killAll). Checked by
+   *  detectCompletion's onExit handler to report failure instead of success. */
+  killedSessions = /* @__PURE__ */ new Set();
+  // ---- AIRunner interface ---------------------------------------------------
+  async run(options) {
+    if (isShuttingDown()) {
+      logger3.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 });
+    const { sessionId, isNew } = this.ensureSession(workDir, agentMode, startMode);
+    if (isNew) {
+      logger3.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 });
+      await this.waitForPrompt(sessionId, 3e4);
+    } else {
+      logger3.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 });
+      const result2 = await this.detectCompletion(sessionId, options, onStreamEvent);
+      logger3.info("PtyRunner continue-session completed", {
+        workDir,
+        agentMode,
+        phaseName,
+        timedOut: result2.timedOut,
+        outputLength: result2.output.length
+      });
+      return this.buildRunResult(result2, sessionId);
+    }
+    await this.ensurePlanMode(sessionId, agentMode, startMode === "plan", workDir);
+    await this.writeCommand(sessionId, "/clear", agentMode);
+    await new Promise((resolve) => setTimeout(resolve, 2e3));
+    const promptFile = this.writePromptFile(workDir, prompt);
+    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", {
+      workDir,
+      agentMode,
+      phaseName,
+      timedOut: result.timedOut,
+      outputLength: result.output.length
+    });
+    return this.buildRunResult(result, sessionId);
+  }
+  killAll() {
+    for (const [, info] of this.sessions) {
+      this.killedSessions.add(info.sessionId);
+      this.terminalManager.destroy(info.sessionId);
+    }
+    this.sessions.clear();
+    logger3.info("PtyRunner: all managed sessions destroyed");
+  }
+  killByWorkDir(targetWorkDir) {
+    const info = this.sessions.get(targetWorkDir);
+    if (!info) return 0;
+    this.killedSessions.add(info.sessionId);
+    this.terminalManager.destroy(info.sessionId);
+    this.sessions.delete(targetWorkDir);
+    return 1;
+  }
+  interruptByWorkDir(targetWorkDir) {
+    const info = this.sessions.get(targetWorkDir);
+    if (!info) return false;
+    const session = this.terminalManager.get(info.sessionId);
+    if (!session) {
+      this.sessions.delete(targetWorkDir);
+      return false;
+    }
+    this.terminalManager.write(info.sessionId, "");
+    logger3.info("Interrupted PTY session for retry", {
+      workDir: targetWorkDir,
+      sessionId: info.sessionId
+    });
+    return true;
+  }
+  // ---- Agent resolution ----------------------------------------------------
+  /** Get the Enter key sequence for the given agent mode */
+  getEnterKey(agentMode) {
+    const profile = getPtyProfile(agentMode);
+    return profile?.enterKey ?? "\r";
+  }
+  /**
+   * Write a command to the PTY and press Enter.
+   *
+   * Some agents (codebuddy) use input coalescing in their TUI: when text and
+   * Enter arrive in the same PTY write, the Enter is treated as a newline
+   * character (paste) instead of triggering message submission. For these
+   * agents (PtyProfile.separateEnter=true), text and Enter are sent in
+   * separate writes with a 150ms gap so the Enter key is recognized as
+   * a standalone key press.
+   */
+  async writeCommand(sessionId, text, agentMode) {
+    const enterKey = this.getEnterKey(agentMode);
+    const profile = getPtyProfile(agentMode);
+    if (profile?.separateEnter) {
+      this.terminalManager.write(sessionId, text);
+      await new Promise((resolve) => setTimeout(resolve, 150));
+      this.terminalManager.write(sessionId, enterKey);
+    } else {
+      this.terminalManager.write(sessionId, text + enterKey);
+    }
+  }
+  /** Resolve agent mode for a given phase (fallback to default) */
+  resolveAgentForPhase(phaseName) {
+    if (phaseName && this.phaseAgentMap[phaseName]) {
+      return this.phaseAgentMap[phaseName];
+    }
+    return this.defaultAgentMode;
+  }
+  /** Look up PtyProfile from registry + resolve agent-specific binary and model */
+  resolveProfileAndModel(agentMode) {
+    const profile = getPtyProfile(agentMode);
+    if (!profile) {
+      throw new Error(
+        `Agent "${agentMode}" has no PtyProfile \u2014 not supported in PTY mode. Compatible agents: claude-internal, codebuddy, cursor-agent`
+      );
+    }
+    const entry = getRegistryEntry(agentMode);
+    const binary = entry && process.env[entry.binaryEnvKey] || entry?.defaultBinary || agentMode;
+    const model = this.globalModel ? resolveModelForRunner(agentMode, this.globalModel) : void 0;
+    return { profile, model, binary };
+  }
+  // ---- Session management ---------------------------------------------------
+  ensureSession(workDir, agentMode, startMode) {
+    const existing = this.sessions.get(workDir);
+    if (existing && existing.agentMode !== agentMode) {
+      logger3.info("Agent switched, destroying old PTY session", {
+        workDir,
+        oldAgent: existing.agentMode,
+        newAgent: agentMode,
+        sessionId: existing.sessionId
+      });
+      this.terminalManager.destroy(existing.sessionId);
+      this.sessions.delete(workDir);
+    }
+    if (existing && existing.agentMode === agentMode) {
+      if (this.terminalManager.get(existing.sessionId)) {
+        logger3.info("Reusing existing PTY session (same agent)", {
+          workDir,
+          agentMode,
+          sessionId: existing.sessionId
+        });
+        return { sessionId: existing.sessionId, isNew: false };
+      }
+      this.sessions.delete(workDir);
+    }
+    const orphan = this.terminalManager.findByWorkDir(workDir);
+    if (orphan) {
+      logger3.info("Destroying orphaned PTY session on workDir", {
+        workDir,
+        sessionId: orphan.id
+      });
+      this.terminalManager.destroy(orphan.id);
+    }
+    const { profile, model, binary } = this.resolveProfileAndModel(agentMode);
+    const args = profile.buildPtyArgs({ model, startMode });
+    const issueIid = extractIidFromPath(workDir);
+    const info = this.terminalManager.create({
+      workDir,
+      issueIid,
+      command: binary,
+      args,
+      managed: true
+    });
+    this.sessions.set(workDir, {
+      sessionId: info.id,
+      agentMode,
+      // Always set initial mode to defaultModeName — CLI args always use bypass
+      // (startMode is applied at runtime via Shift+Tab in ensurePlanMode).
+      currentMode: profile.defaultModeName ?? "bypass",
+      startedWithMode: startMode
+    });
+    logger3.info("Created new PTY session", {
+      workDir,
+      agentMode,
+      binary,
+      args,
+      sessionId: info.id,
+      pid: info.pid,
+      issueIid
+    });
+    return { sessionId: info.id, isNew: true };
+  }
+  // ---- Prompt delivery ------------------------------------------------------
+  /**
+   * Wait for the AI agent to show its idle prompt (❯ or >), indicating
+   * it is ready to accept input. Used before sending /clear and instructions
+   * to prevent commands from arriving before the agent is initialized.
+   */
+  waitForPrompt(sessionId, timeoutMs = 6e4) {
+    return new Promise((resolve) => {
+      let promptSeen = false;
+      let trustDialogHandled = false;
+      let stabilityTimer;
+      const STABILITY_MS = 3e3;
+      const TUI_READY_RE = /bypass\s*permissions|shift\+?\s*tab\s*to\s*cycle/i;
+      let tuiReady = false;
+      let bannerSeen = false;
+      let silenceTimer;
+      const SILENCE_READY_MS = 8e3;
+      const timer = setTimeout(() => {
+        if (stabilityTimer) clearTimeout(stabilityTimer);
+        if (silenceTimer) clearTimeout(silenceTimer);
+        subscription.dispose();
+        logger3.warn("Timed out waiting for AI agent prompt", { sessionId, timeoutMs });
+        resolve();
+      }, timeoutMs);
+      const done = (reason) => {
+        clearTimeout(timer);
+        if (stabilityTimer) clearTimeout(stabilityTimer);
+        if (silenceTimer) clearTimeout(silenceTimer);
+        subscription.dispose();
+        logger3.info("AI agent prompt detected", { sessionId, reason });
+        resolve();
+      };
+      const resetSilenceTimer = () => {
+        if (!bannerSeen) return;
+        if (silenceTimer) clearTimeout(silenceTimer);
+        silenceTimer = setTimeout(() => {
+          if (promptSeen) return;
+          logger3.info("Banner shown and PTY silent \u2014 treating agent as ready", { sessionId });
+          done("silence-after-banner");
+        }, SILENCE_READY_MS);
+      };
+      const subscription = this.terminalManager.onData(sessionId, (data) => {
+        const stripped = stripAnsi(data);
+        const nonEmptyLines = stripped.split("\n").filter((l) => l.trim());
+        const isNoise = nonEmptyLines.length === 0 || nonEmptyLines.every((l) => isTuiNoise(l));
+        if (!bannerSeen && /Claude\s*Code/i.test(stripped)) {
+          bannerSeen = true;
+        }
+        resetSilenceTimer();
+        if (!trustDialogHandled && TRUST_DIALOG_RE.test(stripped)) {
+          trustDialogHandled = true;
+          logger3.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 });
+          setTimeout(() => this.terminalManager.write(sessionId, "\r"), 500);
+        }
+        if (isIdlePrompt(stripped)) {
+          promptSeen = true;
+        }
+        if (!tuiReady && TUI_READY_RE.test(stripped)) {
+          tuiReady = true;
+        }
+        if (promptSeen || tuiReady) {
+          if (stabilityTimer && isNoise) {
+          } else {
+            if (stabilityTimer) clearTimeout(stabilityTimer);
+            const reason = promptSeen ? "idle-prompt-stable" : "status-bar-ready";
+            stabilityTimer = setTimeout(() => done(reason), STABILITY_MS);
+          }
+        }
+      });
+    });
+  }
+  // ---- Interactive mode switching --------------------------------------------
+  /**
+   * Switch the PTY session to (or away from) plan mode by pressing the mode
+   * cycle key (Shift+Tab) until the target mode is detected in the output.
+   *
+   * This is a no-op when the agent has no modeCycleKey configured, or the
+   * session is already in the desired mode.
+   */
+  async ensurePlanMode(sessionId, agentMode, wantPlan, workDir) {
+    const profile = getPtyProfile(agentMode);
+    if (!profile?.modeCycleKey || !profile.detectMode || !profile.planModeName) return;
+    const session = this.sessions.get(workDir);
+    if (!session) return;
+    const targetMode = wantPlan ? profile.planModeName : profile.defaultModeName ?? "bypass";
+    if (session.currentMode === targetMode) {
+      logger3.info("PTY already in target mode", { sessionId, targetMode });
+      return;
+    }
+    const MAX_ATTEMPTS = 5;
+    for (let i = 0; i < MAX_ATTEMPTS; i++) {
+      const outputPromise = this.collectRecentOutput(sessionId, 3e3);
+      this.terminalManager.write(sessionId, profile.modeCycleKey);
+      const recentOutput = await outputPromise;
+      const detected = profile.detectMode(recentOutput);
+      if (detected) {
+        session.currentMode = detected;
+        if (detected === targetMode) {
+          logger3.info("PTY mode switched", {
+            sessionId,
+            agentMode,
+            targetMode,
+            attempts: i + 1
+          });
+          return;
+        }
+      }
+    }
+    logger3.warn("Failed to switch PTY mode after max attempts", {
+      sessionId,
+      agentMode,
+      targetMode,
+      current: session.currentMode
+    });
+  }
+  /**
+   * Briefly subscribe to PTY output and collect all data emitted during a
+   * window. Used by ensurePlanMode to read the mode indicator after pressing
+   * the cycle key.
+   */
+  collectRecentOutput(sessionId, durationMs) {
+    return new Promise((resolve) => {
+      const chunks = [];
+      const subscription = this.terminalManager.onData(sessionId, (data) => {
+        chunks.push(stripAnsi(data));
+      });
+      setTimeout(() => {
+        subscription.dispose();
+        resolve(chunks.join(""));
+      }, durationMs);
+    });
+  }
+  // ---- Native plan mode (two-phase execution) --------------------------------
+  /**
+   * Whether the agent supports the two-phase native plan strategy:
+   *   bypass start → Shift+Tab to plan → execute → Shift+Tab to bypass → commit file.
+   *
+   * Conditions: runner does NOT natively handle plan mode on its own (nativePlanMode=false)
+   * AND the PTY profile supports interactive mode switching (modeCycleKey + planModeName).
+   */
+  shouldUseNativePlan(agentMode) {
+    const caps = getRunnerCapabilities(agentMode);
+    const profile = getPtyProfile(agentMode);
+    return !caps?.nativePlanMode && !!profile?.modeCycleKey && !!profile?.planModeName;
+  }
+  /**
+   * Two-phase plan execution:
+   *   Phase 1 — Switch to plan mode, send plan prompt, wait for idle (no artifact gate).
+   *   Phase 2 — Deterministic copy: resolve plan file from CLI-native storage
+   *             (~/.claude/plans/) and copy it to the expected artifact path.
+   *
+   * Phase 2 was previously prompt-driven ("ask agent to write file"), which was
+   * unreliable because /clear wiped the agent's context. Now it uses PlanFileResolver
+   * to find the plan file by snapshot diffing + content validation.
+   */
+  async runNativePlanMode(sessionId, isNew, options, agentMode, workDir) {
+    const continueSession = options.continueSession && !isNew;
+    const resolver = PlanFileResolver.forRunner(agentMode);
+    resolver.takeBeforeSnapshot();
+    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 });
+    } else {
+      logger3.info("Native plan mode: switching to plan", { sessionId, agentMode });
+      await this.ensurePlanMode(sessionId, agentMode, true, workDir);
+      if (!isNew) {
+        await this.writeCommand(sessionId, "/clear", agentMode);
+        await new Promise((resolve) => setTimeout(resolve, 2e3));
+      }
+      const promptFile = this.writePromptFile(workDir, options.prompt);
+      await this.writeCommand(
+        sessionId,
+        `Please read and follow all instructions in ${promptFile}`,
+        agentMode
+      );
+    }
+    const planArtifactCheck = () => resolver.hasNewOrModifiedFiles();
+    const planResult = await this.detectCompletion(sessionId, {
+      ...options,
+      completionSignal: PLAN_CONFIRM_RE,
+      artifactCheck: planArtifactCheck
+    }, options.onStreamEvent, continueSession);
+    if (planResult.timedOut) {
+      logger3.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
+        });
+      }
+    } else {
+      logger3.warn("Native plan mode: no artifactPaths specified, plan file not copied", {
+        sessionId,
+        resolvedFile: resolved.sourcePath
+      });
+    }
+    logger3.info("Native plan mode completed (deterministic copy)", {
+      sessionId,
+      planSource: path2.basename(resolved.sourcePath),
+      artifactsCopied: artifactPaths.length
+    });
+    return this.buildRunResult(planResult, sessionId);
+  }
+  /** Map detectCompletion result to RunResult. */
+  buildRunResult(detectResult, sessionId) {
+    return {
+      success: !detectResult.timedOut,
+      output: detectResult.output,
+      errorMessage: detectResult.timedOut ? detectResult.timeoutType === "idle" ? "AI \u957F\u65F6\u95F4\u65E0\u54CD\u5E94\uFF0C\u5DF2\u8D85\u65F6\u7EC8\u6B62" : "\u6267\u884C\u8D85\u65F6" : void 0,
+      sessionId,
+      exitCode: detectResult.timedOut ? null : 0,
+      timeoutType: detectResult.timeoutType,
+      wasActiveAtTimeout: detectResult.wasActiveAtTimeout
+    };
+  }
+  writePromptFile(workDir, prompt) {
+    const dir = path2.join(workDir, ".claude-plan");
+    if (!fs2.existsSync(dir)) {
+      fs2.mkdirSync(dir, { recursive: true });
+    }
+    const relPath = ".claude-plan/.phase-prompt.md";
+    const absPath = path2.join(workDir, relPath);
+    fs2.writeFileSync(absPath, prompt, "utf-8");
+    return relPath;
+  }
+  // ---- Completion detection -------------------------------------------------
+  detectCompletion(sessionId, options, onStreamEvent, skipEchoDetection) {
+    return new Promise((resolve) => {
+      const outputLines = [];
+      let lastOutputTime = Date.now();
+      let hasSubstantiveOutput = false;
+      let echoConsumed = skipEchoDetection ?? false;
+      let resolved = false;
+      let debounceTimer;
+      const DIALOG_BUFFER_MAX = 40;
+      const dialogBuffer = [];
+      let dialogHandled = false;
+      const DIALOG_QUIESCE_MS = 2500;
+      let dialogQuiesceTimer;
+      let pendingDialogParsed = null;
+      const idleTimeoutMs = options.idleTimeoutMs ?? 6e5;
+      const timeoutMs = options.timeoutMs;
+      const GRACE_WINDOW_MS = options.timeoutGraceMs ?? 6e4;
+      const EXTENSION_MS = options.timeoutExtensionMs ?? 6e5;
+      const MAX_EXTENSIONS = options.timeoutMaxExtensions ?? 3;
+      let extensions = 0;
+      const finish = (result) => {
+        if (resolved) return;
+        resolved = true;
+        cleanup();
+        resolve(result);
+      };
+      const scheduleWallTimer = (delayMs) => {
+        return setTimeout(() => {
+          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)", {
+              sessionId,
+              extensions,
+              maxExtensions: MAX_EXTENSIONS,
+              lastOutputAgoMs: recentMs
+            });
+            wallTimer = scheduleWallTimer(EXTENSION_MS);
+            return;
+          }
+          finish({
+            output: outputLines.join(""),
+            timedOut: true,
+            timeoutType: "wall-clock",
+            wasActiveAtTimeout: isActive
+          });
+        }, delayMs);
+      };
+      let wallTimer = scheduleWallTimer(timeoutMs);
+      const idleCheck = setInterval(() => {
+        if (!hasSubstantiveOutput) return;
+        if (Date.now() - lastOutputTime >= idleTimeoutMs) {
+          finish({
+            output: outputLines.join(""),
+            timedOut: true,
+            timeoutType: "idle",
+            wasActiveAtTimeout: false
+          });
+        }
+      }, 5e3);
+      const subscription = this.terminalManager.onData(sessionId, (data) => {
+        if (resolved) return;
+        const stripped = stripAnsi(data);
+        const nonEmptyLines = stripped.split("\n").filter((l) => l.trim());
+        const isNoise = nonEmptyLines.length === 0 || nonEmptyLines.every((l) => isTuiNoise(l));
+        const isIdle = isIdlePrompt(stripped);
+        const isMixedFrame = isIdle && containsActiveWork(stripped);
+        const hasRealContent = !isNoise && stripped.trim().length > 0;
+        if (hasRealContent && (!isIdle || isMixedFrame)) {
+          lastOutputTime = Date.now();
+          if (dialogQuiesceTimer) {
+            clearTimeout(dialogQuiesceTimer);
+            dialogQuiesceTimer = void 0;
+            pendingDialogParsed = null;
+            logger3.info("Dialog quiesce cancelled \u2014 new substantive output arrived", { sessionId });
+          }
+        }
+        if (!echoConsumed && stripped.includes(".phase-prompt.md")) {
+          echoConsumed = true;
+          return;
+        }
+        if (QUEUED_MSG_RE.test(stripped)) {
+          return;
+        }
+        if (options.completionSignal && hasSubstantiveOutput && options.completionSignal.test(stripped)) {
+          logger3.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 });
+            finish({ output: outputLines.join(""), timedOut: false });
+            return;
+          }
+          logger3.info("Session summary detected but artifacts not ready, continuing", { sessionId });
+        }
+        if (PERMISSION_DIALOG_RE.test(stripped)) {
+          logger3.info("Permission dialog detected, auto-confirming", { sessionId });
+          setTimeout(() => {
+            if (!resolved) this.terminalManager.write(sessionId, "\r");
+          }, 500);
+          return;
+        }
+        if (options.onInputRequired && !dialogHandled && isInteractiveDialog(stripped)) {
+          const parsed = parseInteractiveDialog(stripped);
+          if (parsed) {
+            const confidence = getDialogConfidence(stripped);
+            if (confidence === "high") {
+              dialogHandled = true;
+              dialogBuffer.length = 0;
+              if (dialogQuiesceTimer) {
+                clearTimeout(dialogQuiesceTimer);
+                dialogQuiesceTimer = void 0;
+              }
+              logger3.info("Interactive dialog detected (high confidence), forwarding to handler", {
+                sessionId,
+                question: parsed.question.slice(0, 80),
+                optionCount: parsed.options.length
+              });
+              options.onInputRequired({
+                type: "interactive-dialog",
+                content: parsed.question,
+                options: parsed.options
+              }).then((response) => {
+                dialogHandled = false;
+                if (!resolved && response) {
+                  this.terminalManager.write(sessionId, response + "\r");
+                }
+              }).catch((err) => {
+                logger3.warn("onInputRequired callback failed for interactive dialog", {
+                  error: err.message
+                });
+                dialogHandled = false;
+              });
+              return;
+            }
+            if (!dialogQuiesceTimer) {
+              pendingDialogParsed = parsed;
+              logger3.info("Interactive dialog detected (low confidence), starting quiesce", {
+                sessionId,
+                question: parsed.question.slice(0, 80),
+                optionCount: parsed.options.length
+              });
+              dialogQuiesceTimer = setTimeout(() => {
+                dialogQuiesceTimer = void 0;
+                if (resolved || dialogHandled || !pendingDialogParsed) return;
+                dialogHandled = true;
+                dialogBuffer.length = 0;
+                const dp = pendingDialogParsed;
+                pendingDialogParsed = null;
+                logger3.info("Dialog quiesce elapsed \u2014 forwarding low-confidence dialog", {
+                  sessionId,
+                  question: dp.question.slice(0, 80)
+                });
+                options.onInputRequired({
+                  type: "interactive-dialog",
+                  content: dp.question,
+                  options: dp.options
+                }).then((response) => {
+                  dialogHandled = false;
+                  if (!resolved && response) {
+                    this.terminalManager.write(sessionId, response + "\r");
+                  }
+                }).catch((err) => {
+                  logger3.warn("onInputRequired callback failed (quiesced dialog)", {
+                    error: err.message
+                  });
+                  dialogHandled = false;
+                });
+              }, DIALOG_QUIESCE_MS);
+            }
+            return;
+          }
+        }
+        if (echoConsumed && !hasSubstantiveOutput && !isNoise && stripped.trim().length > 0) {
+          hasSubstantiveOutput = true;
+        }
+        outputLines.push(stripped);
+        if (onStreamEvent) {
+          for (const line of stripped.split("\n").filter((l) => l.trim())) {
+            if (!isTuiNoise(line)) {
+              onStreamEvent({
+                type: "raw",
+                content: line,
+                timestamp: (/* @__PURE__ */ new Date()).toISOString()
+              });
+            }
+          }
+        }
+        if (!dialogHandled && !isNoise) {
+          for (const line of stripped.split("\n").filter((l) => l.trim())) {
+            if (!isTuiNoise(line)) {
+              dialogBuffer.push(line);
+              if (dialogBuffer.length > DIALOG_BUFFER_MAX) dialogBuffer.shift();
+            }
+          }
+        }
+        if (hasSubstantiveOutput && isIdlePrompt(stripped)) {
+          if (isMixedFrame) {
+          } else if (options.completionSignal) {
+            logger3.debug("Idle prompt ignored (waiting for completionSignal)", { sessionId });
+          } else if (debounceTimer && isNoise) {
+          } else {
+            if (options.onInputRequired && !dialogHandled && dialogBuffer.length >= 2) {
+              const combined = dialogBuffer.join("\n");
+              if (isInteractiveDialog(combined)) {
+                const parsed = parseInteractiveDialog(combined);
+                if (parsed) {
+                  const bufConfidence = getDialogConfidence(combined);
+                  if (bufConfidence === "high") {
+                    dialogHandled = true;
+                    dialogBuffer.length = 0;
+                    if (dialogQuiesceTimer) {
+                      clearTimeout(dialogQuiesceTimer);
+                      dialogQuiesceTimer = void 0;
+                    }
+                    logger3.info("Interactive dialog detected via accumulated buffer (high confidence)", {
+                      sessionId,
+                      question: parsed.question.slice(0, 80),
+                      optionCount: parsed.options.length
+                    });
+                    options.onInputRequired({
+                      type: "interactive-dialog",
+                      content: parsed.question,
+                      options: parsed.options
+                    }).then((response) => {
+                      dialogHandled = false;
+                      if (!resolved && response) {
+                        this.terminalManager.write(sessionId, response + "\r");
+                      }
+                    }).catch((err) => {
+                      logger3.warn("onInputRequired callback failed (accumulated)", {
+                        error: err.message
+                      });
+                      dialogHandled = false;
+                    });
+                    return;
+                  }
+                  if (!dialogQuiesceTimer) {
+                    pendingDialogParsed = parsed;
+                    logger3.info("Dialog detected via buffer (low confidence), starting quiesce", {
+                      sessionId,
+                      question: parsed.question.slice(0, 80)
+                    });
+                    dialogQuiesceTimer = setTimeout(() => {
+                      dialogQuiesceTimer = void 0;
+                      if (resolved || dialogHandled || !pendingDialogParsed) return;
+                      dialogHandled = true;
+                      dialogBuffer.length = 0;
+                      const dp = pendingDialogParsed;
+                      pendingDialogParsed = null;
+                      logger3.info("Buffer dialog quiesce elapsed \u2014 forwarding", { sessionId });
+                      options.onInputRequired({
+                        type: "interactive-dialog",
+                        content: dp.question,
+                        options: dp.options
+                      }).then((response) => {
+                        dialogHandled = false;
+                        if (!resolved && response) {
+                          this.terminalManager.write(sessionId, response + "\r");
+                        }
+                      }).catch((err) => {
+                        logger3.warn("onInputRequired callback failed (buffer quiesced)", {
+                          error: err.message
+                        });
+                        dialogHandled = false;
+                      });
+                    }, DIALOG_QUIESCE_MS);
+                  }
+                }
+              }
+            }
+            if (debounceTimer) clearTimeout(debounceTimer);
+            const scheduleDebounce = () => {
+              debounceTimer = setTimeout(() => {
+                if (resolved) return;
+                const recentActivityMs = Date.now() - lastOutputTime;
+                if (recentActivityMs < 5e3) {
+                  scheduleDebounce();
+                  return;
+                }
+                const artifactReady = options.artifactCheck ? options.artifactCheck() : true;
+                if (!artifactReady) {
+                  logger3.info("Idle prompt detected but artifacts not ready, continuing to wait", {
+                    sessionId
+                  });
+                  scheduleDebounce();
+                  return;
+                }
+                finish({
+                  output: outputLines.join(""),
+                  timedOut: false,
+                  timeoutType: void 0
+                });
+              }, 5e3);
+            };
+            scheduleDebounce();
+          }
+        }
+      });
+      this.terminalManager.onExit(sessionId, (exitCode) => {
+        const wasKilled = this.killedSessions.delete(sessionId);
+        for (const [wd, info] of this.sessions) {
+          if (info.sessionId === sessionId) {
+            this.sessions.delete(wd);
+            break;
+          }
+        }
+        if (!resolved) {
+          logger3.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 });
+        }
+      });
+      const cleanup = () => {
+        clearTimeout(wallTimer);
+        clearInterval(idleCheck);
+        if (debounceTimer) clearTimeout(debounceTimer);
+        if (dialogQuiesceTimer) clearTimeout(dialogQuiesceTimer);
+        subscription.dispose();
+      };
+    });
+  }
+};
+
+export {
+  PlanFileResolver,
+  stripAnsi,
+  isIdlePrompt,
+  TRUST_DIALOG_RE,
+  PERMISSION_DIALOG_RE,
+  PLAN_CONFIRM_RE,
+  INTERACTIVE_NAV_HINT_RE,
+  parseInteractiveDialog,
+  getDialogConfidence,
+  isInteractiveDialog,
+  containsActiveWork,
+  isTuiNoise,
+  PtyRunner
+};
+//# sourceMappingURL=chunk-4XMYOXGZ.js.map