@xdevops/issue-auto-finish 1.0.86 → 1.0.87

package/dist/chunk-U6GWFTKA.js

@@ -0,0 +1,657 @@
+import {
+  getPtyProfile,
+  getRegistryEntry,
+  getRunnerCapabilities,
+  isShuttingDown,
+  resolveModelForRunner
+} from "./chunk-SAMTXC4A.js";
+import {
+  logger
+} from "./chunk-GF2RRYHB.js";
+
+// src/ai-runner/PtyRunner.ts
+import fs from "fs";
+import path from "path";
+var logger2 = 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 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;
+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 (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;
+  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()) {
+      logger2.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;
+    logger2.info("PtyRunner.run()", { workDir, timeoutMs, phaseName, agentMode });
+    const { sessionId, isNew } = this.ensureSession(workDir, agentMode, startMode);
+    if (isNew) {
+      logger2.info("Waiting for AI agent prompt (new session)", { sessionId, phaseName });
+      await this.waitForPrompt(sessionId, 3e5);
+    } else {
+      logger2.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);
+    }
+    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);
+    logger2.info("PtyRunner phase completed", {
+      workDir,
+      agentMode,
+      phaseName,
+      timedOut: result.timedOut,
+      outputLength: result.output.length
+    });
+    return {
+      success: !result.timedOut,
+      output: result.output,
+      errorMessage: result.timedOut ? result.timeoutType === "idle" ? "AI \u957F\u65F6\u95F4\u65E0\u54CD\u5E94\uFF0C\u5DF2\u8D85\u65F6\u7EC8\u6B62" : "\u6267\u884C\u8D85\u65F6" : void 0,
+      sessionId,
+      exitCode: result.timedOut ? null : 0,
+      timeoutType: result.timeoutType
+    };
+  }
+  killAll() {
+    for (const [, info] of this.sessions) {
+      this.killedSessions.add(info.sessionId);
+      this.terminalManager.destroy(info.sessionId);
+    }
+    this.sessions.clear();
+    logger2.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, "");
+    logger2.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) {
+      logger2.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)) {
+        logger2.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) {
+      logger2.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
+    });
+    logger2.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();
+        logger2.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();
+        logger2.info("AI agent prompt detected", { sessionId, reason });
+        resolve();
+      };
+      const resetSilenceTimer = () => {
+        if (!bannerSeen) return;
+        if (silenceTimer) clearTimeout(silenceTimer);
+        silenceTimer = setTimeout(() => {
+          if (promptSeen) return;
+          logger2.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;
+          logger2.info("Trust dialog detected, auto-confirming", { sessionId });
+          setTimeout(() => this.terminalManager.write(sessionId, "\r"), 500);
+        }
+        if (PERMISSION_DIALOG_RE.test(stripped)) {
+          logger2.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) {
+      logger2.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) {
+          logger2.info("PTY mode switched", {
+            sessionId,
+            agentMode,
+            targetMode,
+            attempts: i + 1
+          });
+          return;
+        }
+      }
+    }
+    logger2.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 — Switch to bypass, send commit prompt, wait for artifact file on disk.
+   */
+  async runNativePlanMode(sessionId, isNew, options, agentMode, workDir) {
+    logger2.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 planResult = await this.detectCompletion(sessionId, {
+      ...options,
+      artifactCheck: void 0
+    }, options.onStreamEvent);
+    if (planResult.timedOut) {
+      logger2.warn("Native plan mode: plan phase timed out", { sessionId });
+      return this.buildRunResult(planResult, sessionId);
+    }
+    logger2.info("Native plan mode: switching to bypass for commit", { sessionId });
+    await this.ensurePlanMode(sessionId, agentMode, false, workDir);
+    await this.writeCommand(sessionId, "/clear", agentMode);
+    await new Promise((resolve) => setTimeout(resolve, 2e3));
+    const commitPrompt = this.buildPlanCommitPrompt(options);
+    await this.writeCommand(sessionId, commitPrompt, agentMode);
+    const commitResult = await this.detectCompletion(
+      sessionId,
+      options,
+      options.onStreamEvent,
+      true
+    );
+    logger2.info("Native plan mode completed", {
+      sessionId,
+      timedOut: commitResult.timedOut
+    });
+    return this.buildRunResult(commitResult, sessionId);
+  }
+  /** Build the prompt that instructs the agent to write the plan to disk. */
+  buildPlanCommitPrompt(options) {
+    const paths = options.artifactPaths ?? [];
+    if (paths.length === 0) {
+      return "Write the implementation plan you just created to the project directory.";
+    }
+    const pathList = paths.map((p) => `- ${p}`).join("\n");
+    return "\u4F60\u521A\u624D\u5728\u89C4\u5212\u6A21\u5F0F\u4E0B\u5236\u5B9A\u4E86\u4E00\u4EFD\u5B9E\u65BD\u8BA1\u5212\u3002\u73B0\u5728\u8BF7\u5C06\u5B8C\u6574\u7684\u8BA1\u5212\u5185\u5BB9\u5199\u5165\u4EE5\u4E0B\u6587\u4EF6\uFF1A\n\n" + pathList + "\n\n\u8981\u6C42\uFF1A\n1. \u5C06\u4F60\u521A\u624D\u89C4\u5212\u7684\u5B8C\u6574\u5185\u5BB9\uFF08\u9700\u6C42\u5206\u6790\u3001\u7CFB\u7EDF\u8BBE\u8BA1\u3001\u5B9E\u65BD Todolist\uFF09\u5199\u5165\u4E0A\u8FF0\u6587\u4EF6\n2. \u4FDD\u6301 Markdown \u683C\u5F0F\n3. \u53EA\u5199\u5165\u6587\u4EF6\uFF0C\u4E0D\u8981\u4FEE\u6539\u4EFB\u4F55\u9879\u76EE\u4EE3\u7801";
+  }
+  /** 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
+    };
+  }
+  writePromptFile(workDir, prompt) {
+    const dir = path.join(workDir, ".claude-plan");
+    if (!fs.existsSync(dir)) {
+      fs.mkdirSync(dir, { recursive: true });
+    }
+    const relPath = ".claude-plan/.phase-prompt.md";
+    const absPath = path.join(workDir, relPath);
+    fs.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 idleTimeoutMs = options.idleTimeoutMs ?? 6e5;
+      const timeoutMs = options.timeoutMs;
+      const finish = (result) => {
+        if (resolved) return;
+        resolved = true;
+        cleanup();
+        resolve(result);
+      };
+      const wallTimer = setTimeout(() => {
+        finish({
+          output: outputLines.join(""),
+          timedOut: true,
+          timeoutType: "wall-clock"
+        });
+      }, timeoutMs);
+      const idleCheck = setInterval(() => {
+        if (!hasSubstantiveOutput) return;
+        if (Date.now() - lastOutputTime >= idleTimeoutMs) {
+          finish({
+            output: outputLines.join(""),
+            timedOut: true,
+            timeoutType: "idle"
+          });
+        }
+      }, 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 (!echoConsumed && stripped.includes(".phase-prompt.md")) {
+          echoConsumed = true;
+          return;
+        }
+        if (QUEUED_MSG_RE.test(stripped)) {
+          return;
+        }
+        if (PERMISSION_DIALOG_RE.test(stripped)) {
+          logger2.info("Permission dialog detected, auto-confirming", { sessionId });
+          setTimeout(() => {
+            if (!resolved) this.terminalManager.write(sessionId, "\r");
+          }, 500);
+          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 (hasSubstantiveOutput && isIdlePrompt(stripped)) {
+          if (isMixedFrame) {
+          } else if (debounceTimer && isNoise) {
+          } else {
+            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) {
+                  logger2.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) => {
+        if (!resolved) {
+          const wasKilled = this.killedSessions.delete(sessionId);
+          logger2.warn("PTY process exited during phase", { sessionId, exitCode, wasKilled });
+          for (const [wd, info] of this.sessions) {
+            if (info.sessionId === sessionId) {
+              this.sessions.delete(wd);
+              break;
+            }
+          }
+          finish({
+            output: outputLines.join(""),
+            timedOut: wasKilled,
+            timeoutType: wasKilled ? "wall-clock" : void 0
+          });
+        }
+      });
+      const cleanup = () => {
+        clearTimeout(wallTimer);
+        clearInterval(idleCheck);
+        if (debounceTimer) clearTimeout(debounceTimer);
+        subscription.dispose();
+      };
+    });
+  }
+};
+
+export {
+  stripAnsi,
+  isIdlePrompt,
+  TRUST_DIALOG_RE,
+  PERMISSION_DIALOG_RE,
+  containsActiveWork,
+  isTuiNoise,
+  PtyRunner
+};
+//# sourceMappingURL=chunk-U6GWFTKA.js.map