@rallycry/conveyor-agent 8.12.0 → 9.0.0

package/dist/index.js

@@ -1,1519 +1,97 @@
 import {
   AgentConnection,
-  CommitWatcher,
-  DEFAULT_LIFECYCLE_CONFIG,
-  Lifecycle,
-  ModeController,
   PlanSync,
-  ProjectConnection,
-  ProjectRunner,
   SessionRunner,
-  detachWorktreeBranch,
-  ensureWorktree,
   flushPendingChanges,
   getCurrentBranch,
   hasUncommittedChanges,
   hasUnpushedCommits,
-  injectTelemetry,
   loadConveyorConfig,
   loadForwardPorts,
   pushToOrigin,
-  removeWorktree,
   runAuthTokenCommand,
   runSetupCommand,
   runStartCommand,
   stageAndCommit,
   unshallowRepo,
   updateRemoteToken
-} from "./chunk-FSUVTOFP.js";
-import "./chunk-FDWECEDJ.js";
-import "./chunk-TN2YYT2V.js";
+} from "./chunk-JH7GUOGW.js";
 
-// src/runner/file-cache.ts
-var DEFAULT_MAX_SIZE_BYTES = 50 * 1024 * 1024;
-var DEFAULT_TTL_MS = 60 * 60 * 1e3;
-var FileCache = class {
-  cache = /* @__PURE__ */ new Map();
-  currentSize = 0;
-  maxSizeBytes;
-  ttlMs;
-  constructor(maxSizeBytes = DEFAULT_MAX_SIZE_BYTES, ttlMs = DEFAULT_TTL_MS) {
-    this.maxSizeBytes = maxSizeBytes;
-    this.ttlMs = ttlMs;
-  }
-  get(fileId) {
-    const entry = this.cache.get(fileId);
-    if (!entry) return null;
-    if (Date.now() - entry.createdAt > this.ttlMs) {
-      this.delete(fileId);
-      return null;
-    }
-    this.cache.delete(fileId);
-    this.cache.set(fileId, entry);
-    return entry;
-  }
-  set(fileId, content, mimeType, fileName) {
-    if (this.cache.has(fileId)) {
-      this.delete(fileId);
-    }
-    const size = content.byteLength;
-    if (size > this.maxSizeBytes) return;
-    while (this.currentSize + size > this.maxSizeBytes && this.cache.size > 0) {
-      const oldestKey = this.cache.keys().next().value;
-      if (oldestKey !== void 0) {
-        this.delete(oldestKey);
+// src/runner/worktree.ts
+import { execSync } from "child_process";
+import { existsSync } from "fs";
+import { join } from "path";
+var WORKTREE_DIR = ".worktrees";
+function ensureWorktree(projectDir, taskId, branch) {
+  if (projectDir.includes(`/${WORKTREE_DIR}/`)) {
+    return projectDir;
+  }
+  const worktreePath = join(projectDir, WORKTREE_DIR, taskId);
+  if (existsSync(worktreePath)) {
+    if (branch) {
+      if (hasUncommittedChanges(worktreePath)) {
+        return worktreePath;
       }
-    }
-    this.cache.set(fileId, {
-      content,
-      mimeType,
-      fileName,
-      createdAt: Date.now(),
-      size
-    });
-    this.currentSize += size;
-  }
-  delete(fileId) {
-    const entry = this.cache.get(fileId);
-    if (entry) {
-      this.currentSize -= entry.size;
-      this.cache.delete(fileId);
-    }
-  }
-  clear() {
-    this.cache.clear();
-    this.currentSize = 0;
-  }
-  get stats() {
-    return {
-      entries: this.cache.size,
-      sizeBytes: this.currentSize,
-      maxSizeBytes: this.maxSizeBytes
-    };
-  }
-};
-
-// src/debug/cdp-client.ts
-var MAX_VARIABLE_VALUE_BYTES = 2048;
-var MAX_VARIABLES_PER_SCOPE = 50;
-var AUTO_RESUME_TIMEOUT_MS = 3e4;
-var PROBE_BUFFER_MAX_SIZE = 1e3;
-var CdpDebugClient = class {
-  ws = null;
-  requestId = 0;
-  pendingRequests = /* @__PURE__ */ new Map();
-  breakpoints = /* @__PURE__ */ new Map();
-  probes = /* @__PURE__ */ new Map();
-  probeCounter = 0;
-  probeBufferInjected = false;
-  pausedState = null;
-  autoResumeTimer = null;
-  protocol = "cdp";
-  onPausedCallback = null;
-  onResumedCallback = null;
-  onAutoResumedCallback = null;
-  // ── Connection ─────────────────────────────────────────────────────────
-  // oxlint-disable-next-line require-await
-  async connect(wsUrl, protocol) {
-    if (this.ws) {
-      throw new Error("Already connected to CDP");
-    }
-    this.protocol = protocol ?? "cdp";
-    return new Promise((resolve, reject) => {
-      const ws = new WebSocket(wsUrl);
-      ws.addEventListener("open", async () => {
-        this.ws = ws;
-        try {
-          await this.send("Debugger.enable", {});
-          await this.send("Runtime.enable", {});
-          resolve();
-        } catch (err) {
-          reject(err);
-        }
-      });
-      ws.addEventListener("message", (event) => {
-        const data = typeof event.data === "string" ? event.data : String(event.data);
-        this.handleMessage(data);
-      });
-      ws.addEventListener("error", () => {
-        reject(new Error(`CDP WebSocket connection failed: ${wsUrl}`));
-      });
-      ws.addEventListener("close", () => {
-        this.cleanup();
-      });
-    });
-  }
-  disconnect() {
-    if (this.ws) {
-      this.clearAutoResumeTimer();
-      this.ws.close();
-      this.cleanup();
-    }
-  }
-  isConnected() {
-    return this.ws !== null && this.ws.readyState === WebSocket.OPEN;
-  }
-  getProtocol() {
-    return this.protocol;
-  }
-  // ── Breakpoints ────────────────────────────────────────────────────────
-  async setBreakpoint(file, line, condition) {
-    const params = {
-      urlRegex: this.fileToUrlRegex(file),
-      // CDP uses 0-based lines
-      lineNumber: line - 1
-    };
-    if (condition) {
-      params.condition = condition;
-    }
-    const result = await this.send("Debugger.setBreakpointByUrl", params);
-    const breakpointId = result.breakpointId;
-    this.breakpoints.set(breakpointId, { breakpointId, file, line, condition });
-    return breakpointId;
-  }
-  async removeBreakpoint(breakpointId) {
-    await this.send("Debugger.removeBreakpoint", { breakpointId });
-    this.breakpoints.delete(breakpointId);
-  }
-  async removeAllBreakpoints() {
-    const ids = [...this.breakpoints.keys()];
-    for (const id of ids) {
       try {
-        await this.removeBreakpoint(id);
-      } catch {
-        this.breakpoints.delete(id);
-      }
-    }
-  }
-  listBreakpoints() {
-    return [...this.breakpoints.values()];
-  }
-  // ── Probes (Logpoints) ────────────────────────────────────────────────
-  async setLogpoint(file, line, expressions, label) {
-    await this.ensureProbeBuffer();
-    const probeId = `probe-${++this.probeCounter}`;
-    const probeLabel = label ?? `${file}:${line}`;
-    const dataEntries = expressions.map((expr) => `${JSON.stringify(expr)}: (${expr})`).join(", ");
-    const condition = `(globalThis.__conveyorProbes?.probe(${JSON.stringify(probeLabel)}, {${dataEntries}}), false)`;
-    const breakpointId = await this.setBreakpoint(file, line, condition);
-    const probe = { probeId, breakpointId, file, line, expressions, label: probeLabel };
-    this.probes.set(probeId, probe);
-    return probeId;
-  }
-  async removeProbe(probeId) {
-    const probe = this.probes.get(probeId);
-    if (!probe) {
-      throw new Error(`Probe ${probeId} not found`);
-    }
-    await this.removeBreakpoint(probe.breakpointId);
-    this.probes.delete(probeId);
-  }
-  listProbes() {
-    return [...this.probes.values()];
-  }
-  async getProbeResults(label, limit) {
-    const args = [
-      label === void 0 ? "undefined" : JSON.stringify(label),
-      limit === void 0 ? "undefined" : String(limit)
-    ].join(", ");
-    const result = await this.evaluate(
-      `JSON.stringify(globalThis.__conveyorProbes?.read(${args}) ?? [])`
-    );
-    if (result.type === "error") {
-      return [];
-    }
-    try {
-      const raw = result.value;
-      const parsed = JSON.parse(raw.startsWith('"') ? JSON.parse(raw) : raw);
-      return parsed;
-    } catch {
-      return [];
-    }
-  }
-  async clearProbeResults(label) {
-    const arg = label === void 0 ? "undefined" : JSON.stringify(label);
-    await this.evaluate(`(globalThis.__conveyorProbes?.clear(${arg}), undefined)`);
-  }
-  // ── Paused State ───────────────────────────────────────────────────────
-  isPaused() {
-    return this.pausedState !== null;
-  }
-  getPausedState() {
-    return this.pausedState;
-  }
-  getCallStack() {
-    return this.pausedState?.callFrames ?? [];
-  }
-  async getScopeVariables(callFrameId) {
-    if (!this.pausedState) {
-      throw new Error("Debugger is not paused");
-    }
-    const frame = this.pausedState.callFrames.find((f) => f.callFrameId === callFrameId);
-    if (!frame) {
-      throw new Error(`Call frame ${callFrameId} not found`);
-    }
-    const result = await this.send("Debugger.evaluateOnCallFrame", {
-      callFrameId,
-      expression: "this",
-      returnByValue: false
-    });
-    const variables = [];
-    try {
-      const scopeResult = await this.send("Runtime.getProperties", {
-        objectId: result.result?.objectId,
-        ownProperties: true,
-        generatePreview: false
-      });
-      const descriptors = scopeResult.result ?? [];
-      for (const desc of descriptors.slice(0, MAX_VARIABLES_PER_SCOPE)) {
-        if (desc.value) {
-          variables.push({
-            name: desc.name,
-            type: desc.value.type,
-            value: this.truncateValue(this.formatRemoteObject(desc.value))
-          });
-        }
-      }
-    } catch {
-    }
-    return variables;
-  }
-  // ── Execution Control ──────────────────────────────────────────────────
-  async resume() {
-    this.clearAutoResumeTimer();
-    await this.send("Debugger.resume", {});
-    this.pausedState = null;
-  }
-  async stepOver() {
-    this.clearAutoResumeTimer();
-    await this.send("Debugger.stepOver", {});
-  }
-  async stepInto() {
-    this.clearAutoResumeTimer();
-    await this.send("Debugger.stepInto", {});
-  }
-  // ── Evaluation ─────────────────────────────────────────────────────────
-  async evaluate(expression, callFrameId) {
-    let result;
-    if (callFrameId && this.pausedState) {
-      result = await this.send("Debugger.evaluateOnCallFrame", {
-        callFrameId,
-        expression,
-        returnByValue: false,
-        generatePreview: true
-      });
-    } else {
-      result = await this.send("Runtime.evaluate", {
-        expression,
-        returnByValue: false,
-        generatePreview: true
-      });
-    }
-    const remoteObj = result.result;
-    const errorValue = this.extractEvalError(result, remoteObj);
-    if (errorValue !== null) {
-      return { type: "error", value: errorValue };
-    }
-    return {
-      type: remoteObj?.type ?? "undefined",
-      value: this.truncateValue(this.formatRemoteObject(remoteObj))
-    };
-  }
-  // ── Event Callbacks ────────────────────────────────────────────────────
-  onPaused(callback) {
-    this.onPausedCallback = callback;
-  }
-  onResumed(callback) {
-    this.onResumedCallback = callback;
-  }
-  onAutoResumed(callback) {
-    this.onAutoResumedCallback = callback;
-  }
-  // ── Private: CDP Communication ─────────────────────────────────────────
-  send(method, params) {
-    return new Promise((resolve, reject) => {
-      if (!this.ws || this.ws.readyState !== WebSocket.OPEN) {
-        reject(new Error("CDP WebSocket is not connected"));
-        return;
-      }
-      const id = ++this.requestId;
-      const request = { id, method, params };
-      this.pendingRequests.set(id, { resolve, reject });
-      this.ws.send(JSON.stringify(request));
-      setTimeout(() => {
-        if (this.pendingRequests.has(id)) {
-          this.pendingRequests.delete(id);
-          reject(new Error(`CDP request timed out: ${method}`));
-        }
-      }, 1e4);
-    });
-  }
-  handleMessage(raw) {
-    let msg;
-    try {
-      msg = JSON.parse(raw);
-    } catch {
-      return;
-    }
-    if ("id" in msg && typeof msg.id === "number") {
-      const pending = this.pendingRequests.get(msg.id);
-      if (pending) {
-        this.pendingRequests.delete(msg.id);
-        const response = msg;
-        if (response.error) {
-          pending.reject(new Error(`CDP error: ${response.error.message}`));
-        } else {
-          pending.resolve(response.result ?? {});
-        }
-      }
-      return;
-    }
-    const event = msg;
-    if (event.method === "Debugger.paused") {
-      this.handlePaused(event.params ?? {});
-    } else if (event.method === "Debugger.resumed") {
-      this.pausedState = null;
-      this.clearAutoResumeTimer();
-      this.onResumedCallback?.();
-    }
-  }
-  handlePaused(params) {
-    const rawFrames = params.callFrames ?? [];
-    const reason = params.reason ?? "unknown";
-    const hitBreakpoints = params.hitBreakpoints;
-    const callFrames = rawFrames.map((frame, index) => ({
-      index,
-      functionName: frame.functionName || "(anonymous)",
-      file: frame.url,
-      // Convert to 1-based
-      line: frame.location.lineNumber + 1,
-      column: frame.location.columnNumber + 1,
-      callFrameId: frame.callFrameId
-    }));
-    this.pausedState = { callFrames, reason, hitBreakpoints };
-    this.clearAutoResumeTimer();
-    this.autoResumeTimer = setTimeout(() => {
-      if (this.pausedState) {
-        this.resume().then(() => {
-          this.onAutoResumedCallback?.();
-        }).catch(() => {
+        execSync(`git checkout --detach origin/${branch}`, {
+          cwd: worktreePath,
+          stdio: "ignore"
         });
-      }
-    }, AUTO_RESUME_TIMEOUT_MS);
-    this.onPausedCallback?.(this.pausedState);
-  }
-  // ── Private: Probe Buffer ──────────────────────────────────────────────
-  async ensureProbeBuffer() {
-    if (this.probeBufferInjected) return;
-    await this.send("Runtime.evaluate", {
-      expression: `
-        globalThis.__conveyorProbes = globalThis.__conveyorProbes || {
-          _buffer: [],
-          _maxSize: ${PROBE_BUFFER_MAX_SIZE},
-          probe(label, data) {
-            this._buffer.push({ label, data, timestamp: Date.now() });
-            if (this._buffer.length > this._maxSize) this._buffer.shift();
-          },
-          read(label, limit) {
-            const items = label !== undefined
-              ? this._buffer.filter(function(e) { return e.label === label; })
-              : this._buffer;
-            return limit !== undefined ? items.slice(-limit) : items;
-          },
-          clear(label) {
-            if (label !== undefined) {
-              this._buffer = this._buffer.filter(function(e) { return e.label !== label; });
-            } else {
-              this._buffer = [];
-            }
-          }
-        };
-        "ok"
-      `,
-      returnByValue: true
-    });
-    this.probeBufferInjected = true;
-  }
-  // ── Private: Helpers ───────────────────────────────────────────────────
-  extractEvalError(result, remoteObj) {
-    if (this.protocol === "webkit") {
-      if (result.wasThrown) {
-        return remoteObj?.description ?? remoteObj?.value?.toString() ?? "Unknown error";
-      }
-      return null;
-    }
-    const exceptionDetails = result.exceptionDetails;
-    if (exceptionDetails) {
-      return exceptionDetails.exception?.description ?? exceptionDetails.text ?? "Unknown error";
-    }
-    return null;
-  }
-  fileToUrlRegex(file) {
-    const escaped = file.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-    return `.*${escaped}$`;
-  }
-  formatRemoteObject(obj) {
-    if (!obj) return "undefined";
-    if (obj.type === "undefined") return "undefined";
-    if (obj.type === "boolean" || obj.type === "number") return String(obj.value);
-    if (obj.type === "string") return JSON.stringify(obj.value);
-    if (obj.value === null) return "null";
-    if (obj.description) return obj.description;
-    if (obj.subtype) return `[${obj.type}:${obj.subtype}]`;
-    return `[${obj.type}]`;
-  }
-  truncateValue(value) {
-    if (value.length <= MAX_VARIABLE_VALUE_BYTES) return value;
-    return value.slice(0, MAX_VARIABLE_VALUE_BYTES - 3) + "...";
-  }
-  clearAutoResumeTimer() {
-    if (this.autoResumeTimer) {
-      clearTimeout(this.autoResumeTimer);
-      this.autoResumeTimer = null;
-    }
-  }
-  cleanup() {
-    this.clearAutoResumeTimer();
-    this.ws = null;
-    this.pausedState = null;
-    this.probes.clear();
-    this.probeBufferInjected = false;
-    for (const [, pending] of this.pendingRequests) {
-      pending.reject(new Error("CDP connection closed"));
-    }
-    this.pendingRequests.clear();
-  }
-};
-
-// src/debug/playwright-types.ts
-var MAX_VARIABLE_VALUE_BYTES2 = 2048;
-function formatRemoteObject(obj) {
-  if (!obj) return "undefined";
-  if (obj.type === "undefined") return "undefined";
-  if (obj.type === "boolean" || obj.type === "number") return String(obj.value);
-  if (obj.type === "string") return JSON.stringify(obj.value);
-  if (obj.value === null) return "null";
-  if (obj.description) return obj.description;
-  if (obj.subtype) return `[${obj.type}:${obj.subtype}]`;
-  return `[${obj.type}]`;
-}
-function truncateValue(value) {
-  if (value.length <= MAX_VARIABLE_VALUE_BYTES2) return value;
-  return value.slice(0, MAX_VARIABLE_VALUE_BYTES2 - 3) + "...";
-}
-
-// src/debug/playwright-client.ts
-var MAX_VARIABLES_PER_SCOPE2 = 50;
-var AUTO_RESUME_TIMEOUT_MS2 = 3e4;
-var PROBE_BUFFER_MAX_SIZE2 = 1e3;
-var BUFFER_MAX = 500;
-var ERROR_BUFFER_MAX = 200;
-var INACTIVITY_TIMEOUT_MS = 6e5;
-var PlaywrightDebugClient = class {
-  browser = null;
-  page = null;
-  cdpSession = null;
-  breakpoints = /* @__PURE__ */ new Map();
-  probes = /* @__PURE__ */ new Map();
-  probeCounter = 0;
-  probeBufferInjected = false;
-  pausedState = null;
-  autoResumeTimer = null;
-  inactivityTimer = null;
-  onPausedCallback = null;
-  onResumedCallback = null;
-  onAutoResumedCallback = null;
-  consoleMessages = [];
-  networkRequests = [];
-  pageErrors = [];
-  sourceMapDetected = null;
-  async launch(previewUrl) {
-    if (this.browser) throw new Error("Playwright browser is already running");
-    const { chromium } = await import("playwright-core");
-    this.browser = await chromium.launch({
-      headless: true,
-      args: [
-        "--no-sandbox",
-        "--disable-setuid-sandbox",
-        "--disable-dev-shm-usage",
-        "--disable-gpu"
-      ]
-    });
-    const context = this.browser.contexts()[0] ?? await this.browser.newContext();
-    this.page = await context.newPage();
-    this.setupPassiveCapture();
-    await this.page.goto(previewUrl, { waitUntil: "domcontentloaded" });
-    this.cdpSession = await context.newCDPSession(this.page);
-    await this.cdpSession.send("Debugger.enable", {});
-    await this.cdpSession.send("Runtime.enable", {});
-    this.setupCdpEvents();
-    await this.checkSourceMaps();
-    this.resetInactivityTimer();
-  }
-  async close() {
-    this.clearAutoResumeTimer();
-    this.clearInactivityTimer();
-    if (this.cdpSession) {
-      try {
-        await this.cdpSession.detach();
-      } catch {
-      }
-      this.cdpSession = null;
-    }
-    if (this.browser) {
-      try {
-        await this.browser.close();
-      } catch {
-      }
-      this.browser = null;
-    }
-    this.page = null;
-    this.pausedState = null;
-    this.breakpoints.clear();
-    this.probes.clear();
-    this.probeBufferInjected = false;
-    this.consoleMessages = [];
-    this.networkRequests = [];
-    this.pageErrors = [];
-  }
-  isConnected() {
-    return this.browser !== null && this.cdpSession !== null;
-  }
-  hasSourceMaps() {
-    return this.sourceMapDetected;
-  }
-  async setBreakpoint(file, line, condition) {
-    const session = this.requireSession();
-    this.resetInactivityTimer();
-    const params = {
-      urlRegex: this.fileToUrlRegex(file),
-      // CDP uses 0-based lines
-      lineNumber: line - 1
-    };
-    if (condition) params.condition = condition;
-    const result = await session.send("Debugger.setBreakpointByUrl", params);
-    const breakpointId = result.breakpointId;
-    this.breakpoints.set(breakpointId, { breakpointId, file, line, condition });
-    return breakpointId;
-  }
-  async removeBreakpoint(breakpointId) {
-    const session = this.requireSession();
-    await session.send("Debugger.removeBreakpoint", { breakpointId });
-    this.breakpoints.delete(breakpointId);
-  }
-  async removeAllBreakpoints() {
-    for (const id of [...this.breakpoints.keys()]) {
-      try {
-        await this.removeBreakpoint(id);
       } catch {
-        this.breakpoints.delete(id);
-      }
-    }
-  }
-  listBreakpoints() {
-    return [...this.breakpoints.values()];
-  }
-  async setLogpoint(file, line, expressions, label) {
-    await this.ensureProbeBuffer();
-    const probeId = `client-probe-${++this.probeCounter}`;
-    const probeLabel = label ?? `${file}:${line}`;
-    const dataEntries = expressions.map((expr) => `${JSON.stringify(expr)}: (${expr})`).join(", ");
-    const condition = `(globalThis.__conveyorProbes?.probe(${JSON.stringify(probeLabel)}, {${dataEntries}}), false)`;
-    const breakpointId = await this.setBreakpoint(file, line, condition);
-    this.probes.set(probeId, { probeId, breakpointId, file, line, expressions, label: probeLabel });
-    return probeId;
-  }
-  async removeProbe(probeId) {
-    const probe = this.probes.get(probeId);
-    if (!probe) throw new Error(`Probe ${probeId} not found`);
-    await this.removeBreakpoint(probe.breakpointId);
-    this.probes.delete(probeId);
-  }
-  listProbes() {
-    return [...this.probes.values()];
-  }
-  async getProbeResults(label, limit) {
-    const args = [
-      label === void 0 ? "undefined" : JSON.stringify(label),
-      limit === void 0 ? "undefined" : String(limit)
-    ].join(", ");
-    const result = await this.evaluate(
-      `JSON.stringify(globalThis.__conveyorProbes?.read(${args}) ?? [])`
-    );
-    if (result.type === "error") return [];
-    try {
-      const raw = result.value;
-      return JSON.parse(raw.startsWith('"') ? JSON.parse(raw) : raw);
-    } catch {
-      return [];
-    }
-  }
-  async clearProbeResults(label) {
-    const arg = label === void 0 ? "undefined" : JSON.stringify(label);
-    await this.evaluate(`(globalThis.__conveyorProbes?.clear(${arg}), undefined)`);
-  }
-  isPaused() {
-    return this.pausedState !== null;
-  }
-  getPausedState() {
-    return this.pausedState;
-  }
-  getCallStack() {
-    return this.pausedState?.callFrames ?? [];
-  }
-  async getScopeVariables(callFrameId) {
-    if (!this.pausedState) throw new Error("Debugger is not paused");
-    const session = this.requireSession();
-    const frame = this.pausedState.callFrames.find((f) => f.callFrameId === callFrameId);
-    if (!frame) throw new Error(`Call frame ${callFrameId} not found`);
-    const result = await session.send("Debugger.evaluateOnCallFrame", {
-      callFrameId,
-      expression: "this",
-      returnByValue: false
-    });
-    const variables = [];
-    try {
-      const scopeResult = await session.send("Runtime.getProperties", {
-        objectId: result.result?.objectId,
-        ownProperties: true,
-        generatePreview: false
-      });
-      for (const desc of (scopeResult.result ?? []).slice(
-        0,
-        MAX_VARIABLES_PER_SCOPE2
-      )) {
-        if (desc.value) {
-          variables.push({
-            name: desc.name,
-            type: desc.value.type,
-            value: truncateValue(formatRemoteObject(desc.value))
-          });
-        }
-      }
-    } catch {
-    }
-    return variables;
-  }
-  async resume() {
-    this.clearAutoResumeTimer();
-    await this.requireSession().send("Debugger.resume", {});
-    this.pausedState = null;
-  }
-  async stepOver() {
-    this.clearAutoResumeTimer();
-    await this.requireSession().send("Debugger.stepOver", {});
-  }
-  async stepInto() {
-    this.clearAutoResumeTimer();
-    await this.requireSession().send("Debugger.stepInto", {});
-  }
-  async evaluate(expression, callFrameId) {
-    const session = this.requireSession();
-    this.resetInactivityTimer();
-    let result;
-    if (callFrameId && this.pausedState) {
-      result = await session.send("Debugger.evaluateOnCallFrame", {
-        callFrameId,
-        expression,
-        returnByValue: false,
-        generatePreview: true
-      });
-    } else {
-      result = await session.send("Runtime.evaluate", {
-        expression,
-        returnByValue: false,
-        generatePreview: true
-      });
-    }
-    const remoteObj = result.result;
-    const exDetails = result.exceptionDetails;
-    if (exDetails) {
-      return {
-        type: "error",
-        value: exDetails.exception?.description ?? exDetails.text ?? "Unknown error"
-      };
-    }
-    return {
-      type: remoteObj?.type ?? "undefined",
-      value: truncateValue(formatRemoteObject(remoteObj))
-    };
-  }
-  async navigate(url) {
-    this.requirePage();
-    this.resetInactivityTimer();
-    await this.page?.goto(url, { waitUntil: "domcontentloaded" });
-  }
-  async click(selector) {
-    this.requirePage();
-    this.resetInactivityTimer();
-    await this.page?.click(selector, { timeout: 1e4 });
-  }
-  async screenshot() {
-    this.requirePage();
-    this.resetInactivityTimer();
-    const buffer = await this.page?.screenshot({ type: "png", encoding: "base64" });
-    return typeof buffer === "string" ? buffer : Buffer.from(buffer).toString("base64");
-  }
-  getCurrentUrl() {
-    this.requirePage();
-    return this.page?.url() ?? "";
-  }
-  getConsoleMessages(level, limit) {
-    let messages = this.consoleMessages;
-    if (level) messages = messages.filter((m) => m.level === level);
-    if (limit) messages = messages.slice(-limit);
-    return messages;
-  }
-  getNetworkRequests(filter, limit) {
-    let requests = this.networkRequests;
-    if (filter) {
-      const regex = new RegExp(filter, "i");
-      requests = requests.filter((r) => regex.test(r.url));
-    }
-    if (limit) requests = requests.slice(-limit);
-    return requests;
-  }
-  getPageErrors(limit) {
-    return limit ? this.pageErrors.slice(-limit) : [...this.pageErrors];
-  }
-  onPaused(callback) {
-    this.onPausedCallback = callback;
-  }
-  onResumed(callback) {
-    this.onResumedCallback = callback;
-  }
-  onAutoResumed(callback) {
-    this.onAutoResumedCallback = callback;
-  }
-  // ── Private ───────────────────────────────────────────────────────────
-  setupCdpEvents() {
-    if (!this.cdpSession) return;
-    this.cdpSession.on("Debugger.paused", (params) => this.handlePaused(params));
-    this.cdpSession.on("Debugger.resumed", () => {
-      this.pausedState = null;
-      this.clearAutoResumeTimer();
-      this.onResumedCallback?.();
-    });
-  }
-  handlePaused(params) {
-    const rawFrames = params.callFrames ?? [];
-    const callFrames = rawFrames.map((frame, index) => ({
-      index,
-      functionName: frame.functionName || "(anonymous)",
-      file: frame.url,
-      line: frame.location.lineNumber + 1,
-      column: frame.location.columnNumber + 1,
-      callFrameId: frame.callFrameId
-    }));
-    this.pausedState = {
-      callFrames,
-      reason: params.reason ?? "unknown",
-      hitBreakpoints: params.hitBreakpoints
-    };
-    this.clearAutoResumeTimer();
-    this.autoResumeTimer = setTimeout(() => {
-      if (this.pausedState) {
-        this.resume().then(() => this.onAutoResumedCallback?.()).catch(() => {
-        });
-      }
-    }, AUTO_RESUME_TIMEOUT_MS2);
-    this.onPausedCallback?.(this.pausedState);
-  }
-  setupPassiveCapture() {
-    if (!this.page) return;
-    this.page.on("console", (msg) => {
-      const m = msg;
-      this.consoleMessages.push({
-        level: m.type(),
-        text: m.text(),
-        timestamp: Date.now(),
-        url: m.location()?.url,
-        line: m.location()?.lineNumber
-      });
-      if (this.consoleMessages.length > BUFFER_MAX) this.consoleMessages.shift();
-    });
-    this.page.on("pageerror", (error) => {
-      const e = error;
-      this.pageErrors.push({ message: e.message, stack: e.stack, timestamp: Date.now() });
-      if (this.pageErrors.length > ERROR_BUFFER_MAX) this.pageErrors.shift();
-    });
-    this.page.on("request", (request) => {
-      const r = request;
-      this.networkRequests.push({
-        url: r.url(),
-        method: r.method(),
-        resourceType: r.resourceType(),
-        timestamp: Date.now()
-      });
-      if (this.networkRequests.length > BUFFER_MAX) this.networkRequests.shift();
-    });
-    this.page.on("response", (response) => {
-      const resp = response;
-      const url = resp.url();
-      for (let i = this.networkRequests.length - 1; i >= 0; i--) {
-        const req = this.networkRequests[i];
-        if (req.url === url && req.status === void 0) {
-          req.status = resp.status();
-          req.duration = Date.now() - req.timestamp;
-          break;
-        }
       }
-    });
-  }
-  async checkSourceMaps() {
-    const hasMapFiles = this.networkRequests.some(
-      (r) => r.url.endsWith(".map") || r.url.includes("sourceMappingURL")
-    );
-    if (hasMapFiles) {
-      this.sourceMapDetected = true;
-      return;
-    }
-    try {
-      const result = await this.requireSession().send("Runtime.evaluate", {
-        expression: "true",
-        returnByValue: true
-      });
-      this.sourceMapDetected = result.result ? null : false;
-    } catch {
-      this.sourceMapDetected = null;
-    }
-  }
-  async ensureProbeBuffer() {
-    if (this.probeBufferInjected) return;
-    const session = this.requireSession();
-    await session.send("Runtime.evaluate", {
-      expression: `globalThis.__conveyorProbes=globalThis.__conveyorProbes||{_buffer:[],_maxSize:${PROBE_BUFFER_MAX_SIZE2},probe(l,d){this._buffer.push({label:l,data:d,timestamp:Date.now()});if(this._buffer.length>this._maxSize)this._buffer.shift()},read(l,n){var i=l!==void 0?this._buffer.filter(function(e){return e.label===l}):this._buffer;return n!==void 0?i.slice(-n):i},clear(l){if(l!==void 0){this._buffer=this._buffer.filter(function(e){return e.label!==l})}else{this._buffer=[]}}};"ok"`,
-      returnByValue: true
-    });
-    this.probeBufferInjected = true;
-  }
-  requireSession() {
-    if (!this.cdpSession) throw new Error("Playwright CDP session is not connected");
-    return this.cdpSession;
-  }
-  requirePage() {
-    if (!this.page) throw new Error("No page available");
-  }
-  fileToUrlRegex(file) {
-    return `.*${file.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}$`;
-  }
-  clearAutoResumeTimer() {
-    if (this.autoResumeTimer) {
-      clearTimeout(this.autoResumeTimer);
-      this.autoResumeTimer = null;
-    }
-  }
-  resetInactivityTimer() {
-    this.clearInactivityTimer();
-    this.inactivityTimer = setTimeout(() => {
-      this.close().catch(() => {
-      });
-    }, INACTIVITY_TIMEOUT_MS);
-  }
-  clearInactivityTimer() {
-    if (this.inactivityTimer) {
-      clearTimeout(this.inactivityTimer);
-      this.inactivityTimer = null;
     }
+    return worktreePath;
   }
-};
-
-// src/debug/debug-manager.ts
-import { spawn } from "child_process";
-import { execSync } from "child_process";
-var NODE_INSPECTOR_REGEX = /Debugger listening on (ws:\/\/127\.0\.0\.1:\d+\/[^\s]+)/;
-var BUN_INSPECTOR_REGEX = /(ws:\/\/[\w.-]+:\d+\/[\w-]+)/;
-var CONNECTION_TIMEOUT_MS = 1e4;
-var PLAYWRIGHT_INSTALL_TIMEOUT_MS = 12e4;
-var DebugManager = class {
-  cdpClient = null;
-  playwrightClient = null;
-  debugProcess = null;
-  _isDebugMode = false;
-  _isClientDebugMode = false;
-  startCommand;
-  workingDir;
-  eventHandler;
-  breakpointHitQueue = [];
-  clientBreakpointHitQueue = [];
-  constructor(startCommand, workingDir, eventHandler) {
-    this.startCommand = startCommand;
-    this.workingDir = workingDir;
-    this.eventHandler = eventHandler;
-  }
-  // ── Public API ─────────────────────────────────────────────────────────
-  isDebugMode() {
-    return this._isDebugMode;
-  }
-  isClientDebugMode() {
-    return this._isClientDebugMode;
-  }
-  getClient() {
-    return this.cdpClient;
-  }
-  getPlaywrightClient() {
-    return this.playwrightClient;
-  }
-  drainBreakpointHitQueue() {
-    const queued = [...this.breakpointHitQueue];
-    this.breakpointHitQueue = [];
-    return queued;
-  }
-  drainClientBreakpointHitQueue() {
-    const queued = [...this.clientBreakpointHitQueue];
-    this.clientBreakpointHitQueue = [];
-    return queued;
-  }
-  async enterDebugMode(killCurrentProcess, options) {
-    const serverSide = options?.serverSide ?? !options?.clientSide;
-    const clientSide = options?.clientSide ?? false;
-    if (serverSide && this._isDebugMode) {
-      throw new Error("Already in server debug mode");
-    }
-    if (clientSide && this._isClientDebugMode) {
-      throw new Error("Already in client debug mode");
-    }
-    if (serverSide && !this._isDebugMode) {
-      await this.activateServerDebug(killCurrentProcess);
-    }
-    if (clientSide && !this._isClientDebugMode) {
-      await this.activateClientDebug(options?.previewUrl);
-    }
-    this.eventHandler.onDebugModeEntered();
-  }
-  async exitDebugMode(restartNormalServer) {
-    if (!this._isDebugMode && !this._isClientDebugMode) {
-      throw new Error("Not in debug mode");
-    }
-    if (this.cdpClient) {
-      try {
-        await this.cdpClient.removeAllBreakpoints();
-      } catch {
-      }
-      this.cdpClient.disconnect();
-      this.cdpClient = null;
-    }
-    if (this.playwrightClient) {
-      try {
-        await this.playwrightClient.removeAllBreakpoints();
-      } catch {
-      }
+  const ref = branch ? `origin/${branch}` : "HEAD";
+  execSync(`git worktree add --detach "${worktreePath}" ${ref}`, {
+    cwd: projectDir,
+    stdio: "ignore"
+  });
+  return worktreePath;
+}
+function detachWorktreeBranch(projectDir, branch) {
+  try {
+    const output = execSync("git worktree list --porcelain", {
+      cwd: projectDir,
+      encoding: "utf-8"
+    });
+    const entries = output.split("\n\n");
+    for (const entry of entries) {
+      const lines = entry.trim().split("\n");
+      const worktreeLine = lines.find((l) => l.startsWith("worktree "));
+      const branchLine = lines.find((l) => l.startsWith("branch "));
+      if (!worktreeLine || branchLine !== `branch refs/heads/${branch}`) continue;
+      const worktreePath = worktreeLine.replace("worktree ", "");
+      if (!worktreePath.includes(`/${WORKTREE_DIR}/`)) continue;
       try {
-        await this.playwrightClient.close();
+        execSync("git checkout --detach", { cwd: worktreePath, stdio: "ignore" });
       } catch {
       }
-      this.playwrightClient = null;
-    }
-    if (this.debugProcess && !this.debugProcess.killed) {
-      this.debugProcess.kill("SIGTERM");
-      this.debugProcess = null;
     }
-    this._isDebugMode = false;
-    this._isClientDebugMode = false;
-    this.breakpointHitQueue = [];
-    this.clientBreakpointHitQueue = [];
-    restartNormalServer?.();
-    this.eventHandler.onDebugModeExited();
-  }
-  // ── Debug Mode Activation ────────────────────────────────────────────
-  async activateServerDebug(killCurrentProcess) {
-    killCurrentProcess?.();
-    const runtime = detectRuntime(this.startCommand);
-    const inspectorUrl = await this.startWithInspector();
-    const protocol = runtime === "bun" ? "webkit" : "cdp";
-    this.cdpClient = new CdpDebugClient();
-    this.cdpClient.onPaused((state) => {
-      this.breakpointHitQueue.push(state);
-      this.eventHandler.onBreakpointHit(state);
-    });
-    this.cdpClient.onAutoResumed(() => {
-      this.eventHandler.onAutoResumed();
-    });
-    await this.cdpClient.connect(inspectorUrl, protocol);
-    this._isDebugMode = true;
-    try {
-      await injectTelemetry(this.cdpClient);
-    } catch {
-    }
-  }
-  async activateClientDebug(previewUrl) {
-    if (!previewUrl) {
-      throw new Error("previewUrl is required for client-side debug mode");
-    }
-    await this.ensurePlaywrightInstalled();
-    this.playwrightClient = new PlaywrightDebugClient();
-    this.playwrightClient.onPaused((state) => {
-      this.clientBreakpointHitQueue.push(state);
-      this.eventHandler.onClientBreakpointHit(state);
-    });
-    this.playwrightClient.onAutoResumed(() => {
-      this.eventHandler.onAutoResumed();
-    });
-    await this.playwrightClient.launch(previewUrl);
-    this._isClientDebugMode = true;
-  }
-  // ── Playwright Installation ───────────────────────────────────────────
-  async ensurePlaywrightInstalled() {
-    try {
-      await import("playwright-core");
-      const pw = await import("playwright-core");
-      const executablePath = pw.chromium.executablePath();
-      if (executablePath) return;
-    } catch {
-    }
-    this.eventHandler.onOutput(
-      "stderr",
-      "Installing Playwright Chromium (first-time setup, ~250MB)...\n"
-    );
-    try {
-      execSync("npx playwright install chromium --with-deps", {
-        cwd: this.workingDir,
-        timeout: PLAYWRIGHT_INSTALL_TIMEOUT_MS,
-        stdio: "pipe"
-      });
-      this.eventHandler.onOutput("stderr", "Playwright Chromium installed successfully.\n");
-    } catch (error) {
-      throw new Error(
-        `Failed to install Playwright Chromium: ${error instanceof Error ? error.message : "Unknown error"}`,
-        { cause: error }
-      );
-    }
-  }
-  // ── Private ────────────────────────────────────────────────────────────
-  // oxlint-disable-next-line require-await
-  async startWithInspector() {
-    const runtime = detectRuntime(this.startCommand);
-    return new Promise((resolve, reject) => {
-      let resolved = false;
-      const timeout = setTimeout(() => {
-        if (!resolved) {
-          resolved = true;
-          reject(new Error(getTimeoutMessage(runtime)));
-        }
-      }, CONNECTION_TIMEOUT_MS);
-      let cmd = this.startCommand;
-      let env = { ...process.env };
-      if (runtime === "bun") {
-        cmd = injectBunInspectFlag(this.startCommand);
-      } else {
-        env = { ...env, NODE_OPTIONS: "--inspect=0" };
-      }
-      const inspectorRegex = runtime === "bun" ? BUN_INSPECTOR_REGEX : NODE_INSPECTOR_REGEX;
-      const child = runStartCommandWithEnv(cmd, this.workingDir, env, (stream, data) => {
-        this.eventHandler.onOutput(stream, data);
-        if (!resolved && stream === "stderr") {
-          const match = data.match(inspectorRegex);
-          if (match?.[1]) {
-            resolved = true;
-            clearTimeout(timeout);
-            resolve(match[1]);
-          }
-        }
-      });
-      this.debugProcess = child;
-      child.on("error", (err) => {
-        if (!resolved) {
-          resolved = true;
-          clearTimeout(timeout);
-          reject(err);
-        }
-      });
-      child.on("exit", (code) => {
-        if (!resolved) {
-          resolved = true;
-          clearTimeout(timeout);
-          reject(new Error(`Debug process exited with code ${code} before inspector started`));
-        }
-      });
-    });
-  }
-};
-var BUN_COMMAND_REGEX = /\b(bun|bunx)\b/;
-var NODE_COMMAND_REGEX = /\b(node|npx|tsx|ts-node)\b/;
-function detectRuntime(startCommand) {
-  if (BUN_COMMAND_REGEX.test(startCommand)) return "bun";
-  if (NODE_COMMAND_REGEX.test(startCommand)) return "node";
-  if (process.env.BUN_INSTALL) return "bun";
-  return "node";
-}
-function injectBunInspectFlag(command) {
-  return command.replace(/\b(bunx?)\b/, "$1 --inspect");
-}
-function getTimeoutMessage(runtime) {
-  switch (runtime) {
-    case "bun":
-      return "Timed out waiting for Bun inspector (--inspect flag). Ensure your start command begins with 'bun'";
-    case "node":
-      return "Timed out waiting for Node.js inspector (NODE_OPTIONS='--inspect=0')";
-    default:
-      return "Timed out waiting for debugger inspector. Your runtime may not support CDP.";
+  } catch {
   }
 }
-function runStartCommandWithEnv(cmd, cwd, env, onOutput) {
-  const child = spawn("sh", ["-c", cmd], {
-    cwd,
-    stdio: ["ignore", "pipe", "pipe"],
-    detached: true,
-    env: { ...env }
-  });
-  child.stdout?.on("data", (chunk) => {
-    onOutput("stdout", chunk.toString());
-  });
-  child.stderr?.on("data", (chunk) => {
-    onOutput("stderr", chunk.toString());
-  });
-  child.unref();
-  return child;
-}
-
-// src/debug/lifecycle-manager.ts
-var DebugLifecycleManager = class {
-  connection;
-  debugManager = null;
-  hypothesis;
-  sessionStartedAt;
-  breakpointsHitCount = 0;
-  telemetryEvents = [];
-  reproduceRequested = false;
-  keyFindings = [];
-  _isActive = false;
-  constructor(connection) {
-    this.connection = connection;
-  }
-  get isActive() {
-    return this._isActive;
-  }
-  setDebugManager(manager) {
-    this.debugManager = manager;
-  }
-  /**
-   * Creates a DebugEventHandler that bridges DebugManager events
-   * to the lifecycle manager and broadcasts state to the web UI.
-   */
-  createEventHandler(baseOnOutput) {
-    return {
-      onDebugModeEntered: () => {
-        this._isActive = true;
-        this.sessionStartedAt = (/* @__PURE__ */ new Date()).toISOString();
-        this.breakpointsHitCount = 0;
-        this.telemetryEvents = [];
-        this.keyFindings = [];
-        this.broadcastState();
-      },
-      onDebugModeExited: () => {
-        this.broadcastState();
-      },
-      onBreakpointHit: (state) => {
-        this.breakpointsHitCount++;
-        const file = state.callFrames[0]?.file ?? "unknown";
-        const line = state.callFrames[0]?.line ?? 0;
-        this.keyFindings.push(`Breakpoint hit at ${file}:${line} (${state.reason})`);
-        this.broadcastState();
-      },
-      onClientBreakpointHit: (state) => {
-        this.breakpointsHitCount++;
-        const file = state.callFrames[0]?.file ?? "unknown";
-        const line = state.callFrames[0]?.line ?? 0;
-        this.keyFindings.push(`Client breakpoint hit at ${file}:${line}`);
-        this.broadcastState();
-      },
-      onAutoResumed: () => {
-        this.broadcastState();
-      },
-      onDebugError: (message) => {
-        this.keyFindings.push(`Debug error: ${message}`);
-        this.broadcastState();
-      },
-      onOutput: baseOnOutput
-    };
-  }
-  /** Mark the hypothesis for the current debug session */
-  setHypothesis(hypothesis) {
-    this.hypothesis = hypothesis;
-    this.broadcastState();
-  }
-  /** Signal that the user has been asked to reproduce the bug */
-  requestReproduce(hypothesis) {
-    this.reproduceRequested = true;
-    if (hypothesis) this.hypothesis = hypothesis;
-    this.connection.sendEvent({
-      type: "debug_reproduce_requested",
-      hypothesis: hypothesis ?? this.hypothesis
-    });
-    this.broadcastState();
-  }
-  /** Add a telemetry event to the debug session */
-  addTelemetryEvent(event) {
-    this.telemetryEvents.push(event);
-    if (this.telemetryEvents.length > 100) {
-      this.telemetryEvents = this.telemetryEvents.slice(-100);
-    }
-    this.broadcastState();
-  }
-  /** Generate and broadcast a debug session summary, then reset state */
-  completeSession() {
-    if (!this._isActive && !this.sessionStartedAt) return null;
-    const endedAt = (/* @__PURE__ */ new Date()).toISOString();
-    const startedAt = this.sessionStartedAt ?? endedAt;
-    const durationMs = new Date(endedAt).getTime() - new Date(startedAt).getTime();
-    const breakpoints = this.getBreakpoints();
-    const probes = this.getProbes();
-    const summary = {
-      hypothesis: this.hypothesis,
-      breakpointsSet: breakpoints.length,
-      breakpointsHit: this.breakpointsHitCount,
-      probesSet: probes.length,
-      telemetryEventsCaptured: this.telemetryEvents.length,
-      keyFindings: this.keyFindings.slice(0, 20),
-      durationMs,
-      startedAt,
-      endedAt
-    };
-    this.connection.sendEvent({ type: "debug_session_complete", summary });
-    this._isActive = false;
-    this.hypothesis = void 0;
-    this.sessionStartedAt = void 0;
-    this.breakpointsHitCount = 0;
-    this.telemetryEvents = [];
-    this.reproduceRequested = false;
-    this.keyFindings = [];
-    this.broadcastState();
-    return summary;
-  }
-  /** Auto-exit cleanup — called when agent session ends */
-  autoCleanup() {
-    if (this._isActive || this.sessionStartedAt) {
-      this.completeSession();
-    }
-  }
-  // ── Private ────────────────────────────────────────────────────────
-  getBreakpoints() {
-    if (!this.debugManager) return [];
-    const client = this.debugManager.getClient();
-    if (!client?.isConnected()) return [];
-    try {
-      return client.listBreakpoints().map((bp) => ({
-        id: bp.breakpointId,
-        file: bp.file,
-        line: bp.line,
-        condition: bp.condition,
-        hitCount: 0
-      }));
-    } catch {
-      return [];
-    }
-  }
-  getProbes() {
-    if (!this.debugManager) return [];
-    const client = this.debugManager.getClient();
-    if (!client?.isConnected()) return [];
-    try {
-      return client.listProbes().map((p) => ({
-        id: p.probeId,
-        file: p.file,
-        line: p.line,
-        expressions: p.expressions,
-        label: p.label
-      }));
-    } catch {
-      return [];
-    }
-  }
-  buildState() {
-    const serverDebug = this.debugManager?.isDebugMode() ?? false;
-    const clientDebug = this.debugManager?.isClientDebugMode() ?? false;
-    const active = this._isActive && (serverDebug || clientDebug);
-    let pausedAt;
-    const client = this.debugManager?.getClient();
-    if (client?.isPaused()) {
-      const callStack = client.getCallStack();
-      if (callStack[0]) {
-        pausedAt = {
-          file: callStack[0].file,
-          line: callStack[0].line
-        };
-      }
-    }
-    return {
-      active,
-      hypothesis: this.hypothesis,
-      serverDebug,
-      clientDebug,
-      breakpoints: this.getBreakpoints(),
-      probes: this.getProbes(),
-      telemetryEvents: this.telemetryEvents.slice(-50),
-      pausedAt,
-      reproduceRequested: this.reproduceRequested
-    };
-  }
-  broadcastState() {
-    this.connection.sendEvent({
-      type: "debug_state_changed",
-      state: this.buildState()
-    });
-  }
-};
-
-// src/debug/hypothesis-tracker.ts
-var MAX_ITERATIONS = 3;
-var HypothesisTracker = class {
-  hypothesis = null;
-  iteration = 0;
-  observations = [];
-  _active = false;
-  conclusion = null;
-  // ── Public API ─────────────────────────────────────────────────────────
-  /**
-   * Start or update the current debugging hypothesis.
-   * Increments the iteration count if a hypothesis was already set.
-   */
-  setHypothesis(text) {
-    if (!this._active) {
-      this._active = true;
-      this.hypothesis = text;
-      this.iteration = 1;
-      this.observations = [];
-      this.conclusion = null;
-      return { accepted: true, message: `Hypothesis set (iteration 1/${MAX_ITERATIONS}): ${text}` };
-    }
-    if (this.iteration >= MAX_ITERATIONS) {
-      return {
-        accepted: false,
-        message: `Max iterations (${MAX_ITERATIONS}) reached. You must make a decision based on what you've observed. Use concludeSession() to summarize findings and exit debug mode.`
-      };
-    }
-    this.iteration++;
-    this.hypothesis = text;
-    return {
-      accepted: true,
-      message: `Hypothesis updated (iteration ${this.iteration}/${MAX_ITERATIONS}): ${text}`
-    };
-  }
-  /**
-   * Record an observation from debug data (breakpoint hit, telemetry, etc.).
-   */
-  recordObservation(description, confirmsHypothesis) {
-    this.observations.push({
-      description,
-      confirmsHypothesis,
-      iteration: this.iteration,
-      timestamp: Date.now()
+function removeWorktree(projectDir, taskId) {
+  const worktreePath = join(projectDir, WORKTREE_DIR, taskId);
+  if (!existsSync(worktreePath)) return;
+  try {
+    execSync(`git worktree remove "${worktreePath}" --force`, {
+      cwd: projectDir,
+      stdio: "ignore"
     });
+  } catch {
   }
-  /**
-   * End the debug session with a conclusion.
-   */
-  concludeSession(conclusion) {
-    this.conclusion = conclusion;
-    this._active = false;
-    const summary = this.getSessionSummary();
-    this.reset();
-    return summary;
-  }
-  /**
-   * Get formatted debug context for injection into the agent's system prompt.
-   * Returns empty string if no active session.
-   */
-  getDebugContext() {
-    if (!this._active || !this.hypothesis) return "";
-    const lines = [
-      `Current debug session (iteration ${this.iteration}/${MAX_ITERATIONS}):`,
-      `Hypothesis: "${this.hypothesis}"`
-    ];
-    if (this.observations.length > 0) {
-      const byIteration = /* @__PURE__ */ new Map();
-      for (const obs of this.observations) {
-        const group = byIteration.get(obs.iteration) ?? [];
-        group.push(obs);
-        byIteration.set(obs.iteration, group);
-      }
-      for (const [iter, iterObs] of byIteration) {
-        for (const obs of iterObs) {
-          const verdict = obs.confirmsHypothesis ? "SUPPORTS" : "CONTRADICTS";
-          lines.push(`Iteration ${iter}: ${obs.description} \u2014 ${verdict} hypothesis`);
-        }
-      }
-    }
-    if (this.iteration >= MAX_ITERATIONS) {
-      lines.push(
-        `\u26A0\uFE0F Final iteration reached. Analyze observations and make a decision \u2014 no more debug iterations available.`
-      );
-    }
-    return lines.join("\n");
-  }
-  /**
-   * Get the full state (for serialization/testing).
-   */
-  getState() {
-    return {
-      hypothesis: this.hypothesis,
-      iteration: this.iteration,
-      observations: [...this.observations],
-      active: this._active,
-      conclusion: this.conclusion
-    };
-  }
-  isActive() {
-    return this._active;
-  }
-  getIteration() {
-    return this.iteration;
-  }
-  getMaxIterations() {
-    return MAX_ITERATIONS;
-  }
-  // ── Private ────────────────────────────────────────────────────────────
-  getSessionSummary() {
-    const parts = [`Debug session complete.`];
-    if (this.hypothesis) {
-      parts.push(`Final hypothesis: "${this.hypothesis}"`);
-    }
-    parts.push(`Total iterations: ${this.iteration}`);
-    if (this.observations.length > 0) {
-      parts.push("Observations:");
-      for (const obs of this.observations) {
-        const verdict = obs.confirmsHypothesis ? "\u2713" : "\u2717";
-        parts.push(`  ${verdict} [iter ${obs.iteration}] ${obs.description}`);
-      }
-    }
-    const supporting = this.observations.filter((o) => o.confirmsHypothesis).length;
-    const contradicting = this.observations.length - supporting;
-    parts.push(`Evidence: ${supporting} supporting, ${contradicting} contradicting`);
-    if (this.conclusion) {
-      parts.push(`Conclusion: ${this.conclusion}`);
-    }
-    return parts.join("\n");
-  }
-  reset() {
-    this.hypothesis = null;
-    this.iteration = 0;
-    this.observations = [];
-    this._active = false;
-    this.conclusion = null;
-  }
-};
+}
 export {
   AgentConnection,
-  CommitWatcher,
-  DEFAULT_LIFECYCLE_CONFIG,
-  DebugLifecycleManager,
-  DebugManager,
-  FileCache,
-  HypothesisTracker,
-  Lifecycle,
-  ModeController,
   PlanSync,
-  ProjectConnection,
-  ProjectRunner,
   SessionRunner,
   detachWorktreeBranch,
-  detectRuntime,
   ensureWorktree,
   flushPendingChanges,
   getCurrentBranch,
   hasUncommittedChanges,
   hasUnpushedCommits,
-  injectBunInspectFlag,
   loadConveyorConfig,
   loadForwardPorts,
   pushToOrigin,