tmux-manager 0.1.0

package/dist/index.mjs

@@ -0,0 +1,1951 @@
+// src/ensure-tmux.ts
+import { execSync } from "child_process";
+var _checked = false;
+var _version;
+function ensureTmux(log) {
+  if (_checked && _version) {
+    return _version;
+  }
+  try {
+    const output = execSync("tmux -V", {
+      encoding: "utf-8",
+      timeout: 5e3,
+      stdio: ["pipe", "pipe", "pipe"]
+    }).trim();
+    const match = output.match(/tmux\s+([\w.\-]+)/);
+    _version = match?.[1] ?? output;
+    _checked = true;
+    log?.(`tmux ${_version} found`);
+    return _version;
+  } catch {
+    throw new Error(
+      "tmux is required but not found on PATH. Install it with: brew install tmux (macOS) or apt install tmux (Linux)"
+    );
+  }
+}
+function resetTmuxCheck() {
+  _checked = false;
+  _version = void 0;
+}
+
+// src/tmux-manager.ts
+import { EventEmitter as EventEmitter2 } from "events";
+
+// src/adapters/adapter-registry.ts
+import { AdapterRegistry } from "adapter-types";
+
+// src/tmux-session.ts
+import { EventEmitter } from "events";
+import { randomUUID } from "crypto";
+
+// src/logger.ts
+var consoleLogger = {
+  debug: (...args) => {
+    if (typeof args[0] === "string") {
+      console.debug(args[0], args[1]);
+    } else {
+      console.debug(args[1], args[0]);
+    }
+  },
+  info: (...args) => {
+    if (typeof args[0] === "string") {
+      console.info(args[0], args[1]);
+    } else {
+      console.info(args[1], args[0]);
+    }
+  },
+  warn: (...args) => {
+    if (typeof args[0] === "string") {
+      console.warn(args[0], args[1]);
+    } else {
+      console.warn(args[1], args[0]);
+    }
+  },
+  error: (...args) => {
+    if (typeof args[0] === "string") {
+      console.error(args[0], args[1]);
+    } else {
+      console.error(args[1], args[0]);
+    }
+  }
+};
+
+// src/tmux-transport.ts
+import { execSync as execSync2 } from "child_process";
+var TMUX_KEY_MAP = {
+  "enter": "Enter",
+  "return": "Enter",
+  "tab": "Tab",
+  "escape": "Escape",
+  "esc": "Escape",
+  "space": "Space",
+  "backspace": "BSpace",
+  "delete": "DC",
+  "insert": "IC",
+  "up": "Up",
+  "down": "Down",
+  "left": "Left",
+  "right": "Right",
+  "home": "Home",
+  "end": "End",
+  "pageup": "PageUp",
+  "pagedown": "PageDown",
+  "f1": "F1",
+  "f2": "F2",
+  "f3": "F3",
+  "f4": "F4",
+  "f5": "F5",
+  "f6": "F6",
+  "f7": "F7",
+  "f8": "F8",
+  "f9": "F9",
+  "f10": "F10",
+  "f11": "F11",
+  "f12": "F12",
+  // Ctrl keys map to tmux C- prefix
+  "ctrl+a": "C-a",
+  "ctrl+b": "C-b",
+  "ctrl+c": "C-c",
+  "ctrl+d": "C-d",
+  "ctrl+e": "C-e",
+  "ctrl+f": "C-f",
+  "ctrl+g": "C-g",
+  "ctrl+h": "C-h",
+  "ctrl+i": "C-i",
+  "ctrl+j": "C-j",
+  "ctrl+k": "C-k",
+  "ctrl+l": "C-l",
+  "ctrl+m": "C-m",
+  "ctrl+n": "C-n",
+  "ctrl+o": "C-o",
+  "ctrl+p": "C-p",
+  "ctrl+q": "C-q",
+  "ctrl+r": "C-r",
+  "ctrl+s": "C-s",
+  "ctrl+t": "C-t",
+  "ctrl+u": "C-u",
+  "ctrl+v": "C-v",
+  "ctrl+w": "C-w",
+  "ctrl+x": "C-x",
+  "ctrl+y": "C-y",
+  "ctrl+z": "C-z",
+  // Shift combinations
+  "shift+up": "S-Up",
+  "shift+down": "S-Down",
+  "shift+left": "S-Left",
+  "shift+right": "S-Right",
+  "shift+tab": "BTab"
+};
+var TmuxTransport = class {
+  pollingTimers = /* @__PURE__ */ new Map();
+  lastCapture = /* @__PURE__ */ new Map();
+  constructor() {
+  }
+  /**
+   * Spawn a new tmux session running the given command.
+   */
+  spawn(sessionName, options) {
+    ensureTmux();
+    const fullCommand = [options.command, ...options.args].join(" ");
+    const envExports = Object.entries(options.env).map(([k, v]) => `export ${k}=${this.shellEscape(v)}`).join("; ");
+    const shellCommand = envExports ? `${envExports}; exec ${fullCommand}` : `exec ${fullCommand}`;
+    execSync2(
+      `tmux new-session -d -s ${this.shellEscape(sessionName)} -x ${options.cols} -y ${options.rows} -c ${this.shellEscape(options.cwd)} ${this.shellEscape(shellCommand)}`,
+      { stdio: "pipe", timeout: 1e4 }
+    );
+    this.tmuxExec(`set-option -t ${this.shellEscape(sessionName)} history-limit ${options.historyLimit}`);
+    this.tmuxExec(`set-option -t ${this.shellEscape(sessionName)} remain-on-exit on`);
+  }
+  /**
+   * Check if a tmux session exists and is alive.
+   */
+  isAlive(sessionName) {
+    try {
+      execSync2(`tmux has-session -t ${this.shellEscape(sessionName)}`, {
+        stdio: "pipe",
+        timeout: 3e3
+      });
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  /**
+   * Kill a tmux session.
+   */
+  kill(sessionName) {
+    this.stopOutputStreaming(sessionName);
+    try {
+      this.tmuxExec(`kill-session -t ${this.shellEscape(sessionName)}`);
+    } catch {
+    }
+  }
+  /**
+   * Send a signal to the process in the tmux pane.
+   */
+  signal(sessionName, sig) {
+    try {
+      const pid = this.getPanePid(sessionName);
+      if (pid) {
+        const nodeSignal = sig === "SIGKILL" ? "-9" : sig === "SIGTERM" ? "-15" : `-${sig}`;
+        execSync2(`kill ${nodeSignal} ${pid}`, { stdio: "pipe", timeout: 3e3 });
+      }
+    } catch {
+    }
+  }
+  /**
+   * Send literal text to the tmux session (no key interpretation).
+   */
+  sendText(sessionName, text) {
+    this.tmuxExec(`send-keys -t ${this.shellEscape(sessionName)} -l ${this.shellEscape(text)}`);
+  }
+  /**
+   * Send a named key to the tmux session.
+   * Uses TMUX_KEY_MAP for translation from our key names.
+   */
+  sendKey(sessionName, key) {
+    const tmuxKey = TMUX_KEY_MAP[key.toLowerCase()];
+    if (tmuxKey) {
+      this.tmuxExec(`send-keys -t ${this.shellEscape(sessionName)} ${tmuxKey}`);
+    } else {
+      this.tmuxExec(`send-keys -t ${this.shellEscape(sessionName)} -l ${this.shellEscape(key)}`);
+    }
+  }
+  /**
+   * Capture the current pane content.
+   */
+  capturePane(sessionName, options = {}) {
+    const flags = ["-p"];
+    if (options.ansi) {
+      flags.push("-e");
+    }
+    if (options.scrollback !== void 0) {
+      flags.push(`-S -${options.scrollback}`);
+    }
+    try {
+      return execSync2(
+        `tmux capture-pane -t ${this.shellEscape(sessionName)} ${flags.join(" ")}`,
+        { encoding: "utf-8", timeout: 5e3, stdio: ["pipe", "pipe", "pipe"] }
+      );
+    } catch {
+      return "";
+    }
+  }
+  /**
+   * Start polling output from a tmux session via capture-pane.
+   * Polls at the given interval and calls the callback with new/changed content.
+   *
+   * Uses capture-pane with ANSI codes (-e) and scrollback for full fidelity.
+   * Compares against last capture to detect changes and emit only new data.
+   */
+  startOutputStreaming(sessionName, callback, pollIntervalMs = 100) {
+    this.lastCapture.set(sessionName, "");
+    const timer = setInterval(() => {
+      try {
+        const current = this.capturePane(sessionName, { ansi: true, scrollback: 500 });
+        const last = this.lastCapture.get(sessionName) || "";
+        if (current !== last) {
+          this.lastCapture.set(sessionName, current);
+          if (current.startsWith(last)) {
+            const newData = current.slice(last.length);
+            if (newData) callback(newData);
+          } else {
+            callback(current);
+          }
+        }
+      } catch {
+      }
+    }, pollIntervalMs);
+    this.pollingTimers.set(sessionName, timer);
+  }
+  /**
+   * Stop polling output from a tmux session.
+   */
+  stopOutputStreaming(sessionName) {
+    const timer = this.pollingTimers.get(sessionName);
+    if (timer) {
+      clearInterval(timer);
+      this.pollingTimers.delete(sessionName);
+    }
+    this.lastCapture.delete(sessionName);
+  }
+  /**
+   * Get the PID of the process running in the tmux pane.
+   */
+  getPanePid(sessionName) {
+    try {
+      const output = execSync2(
+        `tmux display-message -t ${this.shellEscape(sessionName)} -p '#{pane_pid}'`,
+        { encoding: "utf-8", timeout: 3e3, stdio: ["pipe", "pipe", "pipe"] }
+      ).trim();
+      const pid = parseInt(output, 10);
+      return isNaN(pid) ? void 0 : pid;
+    } catch {
+      return void 0;
+    }
+  }
+  /**
+   * Get the pane dimensions.
+   */
+  getPaneDimensions(sessionName) {
+    try {
+      const output = execSync2(
+        `tmux display-message -t ${this.shellEscape(sessionName)} -p '#{pane_width}x#{pane_height}'`,
+        { encoding: "utf-8", timeout: 3e3, stdio: ["pipe", "pipe", "pipe"] }
+      ).trim();
+      const [cols, rows] = output.split("x").map(Number);
+      return { cols: cols || 120, rows: rows || 40 };
+    } catch {
+      return { cols: 120, rows: 40 };
+    }
+  }
+  /**
+   * Resize a tmux session window.
+   */
+  resize(sessionName, cols, rows) {
+    try {
+      this.tmuxExec(`resize-window -t ${this.shellEscape(sessionName)} -x ${cols} -y ${rows}`);
+    } catch {
+    }
+  }
+  /**
+   * Check if the pane's process has exited.
+   * Uses remain-on-exit to detect dead panes.
+   */
+  isPaneAlive(sessionName) {
+    try {
+      const output = execSync2(
+        `tmux display-message -t ${this.shellEscape(sessionName)} -p '#{pane_dead}'`,
+        { encoding: "utf-8", timeout: 3e3, stdio: ["pipe", "pipe", "pipe"] }
+      ).trim();
+      return output !== "1";
+    } catch {
+      return false;
+    }
+  }
+  /**
+   * Get the exit status of a dead pane.
+   */
+  getPaneExitStatus(sessionName) {
+    try {
+      const output = execSync2(
+        `tmux display-message -t ${this.shellEscape(sessionName)} -p '#{pane_dead_status}'`,
+        { encoding: "utf-8", timeout: 3e3, stdio: ["pipe", "pipe", "pipe"] }
+      ).trim();
+      const code = parseInt(output, 10);
+      return isNaN(code) ? void 0 : code;
+    } catch {
+      return void 0;
+    }
+  }
+  /**
+   * List all tmux sessions matching a prefix.
+   */
+  static listSessions(prefix) {
+    try {
+      const output = execSync2(
+        `tmux list-sessions -F '#{session_name}|#{session_created}|#{session_attached}'`,
+        { encoding: "utf-8", timeout: 5e3, stdio: ["pipe", "pipe", "pipe"] }
+      ).trim();
+      if (!output) return [];
+      return output.split("\n").map((line) => {
+        const [name, created, attached] = line.split("|");
+        return { name, created, attached: attached === "1" };
+      }).filter((s) => !prefix || s.name.startsWith(prefix));
+    } catch {
+      return [];
+    }
+  }
+  /**
+   * Clean up resources.
+   */
+  destroy() {
+    for (const [, timer] of this.pollingTimers) {
+      clearInterval(timer);
+    }
+    this.pollingTimers.clear();
+    this.lastCapture.clear();
+  }
+  // ─────────────────────────────────────────────────────────────────────────────
+  // Private helpers
+  // ─────────────────────────────────────────────────────────────────────────────
+  tmuxExec(args) {
+    execSync2(`tmux ${args}`, { stdio: "pipe", timeout: 5e3 });
+  }
+  shellEscape(str) {
+    return `'${str.replace(/'/g, "'\\''")}'`;
+  }
+};
+
+// src/tmux-session.ts
+var SPECIAL_KEYS = {
+  // Control keys
+  "ctrl+a": "
",
+  "ctrl+b": "",
+  "ctrl+c": "",
+  "ctrl+d": "",
+  "ctrl+e": "",
+  "ctrl+f": "",
+  "ctrl+g": "\x07",
+  "ctrl+h": "\b",
+  "ctrl+i": "	",
+  "ctrl+j": "\n",
+  "ctrl+k": "\v",
+  "ctrl+l": "\f",
+  "ctrl+m": "\r",
+  "ctrl+n": "",
+  "ctrl+o": "",
+  "ctrl+p": "",
+  "ctrl+q": "",
+  "ctrl+r": "",
+  "ctrl+s": "",
+  "ctrl+t": "",
+  "ctrl+u": "",
+  "ctrl+v": "",
+  "ctrl+w": "",
+  "ctrl+x": "",
+  "ctrl+y": "",
+  "ctrl+z": "",
+  // Navigation
+  "up": "\x1B[A",
+  "down": "\x1B[B",
+  "right": "\x1B[C",
+  "left": "\x1B[D",
+  "home": "\x1B[H",
+  "end": "\x1B[F",
+  "pageup": "\x1B[5~",
+  "pagedown": "\x1B[6~",
+  // Editing
+  "enter": "\r",
+  "return": "\r",
+  "tab": "	",
+  "backspace": "\x7F",
+  "delete": "\x1B[3~",
+  "insert": "\x1B[2~",
+  "escape": "\x1B",
+  "esc": "\x1B",
+  "space": " ",
+  // Function keys
+  "f1": "\x1BOP",
+  "f2": "\x1BOQ",
+  "f3": "\x1BOR",
+  "f4": "\x1BOS",
+  "f5": "\x1B[15~",
+  "f6": "\x1B[17~",
+  "f7": "\x1B[18~",
+  "f8": "\x1B[19~",
+  "f9": "\x1B[20~",
+  "f10": "\x1B[21~",
+  "f11": "\x1B[23~",
+  "f12": "\x1B[24~"
+};
+function generateId() {
+  return `tmux-${Date.now()}-${randomUUID().slice(0, 8)}`;
+}
+var TmuxSession = class _TmuxSession extends EventEmitter {
+  constructor(adapter, config, logger, stallDetectionEnabled, defaultStallTimeoutMs, transport, sessionPrefix, historyLimit) {
+    super();
+    this.adapter = adapter;
+    this.id = config.id || generateId();
+    this.config = { ...config, id: this.id };
+    this.logger = logger || consoleLogger;
+    this._stallDetectionEnabled = stallDetectionEnabled ?? false;
+    this._stallTimeoutMs = config.stallTimeoutMs ?? defaultStallTimeoutMs ?? 8e3;
+    this._stallBackoffMs = this._stallTimeoutMs;
+    this.transport = transport || new TmuxTransport();
+    this.sessionPrefix = sessionPrefix || "parallax";
+    this.historyLimit = historyLimit || 5e4;
+    this.tmuxSessionName = `${this.sessionPrefix}-${this.id}`;
+    if (config.ruleOverrides) {
+      for (const [key, value] of Object.entries(config.ruleOverrides)) {
+        if (value === null) {
+          this._disabledRulePatterns.add(key);
+        } else {
+          this._ruleOverrides.set(key, value);
+        }
+      }
+    }
+  }
+  transport;
+  tmuxSessionName;
+  outputBuffer = "";
+  _status = "pending";
+  _startedAt = null;
+  _lastActivityAt = null;
+  messageCounter = 0;
+  logger;
+  sessionRules = [];
+  _firedOnceRules = /* @__PURE__ */ new Set();
+  _lastBlockingPromptHash = null;
+  _ruleOverrides = /* @__PURE__ */ new Map();
+  _disabledRulePatterns = /* @__PURE__ */ new Set();
+  // Stall detection
+  _stallTimer = null;
+  _stallTimeoutMs;
+  _stallDetectionEnabled;
+  _lastStallHash = null;
+  _stallStartedAt = null;
+  _lastContentHash = null;
+  _stallBackoffMs = 0;
+  static MAX_STALL_BACKOFF_MS = 3e4;
+  _stallEmissionCount = 0;
+  static MAX_STALL_EMISSIONS = 5;
+  // Task completion detection
+  _taskCompleteTimer = null;
+  _taskCompletePending = false;
+  static TASK_COMPLETE_DEBOUNCE_MS = 1500;
+  // Ready detection settle delay
+  _readySettleTimer = null;
+  _readySettlePending = false;
+  // Tool running deduplication
+  _lastToolRunningName = null;
+  // Output buffer cap
+  static MAX_OUTPUT_BUFFER = 1e5;
+  // Poll-based exit detection
+  _exitPollTimer = null;
+  // Session prefix for tmux session naming
+  sessionPrefix;
+  // History limit for tmux scrollback
+  historyLimit;
+  id;
+  config;
+  get status() {
+    return this._status;
+  }
+  get pid() {
+    return this.transport.getPanePid(this.tmuxSessionName);
+  }
+  get startedAt() {
+    return this._startedAt ?? void 0;
+  }
+  get lastActivityAt() {
+    return this._lastActivityAt ?? void 0;
+  }
+  /**
+   * Get the tmux session name (for reconnection/debugging).
+   */
+  get tmuxName() {
+    return this.tmuxSessionName;
+  }
+  // ─────────────────────────────────────────────────────────────────────────────
+  // Runtime Auto-Response Rules API
+  // ─────────────────────────────────────────────────────────────────────────────
+  addAutoResponseRule(rule) {
+    const existingIndex = this.sessionRules.findIndex(
+      (r) => r.pattern.source === rule.pattern.source && r.pattern.flags === rule.pattern.flags
+    );
+    if (existingIndex >= 0) {
+      this.sessionRules[existingIndex] = rule;
+    } else {
+      this.sessionRules.push(rule);
+    }
+  }
+  removeAutoResponseRule(pattern) {
+    const initialLength = this.sessionRules.length;
+    this.sessionRules = this.sessionRules.filter(
+      (r) => !(r.pattern.source === pattern.source && r.pattern.flags === pattern.flags)
+    );
+    return this.sessionRules.length < initialLength;
+  }
+  setAutoResponseRules(rules) {
+    this.sessionRules = [...rules];
+  }
+  getAutoResponseRules() {
+    return [...this.sessionRules];
+  }
+  clearAutoResponseRules() {
+    this.sessionRules = [];
+  }
+  // ─────────────────────────────────────────────────────────────────────────────
+  // Stall Detection
+  // ─────────────────────────────────────────────────────────────────────────────
+  resetStallTimer() {
+    if (!this._stallDetectionEnabled || this._status !== "busy" && this._status !== "authenticating") {
+      this.clearStallTimer();
+      return;
+    }
+    const stripped = this.stripAnsiForStall(this.outputBuffer).trim();
+    const tail = stripped.slice(-500);
+    const hash = this.simpleHash(tail);
+    if (hash === this._lastContentHash) {
+      return;
+    }
+    this._lastContentHash = hash;
+    this._stallEmissionCount = 0;
+    if (this._stallTimer) {
+      clearTimeout(this._stallTimer);
+      this._stallTimer = null;
+    }
+    this._stallStartedAt = Date.now();
+    this._lastStallHash = null;
+    this._stallBackoffMs = this._stallTimeoutMs;
+    this._stallTimer = setTimeout(() => {
+      this.onStallTimerFired();
+    }, this._stallTimeoutMs);
+  }
+  clearStallTimer() {
+    if (this._stallTimer) {
+      clearTimeout(this._stallTimer);
+      this._stallTimer = null;
+    }
+    this._stallStartedAt = null;
+    this._lastContentHash = null;
+    this._stallBackoffMs = this._stallTimeoutMs;
+    this._stallEmissionCount = 0;
+  }
+  onStallTimerFired() {
+    if (this._status !== "busy" && this._status !== "authenticating") {
+      return;
+    }
+    if (this._status === "busy" && this.adapter.detectTaskComplete?.(this.outputBuffer)) {
+      this._status = "ready";
+      this._lastBlockingPromptHash = null;
+      this.outputBuffer = "";
+      this.clearStallTimer();
+      this.emit("status_changed", "ready");
+      this.emit("task_complete");
+      this.logger.info({ sessionId: this.id }, "Task complete (adapter fast-path)");
+      return;
+    }
+    if (this.adapter.detectLoading?.(this.outputBuffer)) {
+      this._stallTimer = setTimeout(() => this.onStallTimerFired(), this._stallBackoffMs);
+      return;
+    }
+    const toolInfo = this.adapter.detectToolRunning?.(this.outputBuffer);
+    if (toolInfo) {
+      if (toolInfo.toolName !== this._lastToolRunningName) {
+        this._lastToolRunningName = toolInfo.toolName;
+        this.emit("tool_running", toolInfo);
+      }
+      this._stallTimer = setTimeout(() => this.onStallTimerFired(), this._stallBackoffMs);
+      return;
+    }
+    if (this._lastToolRunningName) {
+      this._lastToolRunningName = null;
+    }
+    const tail = this.outputBuffer.slice(-500);
+    const hash = this.simpleHash(tail);
+    if (hash === this._lastStallHash) {
+      this._stallTimer = setTimeout(() => this.onStallTimerFired(), this._stallBackoffMs);
+      return;
+    }
+    this._lastStallHash = hash;
+    this._stallEmissionCount++;
+    if (this._stallEmissionCount > _TmuxSession.MAX_STALL_EMISSIONS) {
+      this.logger.warn({ sessionId: this.id }, "Max stall emissions reached");
+      this.clearStallTimer();
+      return;
+    }
+    const recentRaw = this.outputBuffer.slice(-2e3);
+    const recentOutput = this.stripAnsiForClassifier(recentRaw).trim();
+    const stallDurationMs = this._stallStartedAt ? Date.now() - this._stallStartedAt : this._stallTimeoutMs;
+    this.emit("stall_detected", recentOutput, stallDurationMs);
+    this._stallTimer = setTimeout(() => this.onStallTimerFired(), this._stallBackoffMs);
+  }
+  handleStallClassification(classification) {
+    if (this._status !== "busy" && this._status !== "authenticating") {
+      return;
+    }
+    if (!classification || classification.state === "still_working") {
+      this._stallBackoffMs = Math.min(
+        this._stallBackoffMs * 2,
+        _TmuxSession.MAX_STALL_BACKOFF_MS
+      );
+      this._lastContentHash = null;
+      this._lastStallHash = null;
+      if (this._stallTimer) {
+        clearTimeout(this._stallTimer);
+        this._stallTimer = null;
+      }
+      this._stallTimer = setTimeout(() => this.onStallTimerFired(), this._stallBackoffMs);
+      return;
+    }
+    switch (classification.state) {
+      case "waiting_for_input": {
+        const promptInfo = {
+          type: "stall_classified",
+          prompt: classification.prompt,
+          canAutoRespond: !!classification.suggestedResponse
+        };
+        if (classification.suggestedResponse) {
+          const resp = classification.suggestedResponse;
+          if (resp.startsWith("keys:")) {
+            const keys = resp.slice(5).split(",").map((k) => k.trim());
+            this.sendKeySequence(keys);
+          } else {
+            this.transport.sendText(this.tmuxSessionName, resp);
+            this.transport.sendKey(this.tmuxSessionName, "enter");
+          }
+          this.outputBuffer = "";
+          this.emit("blocking_prompt", promptInfo, true);
+        } else {
+          this.emit("blocking_prompt", promptInfo, false);
+        }
+        break;
+      }
+      case "task_complete":
+        this._status = "ready";
+        this._lastBlockingPromptHash = null;
+        this.outputBuffer = "";
+        this.clearStallTimer();
+        this.emit("ready");
+        break;
+      case "error":
+        this.clearStallTimer();
+        this.emit("error", new Error(classification.prompt || "Stall classified as error"));
+        break;
+    }
+  }
+  // ─────────────────────────────────────────────────────────────────────────────
+  // Task Completion Detection
+  // ─────────────────────────────────────────────────────────────────────────────
+  scheduleTaskComplete() {
+    if (this._taskCompleteTimer) {
+      clearTimeout(this._taskCompleteTimer);
+    }
+    this._taskCompletePending = true;
+    this._taskCompleteTimer = setTimeout(() => {
+      this._taskCompleteTimer = null;
+      this._taskCompletePending = false;
+      const signal = this.isTaskCompleteSignal(this.outputBuffer);
+      if (this._status !== "busy") return;
+      if (!signal) return;
+      this._status = "ready";
+      this._lastBlockingPromptHash = null;
+      this.outputBuffer = "";
+      this.clearStallTimer();
+      this.emit("status_changed", "ready");
+      this.emit("task_complete");
+      this.logger.info({ sessionId: this.id }, "Task complete \u2014 agent returned to idle prompt");
+    }, _TmuxSession.TASK_COMPLETE_DEBOUNCE_MS);
+  }
+  isTaskCompleteSignal(output) {
+    if (this.adapter.detectTaskComplete) {
+      return this.adapter.detectTaskComplete(output);
+    }
+    return this.adapter.detectReady(output);
+  }
+  cancelTaskComplete() {
+    if (this._taskCompleteTimer) {
+      clearTimeout(this._taskCompleteTimer);
+      this._taskCompleteTimer = null;
+    }
+    this._taskCompletePending = false;
+  }
+  // ─────────────────────────────────────────────────────────────────────────────
+  // Ready Detection Settle Delay
+  // ─────────────────────────────────────────────────────────────────────────────
+  scheduleReadySettle() {
+    this._readySettlePending = true;
+    if (this._readySettleTimer) {
+      clearTimeout(this._readySettleTimer);
+    }
+    const settleMs = this.config.readySettleMs ?? this.adapter.readySettleMs ?? 100;
+    this._readySettleTimer = setTimeout(() => {
+      this._readySettleTimer = null;
+      this._readySettlePending = false;
+      if (this._status !== "starting" && this._status !== "authenticating") return;
+      if (!this.adapter.detectReady(this.outputBuffer)) return;
+      this._status = "ready";
+      this._lastBlockingPromptHash = null;
+      this.outputBuffer = "";
+      this.clearStallTimer();
+      this.emit("ready");
+      this.logger.info({ sessionId: this.id }, "Session ready (after settle)");
+    }, settleMs);
+  }
+  cancelReadySettle() {
+    if (this._readySettleTimer) {
+      clearTimeout(this._readySettleTimer);
+      this._readySettleTimer = null;
+    }
+    this._readySettlePending = false;
+  }
+  // ─────────────────────────────────────────────────────────────────────────────
+  // Lifecycle
+  // ─────────────────────────────────────────────────────────────────────────────
+  async start() {
+    this._status = "starting";
+    this._startedAt = /* @__PURE__ */ new Date();
+    const command = this.adapter.getCommand();
+    const args = this.adapter.getArgs(this.config);
+    const adapterEnv = this.adapter.getEnv(this.config);
+    const env = _TmuxSession.buildSpawnEnv(this.config, adapterEnv);
+    this.logger.info(
+      { sessionId: this.id, command, args: args.join(" "), tmuxSession: this.tmuxSessionName },
+      "Starting tmux session"
+    );
+    try {
+      this.transport.spawn(this.tmuxSessionName, {
+        command,
+        args,
+        cwd: this.config.workdir || process.cwd(),
+        env,
+        cols: this.config.cols || 120,
+        rows: this.config.rows || 40,
+        historyLimit: this.historyLimit
+      });
+      this.transport.startOutputStreaming(this.tmuxSessionName, (data) => {
+        this._lastActivityAt = /* @__PURE__ */ new Date();
+        this.outputBuffer += data;
+        if (this.outputBuffer.length > _TmuxSession.MAX_OUTPUT_BUFFER) {
+          this.outputBuffer = this.outputBuffer.slice(-_TmuxSession.MAX_OUTPUT_BUFFER);
+        }
+        this.emit("output", data);
+        this.processOutputBuffer();
+      });
+      this._exitPollTimer = setInterval(() => {
+        if (!this.transport.isPaneAlive(this.tmuxSessionName)) {
+          const exitCode = this.transport.getPaneExitStatus(this.tmuxSessionName) ?? 0;
+          this.handleExit(exitCode);
+        }
+      }, 1e3);
+      this.logger.info(
+        { sessionId: this.id, pid: this.pid, tmuxSession: this.tmuxSessionName },
+        "Tmux session started"
+      );
+    } catch (error) {
+      this._status = "error";
+      this.logger.error({ sessionId: this.id, error }, "Failed to start tmux session");
+      throw error;
+    }
+  }
+  /**
+   * Reconnect to an existing tmux session.
+   * Used for crash recovery.
+   */
+  async reconnect(existingTmuxName) {
+    if (!this.transport.isAlive(existingTmuxName)) {
+      throw new Error(`Tmux session ${existingTmuxName} does not exist`);
+    }
+    this.tmuxSessionName = existingTmuxName;
+    this._status = "starting";
+    this._startedAt = /* @__PURE__ */ new Date();
+    this.transport.startOutputStreaming(this.tmuxSessionName, (data) => {
+      this._lastActivityAt = /* @__PURE__ */ new Date();
+      this.outputBuffer += data;
+      if (this.outputBuffer.length > _TmuxSession.MAX_OUTPUT_BUFFER) {
+        this.outputBuffer = this.outputBuffer.slice(-_TmuxSession.MAX_OUTPUT_BUFFER);
+      }
+      this.emit("output", data);
+      this.processOutputBuffer();
+    });
+    const currentContent = this.transport.capturePane(this.tmuxSessionName, { ansi: true });
+    if (currentContent) {
+      this.outputBuffer = currentContent;
+      this.processOutputBuffer();
+    }
+    this._exitPollTimer = setInterval(() => {
+      if (!this.transport.isPaneAlive(this.tmuxSessionName)) {
+        const exitCode = this.transport.getPaneExitStatus(this.tmuxSessionName) ?? 0;
+        this.handleExit(exitCode);
+      }
+    }, 1e3);
+    this.logger.info(
+      { sessionId: this.id, tmuxSession: this.tmuxSessionName },
+      "Reconnected to tmux session"
+    );
+  }
+  handleExit(exitCode) {
+    if (this._status === "stopped" || this._status === "stopping") return;
+    this._status = "stopped";
+    this.clearStallTimer();
+    this.cancelTaskComplete();
+    this.cancelReadySettle();
+    this.stopExitPolling();
+    this.transport.stopOutputStreaming(this.tmuxSessionName);
+    this.logger.info({ sessionId: this.id, exitCode }, "Tmux session exited");
+    this.emit("exit", exitCode);
+  }
+  stopExitPolling() {
+    if (this._exitPollTimer) {
+      clearInterval(this._exitPollTimer);
+      this._exitPollTimer = null;
+    }
+  }
+  // ─────────────────────────────────────────────────────────────────────────────
+  // Output Processing
+  // ─────────────────────────────────────────────────────────────────────────────
+  processOutputBuffer() {
+    if (this._status === "busy" || this._status === "authenticating") {
+      this.resetStallTimer();
+    }
+    if (this._readySettlePending) {
+      if ((this._status === "starting" || this._status === "authenticating") && this.adapter.detectReady(this.outputBuffer)) {
+        this.scheduleReadySettle();
+      } else {
+        this.cancelReadySettle();
+      }
+      return;
+    }
+    if ((this._status === "starting" || this._status === "authenticating") && this.adapter.detectReady(this.outputBuffer)) {
+      this.scheduleReadySettle();
+      return;
+    }
+    if (this._status === "busy") {
+      const toolInfo = this.adapter.detectToolRunning?.(this.outputBuffer);
+      if (toolInfo) {
+        if (toolInfo.toolName !== this._lastToolRunningName) {
+          this._lastToolRunningName = toolInfo.toolName;
+          this.emit("tool_running", toolInfo);
+        }
+      } else if (this._lastToolRunningName) {
+        this._lastToolRunningName = null;
+      }
+    }
+    if (this._status === "busy") {
+      const signal = this.isTaskCompleteSignal(this.outputBuffer);
+      if (this._taskCompletePending || signal) {
+        this.scheduleTaskComplete();
+      }
+    }
+    if (this._status !== "stopping" && this._status !== "stopped") {
+      const blockingPrompt = this.detectAndHandleBlockingPrompt();
+      if (blockingPrompt) return;
+    }
+    if (this._status !== "ready" && this._status !== "busy") {
+      const loginDetection = this.adapter.detectLogin(this.outputBuffer);
+      if (loginDetection.required && this._status !== "authenticating") {
+        this._status = "authenticating";
+        this.clearStallTimer();
+        this.emitAuthRequired({
+          type: loginDetection.type,
+          url: loginDetection.url,
+          deviceCode: loginDetection.deviceCode,
+          instructions: loginDetection.instructions
+        });
+        return;
+      }
+    }
+    const exitDetection = this.adapter.detectExit(this.outputBuffer);
+    if (exitDetection.exited) {
+      this._status = "stopped";
+      this.clearStallTimer();
+      this.emit("exit", exitDetection.code || 0);
+    }
+    if (this._status === "ready") {
+      this.tryParseOutput();
+    }
+  }
+  // ─────────────────────────────────────────────────────────────────────────────
+  // Blocking Prompt Detection & Auto-Response
+  // ─────────────────────────────────────────────────────────────────────────────
+  detectAndHandleBlockingPrompt() {
+    const autoHandled = this.tryAutoResponse();
+    if (autoHandled) return true;
+    if (this.adapter.detectBlockingPrompt) {
+      const detection = this.adapter.detectBlockingPrompt(this.outputBuffer);
+      if (detection.detected) {
+        const normalizedPrompt = (detection.prompt || "").replace(/\s+/g, " ").replace(/\d+/g, "#").trim().slice(0, 100);
+        const promptHash = `${detection.type}:${normalizedPrompt}`;
+        if (promptHash === this._lastBlockingPromptHash) return true;
+        this._lastBlockingPromptHash = promptHash;
+        const promptInfo = {
+          type: detection.type || "unknown",
+          prompt: detection.prompt,
+          options: detection.options,
+          canAutoRespond: detection.canAutoRespond || false,
+          instructions: detection.instructions,
+          url: detection.url
+        };
+        if (detection.canAutoRespond && detection.suggestedResponse && !this.config.skipAdapterAutoResponse) {
+          const resp = detection.suggestedResponse;
+          if (resp.startsWith("keys:")) {
+            const keys = resp.slice(5).split(",").map((k) => k.trim());
+            this.sendKeySequence(keys);
+          } else {
+            this.transport.sendText(this.tmuxSessionName, resp);
+            this.transport.sendKey(this.tmuxSessionName, "enter");
+          }
+          this.outputBuffer = "";
+          this.emit("blocking_prompt", promptInfo, true);
+          return true;
+        }
+        if (detection.type === "login") {
+          this._status = "authenticating";
+          const inferred = this.adapter.detectLogin(this.outputBuffer);
+          this.emitAuthRequired({
+            type: inferred.required ? inferred.type : void 0,
+            url: detection.url ?? inferred.url,
+            deviceCode: inferred.required ? inferred.deviceCode : void 0,
+            instructions: detection.instructions ?? inferred.instructions
+          });
+        }
+        this.emit("blocking_prompt", promptInfo, false);
+        return true;
+      } else {
+        this._lastBlockingPromptHash = null;
+      }
+    }
+    return false;
+  }
+  tryAutoResponse() {
+    const adapterRules = (this.adapter.autoResponseRules || []).filter((r) => !this._disabledRulePatterns.has(r.pattern.source)).map((r) => {
+      const override = this._ruleOverrides.get(r.pattern.source);
+      return override ? { ...r, ...override } : r;
+    });
+    const allRules = [...this.sessionRules, ...adapterRules];
+    if (allRules.length === 0) return false;
+    const stripped = this.stripAnsiForStall(this.outputBuffer);
+    for (const rule of allRules) {
+      if (rule.once) {
+        const ruleKey = `${rule.pattern.source}:${rule.pattern.flags}`;
+        if (this._firedOnceRules.has(ruleKey)) continue;
+      }
+      if (rule.pattern.test(stripped)) {
+        const safe = rule.safe !== false;
+        if (safe) {
+          const useKeys = rule.keys && rule.keys.length > 0;
+          const isTuiDefault = !rule.responseType && !rule.keys && this.adapter.usesTuiMenus;
+          if (useKeys) {
+            this.sendKeySequence(rule.keys);
+          } else if (isTuiDefault) {
+            this.sendKeys("enter");
+          } else {
+            this.transport.sendText(this.tmuxSessionName, rule.response);
+            this.transport.sendKey(this.tmuxSessionName, "enter");
+          }
+          if (rule.once) {
+            const ruleKey = `${rule.pattern.source}:${rule.pattern.flags}`;
+            this._firedOnceRules.add(ruleKey);
+          }
+          this.outputBuffer = "";
+          const promptInfo = {
+            type: rule.type,
+            prompt: rule.description,
+            canAutoRespond: true
+          };
+          this.emit("blocking_prompt", promptInfo, true);
+          return true;
+        } else {
+          const promptInfo = {
+            type: rule.type,
+            prompt: rule.description,
+            canAutoRespond: false,
+            instructions: `Prompt matched but requires user confirmation: ${rule.description}`
+          };
+          this.emit("blocking_prompt", promptInfo, false);
+          return true;
+        }
+      }
+    }
+    return false;
+  }
+  tryParseOutput() {
+    const parsed = this.adapter.parseOutput(this.outputBuffer);
+    if (parsed && parsed.isComplete) {
+      this.outputBuffer = "";
+      const message = {
+        id: `${this.id}-msg-${++this.messageCounter}`,
+        sessionId: this.id,
+        direction: "outbound",
+        type: parsed.type,
+        content: parsed.content,
+        metadata: parsed.metadata,
+        timestamp: /* @__PURE__ */ new Date()
+      };
+      this.emit("message", message);
+      if (parsed.isQuestion) {
+        this.emit("question", parsed.content);
+      }
+    }
+  }
+  // ─────────────────────────────────────────────────────────────────────────────
+  // I/O Methods
+  // ─────────────────────────────────────────────────────────────────────────────
+  /**
+   * Write data to the session (formatted by adapter, with Enter)
+   */
+  write(data) {
+    this._lastActivityAt = /* @__PURE__ */ new Date();
+    const formatted = this.adapter.formatInput(data);
+    this.transport.sendText(this.tmuxSessionName, formatted);
+    this.transport.sendKey(this.tmuxSessionName, "enter");
+  }
+  /**
+   * Write raw data directly (no formatting, no Enter)
+   */
+  writeRaw(data) {
+    this._lastActivityAt = /* @__PURE__ */ new Date();
+    this.transport.sendText(this.tmuxSessionName, data);
+  }
+  /**
+   * Send a task/message to the session
+   */
+  send(message) {
+    this._status = "busy";
+    this.outputBuffer = "";
+    this.emit("status_changed", "busy");
+    this._stallEmissionCount = 0;
+    this.resetStallTimer();
+    const msg = {
+      id: `${this.id}-msg-${++this.messageCounter}`,
+      sessionId: this.id,
+      direction: "inbound",
+      type: "task",
+      content: message,
+      timestamp: /* @__PURE__ */ new Date()
+    };
+    const formatted = this.adapter.formatInput(message);
+    this.transport.sendText(this.tmuxSessionName, formatted);
+    setTimeout(() => {
+      this.transport.sendKey(this.tmuxSessionName, "enter");
+    }, 50);
+    return msg;
+  }
+  /**
+   * Resize the terminal
+   */
+  resize(cols, rows) {
+    this.transport.resize(this.tmuxSessionName, cols, rows);
+  }
+  /**
+   * Send special keys to the session.
+   * Uses tmux send-keys with named keys.
+   */
+  sendKeys(keys) {
+    const keyList = Array.isArray(keys) ? keys : [keys];
+    const normalized = _TmuxSession.normalizeKeyList(keyList);
+    this._stallEmissionCount = 0;
+    this._lastBlockingPromptHash = null;
+    this.outputBuffer = "";
+    this.resetStallTimer();
+    for (const key of normalized) {
+      this._lastActivityAt = /* @__PURE__ */ new Date();
+      this.transport.sendKey(this.tmuxSessionName, key);
+    }
+  }
+  /**
+   * Select a TUI menu option by index (0-based).
+   */
+  async selectMenuOption(optionIndex) {
+    for (let i = 0; i < optionIndex; i++) {
+      this.sendKeys("down");
+      await this.delay(50);
+    }
+    this.sendKeys("enter");
+  }
+  /**
+   * Send a sequence of keys with staggered timing.
+   */
+  sendKeySequence(keys) {
+    keys.forEach((key, i) => {
+      setTimeout(() => this.sendKeys(key), i * 50);
+    });
+  }
+  /**
+   * Paste text using bracketed paste mode
+   */
+  paste(text, useBracketedPaste = true) {
+    this._lastActivityAt = /* @__PURE__ */ new Date();
+    if (useBracketedPaste) {
+      this.transport.sendText(this.tmuxSessionName, "\x1B[200~" + text + "\x1B[201~");
+    } else {
+      this.transport.sendText(this.tmuxSessionName, text);
+    }
+  }
+  /**
+   * Notify the session of an external hook event.
+   */
+  notifyHookEvent(event) {
+    switch (event) {
+      case "tool_running":
+        this._lastActivityAt = /* @__PURE__ */ new Date();
+        this.resetStallTimer();
+        break;
+      case "task_complete":
+        this._status = "ready";
+        this._lastBlockingPromptHash = null;
+        this.outputBuffer = "";
+        this.clearStallTimer();
+        this.emit("status_changed", "ready");
+        this.emit("task_complete");
+        break;
+      case "permission_approved":
+        this._lastActivityAt = /* @__PURE__ */ new Date();
+        this.outputBuffer = "";
+        this.resetStallTimer();
+        break;
+      default:
+        this._lastActivityAt = /* @__PURE__ */ new Date();
+        this.resetStallTimer();
+        break;
+    }
+  }
+  /**
+   * Kill the session.
+   */
+  kill(signal) {
+    this._status = "stopping";
+    this.clearStallTimer();
+    this.cancelTaskComplete();
+    this.cancelReadySettle();
+    this.stopExitPolling();
+    if (signal === "SIGKILL") {
+      this.transport.signal(this.tmuxSessionName, "SIGKILL");
+      setTimeout(() => {
+        this.transport.kill(this.tmuxSessionName);
+        this._status = "stopped";
+        this.emit("exit", 137);
+      }, 200);
+    } else {
+      this.transport.signal(this.tmuxSessionName, signal || "SIGTERM");
+    }
+    this.logger.info({ sessionId: this.id, signal }, "Killing tmux session");
+  }
+  /**
+   * Get current output buffer
+   */
+  getOutputBuffer() {
+    return this.outputBuffer;
+  }
+  /**
+   * Clear output buffer
+   */
+  clearOutputBuffer() {
+    this.outputBuffer = "";
+  }
+  /**
+   * Convert to SessionHandle
+   */
+  toHandle() {
+    return {
+      id: this.id,
+      name: this.config.name,
+      type: this.config.type,
+      status: this._status,
+      pid: this.pid,
+      startedAt: this._startedAt ?? void 0,
+      lastActivityAt: this._lastActivityAt ?? void 0,
+      tmuxSessionName: this.tmuxSessionName
+    };
+  }
+  // ─────────────────────────────────────────────────────────────────────────────
+  // Static Utilities
+  // ─────────────────────────────────────────────────────────────────────────────
+  static buildSpawnEnv(config, adapterEnv) {
+    const baseEnv = config.inheritProcessEnv !== false ? process.env : {};
+    return {
+      ...baseEnv,
+      ...adapterEnv,
+      ...config.env,
+      TERM: "xterm-256color",
+      COLORTERM: "truecolor"
+    };
+  }
+  static normalizeKeyList(keys) {
+    const MODIFIER_MAP = {
+      control: "ctrl",
+      command: "meta",
+      cmd: "meta",
+      option: "alt",
+      opt: "alt"
+    };
+    const MODIFIER_NAMES = /* @__PURE__ */ new Set([
+      "ctrl",
+      "alt",
+      "shift",
+      "meta",
+      ...Object.keys(MODIFIER_MAP)
+    ]);
+    const result = [];
+    let i = 0;
+    while (i < keys.length) {
+      let key = keys[i].toLowerCase().trim();
+      if (MODIFIER_MAP[key]) {
+        key = MODIFIER_MAP[key];
+      }
+      if (MODIFIER_NAMES.has(key) && i + 1 < keys.length) {
+        let nextKey = keys[i + 1].toLowerCase().trim();
+        if (MODIFIER_MAP[nextKey]) {
+          nextKey = MODIFIER_MAP[nextKey];
+        }
+        if (!MODIFIER_NAMES.has(nextKey)) {
+          result.push(`${key}+${nextKey}`);
+          i += 2;
+          continue;
+        }
+      }
+      result.push(key);
+      i++;
+    }
+    return result;
+  }
+  // ─────────────────────────────────────────────────────────────────────────────
+  // Private Helpers
+  // ─────────────────────────────────────────────────────────────────────────────
+  delay(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+  }
+  simpleHash(str) {
+    let hash = 0;
+    for (let i = 0; i < str.length; i++) {
+      const char = str.charCodeAt(i);
+      hash = (hash << 5) - hash + char;
+      hash |= 0;
+    }
+    return hash.toString(36);
+  }
+  mapLoginTypeToAuthMethod(type) {
+    switch (type) {
+      case "api_key":
+        return "api_key";
+      case "cli_auth":
+        return "cli_auth";
+      case "device_code":
+        return "device_code";
+      case "oauth":
+      case "browser":
+        return "oauth_browser";
+      default:
+        return "unknown";
+    }
+  }
+  emitAuthRequired(details) {
+    const info = {
+      method: this.mapLoginTypeToAuthMethod(details.type),
+      url: details.url,
+      deviceCode: details.deviceCode,
+      instructions: details.instructions
+    };
+    this.emit("auth_required", info);
+    this.emit("login_required", info.instructions, info.url);
+  }
+  /**
+   * Strip ANSI codes for stall detection hashing.
+   * Simplified compared to pty-manager since tmux capture-pane can give clean text.
+   */
+  stripAnsiForStall(str) {
+    let result = str.replace(/\x1b\[\d*[CDABGdEF]/g, " ");
+    result = result.replace(/\x1b\[\d*(?:;\d+)?[Hf]/g, " ");
+    result = result.replace(/\x1b\[\d*[JK]/g, " ");
+    result = result.replace(/\x1b\](?:[^\x07\x1b]|\x1b[^\\])*(?:\x07|\x1b\\)/g, "");
+    result = result.replace(/\x1bP(?:[^\x1b]|\x1b[^\\])*\x1b\\/g, "");
+    result = result.replace(/\x1B(?:[@-Z\\-_]|\[[0-?]*[ -/]*[@-~])/g, "");
+    result = result.replace(/[\x00-\x08\x0b-\x1f\x7f]/g, "");
+    result = result.replace(/\xa0/g, " ");
+    result = result.replace(/[│╭╰╮╯─═╌║╔╗╚╝╠╣╦╩╬┌┐└┘├┤┬┴┼●○❯❮▶◀⠋⠙⠹⠸⠼⠴⠦⠧⠇⠏⣾⣽⣻⢿⡿⣟⣯⣷✻✶✳✢⏺←→↑↓⬆⬇◆◇▪▫■□▲△▼▽◈⟨⟩⌘⏎⏏⌫⌦⇧⇪⌥]/g, " ");
+    result = result.replace(/\d+[hms](?:\s+\d+[hms])*/g, "0s");
+    result = result.replace(/ {2,}/g, " ");
+    return result;
+  }
+  /**
+   * Less-aggressive ANSI stripping for classifier context.
+   */
+  stripAnsiForClassifier(str) {
+    let result = str.replace(/\x1b\[\d*[CDABGdEF]/g, " ");
+    result = result.replace(/\x1b\[\d*(?:;\d+)?[Hf]/g, " ");
+    result = result.replace(/\x1b\[\d*[JK]/g, " ");
+    result = result.replace(/\x1b\](?:[^\x07\x1b]|\x1b[^\\])*(?:\x07|\x1b\\)/g, "");
+    result = result.replace(/\x1bP(?:[^\x1b]|\x1b[^\\])*\x1b\\/g, "");
+    result = result.replace(/\x1B(?:[@-Z\\-_]|\[[0-?]*[ -/]*[@-~])/g, "");
+    result = result.replace(/[\x00-\x08\x0b-\x1f\x7f]/g, "");
+    result = result.replace(/\xa0/g, " ");
+    result = result.replace(/ {2,}/g, " ");
+    return result;
+  }
+};
+
+// src/tmux-manager.ts
+var TmuxManager = class extends EventEmitter2 {
+  sessions = /* @__PURE__ */ new Map();
+  outputLogs = /* @__PURE__ */ new Map();
+  maxLogLines;
+  logger;
+  transport;
+  adapters;
+  // Stall detection config
+  _stallDetectionEnabled;
+  _stallTimeoutMs;
+  _onStallClassify;
+  // Tmux-specific config
+  _historyLimit;
+  _sessionPrefix;
+  constructor(config = {}) {
+    super();
+    this.adapters = new AdapterRegistry();
+    this.logger = config.logger || consoleLogger;
+    this.maxLogLines = config.maxLogLines || 1e3;
+    this._stallDetectionEnabled = config.stallDetectionEnabled ?? false;
+    this._stallTimeoutMs = config.stallTimeoutMs ?? 8e3;
+    this._onStallClassify = config.onStallClassify;
+    this._historyLimit = config.historyLimit ?? 5e4;
+    this._sessionPrefix = config.sessionPrefix ?? "parallax";
+    this.transport = new TmuxTransport();
+  }
+  /**
+   * Register a CLI adapter
+   */
+  registerAdapter(adapter) {
+    this.adapters.register(adapter);
+  }
+  /**
+   * Spawn a new tmux session
+   */
+  async spawn(config) {
+    const adapter = this.adapters.get(config.type);
+    if (!adapter) {
+      throw new Error(
+        `No adapter found for type: ${config.type}. Registered adapters: ${this.adapters.list().join(", ") || "none"}`
+      );
+    }
+    if (config.id && this.sessions.has(config.id)) {
+      throw new Error(`Session with ID ${config.id} already exists`);
+    }
+    this.logger.info(
+      { type: config.type, name: config.name },
+      "Spawning tmux session"
+    );
+    const session = new TmuxSession(
+      adapter,
+      config,
+      this.logger,
+      this._stallDetectionEnabled,
+      this._stallTimeoutMs,
+      this.transport,
+      this._sessionPrefix,
+      this._historyLimit
+    );
+    this.setupSessionEvents(session);
+    this.sessions.set(session.id, session);
+    this.outputLogs.set(session.id, []);
+    await session.start();
+    const handle = session.toHandle();
+    this.emit("session_started", handle);
+    return handle;
+  }
+  /**
+   * Set up event handlers for a session
+   */
+  setupSessionEvents(session) {
+    session.on("output", (data) => {
+      const logs = this.outputLogs.get(session.id) || [];
+      const lines = data.split("\n");
+      logs.push(...lines);
+      while (logs.length > this.maxLogLines) {
+        logs.shift();
+      }
+      this.outputLogs.set(session.id, logs);
+    });
+    session.on("ready", () => {
+      this.emit("session_ready", session.toHandle());
+    });
+    session.on("login_required", (instructions, url) => {
+      this.emit("login_required", session.toHandle(), instructions, url);
+    });
+    session.on("auth_required", (info) => {
+      this.emit("auth_required", session.toHandle(), info);
+    });
+    session.on("blocking_prompt", (promptInfo, autoResponded) => {
+      this.emit("blocking_prompt", session.toHandle(), promptInfo, autoResponded);
+    });
+    session.on("message", (message) => {
+      this.emit("message", message);
+    });
+    session.on("question", (question) => {
+      this.emit("question", session.toHandle(), question);
+    });
+    session.on("exit", (code) => {
+      const reason = code === 0 ? "normal exit" : `exit code ${code}`;
+      this.emit("session_stopped", session.toHandle(), reason);
+    });
+    session.on("error", (error) => {
+      this.emit("session_error", session.toHandle(), error.message);
+    });
+    session.on("status_changed", () => {
+      this.emit("session_status_changed", session.toHandle());
+    });
+    session.on("task_complete", () => {
+      this.emit("task_complete", session.toHandle());
+    });
+    session.on("tool_running", (info) => {
+      this.emit("tool_running", session.toHandle(), info);
+    });
+    session.on("stall_detected", (recentOutput, stallDurationMs) => {
+      const handle = session.toHandle();
+      this.emit("stall_detected", handle, recentOutput, stallDurationMs);
+      if (this._onStallClassify) {
+        const sanitized = recentOutput.slice(-1500).replace(/\b(ignore|disregard|forget)\s+(all\s+)?(previous|above|prior)\s+(instructions?|prompts?|rules?)\b/gi, "[REDACTED]").replace(/\b(you\s+are|act\s+as|pretend\s+to\s+be|you\s+must|system\s*:)\b/gi, "[REDACTED]");
+        this._onStallClassify(session.id, sanitized, stallDurationMs).then((classification) => {
+          session.handleStallClassification(classification);
+        }).catch((err) => {
+          this.logger.error(
+            { sessionId: session.id, error: err },
+            "Stall classification callback failed"
+          );
+          session.handleStallClassification(null);
+        });
+      }
+    });
+  }
+  /**
+   * Stop a session
+   */
+  async stop(sessionId, options) {
+    const session = this.sessions.get(sessionId);
+    if (!session) {
+      throw new Error(`Session not found: ${sessionId}`);
+    }
+    this.logger.info({ sessionId, force: options?.force }, "Stopping session");
+    const timeout = options?.timeout || 5e3;
+    return new Promise((resolve) => {
+      const timer = setTimeout(() => {
+        session.kill("SIGKILL");
+        setTimeout(() => {
+          session.removeAllListeners();
+          this.sessions.delete(sessionId);
+          this.outputLogs.delete(sessionId);
+          resolve();
+        }, 500);
+      }, timeout);
+      session.once("exit", () => {
+        clearTimeout(timer);
+        session.removeAllListeners();
+        this.sessions.delete(sessionId);
+        this.outputLogs.delete(sessionId);
+        resolve();
+      });
+      session.kill(options?.force ? "SIGKILL" : "SIGTERM");
+    });
+  }
+  /**
+   * Stop all sessions
+   */
+  async stopAll(options) {
+    const stopPromises = Array.from(this.sessions.keys()).map(
+      (id) => this.stop(id, options).catch((err) => {
+        this.logger.warn({ sessionId: id, error: err }, "Error stopping session");
+      })
+    );
+    await Promise.all(stopPromises);
+  }
+  /**
+   * Get a session by ID
+   */
+  get(sessionId) {
+    const session = this.sessions.get(sessionId);
+    return session ? session.toHandle() : null;
+  }
+  /**
+   * List all sessions
+   */
+  list(filter) {
+    const handles = [];
+    for (const session of this.sessions.values()) {
+      const handle = session.toHandle();
+      if (filter) {
+        if (filter.status) {
+          const statuses = Array.isArray(filter.status) ? filter.status : [filter.status];
+          if (!statuses.includes(handle.status)) continue;
+        }
+        if (filter.type) {
+          const types = Array.isArray(filter.type) ? filter.type : [filter.type];
+          if (!types.includes(handle.type)) continue;
+        }
+      }
+      handles.push(handle);
+    }
+    return handles;
+  }
+  /**
+   * Send a message to a session
+   */
+  send(sessionId, message) {
+    const session = this.sessions.get(sessionId);
+    if (!session) {
+      throw new Error(`Session not found: ${sessionId}`);
+    }
+    return session.send(message);
+  }
+  /**
+   * Get logs for a session
+   */
+  async *logs(sessionId, options) {
+    const logBuffer = this.outputLogs.get(sessionId);
+    if (!logBuffer) {
+      throw new Error(`Session not found: ${sessionId}`);
+    }
+    const lines = options?.tail ? logBuffer.slice(-options.tail) : logBuffer;
+    for (const line of lines) {
+      yield line;
+    }
+  }
+  /**
+   * Get metrics for a session
+   */
+  metrics(sessionId) {
+    const session = this.sessions.get(sessionId);
+    if (!session) return null;
+    const handle = session.toHandle();
+    const uptime = handle.startedAt ? Math.floor((Date.now() - handle.startedAt.getTime()) / 1e3) : void 0;
+    return { uptime };
+  }
+  /**
+   * Shutdown manager and stop all sessions
+   */
+  async shutdown() {
+    this.logger.info({ count: this.sessions.size }, "Shutting down all tmux sessions");
+    await this.stopAll({ timeout: 3e3 });
+    this.sessions.clear();
+    this.outputLogs.clear();
+    this.transport.destroy();
+  }
+  /**
+   * Get count of sessions by status
+   */
+  getStatusCounts() {
+    const counts = {
+      pending: 0,
+      starting: 0,
+      authenticating: 0,
+      ready: 0,
+      busy: 0,
+      stopping: 0,
+      stopped: 0,
+      error: 0
+    };
+    for (const session of this.sessions.values()) {
+      counts[session.status]++;
+    }
+    return counts;
+  }
+  /**
+   * Attach to a session's terminal for raw I/O streaming
+   */
+  attachTerminal(sessionId) {
+    const session = this.sessions.get(sessionId);
+    if (!session) return null;
+    return {
+      onData: (callback) => {
+        session.on("output", callback);
+        return () => session.off("output", callback);
+      },
+      write: (data) => {
+        session.writeRaw(data);
+      },
+      resize: (cols, rows) => {
+        session.resize(cols, rows);
+      }
+    };
+  }
+  /**
+   * Check if a session exists
+   */
+  has(sessionId) {
+    return this.sessions.has(sessionId);
+  }
+  /**
+   * Get the underlying TmuxSession (for advanced use)
+   */
+  getSession(sessionId) {
+    return this.sessions.get(sessionId);
+  }
+  // ─────────────────────────────────────────────────────────────────────────────
+  // Tmux-Specific Features
+  // ─────────────────────────────────────────────────────────────────────────────
+  /**
+   * List orphaned tmux sessions from previous runs.
+   * These are tmux sessions with the configured prefix that aren't tracked by this manager.
+   */
+  listOrphanedSessions() {
+    const tmuxSessions = TmuxTransport.listSessions(this._sessionPrefix);
+    const managedNames = new Set(
+      Array.from(this.sessions.values()).map((s) => s.tmuxName)
+    );
+    return tmuxSessions.filter((s) => !managedNames.has(s.name));
+  }
+  /**
+   * Clean up orphaned tmux sessions from previous runs.
+   */
+  cleanupOrphanedSessions() {
+    const orphans = this.listOrphanedSessions();
+    for (const orphan of orphans) {
+      try {
+        this.transport.kill(orphan.name);
+        this.logger.info({ tmuxSession: orphan.name }, "Cleaned up orphaned tmux session");
+      } catch {
+        this.logger.warn({ tmuxSession: orphan.name }, "Failed to clean up orphaned tmux session");
+      }
+    }
+    return orphans.length;
+  }
+  // ─────────────────────────────────────────────────────────────────────────────
+  // Stall Detection Configuration
+  // ─────────────────────────────────────────────────────────────────────────────
+  configureStallDetection(enabled, timeoutMs, classify) {
+    this._stallDetectionEnabled = enabled;
+    if (timeoutMs !== void 0) {
+      this._stallTimeoutMs = timeoutMs;
+    }
+    if (classify !== void 0) {
+      this._onStallClassify = classify;
+    }
+  }
+  // ─────────────────────────────────────────────────────────────────────────────
+  // Runtime Auto-Response Rules API
+  // ─────────────────────────────────────────────────────────────────────────────
+  addAutoResponseRule(sessionId, rule) {
+    const session = this.sessions.get(sessionId);
+    if (!session) throw new Error(`Session not found: ${sessionId}`);
+    session.addAutoResponseRule(rule);
+  }
+  removeAutoResponseRule(sessionId, pattern) {
+    const session = this.sessions.get(sessionId);
+    if (!session) throw new Error(`Session not found: ${sessionId}`);
+    return session.removeAutoResponseRule(pattern);
+  }
+  setAutoResponseRules(sessionId, rules) {
+    const session = this.sessions.get(sessionId);
+    if (!session) throw new Error(`Session not found: ${sessionId}`);
+    session.setAutoResponseRules(rules);
+  }
+  getAutoResponseRules(sessionId) {
+    const session = this.sessions.get(sessionId);
+    if (!session) throw new Error(`Session not found: ${sessionId}`);
+    return session.getAutoResponseRules();
+  }
+  clearAutoResponseRules(sessionId) {
+    const session = this.sessions.get(sessionId);
+    if (!session) throw new Error(`Session not found: ${sessionId}`);
+    session.clearAutoResponseRules();
+  }
+};
+
+// src/task-completion-trace.ts
+function extractTaskCompletionTraceRecords(entries) {
+  const out = [];
+  for (const entry of entries) {
+    let obj = null;
+    if (typeof entry === "string") {
+      const line = entry.trim();
+      if (!line.startsWith("{") || !line.endsWith("}")) continue;
+      try {
+        obj = JSON.parse(line);
+      } catch {
+        continue;
+      }
+    } else if (entry && typeof entry === "object") {
+      obj = entry;
+    }
+    if (!obj) continue;
+    if (obj.msg !== "Task completion trace") continue;
+    if (typeof obj.event !== "string") continue;
+    out.push({
+      sessionId: asString(obj.sessionId),
+      adapterType: asString(obj.adapterType),
+      event: obj.event,
+      status: asString(obj.status),
+      taskCompletePending: asBool(obj.taskCompletePending),
+      signal: asBool(obj.signal),
+      wasPending: asBool(obj.wasPending),
+      debounceMs: asNumber(obj.debounceMs),
+      detectTaskComplete: asBool(obj.detectTaskComplete),
+      detectReady: asBool(obj.detectReady),
+      detectLoading: asBool(obj.detectLoading),
+      tailHash: asString(obj.tailHash),
+      tailSnippet: asString(obj.tailSnippet),
+      timestamp: asTimestamp(obj.time) ?? asTimestamp(obj.timestamp)
+    });
+  }
+  return out;
+}
+function buildTaskCompletionTimeline(records, options = {}) {
+  const filtered = records.filter((r) => {
+    if (!options.adapterType) return true;
+    return r.adapterType === options.adapterType;
+  });
+  const turns = [];
+  let current = null;
+  let ignored = 0;
+  filtered.forEach((record, index) => {
+    if (record.event === "busy_signal" && current && current.completed) {
+      current = null;
+    }
+    if (!current) {
+      current = {
+        turn: turns.length + 1,
+        startIndex: index,
+        endIndex: index,
+        completed: false,
+        maxConfidence: 0,
+        finalConfidence: 0,
+        events: []
+      };
+      turns.push(current);
+    }
+    const step = toStep(record, index);
+    if (!step) {
+      ignored++;
+      return;
+    }
+    current.events.push(step);
+    current.endIndex = index;
+    current.maxConfidence = Math.max(current.maxConfidence, step.confidence);
+    current.finalConfidence = step.confidence;
+    if (step.status === "completed") {
+      current.completed = true;
+    }
+  });
+  return {
+    turns,
+    totalRecords: filtered.length,
+    ignoredRecords: ignored
+  };
+}
+function toStep(record, atIndex) {
+  const event = record.event;
+  const confidence = scoreConfidence(record);
+  if (event === "transition_ready") {
+    return withCommon(record, { event, atIndex, status: "completed", confidence: 100 });
+  }
+  if (event === "debounce_reject_signal" || event === "debounce_reject_status") {
+    return withCommon(record, { event, atIndex, status: "rejected", confidence });
+  }
+  if (record.detectLoading) {
+    return withCommon(record, { event, atIndex, status: "active_loading", confidence });
+  }
+  if (event === "debounce_fire" && record.signal) {
+    return withCommon(record, { event, atIndex, status: "likely_complete", confidence });
+  }
+  if (event === "busy_signal" || event === "debounce_schedule" || event === "debounce_fire") {
+    return withCommon(record, { event, atIndex, status: "active", confidence });
+  }
+  return null;
+}
+function scoreConfidence(record) {
+  let score = 10;
+  if (record.detectLoading) score -= 40;
+  if (record.detectReady) score += 20;
+  if (record.detectTaskComplete) score += 45;
+  if (record.signal) score += 20;
+  if (record.event === "debounce_reject_signal" || record.event === "debounce_reject_status") {
+    score -= 30;
+  }
+  if (record.event === "transition_ready") score = 100;
+  if (score < 0) return 0;
+  if (score > 100) return 100;
+  return score;
+}
+function withCommon(record, step) {
+  return {
+    ...step,
+    signal: record.signal,
+    detectTaskComplete: record.detectTaskComplete,
+    detectReady: record.detectReady,
+    detectLoading: record.detectLoading
+  };
+}
+function asString(value) {
+  return typeof value === "string" ? value : void 0;
+}
+function asBool(value) {
+  return typeof value === "boolean" ? value : void 0;
+}
+function asNumber(value) {
+  return typeof value === "number" ? value : void 0;
+}
+function asTimestamp(value) {
+  if (typeof value === "string" || typeof value === "number" || value instanceof Date) {
+    return value;
+  }
+  return void 0;
+}
+
+// src/adapters/base-adapter.ts
+import { BaseCLIAdapter } from "adapter-types";
+
+// src/adapters/adapter-factory.ts
+import { createAdapter } from "adapter-types";
+
+// src/adapters/shell-adapter.ts
+var ShellAdapter = class {
+  adapterType = "shell";
+  displayName = "Shell";
+  autoResponseRules = [];
+  shell;
+  promptStr;
+  constructor(options = {}) {
+    this.shell = options.shell || process.env.SHELL || "/bin/bash";
+    this.promptStr = options.prompt || "pty> ";
+  }
+  getCommand() {
+    return this.shell;
+  }
+  getArgs(_config) {
+    if (this.shell.endsWith("/zsh") || this.shell === "zsh") {
+      return ["-f"];
+    }
+    if (this.shell.endsWith("/bash") || this.shell === "bash") {
+      return ["--norc", "--noprofile"];
+    }
+    return [];
+  }
+  getEnv(_config) {
+    return {
+      PS1: this.promptStr,
+      PROMPT: this.promptStr
+      // zsh uses PROMPT instead of PS1
+    };
+  }
+  detectLogin(_output) {
+    return { required: false };
+  }
+  detectBlockingPrompt(_output) {
+    return { detected: false };
+  }
+  detectReady(output) {
+    if (this.isContinuationPrompt(output)) {
+      return false;
+    }
+    return this.getPromptPattern().test(this.stripAnsi(output));
+  }
+  isContinuationPrompt(output) {
+    const stripped = this.stripAnsi(output);
+    return /(?:quote|dquote|heredoc|bquote|cmdsubst|pipe|then|else|do|loop)>\s*$/.test(stripped) || /(?:quote|dquote|heredoc|bquote)>\s*$/m.test(stripped);
+  }
+  detectExit(output) {
+    if (output.includes("exit")) {
+      return { exited: true, code: 0 };
+    }
+    return { exited: false };
+  }
+  parseOutput(output) {
+    const cleaned = this.stripAnsi(output).trim();
+    if (!cleaned) return null;
+    return {
+      type: "response",
+      content: cleaned,
+      isComplete: true,
+      isQuestion: false
+    };
+  }
+  formatInput(message) {
+    return message;
+  }
+  getPromptPattern() {
+    const escaped = this.promptStr.trimEnd().replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+    return new RegExp(`(?:${escaped}|\\$|#)\\s*$`, "m");
+  }
+  async validateInstallation() {
+    return { installed: true };
+  }
+  stripAnsi(str) {
+    return str.replace(/\x1B(?:[@-Z\\-_]|\[[0-?]*[ -/]*[@-~])/g, "");
+  }
+};
+export {
+  AdapterRegistry,
+  BaseCLIAdapter,
+  SPECIAL_KEYS,
+  ShellAdapter,
+  TMUX_KEY_MAP,
+  TmuxManager,
+  TmuxSession,
+  TmuxTransport,
+  buildTaskCompletionTimeline,
+  createAdapter,
+  ensureTmux,
+  extractTaskCompletionTraceRecords,
+  resetTmuxCheck
+};
+//# sourceMappingURL=index.mjs.map