svamp-cli 0.1.30 → 0.1.31

package/dist/run-CtCTd6if.mjs

@@ -1,4958 +0,0 @@
-import os from 'os';
-import fs from 'fs/promises';
-import { existsSync as existsSync$1, readFileSync as readFileSync$1, writeFileSync as writeFileSync$1, mkdirSync as mkdirSync$1, copyFileSync, unlinkSync, rmdirSync } from 'fs';
-import { dirname, join as join$1, resolve, basename } from 'path';
-import { fileURLToPath } from 'url';
-import { spawn as spawn$1 } from 'child_process';
-import { randomUUID as randomUUID$1 } from 'crypto';
-import { randomUUID } from 'node:crypto';
-import { existsSync, readFileSync, mkdirSync, appendFileSync, writeFileSync } from 'node:fs';
-import { join } from 'node:path';
-import { spawn, execSync, execFile } from 'node:child_process';
-import { ndJsonStream, ClientSideConnection } from '@agentclientprotocol/sdk';
-import { homedir, tmpdir } from 'node:os';
-import { Client } from '@modelcontextprotocol/sdk/client/index.js';
-import { StdioClientTransport } from '@modelcontextprotocol/sdk/client/stdio.js';
-import { ElicitRequestSchema } from '@modelcontextprotocol/sdk/types.js';
-import { z } from 'zod';
-import { mkdir, access, mkdtemp, rm, writeFile } from 'node:fs/promises';
-import { promisify } from 'node:util';
-
-let connectToServerFn = null;
-async function getConnectToServer() {
-  if (!connectToServerFn) {
-    const mod = await import('hypha-rpc');
-    connectToServerFn = mod.connectToServer || mod.default && mod.default.connectToServer || mod.hyphaWebsocketClient && mod.hyphaWebsocketClient.connectToServer;
-    if (!connectToServerFn) {
-      throw new Error("Could not find connectToServer in hypha-rpc module");
-    }
-  }
-  return connectToServerFn;
-}
-async function connectToHypha(config) {
-  const connectToServer = await getConnectToServer();
-  const workspace = config.token ? parseWorkspaceFromToken(config.token) : void 0;
-  const server = await connectToServer({
-    server_url: config.serverUrl,
-    token: config.token,
-    client_id: config.clientId,
-    name: config.name || "svamp-cli",
-    workspace,
-    ...config.transport ? { transport: config.transport } : {}
-  });
-  return server;
-}
-function parseWorkspaceFromToken(token) {
-  try {
-    const payload = JSON.parse(Buffer.from(token.split(".")[1], "base64").toString());
-    const scope = payload.scope || "";
-    const match = scope.match(/wid:([^\s]+)/);
-    return match ? match[1] : void 0;
-  } catch {
-    return void 0;
-  }
-}
-function getHyphaServerUrl() {
-  return process.env.HYPHA_SERVER_URL || "http://localhost:9527";
-}
-
-const ROLE_HIERARCHY = {
-  view: 0,
-  interact: 1,
-  admin: 2
-};
-const ISOLATION_PREFERENCE = ["srt", "bwrap", "docker", "podman"];
-
-function authorizeRequest(context, sharing, requiredRole = "view") {
-  if (!context?.user) return;
-  const userEmail = context.user.email;
-  if (!sharing) return;
-  if (userEmail && userEmail === sharing.owner) return;
-  if (!sharing.enabled) {
-    throw new Error("Access denied: this resource is not shared");
-  }
-  if (!userEmail) {
-    throw new Error("Access denied: no email in user context");
-  }
-  const sharedUser = sharing.allowedUsers.find(
-    (u) => u.email.toLowerCase() === userEmail.toLowerCase()
-  );
-  if (!sharedUser) {
-    throw new Error("Access denied: you are not in the allowed users list");
-  }
-  if (ROLE_HIERARCHY[sharedUser.role] < ROLE_HIERARCHY[requiredRole]) {
-    throw new Error(
-      `Access denied: requires '${requiredRole}' role, you have '${sharedUser.role}'`
-    );
-  }
-}
-
-async function registerMachineService(server, machineId, metadata, daemonState, handlers) {
-  let currentMetadata = { ...metadata };
-  let currentDaemonState = { ...daemonState };
-  let metadataVersion = 1;
-  let daemonStateVersion = 1;
-  const listeners = [];
-  const removeListener = (listener, reason) => {
-    const idx = listeners.indexOf(listener);
-    if (idx >= 0) {
-      listeners.splice(idx, 1);
-      console.log(`[HYPHA MACHINE] Listener removed (${reason}), remaining: ${listeners.length}`);
-      const rintfId = listener._rintf_service_id;
-      if (rintfId) {
-        server.unregisterService(rintfId).catch(() => {
-        });
-      }
-    }
-  };
-  const notifyListeners = (update) => {
-    for (let i = listeners.length - 1; i >= 0; i--) {
-      try {
-        const result = listeners[i].onUpdate(update);
-        if (result && typeof result.catch === "function") {
-          const listener = listeners[i];
-          result.catch((err) => {
-            console.error(`[HYPHA MACHINE] Async listener error:`, err);
-            removeListener(listener, "async error");
-          });
-        }
-      } catch (err) {
-        console.error(`[HYPHA MACHINE] Listener error:`, err);
-        removeListener(listeners[i], "sync error");
-      }
-    }
-  };
-  const serviceInfo = await server.registerService(
-    {
-      id: "default",
-      name: `Svamp Machine (${metadata.displayName || machineId})`,
-      type: "svamp-machine",
-      config: { visibility: "public", require_context: true },
-      // Machine info
-      getMachineInfo: async (context) => {
-        authorizeRequest(context, currentMetadata.sharing, "view");
-        return {
-          machineId,
-          metadata: currentMetadata,
-          metadataVersion,
-          daemonState: currentDaemonState,
-          daemonStateVersion
-        };
-      },
-      // Heartbeat
-      heartbeat: async (context) => ({
-        time: Date.now(),
-        status: currentDaemonState.status,
-        machineId
-      }),
-      // List active sessions on this machine
-      listSessions: async (context) => {
-        authorizeRequest(context, currentMetadata.sharing, "view");
-        return handlers.getTrackedSessions();
-      },
-      // Spawn a new session
-      spawnSession: async (options, context) => {
-        authorizeRequest(context, currentMetadata.sharing, "interact");
-        if (options.sharing?.enabled && !options.sharing.owner && context?.user?.email) {
-          options = {
-            ...options,
-            sharing: { ...options.sharing, owner: context.user.email }
-          };
-        }
-        const result = await handlers.spawnSession({
-          ...options,
-          machineId
-        });
-        if (result.type === "success" && result.sessionId) {
-          notifyListeners({
-            type: "new-session",
-            sessionId: result.sessionId,
-            machineId
-          });
-        }
-        return result;
-      },
-      // Stop a session
-      stopSession: async (sessionId, context) => {
-        authorizeRequest(context, currentMetadata.sharing, "admin");
-        const result = handlers.stopSession(sessionId);
-        notifyListeners({
-          type: "session-stopped",
-          sessionId,
-          machineId
-        });
-        return result;
-      },
-      // Stop the daemon
-      stopDaemon: async (context) => {
-        authorizeRequest(context, currentMetadata.sharing, "admin");
-        handlers.requestShutdown();
-        return { success: true };
-      },
-      // Metadata management (with optimistic concurrency)
-      getMetadata: async (context) => {
-        authorizeRequest(context, currentMetadata.sharing, "view");
-        return {
-          metadata: currentMetadata,
-          version: metadataVersion
-        };
-      },
-      updateMetadata: async (newMetadata, expectedVersion, context) => {
-        authorizeRequest(context, currentMetadata.sharing, "admin");
-        if (expectedVersion !== metadataVersion) {
-          return {
-            result: "version-mismatch",
-            version: metadataVersion,
-            metadata: currentMetadata
-          };
-        }
-        currentMetadata = newMetadata;
-        metadataVersion++;
-        notifyListeners({
-          type: "update-machine",
-          machineId,
-          metadata: { value: currentMetadata, version: metadataVersion }
-        });
-        return {
-          result: "success",
-          version: metadataVersion,
-          metadata: currentMetadata
-        };
-      },
-      // Daemon state management
-      getDaemonState: async (context) => {
-        authorizeRequest(context, currentMetadata.sharing, "view");
-        return {
-          daemonState: currentDaemonState,
-          version: daemonStateVersion
-        };
-      },
-      updateDaemonState: async (newState, expectedVersion, context) => {
-        authorizeRequest(context, currentMetadata.sharing, "admin");
-        if (expectedVersion !== daemonStateVersion) {
-          return {
-            result: "version-mismatch",
-            version: daemonStateVersion,
-            daemonState: currentDaemonState
-          };
-        }
-        currentDaemonState = newState;
-        daemonStateVersion++;
-        notifyListeners({
-          type: "update-machine",
-          machineId,
-          daemonState: { value: currentDaemonState, version: daemonStateVersion }
-        });
-        return {
-          result: "success",
-          version: daemonStateVersion,
-          daemonState: currentDaemonState
-        };
-      },
-      // ── Sharing Management ──
-      getSharing: async (context) => {
-        authorizeRequest(context, currentMetadata.sharing, "view");
-        return { sharing: currentMetadata.sharing || null };
-      },
-      updateSharing: async (newSharing, context) => {
-        authorizeRequest(context, currentMetadata.sharing, "admin");
-        if (currentMetadata.sharing && context?.user?.email && context.user.email !== currentMetadata.sharing.owner) {
-          throw new Error("Only the machine owner can update sharing settings");
-        }
-        currentMetadata = { ...currentMetadata, sharing: newSharing };
-        metadataVersion++;
-        notifyListeners({
-          type: "update-machine",
-          machineId,
-          metadata: { value: currentMetadata, version: metadataVersion }
-        });
-        return { success: true, sharing: newSharing };
-      },
-      // Register a listener for real-time updates (app calls this with _rintf callback)
-      registerListener: async (callback, context) => {
-        authorizeRequest(context, currentMetadata.sharing, "view");
-        listeners.push(callback);
-        console.log(`[HYPHA MACHINE] Listener registered (total: ${listeners.length})`);
-        return { success: true, listenerId: listeners.length - 1 };
-      },
-      // Shell access
-      bash: async (command, cwd, context) => {
-        authorizeRequest(context, currentMetadata.sharing, "admin");
-        const { exec } = await import('child_process');
-        const { homedir } = await import('os');
-        return new Promise((resolve) => {
-          exec(command, { cwd: cwd || homedir(), timeout: 3e4, maxBuffer: 1024 * 1024 }, (err, stdout, stderr) => {
-            if (err) {
-              resolve({ success: false, stdout: stdout || "", stderr: stderr || err.message, exitCode: err.code ?? 1 });
-            } else {
-              resolve({ success: true, stdout, stderr: stderr || "", exitCode: 0 });
-            }
-          });
-        });
-      },
-      // WISE voice — create ephemeral token for OpenAI Realtime API
-      wiseCreateEphemeralToken: async (params, context) => {
-        authorizeRequest(context, currentMetadata.sharing, "interact");
-        const apiKey = params.apiKey || process.env.OPENAI_API_KEY;
-        if (!apiKey) {
-          return { success: false, error: "No OpenAI API key found. Set OPENAI_API_KEY or pass apiKey." };
-        }
-        try {
-          const response = await fetch("https://api.openai.com/v1/realtime/client_secrets", {
-            method: "POST",
-            headers: {
-              "Authorization": `Bearer ${apiKey}`,
-              "Content-Type": "application/json"
-            },
-            body: JSON.stringify({
-              session: {
-                type: "realtime",
-                model: params.model || "gpt-realtime-mini"
-              }
-            })
-          });
-          if (!response.ok) {
-            return { success: false, error: `OpenAI API error: ${response.status}` };
-          }
-          const result = await response.json();
-          return { success: true, clientSecret: result.value };
-        } catch (error) {
-          return { success: false, error: error instanceof Error ? error.message : "Failed to create token" };
-        }
-      }
-    },
-    { overwrite: true }
-  );
-  console.log(`[HYPHA MACHINE] Machine service registered: ${serviceInfo.id}`);
-  return {
-    serviceInfo,
-    updateMetadata: (newMetadata) => {
-      currentMetadata = newMetadata;
-      metadataVersion++;
-      notifyListeners({
-        type: "update-machine",
-        machineId,
-        metadata: { value: currentMetadata, version: metadataVersion }
-      });
-    },
-    updateDaemonState: (newState) => {
-      currentDaemonState = newState;
-      daemonStateVersion++;
-      notifyListeners({
-        type: "update-machine",
-        machineId,
-        daemonState: { value: currentDaemonState, version: daemonStateVersion }
-      });
-    },
-    disconnect: async () => {
-      await server.unregisterService(serviceInfo.id);
-    }
-  };
-}
-
-function loadMessages(messagesDir, sessionId) {
-  const filePath = join(messagesDir, "messages.jsonl");
-  if (!existsSync(filePath)) return [];
-  try {
-    const lines = readFileSync(filePath, "utf-8").split("\n").filter((l) => l.trim());
-    const messages = [];
-    for (const line of lines) {
-      try {
-        messages.push(JSON.parse(line));
-      } catch {
-      }
-    }
-    return messages.slice(-5e3);
-  } catch {
-    return [];
-  }
-}
-function appendMessage(messagesDir, sessionId, msg) {
-  const filePath = join(messagesDir, "messages.jsonl");
-  if (!existsSync(messagesDir)) {
-    mkdirSync(messagesDir, { recursive: true });
-  }
-  appendFileSync(filePath, JSON.stringify(msg) + "\n");
-}
-async function registerSessionService(server, sessionId, initialMetadata, initialAgentState, callbacks, options) {
-  const messages = options?.messagesDir ? loadMessages(options.messagesDir) : [];
-  let nextSeq = messages.length > 0 ? messages[messages.length - 1].seq + 1 : 1;
-  let metadata = { ...initialMetadata };
-  let metadataVersion = 1;
-  let agentState = initialAgentState ? { ...initialAgentState } : null;
-  let agentStateVersion = 1;
-  let lastActivity = {
-    active: false,
-    thinking: false,
-    mode: "remote",
-    time: Date.now()
-  };
-  const listeners = [];
-  const removeListener = (listener, reason) => {
-    const idx = listeners.indexOf(listener);
-    if (idx >= 0) {
-      listeners.splice(idx, 1);
-      console.log(`[HYPHA SESSION ${sessionId}] Listener removed (${reason}), remaining: ${listeners.length}`);
-      const rintfId = listener._rintf_service_id;
-      if (rintfId) {
-        server.unregisterService(rintfId).catch(() => {
-        });
-      }
-    }
-  };
-  const notifyListeners = (update) => {
-    for (let i = listeners.length - 1; i >= 0; i--) {
-      try {
-        const result = listeners[i].onUpdate(update);
-        if (result && typeof result.catch === "function") {
-          const listener = listeners[i];
-          result.catch((err) => {
-            console.error(`[HYPHA SESSION ${sessionId}] Async listener error:`, err);
-            removeListener(listener, "async error");
-          });
-        }
-      } catch (err) {
-        console.error(`[HYPHA SESSION ${sessionId}] Listener error:`, err);
-        removeListener(listeners[i], "sync error");
-      }
-    }
-  };
-  const pushMessage = (content, role = "agent") => {
-    let wrappedContent;
-    if (role === "agent") {
-      const data = { ...content };
-      if ((data.type === "assistant" || data.type === "user") && !data.uuid) {
-        data.uuid = randomUUID();
-      }
-      wrappedContent = { role: "agent", content: { type: "output", data } };
-    } else if (role === "event") {
-      wrappedContent = { role: "agent", content: { type: "event", data: content } };
-    } else if (role === "session") {
-      wrappedContent = { role: "session", content: { type: "session", data: content } };
-    } else {
-      const text = typeof content === "string" ? content : content?.text || content?.content || JSON.stringify(content);
-      wrappedContent = { role: "user", content: { type: "text", text } };
-    }
-    const msg = {
-      id: randomUUID(),
-      seq: nextSeq++,
-      content: wrappedContent,
-      localId: null,
-      createdAt: Date.now(),
-      updatedAt: Date.now()
-    };
-    messages.push(msg);
-    if (messages.length > 1e3) messages.splice(0, messages.length - 1e3);
-    if (options?.messagesDir) {
-      appendMessage(options.messagesDir, sessionId, msg);
-    }
-    notifyListeners({
-      type: "new-message",
-      sessionId,
-      message: msg
-    });
-    return msg;
-  };
-  const serviceInfo = await server.registerService(
-    {
-      id: `svamp-session-${sessionId}`,
-      name: `Svamp Session ${sessionId.slice(0, 8)}`,
-      type: "svamp-session",
-      config: { visibility: "public", require_context: true },
-      // ── Messages ──
-      getMessages: async (afterSeq, limit, context) => {
-        authorizeRequest(context, metadata.sharing, "view");
-        const after = afterSeq ?? 0;
-        const lim = Math.min(limit ?? 100, 500);
-        const filtered = messages.filter((m) => m.seq > after);
-        const page = filtered.slice(0, lim);
-        return {
-          messages: page,
-          hasMore: filtered.length > lim
-        };
-      },
-      sendMessage: async (content, localId, meta, context) => {
-        authorizeRequest(context, metadata.sharing, "interact");
-        if (localId) {
-          const existing = messages.find((m) => m.localId === localId);
-          if (existing) {
-            return { id: existing.id, seq: existing.seq, localId: existing.localId };
-          }
-        }
-        let parsed = content;
-        if (typeof parsed === "string") {
-          try {
-            parsed = JSON.parse(parsed);
-          } catch {
-          }
-        }
-        if (parsed && typeof parsed.content === "string" && !parsed.role) {
-          try {
-            const inner = JSON.parse(parsed.content);
-            if (inner && typeof inner === "object") parsed = inner;
-          } catch {
-          }
-        }
-        const wrappedContent = parsed && parsed.role === "user" ? { role: "user", content: parsed.content } : { role: "user", content: { type: "text", text: typeof parsed === "string" ? parsed : JSON.stringify(parsed) } };
-        const msg = {
-          id: randomUUID(),
-          seq: nextSeq++,
-          content: wrappedContent,
-          localId: localId || randomUUID(),
-          createdAt: Date.now(),
-          updatedAt: Date.now()
-        };
-        messages.push(msg);
-        if (messages.length > 1e3) messages.splice(0, messages.length - 1e3);
-        if (options?.messagesDir) {
-          appendMessage(options.messagesDir, sessionId, msg);
-        }
-        notifyListeners({
-          type: "new-message",
-          sessionId,
-          message: msg
-        });
-        callbacks.onUserMessage(content, meta);
-        return { id: msg.id, seq: msg.seq, localId: msg.localId };
-      },
-      // ── Metadata ──
-      getMetadata: async (context) => {
-        authorizeRequest(context, metadata.sharing, "view");
-        return {
-          metadata,
-          version: metadataVersion
-        };
-      },
-      updateMetadata: async (newMetadata, expectedVersion, context) => {
-        authorizeRequest(context, metadata.sharing, "admin");
-        if (expectedVersion !== void 0 && expectedVersion !== metadataVersion) {
-          return {
-            result: "version-mismatch",
-            version: metadataVersion,
-            metadata
-          };
-        }
-        metadata = newMetadata;
-        metadataVersion++;
-        notifyListeners({
-          type: "update-session",
-          sessionId,
-          metadata: { value: metadata, version: metadataVersion }
-        });
-        return {
-          result: "success",
-          version: metadataVersion,
-          metadata
-        };
-      },
-      // ── Agent State ──
-      getAgentState: async (context) => {
-        authorizeRequest(context, metadata.sharing, "view");
-        return {
-          agentState,
-          version: agentStateVersion
-        };
-      },
-      updateAgentState: async (newState, expectedVersion, context) => {
-        authorizeRequest(context, metadata.sharing, "admin");
-        if (expectedVersion !== void 0 && expectedVersion !== agentStateVersion) {
-          return {
-            result: "version-mismatch",
-            version: agentStateVersion,
-            agentState
-          };
-        }
-        agentState = newState;
-        agentStateVersion++;
-        notifyListeners({
-          type: "update-session",
-          sessionId,
-          agentState: { value: agentState, version: agentStateVersion }
-        });
-        return {
-          result: "success",
-          version: agentStateVersion,
-          agentState
-        };
-      },
-      // ── Session Control RPCs ──
-      abort: async (context) => {
-        authorizeRequest(context, metadata.sharing, "interact");
-        callbacks.onAbort();
-        return { success: true };
-      },
-      permissionResponse: async (params, context) => {
-        authorizeRequest(context, metadata.sharing, "interact");
-        callbacks.onPermissionResponse(params);
-        return { success: true };
-      },
-      switchMode: async (mode, context) => {
-        authorizeRequest(context, metadata.sharing, "interact");
-        callbacks.onSwitchMode(mode);
-        return { success: true };
-      },
-      restartClaude: async (context) => {
-        authorizeRequest(context, metadata.sharing, "admin");
-        return await callbacks.onRestartClaude();
-      },
-      killSession: async (context) => {
-        authorizeRequest(context, metadata.sharing, "admin");
-        callbacks.onKillSession();
-        return { success: true };
-      },
-      // ── Activity ──
-      keepAlive: async (thinking, mode, context) => {
-        lastActivity = { active: true, thinking: thinking || false, mode: mode || "remote", time: Date.now() };
-        notifyListeners({
-          type: "activity",
-          sessionId,
-          ...lastActivity
-        });
-      },
-      sessionEnd: async (context) => {
-        lastActivity = { active: false, thinking: false, mode: "remote", time: Date.now() };
-        notifyListeners({
-          type: "activity",
-          sessionId,
-          ...lastActivity
-        });
-      },
-      // ── Activity State Query ──
-      getActivityState: async (context) => {
-        authorizeRequest(context, metadata.sharing, "view");
-        return { ...lastActivity, sessionId };
-      },
-      // ── File Operations (optional, admin-only) ──
-      readFile: async (path, context) => {
-        authorizeRequest(context, metadata.sharing, "admin");
-        if (!callbacks.onReadFile) throw new Error("readFile not supported");
-        return await callbacks.onReadFile(path);
-      },
-      writeFile: async (path, content, context) => {
-        authorizeRequest(context, metadata.sharing, "admin");
-        if (!callbacks.onWriteFile) throw new Error("writeFile not supported");
-        await callbacks.onWriteFile(path, content);
-        return { success: true };
-      },
-      listDirectory: async (path, context) => {
-        authorizeRequest(context, metadata.sharing, "admin");
-        if (!callbacks.onListDirectory) throw new Error("listDirectory not supported");
-        return await callbacks.onListDirectory(path);
-      },
-      bash: async (command, cwd, context) => {
-        authorizeRequest(context, metadata.sharing, "admin");
-        if (!callbacks.onBash) throw new Error("bash not supported");
-        return await callbacks.onBash(command, cwd);
-      },
-      ripgrep: async (args, cwd, context) => {
-        authorizeRequest(context, metadata.sharing, "admin");
-        if (!callbacks.onRipgrep) throw new Error("ripgrep not supported");
-        try {
-          const stdout = await callbacks.onRipgrep(args, cwd);
-          return { success: true, stdout, stderr: "", exitCode: 0 };
-        } catch (err) {
-          return { success: false, stdout: "", stderr: err.message || "", exitCode: 1, error: err.message };
-        }
-      },
-      getDirectoryTree: async (path, maxDepth, context) => {
-        authorizeRequest(context, metadata.sharing, "admin");
-        if (!callbacks.onGetDirectoryTree) throw new Error("getDirectoryTree not supported");
-        return await callbacks.onGetDirectoryTree(path, maxDepth ?? 3);
-      },
-      // ── Sharing Management ──
-      getSharing: async (context) => {
-        authorizeRequest(context, metadata.sharing, "view");
-        return { sharing: metadata.sharing || null };
-      },
-      updateSharing: async (newSharing, context) => {
-        authorizeRequest(context, metadata.sharing, "admin");
-        if (metadata.sharing && context?.user?.email && context.user.email !== metadata.sharing.owner) {
-          throw new Error("Only the session owner can update sharing settings");
-        }
-        if (newSharing.enabled && !newSharing.owner && context?.user?.email) {
-          newSharing = { ...newSharing, owner: context.user.email };
-        }
-        metadata = { ...metadata, sharing: newSharing };
-        metadataVersion++;
-        notifyListeners({
-          type: "update-session",
-          sessionId,
-          metadata: { value: metadata, version: metadataVersion }
-        });
-        return { success: true, sharing: newSharing };
-      },
-      // ── Listener Registration ──
-      registerListener: async (callback, context) => {
-        authorizeRequest(context, metadata.sharing, "view");
-        listeners.push(callback);
-        const replayMessages = messages.slice(-50);
-        console.log(`[HYPHA SESSION ${sessionId}] Listener registered (total: ${listeners.length}), replaying ${replayMessages.length} of ${messages.length} messages`);
-        for (const msg of replayMessages) {
-          if (listeners.indexOf(callback) < 0) break;
-          try {
-            const result = callback.onUpdate({
-              type: "new-message",
-              sessionId,
-              message: msg
-            });
-            if (result && typeof result.catch === "function") {
-              try {
-                await result;
-              } catch (err) {
-                console.error(`[HYPHA SESSION ${sessionId}] Replay listener error, removing:`, err?.message ?? err);
-                removeListener(callback, "replay error");
-                return { success: false, error: "Listener removed during replay" };
-              }
-            }
-          } catch (err) {
-            console.error(`[HYPHA SESSION ${sessionId}] Replay listener error, removing:`, err?.message ?? err);
-            removeListener(callback, "replay error");
-            return { success: false, error: "Listener removed during replay" };
-          }
-        }
-        if (listeners.indexOf(callback) < 0) {
-          return { success: false, error: "Listener was removed during replay" };
-        }
-        try {
-          const result = callback.onUpdate({
-            type: "update-session",
-            sessionId,
-            metadata: { value: metadata, version: metadataVersion },
-            agentState: { value: agentState, version: agentStateVersion }
-          });
-          if (result && typeof result.catch === "function") {
-            result.catch(() => {
-            });
-          }
-        } catch {
-        }
-        try {
-          const result = callback.onUpdate({
-            type: "activity",
-            sessionId,
-            ...lastActivity
-          });
-          if (result && typeof result.catch === "function") {
-            result.catch(() => {
-            });
-          }
-        } catch {
-        }
-        return { success: true, listenerId: listeners.length - 1 };
-      }
-    },
-    { overwrite: true }
-  );
-  console.log(`[HYPHA SESSION] Session service registered: ${serviceInfo.id}`);
-  return {
-    serviceInfo,
-    pushMessage,
-    get _agentState() {
-      return agentState;
-    },
-    updateMetadata: (newMetadata) => {
-      metadata = newMetadata;
-      metadataVersion++;
-      notifyListeners({
-        type: "update-session",
-        sessionId,
-        metadata: { value: metadata, version: metadataVersion }
-      });
-    },
-    updateAgentState: (newAgentState) => {
-      agentState = newAgentState;
-      agentStateVersion++;
-      notifyListeners({
-        type: "update-session",
-        sessionId,
-        agentState: { value: agentState, version: agentStateVersion }
-      });
-    },
-    sendKeepAlive: (thinking, mode) => {
-      lastActivity = { active: true, thinking: thinking || false, mode: mode || "remote", time: Date.now() };
-      notifyListeners({
-        type: "activity",
-        sessionId,
-        ...lastActivity
-      });
-    },
-    sendSessionEnd: () => {
-      lastActivity = { active: false, thinking: false, mode: "remote", time: Date.now() };
-      notifyListeners({
-        type: "activity",
-        sessionId,
-        ...lastActivity
-      });
-    },
-    disconnect: async () => {
-      await server.unregisterService(serviceInfo.id);
-    }
-  };
-}
-
-async function registerDebugService(server, machineId, deps) {
-  const serviceInfo = await server.registerService(
-    {
-      id: `svamp-debug-${machineId}`,
-      name: `Svamp Debug ${machineId.slice(0, 8)}`,
-      type: "svamp-debug",
-      config: { visibility: "public" },
-      healthCheck: async () => ({
-        ok: true,
-        machineId,
-        uptime: process.uptime(),
-        timestamp: Date.now()
-      }),
-      getSessionStates: async () => {
-        const sessions = deps.getTrackedSessions();
-        const states = [];
-        for (const s of sessions) {
-          let activityState = null;
-          try {
-            const svc = deps.getSessionService(s.sessionId);
-            if (svc) {
-              activityState = await svc.getActivityState?.();
-            }
-          } catch {
-          }
-          states.push({
-            sessionId: s.sessionId,
-            active: s.active,
-            pid: s.pid,
-            startedBy: s.startedBy,
-            directory: s.directory,
-            activityState
-          });
-        }
-        return states;
-      },
-      getMachineInfo: async () => ({
-        machineId,
-        hostname: (await import('os')).hostname(),
-        platform: (await import('os')).platform(),
-        uptime: process.uptime(),
-        sessions: deps.getTrackedSessions().length
-      }),
-      // ── Artifact Sync RPCs ──
-      getArtifactSyncStatus: async () => {
-        const sync = deps.getArtifactSync?.();
-        if (!sync) return { error: "Artifact sync not available" };
-        return sync.getStatus();
-      },
-      forceSyncAll: async () => {
-        const sync = deps.getArtifactSync?.();
-        const sessionsDir = deps.getSessionsDir?.();
-        if (!sync || !sessionsDir) return { error: "Artifact sync not available" };
-        await sync.syncAll(sessionsDir, machineId);
-        return { success: true, status: sync.getStatus() };
-      },
-      listRemoteSessions: async () => {
-        const sync = deps.getArtifactSync?.();
-        if (!sync) return [];
-        return await sync.listRemoteSessions();
-      }
-    },
-    { overwrite: true }
-  );
-  return {
-    disconnect: async () => {
-      await server.unregisterService(serviceInfo.id);
-    }
-  };
-}
-
-const COLLECTION_ALIAS = "svamp-agent-sessions";
-class SessionArtifactSync {
-  server;
-  artifactManager = null;
-  collectionId = null;
-  initialized = false;
-  syncing = false;
-  lastSyncAt = null;
-  syncedSessions = /* @__PURE__ */ new Set();
-  error = null;
-  syncTimers = /* @__PURE__ */ new Map();
-  log;
-  constructor(server, log) {
-    this.server = server;
-    this.log = log;
-  }
-  async init() {
-    try {
-      this.artifactManager = await this.server.getService("public/artifact-manager");
-      if (!this.artifactManager) {
-        this.log("[ARTIFACT SYNC] Artifact manager service not available");
-        this.error = "Artifact manager not available";
-        return;
-      }
-      await this.ensureCollection();
-      this.initialized = true;
-      this.log("[ARTIFACT SYNC] Initialized successfully");
-    } catch (err) {
-      this.error = `Init failed: ${err.message}`;
-      this.log(`[ARTIFACT SYNC] Init failed: ${err.message}`);
-    }
-  }
-  async ensureCollection() {
-    try {
-      const existing = await this.artifactManager.read({
-        artifact_id: COLLECTION_ALIAS,
-        _rkwargs: true
-      });
-      this.collectionId = existing.id;
-      this.log(`[ARTIFACT SYNC] Found existing collection: ${this.collectionId}`);
-    } catch {
-      const collection = await this.artifactManager.create({
-        alias: COLLECTION_ALIAS,
-        type: "collection",
-        manifest: {
-          name: "Svamp Agent Sessions",
-          description: "Cloud-persisted session data for cross-machine continuity"
-        },
-        _rkwargs: true
-      });
-      this.collectionId = collection.id;
-      await this.artifactManager.commit({
-        artifact_id: this.collectionId,
-        _rkwargs: true
-      });
-      this.log(`[ARTIFACT SYNC] Created new collection: ${this.collectionId}`);
-    }
-  }
-  /**
-   * Upload a file to an artifact using the presigned URL pattern:
-   * 1. put_file() returns a presigned upload URL
-   * 2. HTTP PUT the content to that URL
-   */
-  async uploadFile(artifactId, filePath, content) {
-    const putUrl = await this.artifactManager.put_file({
-      artifact_id: artifactId,
-      file_path: filePath,
-      _rkwargs: true
-    });
-    if (!putUrl || typeof putUrl !== "string") {
-      throw new Error(`put_file returned invalid URL for ${filePath}: ${putUrl}`);
-    }
-    const resp = await fetch(putUrl, {
-      method: "PUT",
-      body: content,
-      headers: { "Content-Type": "application/octet-stream" }
-    });
-    if (!resp.ok) {
-      throw new Error(`Upload failed for ${filePath}: ${resp.status} ${resp.statusText}`);
-    }
-  }
-  /**
-   * Download a file from an artifact using the presigned URL pattern:
-   * 1. get_file() returns a presigned download URL
-   * 2. HTTP GET the content from that URL
-   */
-  async downloadFile(artifactId, filePath) {
-    const getUrl = await this.artifactManager.get_file({
-      artifact_id: artifactId,
-      file_path: filePath,
-      _rkwargs: true
-    });
-    if (!getUrl || typeof getUrl !== "string") return null;
-    const resp = await fetch(getUrl);
-    if (!resp.ok) return null;
-    return await resp.text();
-  }
-  /**
-   * Sync a session's metadata and messages to the artifact store.
-   * Creates the artifact if it doesn't exist, updates if it does.
-   */
-  async syncSession(sessionId, sessionsDir, metadata, machineId) {
-    if (!this.initialized || !this.artifactManager || !this.collectionId) {
-      this.log(`[ARTIFACT SYNC] Not initialized, skipping sync for ${sessionId}`);
-      return;
-    }
-    this.syncing = true;
-    try {
-      const artifactAlias = `session-${sessionId}`;
-      const sessionJsonPath = join(sessionsDir, "session.json");
-      const messagesPath = join(sessionsDir, "messages.jsonl");
-      const sessionData = existsSync(sessionJsonPath) ? JSON.parse(readFileSync(sessionJsonPath, "utf-8")) : null;
-      const messagesExist = existsSync(messagesPath);
-      const messageCount = messagesExist ? readFileSync(messagesPath, "utf-8").split("\n").filter((l) => l.trim()).length : 0;
-      let artifactId;
-      try {
-        const existing = await this.artifactManager.read({
-          artifact_id: artifactAlias,
-          _rkwargs: true
-        });
-        artifactId = existing.id;
-        await this.artifactManager.edit({
-          artifact_id: artifactId,
-          manifest: {
-            sessionId,
-            machineId,
-            metadata,
-            messageCount,
-            lastSyncAt: Date.now(),
-            ...sessionData || {}
-          },
-          stage: true,
-          _rkwargs: true
-        });
-      } catch {
-        const artifact = await this.artifactManager.create({
-          alias: artifactAlias,
-          parent_id: this.collectionId,
-          type: "session",
-          manifest: {
-            sessionId,
-            machineId,
-            metadata,
-            messageCount,
-            createdAt: Date.now(),
-            lastSyncAt: Date.now(),
-            ...sessionData || {}
-          },
-          stage: true,
-          _rkwargs: true
-        });
-        artifactId = artifact.id;
-      }
-      if (sessionData) {
-        await this.uploadFile(artifactId, "session.json", JSON.stringify(sessionData, null, 2));
-      }
-      if (messagesExist) {
-        const messagesContent = readFileSync(messagesPath, "utf-8");
-        await this.uploadFile(artifactId, "messages.jsonl", messagesContent);
-      }
-      await this.artifactManager.commit({
-        artifact_id: artifactId,
-        _rkwargs: true
-      });
-      this.syncedSessions.add(sessionId);
-      this.lastSyncAt = Date.now();
-      this.log(`[ARTIFACT SYNC] Synced session ${sessionId} (${messageCount} messages)`);
-    } catch (err) {
-      this.error = `Sync failed for ${sessionId}: ${err.message}`;
-      this.log(`[ARTIFACT SYNC] Sync failed for ${sessionId}: ${err.message}`);
-    } finally {
-      this.syncing = false;
-    }
-  }
-  /**
-   * Schedule a debounced sync for a session (e.g., on each new message).
-   * Waits 30 seconds before syncing to batch multiple messages.
-   */
-  scheduleDebouncedSync(sessionId, sessionsDir, metadata, machineId, delayMs = 3e4) {
-    const existing = this.syncTimers.get(sessionId);
-    if (existing) clearTimeout(existing);
-    const timer = setTimeout(() => {
-      this.syncSession(sessionId, sessionsDir, metadata, machineId).catch(() => {
-      });
-      this.syncTimers.delete(sessionId);
-    }, delayMs);
-    this.syncTimers.set(sessionId, timer);
-  }
-  /**
-   * Download a session from artifact store to local disk.
-   */
-  async downloadSession(sessionId, targetDir) {
-    if (!this.initialized || !this.artifactManager) return null;
-    try {
-      const artifactAlias = `session-${sessionId}`;
-      const artifact = await this.artifactManager.read({
-        artifact_id: artifactAlias,
-        _rkwargs: true
-      });
-      if (!existsSync(targetDir)) mkdirSync(targetDir, { recursive: true });
-      try {
-        const data = await this.downloadFile(artifact.id, "session.json");
-        if (data) {
-          writeFileSync(join(targetDir, "session.json"), data);
-        }
-      } catch {
-      }
-      try {
-        const data = await this.downloadFile(artifact.id, "messages.jsonl");
-        if (data) {
-          writeFileSync(join(targetDir, "messages.jsonl"), data);
-        }
-      } catch {
-      }
-      return {
-        sessionData: artifact.manifest,
-        messageCount: artifact.manifest?.messageCount || 0
-      };
-    } catch (err) {
-      this.log(`[ARTIFACT SYNC] Download failed for ${sessionId}: ${err.message}`);
-      return null;
-    }
-  }
-  /**
-   * List all sessions stored in the artifact collection.
-   */
-  async listRemoteSessions() {
-    if (!this.initialized || !this.artifactManager || !this.collectionId) return [];
-    try {
-      const children = await this.artifactManager.list({
-        parent_id: this.collectionId,
-        _rkwargs: true
-      });
-      return (children || []).map((child) => ({
-        sessionId: child.manifest?.sessionId || child.alias?.replace("session-", ""),
-        machineId: child.manifest?.machineId,
-        messageCount: child.manifest?.messageCount || 0,
-        lastSyncAt: child.manifest?.lastSyncAt || 0
-      }));
-    } catch (err) {
-      this.log(`[ARTIFACT SYNC] List failed: ${err.message}`);
-      return [];
-    }
-  }
-  /**
-   * Get current sync status.
-   */
-  getStatus() {
-    return {
-      initialized: this.initialized,
-      collectionId: this.collectionId,
-      lastSyncAt: this.lastSyncAt,
-      syncing: this.syncing,
-      syncedSessions: [...this.syncedSessions],
-      error: this.error
-    };
-  }
-  /**
-   * Force sync all known sessions using the session index.
-   * @param svampHome The ~/.svamp/ directory (reads sessions-index.json)
-   */
-  async syncAll(svampHome, machineId) {
-    if (!this.initialized) return;
-    const indexFile = join(svampHome, "sessions-index.json");
-    if (!existsSync(indexFile)) return;
-    try {
-      const index = JSON.parse(readFileSync(indexFile, "utf-8"));
-      for (const [sessionId, entry] of Object.entries(index)) {
-        const sessionDir = join(entry.directory, ".svamp", sessionId);
-        if (existsSync(join(sessionDir, "session.json"))) {
-          await this.syncSession(sessionId, sessionDir, void 0, machineId);
-        }
-      }
-    } catch {
-    }
-  }
-  /**
-   * Cleanup timers on shutdown.
-   */
-  destroy() {
-    for (const timer of this.syncTimers.values()) {
-      clearTimeout(timer);
-    }
-    this.syncTimers.clear();
-  }
-}
-
-const DEFAULT_TIMEOUTS = {
-  init: 6e4,
-  toolCall: 12e4,
-  think: 3e4
-};
-class DefaultTransport {
-  agentName;
-  constructor(agentName = "generic-acp") {
-    this.agentName = agentName;
-  }
-  getInitTimeout() {
-    return DEFAULT_TIMEOUTS.init;
-  }
-  filterStdoutLine(line) {
-    const trimmed = line.trim();
-    if (!trimmed) return null;
-    if (!trimmed.startsWith("{") && !trimmed.startsWith("[")) return null;
-    try {
-      const parsed = JSON.parse(trimmed);
-      if (typeof parsed !== "object" || parsed === null) return null;
-      return line;
-    } catch {
-      return null;
-    }
-  }
-  handleStderr(_text, _context) {
-    return { message: null };
-  }
-  getToolPatterns() {
-    return [];
-  }
-  isInvestigationTool(_toolCallId, _toolKind) {
-    return false;
-  }
-  getToolCallTimeout(_toolCallId, toolKind) {
-    if (toolKind === "think") return DEFAULT_TIMEOUTS.think;
-    return DEFAULT_TIMEOUTS.toolCall;
-  }
-  extractToolNameFromId(_toolCallId) {
-    return null;
-  }
-  determineToolName(toolName, _toolCallId, _input, _context) {
-    return toolName;
-  }
-}
-
-var DefaultTransport$1 = /*#__PURE__*/Object.freeze({
-    __proto__: null,
-    DefaultTransport: DefaultTransport
-});
-
-const SVAMP_TOOLS_DIR$1 = join(homedir(), ".svamp", "tools");
-const SVAMP_TOOLS_BIN$1 = join(SVAMP_TOOLS_DIR$1, "node_modules", ".bin");
-const SVAMP_TOOLS_RG_BIN$1 = join(SVAMP_TOOLS_DIR$1, "node_modules", "@vscode", "ripgrep", "bin");
-function wrapWithIsolation(originalCommand, originalArgs, config) {
-  switch (config.method) {
-    case "srt":
-      return wrapWithSrt(originalCommand, originalArgs, config);
-    case "bwrap":
-      return wrapWithBwrap(originalCommand, originalArgs, config);
-    case "docker":
-      return wrapWithContainer("docker", originalCommand, originalArgs, config);
-    case "podman":
-      return wrapWithContainer("podman", originalCommand, originalArgs, config);
-  }
-}
-function wrapWithSrt(command, args, config) {
-  const settings = {
-    filesystem: {
-      denyRead: config.srtConfig?.filesystem?.denyRead ?? [],
-      allowWrite: config.srtConfig?.filesystem?.allowWrite ?? [config.workspacePath],
-      denyWrite: config.srtConfig?.filesystem?.denyWrite ?? []
-    },
-    network: {
-      allowedDomains: config.srtConfig?.network?.allowedDomains ?? [],
-      deniedDomains: config.srtConfig?.network?.deniedDomains ?? []
-    }
-  };
-  const settingsPath = join(tmpdir(), `srt-settings-${process.pid}-${Date.now()}.json`);
-  writeFileSync(settingsPath, JSON.stringify(settings));
-  const pathParts = [SVAMP_TOOLS_BIN$1, SVAMP_TOOLS_RG_BIN$1];
-  if (process.env.PATH) pathParts.push(process.env.PATH);
-  return {
-    command: config.binaryPath,
-    args: ["--settings", settingsPath, command, ...args],
-    env: { PATH: pathParts.join(":") },
-    cleanupFiles: [settingsPath]
-  };
-}
-function wrapWithBwrap(command, args, config) {
-  const bwrapArgs = [
-    // Mount root filesystem read-only
-    "--ro-bind",
-    "/",
-    "/",
-    // Mount workspace read-write
-    "--bind",
-    config.workspacePath,
-    config.workspacePath,
-    // Mount /tmp read-write (many tools need it)
-    "--bind",
-    "/tmp",
-    "/tmp",
-    // Mount /dev read-write
-    "--dev",
-    "/dev",
-    // Mount /proc
-    "--proc",
-    "/proc",
-    // Unshare network — no network access inside sandbox
-    "--unshare-net",
-    // Unshare PID namespace
-    "--unshare-pid",
-    // Die when parent dies
-    "--die-with-parent",
-    // The actual command
-    "--",
-    command,
-    ...args
-  ];
-  return {
-    command: config.binaryPath,
-    args: bwrapArgs
-  };
-}
-function wrapWithContainer(runtime, command, args, config) {
-  const image = config.containerConfig?.image || "node:lts-slim";
-  const networkMode = config.containerConfig?.networkMode || "none";
-  const containerArgs = [
-    "run",
-    "--rm",
-    "-i",
-    // interactive (for stdin/stdout piping)
-    `--network=${networkMode}`,
-    "-v",
-    `${config.workspacePath}:${config.workspacePath}`,
-    "-w",
-    config.workspacePath
-  ];
-  if (config.containerConfig?.extraMounts) {
-    for (const mount of config.containerConfig.extraMounts) {
-      containerArgs.push("-v", mount);
-    }
-  }
-  containerArgs.push(image, command, ...args);
-  return {
-    command: config.binaryPath,
-    args: containerArgs
-  };
-}
-
-const DEFAULT_IDLE_TIMEOUT_MS = 500;
-const DEFAULT_TOOL_CALL_TIMEOUT_MS = 12e4;
-function parseArgsFromContent(content) {
-  if (Array.isArray(content)) return { items: content };
-  if (content && typeof content === "object" && content !== null) {
-    return content;
-  }
-  return {};
-}
-function extractErrorDetail(content) {
-  if (!content) return void 0;
-  if (typeof content === "string") return content;
-  if (typeof content === "object" && content !== null && !Array.isArray(content)) {
-    const obj = content;
-    if (obj.error) {
-      const error = obj.error;
-      if (typeof error === "string") return error;
-      if (error && typeof error === "object" && "message" in error) {
-        const errObj = error;
-        if (typeof errObj.message === "string") return errObj.message;
-      }
-      return JSON.stringify(error);
-    }
-    if (typeof obj.message === "string") return obj.message;
-    const status = typeof obj.status === "string" ? obj.status : void 0;
-    const reason = typeof obj.reason === "string" ? obj.reason : void 0;
-    return status || reason || JSON.stringify(obj).substring(0, 500);
-  }
-  return void 0;
-}
-function formatDuration(startTime) {
-  if (!startTime) return "unknown";
-  const duration = Date.now() - startTime;
-  return `${(duration / 1e3).toFixed(2)}s`;
-}
-function handleAgentMessageChunk(update, ctx) {
-  const content = update.content;
-  if (!content || typeof content !== "object" || !("text" in content)) {
-    return { handled: false };
-  }
-  const text = content.text;
-  if (typeof text !== "string") return { handled: false };
-  const isThinking = /^\*\*[^*]+\*\*\n/.test(text);
-  if (isThinking) {
-    ctx.emit({ type: "event", name: "thinking", payload: { text, streaming: true } });
-  } else {
-    ctx.emit({ type: "model-output", textDelta: text });
-    ctx.clearIdleTimeout();
-    const idleTimeoutMs = ctx.transport.getIdleTimeout?.() ?? DEFAULT_IDLE_TIMEOUT_MS;
-    ctx.setIdleTimeout(() => {
-      if (ctx.activeToolCalls.size === 0) {
-        ctx.emitIdleStatus();
-      }
-    }, idleTimeoutMs);
-  }
-  return { handled: true };
-}
-function handleAgentThoughtChunk(update, ctx) {
-  const content = update.content;
-  if (!content || typeof content !== "object" || !("text" in content)) {
-    return { handled: false };
-  }
-  const text = content.text;
-  if (typeof text !== "string") return { handled: false };
-  ctx.emit({ type: "event", name: "thinking", payload: { text, streaming: true } });
-  return { handled: true };
-}
-function startToolCall(toolCallId, toolKind, update, ctx, source) {
-  const startTime = Date.now();
-  const toolKindStr = typeof toolKind === "string" ? toolKind : void 0;
-  const isInvestigation = ctx.transport.isInvestigationTool?.(toolCallId, toolKindStr) ?? false;
-  const extractedName = ctx.transport.extractToolNameFromId?.(toolCallId);
-  const realToolName = extractedName ?? (toolKindStr || "unknown");
-  ctx.toolCallIdToNameMap.set(toolCallId, realToolName);
-  ctx.activeToolCalls.add(toolCallId);
-  ctx.toolCallStartTimes.set(toolCallId, startTime);
-  ctx.log(`Tool call START: ${toolCallId} (${toolKind} -> ${realToolName})${isInvestigation ? " [INVESTIGATION]" : ""} (from ${source})`);
-  const timeoutMs = ctx.transport.getToolCallTimeout?.(toolCallId, toolKindStr) ?? DEFAULT_TOOL_CALL_TIMEOUT_MS;
-  if (!ctx.toolCallTimeouts.has(toolCallId)) {
-    const timeout = setTimeout(() => {
-      ctx.activeToolCalls.delete(toolCallId);
-      ctx.toolCallStartTimes.delete(toolCallId);
-      ctx.toolCallTimeouts.delete(toolCallId);
-      ctx.log(`Tool call TIMEOUT: ${toolCallId} (${toolKind}) after ${(timeoutMs / 1e3).toFixed(0)}s`);
-      if (ctx.activeToolCalls.size === 0) {
-        ctx.emitIdleStatus();
-      }
-    }, timeoutMs);
-    ctx.toolCallTimeouts.set(toolCallId, timeout);
-  }
-  ctx.clearIdleTimeout();
-  ctx.emit({ type: "status", status: "running" });
-  const args = parseArgsFromContent(update.content);
-  if (update.locations && Array.isArray(update.locations)) {
-    args.locations = update.locations;
-  }
-  ctx.emit({
-    type: "tool-call",
-    toolName: toolKindStr || "unknown",
-    args,
-    callId: toolCallId
-  });
-}
-function completeToolCall(toolCallId, toolKind, content, ctx) {
-  const startTime = ctx.toolCallStartTimes.get(toolCallId);
-  const duration = formatDuration(startTime);
-  const toolKindStr = typeof toolKind === "string" ? toolKind : "unknown";
-  ctx.activeToolCalls.delete(toolCallId);
-  ctx.toolCallStartTimes.delete(toolCallId);
-  const timeout = ctx.toolCallTimeouts.get(toolCallId);
-  if (timeout) {
-    clearTimeout(timeout);
-    ctx.toolCallTimeouts.delete(toolCallId);
-  }
-  ctx.log(`Tool call COMPLETED: ${toolCallId} (${toolKindStr}) - ${duration}. Active: ${ctx.activeToolCalls.size}`);
-  ctx.emit({ type: "tool-result", toolName: toolKindStr, result: content, callId: toolCallId });
-  if (ctx.activeToolCalls.size === 0) {
-    ctx.clearIdleTimeout();
-    ctx.emitIdleStatus();
-  }
-}
-function failToolCall(toolCallId, status, toolKind, content, ctx) {
-  const startTime = ctx.toolCallStartTimes.get(toolCallId);
-  const duration = formatDuration(startTime);
-  const toolKindStr = typeof toolKind === "string" ? toolKind : "unknown";
-  ctx.activeToolCalls.delete(toolCallId);
-  ctx.toolCallStartTimes.delete(toolCallId);
-  const timeout = ctx.toolCallTimeouts.get(toolCallId);
-  if (timeout) {
-    clearTimeout(timeout);
-    ctx.toolCallTimeouts.delete(toolCallId);
-  }
-  const errorDetail = extractErrorDetail(content);
-  ctx.log(`Tool call ${status.toUpperCase()}: ${toolCallId} (${toolKindStr}) - ${duration}. Active: ${ctx.activeToolCalls.size}`);
-  ctx.emit({
-    type: "tool-result",
-    toolName: toolKindStr,
-    result: errorDetail ? { error: errorDetail, status } : { error: `Tool call ${status}`, status },
-    callId: toolCallId
-  });
-  if (ctx.activeToolCalls.size === 0) {
-    ctx.clearIdleTimeout();
-    ctx.emitIdleStatus();
-  }
-}
-function handleToolCallUpdate(update, ctx) {
-  const status = update.status;
-  const toolCallId = update.toolCallId;
-  if (!toolCallId) return { handled: false };
-  const toolKind = update.kind || "unknown";
-  let toolCallCountSincePrompt = ctx.toolCallCountSincePrompt;
-  if (status === "in_progress" || status === "pending") {
-    if (!ctx.activeToolCalls.has(toolCallId)) {
-      toolCallCountSincePrompt++;
-      startToolCall(toolCallId, toolKind, update, ctx, "tool_call_update");
-    }
-  } else if (status === "completed") {
-    completeToolCall(toolCallId, toolKind, update.content, ctx);
-  } else if (status === "failed" || status === "cancelled") {
-    failToolCall(toolCallId, status, toolKind, update.content, ctx);
-  }
-  return { handled: true, toolCallCountSincePrompt };
-}
-function handleToolCall(update, ctx) {
-  const toolCallId = update.toolCallId;
-  const status = update.status;
-  const isInProgress = !status || status === "in_progress" || status === "pending";
-  if (!toolCallId || !isInProgress) return { handled: false };
-  if (ctx.activeToolCalls.has(toolCallId)) return { handled: true };
-  startToolCall(toolCallId, update.kind, update, ctx, "tool_call");
-  return { handled: true };
-}
-function handleLegacyMessageChunk(update, ctx) {
-  if (!update.messageChunk) return { handled: false };
-  const chunk = update.messageChunk;
-  if (chunk.textDelta) {
-    ctx.emit({ type: "model-output", textDelta: chunk.textDelta });
-    return { handled: true };
-  }
-  return { handled: false };
-}
-function handlePlanUpdate(update, ctx) {
-  if (!update.plan) return { handled: false };
-  ctx.emit({ type: "event", name: "plan", payload: update.plan });
-  return { handled: true };
-}
-function handleThinkingUpdate(update, ctx) {
-  if (!update.thinking) return { handled: false };
-  ctx.emit({ type: "event", name: "thinking", payload: update.thinking });
-  return { handled: true };
-}
-
-function delay(ms) {
-  return new Promise((resolve) => setTimeout(resolve, ms));
-}
-const RETRY_CONFIG = {
-  maxAttempts: 3,
-  baseDelayMs: 1e3,
-  maxDelayMs: 5e3
-};
-function nodeToWebStreams(stdin, stdout) {
-  const writable = new WritableStream({
-    write(chunk) {
-      return new Promise((resolve, reject) => {
-        const ok = stdin.write(chunk, (err) => {
-          if (err) reject(err);
-        });
-        if (ok) resolve();
-        else stdin.once("drain", resolve);
-      });
-    },
-    close() {
-      return new Promise((resolve) => {
-        stdin.end(resolve);
-      });
-    },
-    abort(reason) {
-      stdin.destroy(reason instanceof Error ? reason : new Error(String(reason)));
-    }
-  });
-  const readable = new ReadableStream({
-    start(controller) {
-      stdout.on("data", (chunk) => {
-        controller.enqueue(new Uint8Array(chunk));
-      });
-      stdout.on("end", () => {
-        controller.close();
-      });
-      stdout.on("error", (err) => {
-        controller.error(err);
-      });
-    },
-    cancel() {
-      stdout.destroy();
-    }
-  });
-  return { writable, readable };
-}
-async function withRetry(operation, opts) {
-  let lastError = null;
-  const log = opts.log || (() => {
-  });
-  for (let attempt = 1; attempt <= opts.maxAttempts; attempt++) {
-    try {
-      return await operation();
-    } catch (error) {
-      if (error instanceof Error) {
-        lastError = error;
-      } else if (typeof error === "object" && error !== null) {
-        const obj = error;
-        const msg = typeof obj.message === "string" ? obj.message : JSON.stringify(error);
-        lastError = new Error(msg);
-      } else {
-        lastError = new Error(String(error));
-      }
-      const shouldRetry = opts.shouldRetry ? opts.shouldRetry(lastError) : true;
-      if (attempt < opts.maxAttempts && shouldRetry) {
-        const delayMs = Math.min(opts.baseDelayMs * Math.pow(2, attempt - 1), opts.maxDelayMs);
-        log(`${opts.operationName} failed (attempt ${attempt}/${opts.maxAttempts}): ${lastError.message}. Retrying in ${delayMs}ms...`);
-        await delay(delayMs);
-      } else {
-        break;
-      }
-    }
-  }
-  throw lastError;
-}
-class AcpBackend {
-  constructor(options) {
-    this.options = options;
-    this.transport = options.transportHandler ?? new DefaultTransport(options.agentName);
-    this.log = options.log || ((...args) => {
-    });
-  }
-  listeners = [];
-  process = null;
-  connection = null;
-  acpSessionId = null;
-  disposed = false;
-  activeToolCalls = /* @__PURE__ */ new Set();
-  toolCallTimeouts = /* @__PURE__ */ new Map();
-  toolCallStartTimes = /* @__PURE__ */ new Map();
-  toolCallIdToNameMap = /* @__PURE__ */ new Map();
-  recentPromptHadChangeTitle = false;
-  toolCallCountSincePrompt = 0;
-  idleTimeout = null;
-  transport;
-  log;
-  // Promise resolver for waitForIdle
-  idleResolver = null;
-  waitingForResponse = false;
-  onMessage(handler) {
-    this.listeners.push(handler);
-  }
-  offMessage(handler) {
-    const index = this.listeners.indexOf(handler);
-    if (index !== -1) this.listeners.splice(index, 1);
-  }
-  emit(msg) {
-    if (this.disposed) return;
-    for (const listener of this.listeners) {
-      try {
-        listener(msg);
-      } catch {
-      }
-    }
-  }
-  /** Get the underlying child process (for cleanup) */
-  getProcess() {
-    return this.process;
-  }
-  async startSession(initialPrompt) {
-    if (this.disposed) throw new Error("Backend has been disposed");
-    const sessionId = randomUUID();
-    this.emit({ type: "status", status: "starting" });
-    let startupStatusErrorEmitted = false;
-    try {
-      const args = this.options.args || [];
-      let spawnCommand = this.options.command;
-      let spawnArgs = args;
-      let isoEnv = {};
-      let isoCleanupFiles = [];
-      if (this.options.isolationConfig) {
-        const wrapped = wrapWithIsolation(spawnCommand, spawnArgs, this.options.isolationConfig);
-        spawnCommand = wrapped.command;
-        spawnArgs = wrapped.args;
-        if (wrapped.env) isoEnv = wrapped.env;
-        if (wrapped.cleanupFiles) isoCleanupFiles = wrapped.cleanupFiles;
-        this.log(`[ACP] Isolation: ${this.options.isolationConfig.method}`);
-      }
-      const spawnEnv = { ...process.env, ...this.options.env, ...isoEnv };
-      if (process.platform === "win32") {
-        const fullCommand = [spawnCommand, ...spawnArgs].join(" ");
-        this.process = spawn("cmd.exe", ["/c", fullCommand], {
-          cwd: this.options.cwd,
-          env: spawnEnv,
-          stdio: ["pipe", "pipe", "pipe"],
-          windowsHide: true
-        });
-      } else {
-        this.process = spawn(spawnCommand, spawnArgs, {
-          cwd: this.options.cwd,
-          env: spawnEnv,
-          stdio: ["pipe", "pipe", "pipe"]
-        });
-      }
-      if (isoCleanupFiles.length > 0) {
-        this.process.on("exit", async () => {
-          const { rm } = await import('node:fs/promises');
-          for (const f of isoCleanupFiles) rm(f, { force: true }).catch(() => {
-          });
-        });
-      }
-      if (!this.process.stdin || !this.process.stdout || !this.process.stderr) {
-        throw new Error("Failed to create stdio pipes");
-      }
-      let startupFailure = null;
-      let startupFailureSettled = false;
-      let rejectStartupFailure = null;
-      const startupFailurePromise = new Promise((_, reject) => {
-        rejectStartupFailure = (error) => {
-          if (startupFailureSettled) return;
-          startupFailureSettled = true;
-          startupFailure = error;
-          reject(error);
-        };
-      });
-      const signalStartupFailure = (error) => {
-        rejectStartupFailure?.(error);
-      };
-      this.process.stderr.on("data", (data) => {
-        const text = data.toString();
-        if (!text.trim()) return;
-        const hasActiveInvestigation = this.transport.isInvestigationTool ? Array.from(this.activeToolCalls).some((id) => this.transport.isInvestigationTool(id)) : false;
-        const context = {
-          activeToolCalls: this.activeToolCalls,
-          hasActiveInvestigation
-        };
-        this.log(`[ACP] stderr: ${text.trim()}`);
-        if (this.transport.handleStderr) {
-          const result = this.transport.handleStderr(text, context);
-          if (result.message) this.emit(result.message);
-        }
-      });
-      this.process.on("error", (err) => {
-        signalStartupFailure(err);
-        this.log(`[ACP] Process error: ${err.message}`);
-        startupStatusErrorEmitted = true;
-        this.emit({ type: "status", status: "error", detail: err.message });
-      });
-      this.process.on("exit", (code, signal) => {
-        if (!this.disposed && code !== 0 && code !== null) {
-          signalStartupFailure(new Error(`Exit code: ${code}`));
-          this.log(`[ACP] Process exited: code=${code}, signal=${signal}`);
-          this.emit({ type: "status", status: "stopped", detail: `Exit code: ${code}` });
-        }
-      });
-      const streams = nodeToWebStreams(this.process.stdin, this.process.stdout);
-      const transport = this.transport;
-      const logFn = this.log;
-      const filteredReadable = new ReadableStream({
-        async start(controller) {
-          const reader = streams.readable.getReader();
-          const decoder = new TextDecoder();
-          const encoder = new TextEncoder();
-          let buffer = "";
-          let filteredCount = 0;
-          try {
-            while (true) {
-              const { done, value } = await reader.read();
-              if (done) {
-                if (buffer.trim()) {
-                  const filtered = transport.filterStdoutLine?.(buffer);
-                  if (filtered === void 0) controller.enqueue(encoder.encode(buffer));
-                  else if (filtered !== null) controller.enqueue(encoder.encode(filtered));
-                  else filteredCount++;
-                }
-                if (filteredCount > 0) {
-                  logFn(`[ACP] Filtered ${filteredCount} non-JSON lines from ${transport.agentName} stdout`);
-                }
-                controller.close();
-                break;
-              }
-              buffer += decoder.decode(value, { stream: true });
-              const lines = buffer.split("\n");
-              buffer = lines.pop() || "";
-              for (const line of lines) {
-                if (!line.trim()) continue;
-                const filtered = transport.filterStdoutLine?.(line);
-                if (filtered === void 0) controller.enqueue(encoder.encode(line + "\n"));
-                else if (filtered !== null) controller.enqueue(encoder.encode(filtered + "\n"));
-                else filteredCount++;
-              }
-            }
-          } catch (error) {
-            controller.error(error);
-          } finally {
-            reader.releaseLock();
-          }
-        }
-      });
-      const stream = ndJsonStream(streams.writable, filteredReadable);
-      const client = {
-        sessionUpdate: async (params) => {
-          this.handleSessionUpdate(params);
-        },
-        requestPermission: async (params) => {
-          const extendedParams = params;
-          const toolCall = extendedParams.toolCall;
-          let toolName = toolCall?.kind || toolCall?.toolName || extendedParams.kind || "Unknown tool";
-          const toolCallId = toolCall?.id || randomUUID();
-          const permissionId = toolCallId;
-          let input = {};
-          if (toolCall) {
-            input = toolCall.input || toolCall.arguments || toolCall.content || {};
-          } else {
-            input = extendedParams.input || extendedParams.arguments || extendedParams.content || {};
-          }
-          const context = {
-            recentPromptHadChangeTitle: this.recentPromptHadChangeTitle,
-            toolCallCountSincePrompt: this.toolCallCountSincePrompt
-          };
-          toolName = this.transport.determineToolName?.(toolName, toolCallId, input, context) ?? toolName;
-          this.toolCallCountSincePrompt++;
-          const options = extendedParams.options || [];
-          this.log(`[ACP] Permission request: tool=${toolName}, toolCallId=${toolCallId}`);
-          this.emit({
-            type: "permission-request",
-            id: permissionId,
-            reason: toolName,
-            payload: {
-              ...params,
-              permissionId,
-              toolCallId,
-              toolName,
-              input,
-              options: options.map((opt) => ({
-                id: opt.optionId,
-                name: opt.name,
-                kind: opt.kind
-              }))
-            }
-          });
-          if (this.options.permissionHandler) {
-            try {
-              const result = await this.options.permissionHandler.handleToolCall(toolCallId, toolName, input);
-              let optionId = "cancel";
-              if (result.decision === "approved" || result.decision === "approved_for_session") {
-                const proceedOnceOption2 = options.find(
-                  (opt) => opt.optionId === "proceed_once" || opt.name?.toLowerCase().includes("once")
-                );
-                const proceedAlwaysOption = options.find(
-                  (opt) => opt.optionId === "proceed_always" || opt.name?.toLowerCase().includes("always")
-                );
-                if (result.decision === "approved_for_session" && proceedAlwaysOption) {
-                  optionId = proceedAlwaysOption.optionId || "proceed_always";
-                } else if (proceedOnceOption2) {
-                  optionId = proceedOnceOption2.optionId || "proceed_once";
-                } else if (options.length > 0) {
-                  optionId = options[0].optionId || "proceed_once";
-                }
-                this.emit({
-                  type: "tool-result",
-                  toolName,
-                  result: { status: "approved", decision: result.decision },
-                  callId: permissionId
-                });
-              } else {
-                const cancelOption = options.find(
-                  (opt) => opt.optionId === "cancel" || opt.name?.toLowerCase().includes("cancel")
-                );
-                if (cancelOption) optionId = cancelOption.optionId || "cancel";
-                this.emit({
-                  type: "tool-result",
-                  toolName,
-                  result: { status: "denied", decision: result.decision },
-                  callId: permissionId
-                });
-              }
-              return { outcome: { outcome: "selected", optionId } };
-            } catch (error) {
-              this.log("[ACP] Error in permission handler:", error);
-              return { outcome: { outcome: "selected", optionId: "cancel" } };
-            }
-          }
-          const proceedOnceOption = options.find(
-            (opt) => opt.optionId === "proceed_once" || typeof opt.name === "string" && opt.name.toLowerCase().includes("once")
-          );
-          const defaultOptionId = proceedOnceOption?.optionId || (options.length > 0 && options[0].optionId ? options[0].optionId : "proceed_once");
-          return { outcome: { outcome: "selected", optionId: defaultOptionId } };
-        }
-      };
-      this.connection = new ClientSideConnection(
-        (agent) => client,
-        stream
-      );
-      const initRequest = {
-        protocolVersion: 1,
-        clientCapabilities: {
-          fs: { readTextFile: false, writeTextFile: false }
-        },
-        clientInfo: { name: "svamp-cli", version: "0.1.0" }
-      };
-      const initTimeout = this.transport.getInitTimeout();
-      this.log(`[ACP] Initializing connection (timeout: ${initTimeout}ms)...`);
-      const isNonRetryableStartupError = (error) => {
-        const maybeErr = error;
-        if (startupFailure && error === startupFailure) return true;
-        if (maybeErr.code === "ENOENT" || maybeErr.code === "EACCES" || maybeErr.code === "EPIPE") return true;
-        const msg = error.message.toLowerCase();
-        if (msg.includes("api key") || msg.includes("not configured") || msg.includes("401") || msg.includes("403")) return true;
-        return false;
-      };
-      await withRetry(
-        async () => {
-          let timeoutHandle = null;
-          try {
-            const result = await Promise.race([
-              startupFailurePromise,
-              this.connection.initialize(initRequest).then((res) => {
-                if (timeoutHandle) {
-                  clearTimeout(timeoutHandle);
-                  timeoutHandle = null;
-                }
-                return res;
-              }),
-              new Promise((_, reject) => {
-                timeoutHandle = setTimeout(() => {
-                  reject(new Error(`Initialize timeout after ${initTimeout}ms - ${this.transport.agentName} did not respond`));
-                }, initTimeout);
-              })
-            ]);
-            return result;
-          } finally {
-            if (timeoutHandle) clearTimeout(timeoutHandle);
-          }
-        },
-        {
-          operationName: "Initialize",
-          maxAttempts: RETRY_CONFIG.maxAttempts,
-          baseDelayMs: RETRY_CONFIG.baseDelayMs,
-          maxDelayMs: RETRY_CONFIG.maxDelayMs,
-          shouldRetry: (error) => !isNonRetryableStartupError(error),
-          log: this.log
-        }
-      );
-      this.log(`[ACP] Initialize completed`);
-      const mcpServers = this.options.mcpServers ? Object.entries(this.options.mcpServers).map(([name, config]) => {
-        if (config.type === "http" && config.url) {
-          return { name, url: config.url };
-        }
-        return {
-          name,
-          command: config.command || "",
-          args: config.args || [],
-          env: config.env ? Object.entries(config.env).map(([envName, envValue]) => ({ name: envName, value: envValue })) : []
-        };
-      }) : [];
-      const newSessionRequest = {
-        cwd: this.options.cwd,
-        mcpServers
-      };
-      this.log(`[ACP] Creating new session...`);
-      const sessionResponse = await withRetry(
-        async () => {
-          let timeoutHandle = null;
-          try {
-            const result = await Promise.race([
-              startupFailurePromise,
-              this.connection.newSession(newSessionRequest).then((res) => {
-                if (timeoutHandle) {
-                  clearTimeout(timeoutHandle);
-                  timeoutHandle = null;
-                }
-                return res;
-              }),
-              new Promise((_, reject) => {
-                timeoutHandle = setTimeout(() => {
-                  reject(new Error(`New session timeout after ${initTimeout}ms - ${this.transport.agentName} did not respond`));
-                }, initTimeout);
-              })
-            ]);
-            return result;
-          } finally {
-            if (timeoutHandle) clearTimeout(timeoutHandle);
-          }
-        },
-        {
-          operationName: "NewSession",
-          maxAttempts: RETRY_CONFIG.maxAttempts,
-          baseDelayMs: RETRY_CONFIG.baseDelayMs,
-          maxDelayMs: RETRY_CONFIG.maxDelayMs,
-          shouldRetry: (error) => !isNonRetryableStartupError(error),
-          log: this.log
-        }
-      );
-      this.acpSessionId = sessionResponse.sessionId;
-      this.log(`[ACP] Session created: ${this.acpSessionId}`);
-      this.emitInitialSessionMetadata(sessionResponse);
-      this.emitIdleStatus();
-      if (initialPrompt) {
-        this.sendPrompt(sessionId, initialPrompt).catch((error) => {
-          this.log("[ACP] Error sending initial prompt:", error);
-          this.emit({ type: "status", status: "error", detail: String(error) });
-        });
-      }
-      return { sessionId };
-    } catch (error) {
-      this.log("[ACP] Error starting session:", error);
-      if (!startupStatusErrorEmitted) {
-        this.emit({
-          type: "status",
-          status: "error",
-          detail: error instanceof Error ? error.message : String(error)
-        });
-      }
-      throw error;
-    }
-  }
-  createHandlerContext() {
-    return {
-      transport: this.transport,
-      activeToolCalls: this.activeToolCalls,
-      toolCallStartTimes: this.toolCallStartTimes,
-      toolCallTimeouts: this.toolCallTimeouts,
-      toolCallIdToNameMap: this.toolCallIdToNameMap,
-      idleTimeout: this.idleTimeout,
-      toolCallCountSincePrompt: this.toolCallCountSincePrompt,
-      emit: (msg) => this.emit(msg),
-      emitIdleStatus: () => this.emitIdleStatus(),
-      clearIdleTimeout: () => {
-        if (this.idleTimeout) {
-          clearTimeout(this.idleTimeout);
-          this.idleTimeout = null;
-        }
-      },
-      setIdleTimeout: (callback, ms) => {
-        this.idleTimeout = setTimeout(() => {
-          callback();
-          this.idleTimeout = null;
-        }, ms);
-      },
-      log: this.log
-    };
-  }
-  emitInitialSessionMetadata(sessionResponse) {
-    if (Array.isArray(sessionResponse.configOptions)) {
-      this.emit({
-        type: "event",
-        name: "config_options_update",
-        payload: { configOptions: sessionResponse.configOptions }
-      });
-    }
-    if (sessionResponse.modes) {
-      this.emit({ type: "event", name: "modes_update", payload: sessionResponse.modes });
-      this.emit({ type: "event", name: "current_mode_update", payload: { currentModeId: sessionResponse.modes.currentModeId } });
-    }
-    if (sessionResponse.models) {
-      this.emit({ type: "event", name: "models_update", payload: sessionResponse.models });
-    }
-  }
-  handleSessionUpdate(params) {
-    const notification = params;
-    const update = notification.update;
-    if (!update) return;
-    const sessionUpdateType = update.sessionUpdate;
-    const updateType = sessionUpdateType;
-    this.log(`[ACP] sessionUpdate: ${sessionUpdateType}`);
-    const ctx = this.createHandlerContext();
-    if (sessionUpdateType === "agent_message_chunk") {
-      handleAgentMessageChunk(update, ctx);
-      return;
-    }
-    if (sessionUpdateType === "tool_call_update") {
-      const result = handleToolCallUpdate(update, ctx);
-      if (result.toolCallCountSincePrompt !== void 0) {
-        this.toolCallCountSincePrompt = result.toolCallCountSincePrompt;
-      }
-      return;
-    }
-    if (sessionUpdateType === "agent_thought_chunk") {
-      handleAgentThoughtChunk(update, ctx);
-      return;
-    }
-    if (sessionUpdateType === "tool_call") {
-      handleToolCall(update, ctx);
-      return;
-    }
-    if (sessionUpdateType === "available_commands_update") {
-      const commands = update.availableCommands;
-      if (Array.isArray(commands)) {
-        this.emit({ type: "event", name: "available_commands", payload: commands });
-      }
-      return;
-    }
-    if (updateType === "config_option_update" || updateType === "config_options_update") {
-      const configOptions = update.configOptions;
-      if (Array.isArray(configOptions)) {
-        this.emit({ type: "event", name: "config_options_update", payload: { configOptions } });
-      }
-      return;
-    }
-    if (updateType === "current_mode_update") {
-      const currentModeId = update.currentModeId;
-      if (typeof currentModeId === "string" && currentModeId.length > 0) {
-        this.emit({ type: "event", name: "current_mode_update", payload: { currentModeId } });
-      }
-      return;
-    }
-    handleLegacyMessageChunk(update, ctx);
-    handlePlanUpdate(update, ctx);
-    handleThinkingUpdate(update, ctx);
-  }
-  emitIdleStatus() {
-    this.emit({ type: "status", status: "idle" });
-    if (this.idleResolver) {
-      this.idleResolver();
-    }
-  }
-  async sendPrompt(sessionId, prompt) {
-    const promptHasChangeTitle = this.options.hasChangeTitleInstruction?.(prompt) ?? false;
-    this.toolCallCountSincePrompt = 0;
-    this.recentPromptHadChangeTitle = promptHasChangeTitle;
-    if (this.disposed) throw new Error("Backend has been disposed");
-    if (!this.connection || !this.acpSessionId) throw new Error("Session not started");
-    this.emit({ type: "status", status: "running" });
-    this.waitingForResponse = true;
-    try {
-      this.log(`[ACP] Sending prompt (length: ${prompt.length})`);
-      const contentBlock = { type: "text", text: prompt };
-      const promptRequest = {
-        sessionId: this.acpSessionId,
-        prompt: [contentBlock]
-      };
-      await this.connection.prompt(promptRequest);
-      this.log("[ACP] Prompt request sent");
-    } catch (error) {
-      this.log("[ACP] Error sending prompt:", error);
-      this.waitingForResponse = false;
-      let errorDetail;
-      if (error instanceof Error) {
-        errorDetail = error.message;
-      } else if (typeof error === "object" && error !== null) {
-        const errObj = error;
-        errorDetail = typeof errObj.message === "string" ? errObj.message : String(error);
-      } else {
-        errorDetail = String(error);
-      }
-      this.emit({ type: "status", status: "error", detail: errorDetail });
-      throw error;
-    }
-  }
-  async waitForResponseComplete(timeoutMs = 12e4) {
-    if (!this.waitingForResponse) return;
-    return new Promise((resolve, reject) => {
-      const timeout = setTimeout(() => {
-        this.idleResolver = null;
-        this.waitingForResponse = false;
-        reject(new Error("Timeout waiting for response to complete"));
-      }, timeoutMs);
-      this.idleResolver = () => {
-        clearTimeout(timeout);
-        this.idleResolver = null;
-        this.waitingForResponse = false;
-        resolve();
-      };
-    });
-  }
-  async cancel(sessionId) {
-    if (!this.connection || !this.acpSessionId) return;
-    try {
-      await this.connection.cancel({ sessionId: this.acpSessionId });
-      this.emit({ type: "status", status: "stopped", detail: "Cancelled by user" });
-    } catch (error) {
-      this.log("[ACP] Error cancelling:", error);
-    }
-  }
-  async respondToPermission(requestId, approved) {
-    this.log(`[ACP] Permission response (UI only): ${requestId} = ${approved}`);
-    this.emit({ type: "permission-response", id: requestId, approved });
-  }
-  async dispose() {
-    if (this.disposed) return;
-    this.log("[ACP] Disposing backend");
-    this.disposed = true;
-    if (this.connection && this.acpSessionId) {
-      try {
-        await Promise.race([
-          this.connection.cancel({ sessionId: this.acpSessionId }),
-          new Promise((resolve) => setTimeout(resolve, 2e3))
-        ]);
-      } catch {
-      }
-    }
-    if (this.process) {
-      this.process.kill("SIGTERM");
-      await new Promise((resolve) => {
-        const timeout = setTimeout(() => {
-          if (this.process) this.process.kill("SIGKILL");
-          resolve();
-        }, 1e3);
-        this.process?.once("exit", () => {
-          clearTimeout(timeout);
-          resolve();
-        });
-      });
-      this.process = null;
-    }
-    if (this.idleTimeout) {
-      clearTimeout(this.idleTimeout);
-      this.idleTimeout = null;
-    }
-    this.listeners = [];
-    this.connection = null;
-    this.acpSessionId = null;
-    this.activeToolCalls.clear();
-    for (const timeout of this.toolCallTimeouts.values()) clearTimeout(timeout);
-    this.toolCallTimeouts.clear();
-    this.toolCallStartTimes.clear();
-  }
-}
-
-var acpBackend = /*#__PURE__*/Object.freeze({
-    __proto__: null,
-    AcpBackend: AcpBackend
-});
-
-const KNOWN_ACP_AGENTS = {
-  gemini: { command: "gemini", args: ["--experimental-acp"] },
-  opencode: { command: "opencode", args: ["acp"] }
-};
-const KNOWN_MCP_AGENTS = {
-  codex: { command: "codex", args: ["mcp-server"] }
-};
-function resolveAcpAgentConfig(cliArgs) {
-  if (cliArgs.length === 0) {
-    throw new Error("Usage: svamp agent <agent-name> or svamp agent -- <command> [args]");
-  }
-  if (cliArgs[0] === "--") {
-    const command = cliArgs[1];
-    if (!command) {
-      throw new Error('Missing command after "--". Usage: svamp agent -- <command> [args]');
-    }
-    return {
-      agentName: command,
-      command,
-      args: cliArgs.slice(2)
-    };
-  }
-  const agentName = cliArgs[0];
-  const knownAcp = KNOWN_ACP_AGENTS[agentName];
-  if (knownAcp) {
-    const passthroughArgs = cliArgs.slice(1).filter((arg) => !(agentName === "opencode" && arg === "--acp"));
-    return {
-      agentName,
-      command: knownAcp.command,
-      args: [...knownAcp.args, ...passthroughArgs]
-    };
-  }
-  const knownMcp = KNOWN_MCP_AGENTS[agentName];
-  if (knownMcp) {
-    return {
-      agentName,
-      command: knownMcp.command,
-      args: [...knownMcp.args, ...cliArgs.slice(1)]
-    };
-  }
-  return {
-    agentName,
-    command: agentName,
-    args: cliArgs.slice(1)
-  };
-}
-
-var acpAgentConfig = /*#__PURE__*/Object.freeze({
-    __proto__: null,
-    KNOWN_ACP_AGENTS: KNOWN_ACP_AGENTS,
-    KNOWN_MCP_AGENTS: KNOWN_MCP_AGENTS,
-    resolveAcpAgentConfig: resolveAcpAgentConfig
-});
-
-function bridgeAcpToSession(backend, sessionService, getMetadata, setMetadata, log, onTurnEnd) {
-  let pendingText = "";
-  let flushTimer = null;
-  function flushText() {
-    if (pendingText) {
-      sessionService.pushMessage({
-        type: "assistant",
-        content: [{ type: "text", text: pendingText }]
-      }, "agent");
-      pendingText = "";
-    }
-    if (flushTimer) {
-      clearTimeout(flushTimer);
-      flushTimer = null;
-    }
-  }
-  backend.onMessage((msg) => {
-    switch (msg.type) {
-      case "model-output": {
-        if (msg.textDelta) {
-          pendingText += msg.textDelta;
-          if (!flushTimer) {
-            flushTimer = setTimeout(flushText, 100);
-          }
-        } else if (msg.fullText) {
-          flushText();
-          sessionService.pushMessage({
-            type: "assistant",
-            content: [{ type: "text", text: msg.fullText }]
-          }, "agent");
-        }
-        break;
-      }
-      case "status": {
-        if (msg.status === "idle") {
-          flushText();
-          sessionService.sendKeepAlive(false);
-          setMetadata((m) => ({ ...m, lifecycleState: "idle" }));
-          onTurnEnd?.();
-        } else if (msg.status === "running" || msg.status === "starting") {
-          sessionService.sendKeepAlive(true);
-          setMetadata((m) => ({ ...m, lifecycleState: "running" }));
-        } else if (msg.status === "error") {
-          flushText();
-          sessionService.pushMessage(
-            { type: "message", message: `Agent process exited unexpectedly: ${msg.detail || "Unknown error"}` },
-            "event"
-          );
-          sessionService.sendSessionEnd();
-          setMetadata((m) => ({ ...m, lifecycleState: "error" }));
-        } else if (msg.status === "stopped") {
-          flushText();
-          sessionService.sendSessionEnd();
-          setMetadata((m) => ({ ...m, lifecycleState: "stopped" }));
-        }
-        break;
-      }
-      case "tool-call": {
-        flushText();
-        sessionService.pushMessage({
-          type: "assistant",
-          content: [{
-            type: "tool_use",
-            id: msg.callId,
-            name: msg.toolName,
-            input: msg.args
-          }]
-        }, "agent");
-        break;
-      }
-      case "tool-result": {
-        sessionService.pushMessage({
-          type: "assistant",
-          content: [{
-            type: "tool_result",
-            tool_use_id: msg.callId,
-            content: typeof msg.result === "string" ? msg.result : JSON.stringify(msg.result)
-          }]
-        }, "agent");
-        break;
-      }
-      case "permission-request": {
-        const currentRequests = { ...sessionService._agentState?.requests };
-        const payload = msg.payload;
-        sessionService.updateAgentState({
-          controlledByUser: false,
-          requests: {
-            ...currentRequests,
-            [msg.id]: {
-              tool: payload?.toolName || msg.reason,
-              arguments: payload?.input || {},
-              createdAt: Date.now()
-            }
-          }
-        });
-        break;
-      }
-      case "permission-response": {
-        const reqs = { ...sessionService._agentState?.requests };
-        const completedReqs = { ...sessionService._agentState?.completedRequests };
-        const existingReq = reqs[msg.id];
-        delete reqs[msg.id];
-        sessionService.updateAgentState({
-          controlledByUser: false,
-          requests: reqs,
-          completedRequests: {
-            ...completedReqs,
-            [msg.id]: {
-              ...existingReq || {},
-              completedAt: Date.now(),
-              status: msg.approved ? "approved" : "denied"
-            }
-          }
-        });
-        break;
-      }
-      case "event": {
-        if (msg.name === "thinking") {
-          const payload = msg.payload;
-          const text = payload?.text || JSON.stringify(payload);
-          sessionService.pushMessage({
-            type: "assistant",
-            content: [{ type: "thinking", thinking: text }]
-          }, "agent");
-        } else {
-          sessionService.pushMessage({
-            type: "session_event",
-            message: `[${msg.name}] ${JSON.stringify(msg.payload)}`
-          }, "session");
-        }
-        break;
-      }
-    }
-  });
-}
-class HyphaPermissionHandler {
-  constructor(shouldAutoAllow, log) {
-    this.shouldAutoAllow = shouldAutoAllow;
-    this.log = log;
-  }
-  pendingPermissions = /* @__PURE__ */ new Map();
-  async handleToolCall(toolCallId, toolName, input) {
-    if (this.shouldAutoAllow(toolName, input)) {
-      this.log(`[ACP Permission] Auto-allowing ${toolName}`);
-      return { decision: "approved" };
-    }
-    return new Promise((resolve) => {
-      this.pendingPermissions.set(toolCallId, { resolve, toolName, input });
-    });
-  }
-  /**
-   * Called from the session service's onPermissionResponse callback
-   */
-  resolvePermission(requestId, approved) {
-    const pending = this.pendingPermissions.get(requestId);
-    if (pending) {
-      this.pendingPermissions.delete(requestId);
-      pending.resolve({
-        decision: approved ? "approved" : "denied"
-      });
-    } else {
-      this.log(`[ACP Permission] No pending permission for id=${requestId}`);
-    }
-  }
-  /** Reject all pending permissions (e.g. when process exits) */
-  rejectAll(reason) {
-    for (const [id, pending] of this.pendingPermissions) {
-      pending.resolve({ decision: "denied" });
-    }
-    this.pendingPermissions.clear();
-  }
-}
-
-const DEFAULT_TIMEOUT = 14 * 24 * 60 * 60 * 1e3;
-function getCodexMcpCommand() {
-  try {
-    const version = execSync("codex --version", { encoding: "utf8" }).trim();
-    const match = version.match(/codex-cli\s+(\d+\.\d+\.\d+(?:-alpha\.\d+)?)/);
-    if (!match) return "mcp-server";
-    const versionStr = match[1];
-    const [major, minor, patch] = versionStr.split(/[-.]/).map(Number);
-    if (major > 0 || minor > 43) return "mcp-server";
-    if (minor === 43 && patch === 0) {
-      if (versionStr.includes("-alpha.")) {
-        const alphaNum = parseInt(versionStr.split("-alpha.")[1]);
-        return alphaNum >= 5 ? "mcp-server" : "mcp";
-      }
-      return "mcp-server";
-    }
-    return "mcp";
-  } catch {
-    return null;
-  }
-}
-class CodexMcpBackend {
-  listeners = [];
-  client;
-  transport = null;
-  disposed = false;
-  codexSessionId = null;
-  conversationId = null;
-  svampSessionId = null;
-  log;
-  options;
-  connected = false;
-  // Pending elicitation approvals
-  pendingApprovals = /* @__PURE__ */ new Map();
-  // Temp files from isolation wrapping (cleaned up on disconnect)
-  _isolationCleanupFiles = [];
-  constructor(options) {
-    this.options = options;
-    this.log = options.log || (() => {
-    });
-    this.client = new Client(
-      { name: "svamp-codex-client", version: "1.0.0" },
-      { capabilities: { elicitation: {} } }
-    );
-    this.client.setNotificationHandler(z.object({
-      method: z.literal("codex/event"),
-      params: z.object({ msg: z.any() })
-    }).passthrough(), (data) => {
-      const msg = data.params.msg;
-      this.updateIdentifiersFromEvent(msg);
-      this.handleCodexEvent(msg);
-    });
-  }
-  // ── AgentBackend interface ──────────────────────────────────────────
-  onMessage(handler) {
-    this.listeners.push(handler);
-  }
-  offMessage(handler) {
-    const idx = this.listeners.indexOf(handler);
-    if (idx !== -1) this.listeners.splice(idx, 1);
-  }
-  async startSession(initialPrompt) {
-    const sessionId = randomUUID();
-    this.svampSessionId = sessionId;
-    this.emit({ type: "status", status: "starting" });
-    await this.connect();
-    this.emit({ type: "status", status: "idle" });
-    if (initialPrompt) {
-      this.sendPrompt(sessionId, initialPrompt).catch((err) => {
-        this.log(`[Codex] Error sending initial prompt: ${err.message}`);
-        this.emit({ type: "status", status: "error", detail: err.message });
-      });
-    }
-    return { sessionId };
-  }
-  async sendPrompt(sessionId, prompt) {
-    if (!this.connected) throw new Error("Codex not connected");
-    this.emit({ type: "status", status: "running" });
-    try {
-      let response;
-      if (this.codexSessionId) {
-        response = await this.continueSession(prompt);
-      } else {
-        const config = {
-          prompt,
-          cwd: this.options.cwd,
-          ...this.options.model ? { model: this.options.model } : {}
-        };
-        response = await this.startCodexSession(config);
-      }
-      if (response?.content && Array.isArray(response.content)) {
-        for (const block of response.content) {
-          if (block.type === "text" && block.text) {
-            this.emit({ type: "model-output", fullText: block.text });
-          }
-        }
-      }
-    } catch (err) {
-      this.log(`[Codex] Error in sendPrompt: ${err.message}`);
-      this.emit({ type: "status", status: "error", detail: err.message });
-      throw err;
-    } finally {
-      this.emit({ type: "status", status: "idle" });
-    }
-  }
-  async cancel(_sessionId) {
-    this.log("[Codex] Cancel requested");
-    this.emit({ type: "status", status: "idle" });
-  }
-  async respondToPermission(requestId, approved) {
-    const pending = this.pendingApprovals.get(requestId);
-    if (pending) {
-      this.pendingApprovals.delete(requestId);
-      pending.resolve({
-        action: approved ? "accept" : "decline",
-        content: { approval: approved ? "approve" : "deny" }
-      });
-      this.emit({ type: "permission-response", id: requestId, approved });
-    }
-  }
-  async dispose() {
-    if (this.disposed) return;
-    this.disposed = true;
-    this.log("[Codex] Disposing backend");
-    for (const [, pending] of this.pendingApprovals) {
-      pending.resolve({ action: "decline" });
-    }
-    this.pendingApprovals.clear();
-    await this.disconnect();
-    this.listeners = [];
-  }
-  /** Get the transport's child process PID for tracking */
-  get pid() {
-    return this.transport?.pid ?? null;
-  }
-  /**
-   * Return a process-like object for TrackedSession.childProcess.
-   * We expose a minimal { kill } object that closes the transport.
-   */
-  getProcess() {
-    if (!this.transport) return null;
-    const pid = this.pid;
-    return {
-      kill: (signal) => {
-        if (pid) {
-          try {
-            process.kill(pid, signal || "SIGTERM");
-          } catch {
-          }
-        }
-      }
-    };
-  }
-  // ── MCP connection ─────────────────────────────────────────────────
-  async connect() {
-    if (this.connected) return;
-    const mcpCommand = getCodexMcpCommand();
-    if (mcpCommand === null) {
-      throw new Error(
-        "Codex CLI not found or not executable.\n\nTo install codex:\n  npm install -g @openai/codex\n"
-      );
-    }
-    this.log(`[Codex] Connecting via: codex ${mcpCommand}`);
-    const env = {};
-    for (const key of Object.keys(process.env)) {
-      const value = process.env[key];
-      if (typeof value === "string") env[key] = value;
-    }
-    if (this.options.env) {
-      Object.assign(env, this.options.env);
-    }
-    const rolloutFilter = "codex_core::rollout::list=off";
-    const existingRustLog = env.RUST_LOG?.trim();
-    if (!existingRustLog) {
-      env.RUST_LOG = rolloutFilter;
-    } else if (!existingRustLog.includes("codex_core::rollout::list=")) {
-      env.RUST_LOG = `${existingRustLog},${rolloutFilter}`;
-    }
-    let transportCommand = "codex";
-    let transportArgs = [mcpCommand];
-    if (this.options.isolationConfig) {
-      const wrapped = wrapWithIsolation(transportCommand, transportArgs, this.options.isolationConfig);
-      transportCommand = wrapped.command;
-      transportArgs = wrapped.args;
-      if (wrapped.env) Object.assign(env, wrapped.env);
-      if (wrapped.cleanupFiles) {
-        this._isolationCleanupFiles = wrapped.cleanupFiles;
-      }
-      this.log(`[Codex] Isolation: ${this.options.isolationConfig.method}`);
-    }
-    this.transport = new StdioClientTransport({
-      command: transportCommand,
-      args: transportArgs,
-      env
-    });
-    this.registerPermissionHandlers();
-    try {
-      await this.client.connect(this.transport);
-      this.connected = true;
-      this.log("[Codex] MCP connection established");
-    } catch (err) {
-      this.transport = null;
-      throw err;
-    }
-  }
-  async disconnect() {
-    if (!this.connected) return;
-    const pid = this.pid;
-    this.log(`[Codex] Disconnecting (pid=${pid ?? "none"})`);
-    try {
-      await this.client.close();
-    } catch {
-      try {
-        await this.transport?.close?.();
-      } catch {
-      }
-    }
-    if (pid) {
-      try {
-        process.kill(pid, 0);
-        try {
-          process.kill(pid, "SIGKILL");
-        } catch {
-        }
-      } catch {
-      }
-    }
-    this.transport = null;
-    this.connected = false;
-    if (this._isolationCleanupFiles.length > 0) {
-      const { rm } = await import('node:fs/promises');
-      for (const f of this._isolationCleanupFiles) rm(f, { force: true }).catch(() => {
-      });
-      this._isolationCleanupFiles = [];
-    }
-  }
-  // ── Permission handling ────────────────────────────────────────────
-  registerPermissionHandlers() {
-    this.client.setRequestHandler(
-      ElicitRequestSchema,
-      async (request) => {
-        const params = request.params;
-        const callId = params.codex_call_id || randomUUID();
-        this.log(`[Codex] Elicitation request: ${params.message}`);
-        this.emit({
-          type: "permission-request",
-          id: callId,
-          reason: params.codex_command ? `Execute: ${Array.isArray(params.codex_command) ? params.codex_command.join(" ") : params.codex_command}` : params.message || "Codex requires approval",
-          payload: {
-            toolName: "CodexBash",
-            input: {
-              command: params.codex_command,
-              cwd: params.codex_cwd
-            }
-          }
-        });
-        return new Promise((resolve) => {
-          this.pendingApprovals.set(callId, { resolve });
-          setTimeout(() => {
-            if (this.pendingApprovals.has(callId)) {
-              this.pendingApprovals.delete(callId);
-              resolve({ action: "decline" });
-            }
-          }, 5 * 60 * 1e3);
-        });
-      }
-    );
-  }
-  // ── Codex MCP tools ────────────────────────────────────────────────
-  async startCodexSession(config) {
-    const response = await this.client.callTool({
-      name: "codex",
-      arguments: config
-    }, void 0, { timeout: DEFAULT_TIMEOUT });
-    this.extractIdentifiers(response);
-    return response;
-  }
-  async continueSession(prompt) {
-    if (!this.conversationId) {
-      this.conversationId = this.codexSessionId;
-    }
-    const response = await this.client.callTool({
-      name: "codex-reply",
-      arguments: {
-        sessionId: this.codexSessionId,
-        conversationId: this.conversationId,
-        prompt
-      }
-    }, void 0, { timeout: DEFAULT_TIMEOUT });
-    this.extractIdentifiers(response);
-    return response;
-  }
-  // ── Event handling ─────────────────────────────────────────────────
-  handleCodexEvent(event) {
-    if (!event || typeof event !== "object") return;
-    const eventType = event.type;
-    this.log(`[Codex] Event: ${eventType}`);
-    switch (eventType) {
-      case "task_started":
-        this.emit({ type: "status", status: "running" });
-        break;
-      case "task_complete":
-      case "turn_aborted":
-        this.emit({ type: "status", status: "idle" });
-        break;
-      case "agent_message": {
-        const content = event.content;
-        if (Array.isArray(content)) {
-          for (const block of content) {
-            if (block.type === "output_text" && block.text) {
-              this.emit({ type: "model-output", fullText: block.text });
-            }
-          }
-        }
-        break;
-      }
-      case "agent_reasoning_delta": {
-        const text = event.delta?.text || event.text;
-        if (text) {
-          this.emit({ type: "event", name: "thinking", payload: { text } });
-        }
-        break;
-      }
-      case "agent_reasoning": {
-        const text = event.text || (Array.isArray(event.content) ? event.content.map((c) => c.text).join("") : "");
-        if (text) {
-          this.emit({ type: "event", name: "thinking", payload: { text } });
-        }
-        break;
-      }
-      case "exec_command_begin": {
-        const callId = event.call_id || event.callId || randomUUID();
-        const command = Array.isArray(event.command) ? event.command.join(" ") : String(event.command || "");
-        this.emit({
-          type: "tool-call",
-          toolName: "CodexBash",
-          callId,
-          args: { command, cwd: event.cwd }
-        });
-        break;
-      }
-      case "exec_command_end": {
-        const callId = event.call_id || event.callId || "";
-        this.emit({
-          type: "tool-result",
-          toolName: "CodexBash",
-          callId,
-          result: {
-            exitCode: event.exit_code ?? event.exitCode,
-            stdout: event.stdout || "",
-            stderr: event.stderr || ""
-          }
-        });
-        break;
-      }
-      case "patch_apply_begin": {
-        const callId = event.call_id || event.callId || randomUUID();
-        this.emit({
-          type: "tool-call",
-          toolName: "CodexPatch",
-          callId,
-          args: { filePath: event.file_path || event.filePath, patch: event.patch }
-        });
-        break;
-      }
-      case "patch_apply_end": {
-        const callId = event.call_id || event.callId || "";
-        this.emit({
-          type: "tool-result",
-          toolName: "CodexPatch",
-          callId,
-          result: {
-            filePath: event.file_path || event.filePath,
-            applied: event.applied,
-            error: event.error
-          }
-        });
-        break;
-      }
-      default:
-        this.log(`[Codex] Unhandled event: ${eventType}`);
-        break;
-    }
-  }
-  // ── Identifier extraction ──────────────────────────────────────────
-  updateIdentifiersFromEvent(event) {
-    if (!event || typeof event !== "object") return;
-    const candidates = [event];
-    if (event.data && typeof event.data === "object") candidates.push(event.data);
-    for (const c of candidates) {
-      const sid = c.session_id ?? c.sessionId;
-      if (sid) this.codexSessionId = sid;
-      const cid = c.conversation_id ?? c.conversationId;
-      if (cid) this.conversationId = cid;
-    }
-  }
-  extractIdentifiers(response) {
-    const meta = response?.meta || {};
-    this.codexSessionId = meta.sessionId || response?.sessionId || this.codexSessionId;
-    this.conversationId = meta.conversationId || response?.conversationId || this.conversationId;
-    const content = response?.content;
-    if (Array.isArray(content)) {
-      for (const item of content) {
-        if (!this.codexSessionId && item?.sessionId) this.codexSessionId = item.sessionId;
-        if (!this.conversationId && item?.conversationId) this.conversationId = item.conversationId;
-      }
-    }
-  }
-  // ── Helpers ────────────────────────────────────────────────────────
-  emit(msg) {
-    if (this.disposed) return;
-    for (const h of this.listeners) {
-      try {
-        h(msg);
-      } catch {
-      }
-    }
-  }
-}
-
-const GEMINI_TIMEOUTS = {
-  init: 12e4,
-  toolCall: 12e4,
-  investigation: 6e5,
-  think: 3e4,
-  idle: 500
-};
-const GEMINI_TOOL_PATTERNS = [
-  {
-    name: "change_title",
-    patterns: ["change_title", "change-title", "svamp__change_title", "mcp__svamp__change_title"],
-    inputFields: ["title"],
-    emptyInputDefault: true
-  },
-  {
-    name: "set_session_link",
-    patterns: ["set_session_link", "set-session-link", "svamp__set_session_link", "mcp__svamp__set_session_link"],
-    inputFields: ["url"]
-  },
-  {
-    name: "save_memory",
-    patterns: ["save_memory", "save-memory"],
-    inputFields: ["memory", "content"]
-  },
-  {
-    name: "think",
-    patterns: ["think"],
-    inputFields: ["thought", "thinking"]
-  }
-];
-const AVAILABLE_MODELS = [
-  "gemini-2.5-pro",
-  "gemini-2.5-flash",
-  "gemini-2.5-flash-lite"
-];
-class GeminiTransport {
-  agentName = "gemini";
-  getInitTimeout() {
-    return GEMINI_TIMEOUTS.init;
-  }
-  filterStdoutLine(line) {
-    const trimmed = line.trim();
-    if (!trimmed) return null;
-    if (!trimmed.startsWith("{") && !trimmed.startsWith("[")) return null;
-    try {
-      const parsed = JSON.parse(trimmed);
-      if (typeof parsed !== "object" || parsed === null) return null;
-      return line;
-    } catch {
-      return null;
-    }
-  }
-  handleStderr(text, context) {
-    const trimmed = text.trim();
-    if (!trimmed) return { message: null, suppress: true };
-    if (trimmed.includes("status 429") || trimmed.includes('code":429') || trimmed.includes("rateLimitExceeded") || trimmed.includes("RESOURCE_EXHAUSTED")) {
-      return { message: null, suppress: false };
-    }
-    if (trimmed.includes("status 404") || trimmed.includes('code":404')) {
-      const msg = {
-        type: "status",
-        status: "error",
-        detail: `Model not found. Available models: ${AVAILABLE_MODELS.join(", ")}`
-      };
-      return { message: msg };
-    }
-    if (context.hasActiveInvestigation) {
-      const hasError = trimmed.includes("timeout") || trimmed.includes("Timeout") || trimmed.includes("failed") || trimmed.includes("Failed") || trimmed.includes("error") || trimmed.includes("Error");
-      if (hasError) {
-        return { message: null, suppress: false };
-      }
-    }
-    return { message: null };
-  }
-  getToolPatterns() {
-    return GEMINI_TOOL_PATTERNS;
-  }
-  isInvestigationTool(toolCallId, toolKind) {
-    const lowerId = toolCallId.toLowerCase();
-    return lowerId.includes("codebase_investigator") || lowerId.includes("investigator") || typeof toolKind === "string" && toolKind.includes("investigator");
-  }
-  getToolCallTimeout(toolCallId, toolKind) {
-    if (this.isInvestigationTool(toolCallId, toolKind)) return GEMINI_TIMEOUTS.investigation;
-    if (toolKind === "think") return GEMINI_TIMEOUTS.think;
-    return GEMINI_TIMEOUTS.toolCall;
-  }
-  getIdleTimeout() {
-    return GEMINI_TIMEOUTS.idle;
-  }
-  extractToolNameFromId(toolCallId) {
-    const lowerId = toolCallId.toLowerCase();
-    for (const toolPattern of GEMINI_TOOL_PATTERNS) {
-      for (const pattern of toolPattern.patterns) {
-        if (lowerId.includes(pattern.toLowerCase())) {
-          return toolPattern.name;
-        }
-      }
-    }
-    return null;
-  }
-  isEmptyInput(input) {
-    if (!input) return true;
-    if (Array.isArray(input)) return input.length === 0;
-    if (typeof input === "object") return Object.keys(input).length === 0;
-    return false;
-  }
-  determineToolName(toolName, toolCallId, input, _context) {
-    if (toolName !== "other" && toolName !== "Unknown tool") return toolName;
-    const idToolName = this.extractToolNameFromId(toolCallId);
-    if (idToolName) return idToolName;
-    if (input && typeof input === "object" && !Array.isArray(input)) {
-      const inputKeys = Object.keys(input);
-      for (const toolPattern of GEMINI_TOOL_PATTERNS) {
-        if (toolPattern.inputFields) {
-          const hasMatchingField = toolPattern.inputFields.some(
-            (field) => inputKeys.some((key) => key.toLowerCase() === field.toLowerCase())
-          );
-          if (hasMatchingField) return toolPattern.name;
-        }
-      }
-    }
-    if (this.isEmptyInput(input) && toolName === "other") {
-      const defaultTool = GEMINI_TOOL_PATTERNS.find((p) => p.emptyInputDefault);
-      if (defaultTool) return defaultTool.name;
-    }
-    return toolName;
-  }
-}
-
-var GeminiTransport$1 = /*#__PURE__*/Object.freeze({
-    __proto__: null,
-    GEMINI_TIMEOUTS: GEMINI_TIMEOUTS,
-    GeminiTransport: GeminiTransport
-});
-
-const execFileAsync = promisify(execFile);
-const SVAMP_TOOLS_DIR = join(homedir(), ".svamp", "tools");
-const SVAMP_TOOLS_BIN = join(SVAMP_TOOLS_DIR, "node_modules", ".bin");
-const SVAMP_TOOLS_RG_BIN = join(SVAMP_TOOLS_DIR, "node_modules", "@vscode", "ripgrep", "bin");
-function getToolsPath() {
-  const parts = [SVAMP_TOOLS_BIN, SVAMP_TOOLS_RG_BIN];
-  if (process.env.PATH) parts.push(process.env.PATH);
-  return parts.join(":");
-}
-async function checkCommand(command, versionArgs, extraEnv) {
-  const envWithPath = extraEnv ? { ...process.env, ...extraEnv } : void 0;
-  try {
-    const { stdout } = await execFileAsync(command, versionArgs, {
-      timeout: 5e3,
-      env: envWithPath
-    });
-    const version = stdout.trim().split("\n")[0];
-    return { found: true, version, path: command };
-  } catch {
-  }
-  const localPath = join(SVAMP_TOOLS_BIN, command);
-  try {
-    const { stdout } = await execFileAsync(localPath, versionArgs, {
-      timeout: 5e3,
-      env: envWithPath
-    });
-    const version = stdout.trim().split("\n")[0];
-    return { found: true, version, path: localPath };
-  } catch {
-  }
-  return { found: false };
-}
-async function installSrt() {
-  const platform = process.platform;
-  if (platform !== "darwin" && platform !== "linux") {
-    return false;
-  }
-  console.log("[isolation] srt not found. Installing @anthropic-ai/sandbox-runtime...");
-  try {
-    await mkdir(SVAMP_TOOLS_DIR, { recursive: true });
-    await execFileAsync("npm", [
-      "install",
-      "--prefix",
-      SVAMP_TOOLS_DIR,
-      "@anthropic-ai/sandbox-runtime@latest",
-      "@vscode/ripgrep"
-    ], { timeout: 12e4 });
-    const srtPath = join(SVAMP_TOOLS_BIN, "srt");
-    try {
-      await access(srtPath);
-      console.log(`[isolation] srt installed successfully at ${srtPath}`);
-      return true;
-    } catch {
-      console.warn("[isolation] npm install completed but srt binary not found");
-      return false;
-    }
-  } catch (e) {
-    console.warn(`[isolation] Failed to install srt: ${e.message}`);
-    return false;
-  }
-}
-async function parseIsolationTestOutput(stdout, probeFile) {
-  const output = stdout.trim();
-  const wMatch = output.match(/W=(\d+)/);
-  const pMatch = output.match(/P=(\d+)/);
-  if (!wMatch || !pMatch) {
-    return { passed: false, error: `unexpected test output: ${output}` };
-  }
-  const workspaceWriteOk = wMatch[1] === "0";
-  const probeExitCode = parseInt(pMatch[1], 10);
-  if (!workspaceWriteOk) {
-    return { passed: false, error: "sandbox blocked writes to allowed workspace path" };
-  }
-  if (probeExitCode === 0) {
-    try {
-      await access(probeFile);
-      return {
-        passed: false,
-        error: "writes outside workspace were NOT blocked \u2014 file leaked to host filesystem"
-      };
-    } catch {
-      return { passed: true };
-    }
-  }
-  return { passed: true };
-}
-async function verifySrtIsolation(binaryPath) {
-  const testBase = "/tmp";
-  const workDir = await mkdtemp(join(testBase, "svamp-iso-work-"));
-  const probeDir = await mkdtemp(join(testBase, "svamp-iso-probe-"));
-  const probeFile = join(probeDir, "leak-test");
-  const settingsFile = join(workDir, "srt-settings.json");
-  try {
-    await writeFile(settingsFile, JSON.stringify({
-      filesystem: {
-        denyRead: [],
-        allowWrite: [workDir],
-        denyWrite: []
-      },
-      network: {
-        allowedDomains: [],
-        deniedDomains: []
-      }
-    }));
-    const testScript = [
-      `echo ok > "${workDir}/test" 2>/dev/null; W=$?`,
-      `echo leak > "${probeFile}" 2>/dev/null; P=$?`,
-      `echo "W=$W P=$P"`
-    ].join("; ");
-    const { stdout } = await execFileAsync(binaryPath, [
-      "--settings",
-      settingsFile,
-      "sh",
-      "-c",
-      testScript
-    ], {
-      timeout: 15e3,
-      env: { ...process.env, PATH: getToolsPath() }
-    });
-    return parseIsolationTestOutput(stdout, probeFile);
-  } catch (e) {
-    return { passed: false, error: e.message };
-  } finally {
-    await rm(workDir, { recursive: true, force: true }).catch(() => {
-    });
-    await rm(probeDir, { recursive: true, force: true }).catch(() => {
-    });
-  }
-}
-async function verifyBwrapIsolation(binaryPath) {
-  const testBase = "/tmp";
-  const workDir = await mkdtemp(join(testBase, "svamp-iso-work-"));
-  const probeDir = await mkdtemp(join(testBase, "svamp-iso-probe-"));
-  const probeFile = join(probeDir, "leak-test");
-  try {
-    const testScript = [
-      `echo ok > "${workDir}/test" 2>/dev/null; W=$?`,
-      `echo leak > "${probeFile}" 2>/dev/null; P=$?`,
-      `echo "W=$W P=$P"`
-    ].join("; ");
-    const { stdout } = await execFileAsync(binaryPath, [
-      "--ro-bind",
-      "/",
-      "/",
-      "--bind",
-      workDir,
-      workDir,
-      "--dev",
-      "/dev",
-      "--proc",
-      "/proc",
-      "--unshare-pid",
-      "--die-with-parent",
-      "--",
-      "sh",
-      "-c",
-      testScript
-    ], { timeout: 15e3 });
-    return parseIsolationTestOutput(stdout, probeFile);
-  } catch (e) {
-    return { passed: false, error: e.message };
-  } finally {
-    await rm(workDir, { recursive: true, force: true }).catch(() => {
-    });
-    await rm(probeDir, { recursive: true, force: true }).catch(() => {
-    });
-  }
-}
-async function verifyContainerIsolation(method, binaryPath) {
-  try {
-    await execFileAsync(binaryPath, ["info"], { timeout: 15e3 });
-  } catch (e) {
-    return { passed: false, error: `${method} daemon not accessible: ${e.message}` };
-  }
-  try {
-    const { stdout } = await execFileAsync(
-      binaryPath,
-      ["run", "--rm", "--network=none", "alpine", "echo", "isolation-ok"],
-      { timeout: 3e4 }
-    );
-    if (!stdout.includes("isolation-ok")) {
-      return { passed: false, error: `container test returned unexpected output: ${stdout.trim()}` };
-    }
-    return { passed: true };
-  } catch (e) {
-    if (e.message?.includes("pull access denied") || e.message?.includes("not found")) {
-      return { passed: true };
-    }
-    return { passed: false, error: `container test failed: ${e.message}` };
-  }
-}
-async function verifyIsolation(method, binaryPath) {
-  switch (method) {
-    case "srt":
-      return verifySrtIsolation(binaryPath);
-    case "bwrap":
-      return verifyBwrapIsolation(binaryPath);
-    case "docker":
-    case "podman":
-      return verifyContainerIsolation(method, binaryPath);
-  }
-}
-async function detectIsolationCapabilities() {
-  const srtEnv = { PATH: getToolsPath() };
-  const checks = {
-    srt: checkCommand("srt", ["--version"], srtEnv),
-    bwrap: checkCommand("bwrap", ["--version"]),
-    docker: checkCommand("docker", ["--version"]),
-    podman: checkCommand("podman", ["--version"])
-  };
-  const checkResults = await Promise.all(
-    Object.entries(checks).map(async ([method, promise]) => {
-      const detail = await promise;
-      return [method, detail];
-    })
-  );
-  const details = Object.fromEntries(checkResults);
-  if (!details.srt.found) {
-    const installed = await installSrt();
-    if (installed) {
-      details.srt = await checkCommand("srt", ["--version"], srtEnv);
-    }
-  }
-  const foundMethods = ISOLATION_PREFERENCE.filter((m) => details[m].found);
-  if (foundMethods.length > 0) {
-    console.log(`[isolation] Found runtimes: ${foundMethods.join(", ")}. Verifying isolation...`);
-    await Promise.all(
-      foundMethods.map(async (method) => {
-        const binaryPath = details[method].path || method;
-        const result = await verifyIsolation(method, binaryPath);
-        details[method].verified = result.passed;
-        if (!result.passed) {
-          details[method].verificationError = result.error;
-          console.warn(
-            `[isolation] WARNING: ${method} found but verification FAILED: ${result.error}. This runtime will NOT be used for isolation.`
-          );
-        } else {
-          console.log(`[isolation] ${method}: verified OK`);
-        }
-      })
-    );
-  }
-  const available = ISOLATION_PREFERENCE.filter(
-    (m) => details[m].found && details[m].verified === true
-  );
-  const preferred = available.length > 0 ? available[0] : null;
-  if (available.length === 0 && foundMethods.length > 0) {
-    console.warn(
-      `[isolation] No isolation runtime passed verification (found: ${foundMethods.join(", ")}). Session sharing will be DISABLED.`
-    );
-  } else if (available.length === 0) {
-    console.log("[isolation] No isolation runtimes found. Session sharing will be unavailable.");
-  } else {
-    console.log(`[isolation] Preferred isolation method: ${preferred}`);
-  }
-  return { available, preferred, details };
-}
-
-const __filename$1 = fileURLToPath(import.meta.url);
-const __dirname$1 = dirname(__filename$1);
-function loadDotEnv() {
-  const envDir = process.env.SVAMP_HOME || join$1(os.homedir(), ".svamp");
-  const envFile = join$1(envDir, ".env");
-  if (existsSync$1(envFile)) {
-    const lines = readFileSync$1(envFile, "utf-8").split("\n");
-    for (const line of lines) {
-      const trimmed = line.trim();
-      if (!trimmed || trimmed.startsWith("#")) continue;
-      const eqIdx = trimmed.indexOf("=");
-      if (eqIdx === -1) continue;
-      const key = trimmed.slice(0, eqIdx).trim();
-      const value = trimmed.slice(eqIdx + 1).trim().replace(/^["']|["']$/g, "");
-      if (!process.env[key]) {
-        process.env[key] = value;
-      }
-    }
-  }
-}
-loadDotEnv();
-const SVAMP_HOME = process.env.SVAMP_HOME || join$1(os.homedir(), ".svamp");
-const DAEMON_STATE_FILE = join$1(SVAMP_HOME, "daemon.state.json");
-const DAEMON_LOCK_FILE = join$1(SVAMP_HOME, "daemon.lock");
-const LOGS_DIR = join$1(SVAMP_HOME, "logs");
-const SESSION_INDEX_FILE = join$1(SVAMP_HOME, "sessions-index.json");
-function readPackageVersion() {
-  try {
-    const pkgPath = join$1(__dirname$1, "../package.json");
-    if (existsSync$1(pkgPath)) {
-      return JSON.parse(readFileSync$1(pkgPath, "utf-8")).version || "unknown";
-    }
-  } catch {
-  }
-  return "unknown";
-}
-const DAEMON_VERSION = readPackageVersion();
-function loadAgentConfig() {
-  const configPath = join$1(SVAMP_HOME, "agent-config.json");
-  if (existsSync$1(configPath)) {
-    try {
-      return JSON.parse(readFileSync$1(configPath, "utf-8"));
-    } catch {
-      return {};
-    }
-  }
-  return {};
-}
-function getSessionSvampDir(directory) {
-  return join$1(directory, ".svamp");
-}
-function getSessionDir(directory, sessionId) {
-  return join$1(getSessionSvampDir(directory), sessionId);
-}
-function getSessionFilePath(directory, sessionId) {
-  return join$1(getSessionDir(directory, sessionId), "session.json");
-}
-function getSessionMessagesPath(directory, sessionId) {
-  return join$1(getSessionDir(directory, sessionId), "messages.jsonl");
-}
-function getSvampConfigPath(directory, sessionId) {
-  return join$1(getSessionDir(directory, sessionId), "config.json");
-}
-function createSvampConfigChecker(directory, sessionId, getMetadata, setMetadata, sessionService, logger) {
-  const configPath = getSvampConfigPath(directory, sessionId);
-  let lastContent = "";
-  if (existsSync$1(configPath)) {
-    try {
-      lastContent = readFileSync$1(configPath, "utf-8");
-    } catch {
-    }
-  }
-  function processConfig(config, meta) {
-    if (typeof config.title === "string" && config.title.trim()) {
-      const newTitle = config.title.trim();
-      if (meta.summary?.text !== newTitle) {
-        setMetadata((m) => ({
-          ...m,
-          summary: { text: newTitle, updatedAt: Date.now() }
-        }));
-        sessionService.pushMessage({ type: "summary", summary: newTitle }, "session");
-        logger.log(`[svampConfig] Title updated: "${newTitle}"`);
-      }
-    }
-    if (config.session_link && typeof config.session_link.url === "string" && config.session_link.url.trim()) {
-      const url = config.session_link.url.trim();
-      const label = config.session_link.label || "View";
-      if (meta.sessionLink?.url !== url || meta.sessionLink?.label !== label) {
-        setMetadata((m) => ({
-          ...m,
-          sessionLink: { url, label, updatedAt: Date.now() }
-        }));
-        const currentSummary = getMetadata().summary?.text;
-        if (currentSummary) {
-          sessionService.pushMessage({ type: "summary", summary: currentSummary }, "session");
-        }
-        logger.log(`[svampConfig] Session link updated: "${label}" \u2192 ${url}`);
-      }
-    }
-  }
-  return () => {
-    try {
-      const meta = getMetadata();
-      if (existsSync$1(configPath)) {
-        const content = readFileSync$1(configPath, "utf-8");
-        if (content !== lastContent) {
-          lastContent = content;
-          processConfig(JSON.parse(content), meta);
-        }
-      }
-    } catch (err) {
-    }
-  };
-}
-function loadSessionIndex() {
-  if (!existsSync$1(SESSION_INDEX_FILE)) return {};
-  try {
-    return JSON.parse(readFileSync$1(SESSION_INDEX_FILE, "utf-8"));
-  } catch {
-    return {};
-  }
-}
-function saveSessionIndex(index) {
-  writeFileSync$1(SESSION_INDEX_FILE, JSON.stringify(index, null, 2), "utf-8");
-}
-function saveSession(session) {
-  const sessionDir = getSessionDir(session.directory, session.sessionId);
-  if (!existsSync$1(sessionDir)) {
-    mkdirSync$1(sessionDir, { recursive: true });
-  }
-  writeFileSync$1(
-    getSessionFilePath(session.directory, session.sessionId),
-    JSON.stringify(session, null, 2),
-    "utf-8"
-  );
-  const index = loadSessionIndex();
-  index[session.sessionId] = { directory: session.directory, createdAt: session.createdAt };
-  saveSessionIndex(index);
-}
-function deletePersistedSession(sessionId) {
-  const index = loadSessionIndex();
-  const entry = index[sessionId];
-  if (entry) {
-    const sessionFile = getSessionFilePath(entry.directory, sessionId);
-    try {
-      if (existsSync$1(sessionFile)) unlinkSync(sessionFile);
-    } catch {
-    }
-    const messagesFile = getSessionMessagesPath(entry.directory, sessionId);
-    try {
-      if (existsSync$1(messagesFile)) unlinkSync(messagesFile);
-    } catch {
-    }
-    const configFile = getSvampConfigPath(entry.directory, sessionId);
-    try {
-      if (existsSync$1(configFile)) unlinkSync(configFile);
-    } catch {
-    }
-    const sessionDir = getSessionDir(entry.directory, sessionId);
-    try {
-      rmdirSync(sessionDir);
-    } catch {
-    }
-    delete index[sessionId];
-    saveSessionIndex(index);
-  }
-}
-function loadPersistedSessions() {
-  const sessions = [];
-  const index = loadSessionIndex();
-  let indexChanged = false;
-  for (const [sessionId, entry] of Object.entries(index)) {
-    const filePath = getSessionFilePath(entry.directory, sessionId);
-    try {
-      const data = JSON.parse(readFileSync$1(filePath, "utf-8"));
-      if (data.sessionId && data.directory) {
-        if (!data.stopped) {
-          sessions.push(data);
-        }
-      }
-    } catch {
-      delete index[sessionId];
-      indexChanged = true;
-    }
-  }
-  if (indexChanged) {
-    saveSessionIndex(index);
-  }
-  return sessions;
-}
-function ensureHomeDir() {
-  if (!existsSync$1(SVAMP_HOME)) {
-    mkdirSync$1(SVAMP_HOME, { recursive: true });
-  }
-  if (!existsSync$1(LOGS_DIR)) {
-    mkdirSync$1(LOGS_DIR, { recursive: true });
-  }
-}
-function createLogger() {
-  ensureHomeDir();
-  const logFile = join$1(LOGS_DIR, `daemon-${(/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-")}.log`);
-  return {
-    logFilePath: logFile,
-    log: (...args) => {
-      const line = `[${(/* @__PURE__ */ new Date()).toISOString()}] ${args.map((a) => typeof a === "string" ? a : JSON.stringify(a)).join(" ")}
-`;
-      fs.appendFile(logFile, line).catch(() => {
-      });
-      if (process.env.DEBUG) {
-        console.log(...args);
-      }
-    },
-    error: (...args) => {
-      const line = `[${(/* @__PURE__ */ new Date()).toISOString()}] ERROR: ${args.map((a) => typeof a === "string" ? a : JSON.stringify(a)).join(" ")}
-`;
-      fs.appendFile(logFile, line).catch(() => {
-      });
-      console.error(...args);
-    }
-  };
-}
-function writeDaemonStateFile(state) {
-  ensureHomeDir();
-  writeFileSync$1(DAEMON_STATE_FILE, JSON.stringify(state, null, 2), "utf-8");
-}
-function readDaemonStateFile() {
-  try {
-    if (!existsSync$1(DAEMON_STATE_FILE)) return null;
-    return JSON.parse(readFileSync$1(DAEMON_STATE_FILE, "utf-8"));
-  } catch {
-    return null;
-  }
-}
-function cleanupDaemonStateFile() {
-  try {
-    if (existsSync$1(DAEMON_STATE_FILE)) {
-      fs.unlink(DAEMON_STATE_FILE).catch(() => {
-      });
-    }
-    if (existsSync$1(DAEMON_LOCK_FILE)) {
-      fs.unlink(DAEMON_LOCK_FILE).catch(() => {
-      });
-    }
-  } catch {
-  }
-}
-function isDaemonAlive() {
-  const state = readDaemonStateFile();
-  if (!state) return false;
-  try {
-    process.kill(state.pid, 0);
-    return true;
-  } catch {
-    return false;
-  }
-}
-async function startDaemon() {
-  const logger = createLogger();
-  const agentConfig = loadAgentConfig();
-  if (Object.keys(agentConfig).length > 0) {
-    logger.log("Loaded agent config:", JSON.stringify(agentConfig));
-  }
-  let shutdownRequested = false;
-  let requestShutdown;
-  const resolvesWhenShutdownRequested = new Promise((resolve2) => {
-    requestShutdown = (source, errorMessage) => {
-      if (shutdownRequested) return;
-      shutdownRequested = true;
-      logger.log(`Requesting shutdown (source: ${source}, errorMessage: ${errorMessage})`);
-      setTimeout(() => {
-        logger.log("Forced exit after timeout");
-        process.exit(1);
-      }, 5e3);
-      resolve2({ source, errorMessage });
-    };
-  });
-  let isReconnecting = false;
-  process.on("SIGINT", () => requestShutdown("os-signal"));
-  process.on("SIGTERM", () => requestShutdown("os-signal"));
-  process.on("SIGUSR1", () => requestShutdown("os-signal-cleanup"));
-  process.on("uncaughtException", (error) => {
-    if (shutdownRequested) return;
-    logger.error("Uncaught exception:", error);
-    requestShutdown("exception", error.message);
-  });
-  const TRANSIENT_REJECTION_PATTERNS = [
-    "_rintf",
-    // _rintf callback timeouts (app disconnected)
-    "Method call timed out",
-    // RPC timeout during reconnection
-    "WebSocket",
-    // WebSocket errors during reconnect
-    "ECONNRESET",
-    // TCP connection reset
-    "ECONNREFUSED",
-    // Server temporarily unreachable
-    "EPIPE",
-    // Broken pipe (write to closed socket)
-    "ETIMEDOUT",
-    // Connection timed out
-    "socket hang up",
-    // HTTP socket closed unexpectedly
-    "network",
-    // Generic network errors
-    "Connection closed",
-    // WebSocket closed during RPC call
-    "connection was closed",
-    // hypha-rpc connection closed message
-    "Client disconnected",
-    // Hypha client disconnect events
-    "fetch failed"
-    // Fetch API errors during reconnect
-  ];
-  let unhandledRejectionCount = 0;
-  let unhandledRejectionResetTimer = null;
-  const UNHANDLED_REJECTION_THRESHOLD = 10;
-  const UNHANDLED_REJECTION_WINDOW_MS = 6e4;
-  process.on("unhandledRejection", (reason) => {
-    if (shutdownRequested) return;
-    const msg = String(reason);
-    logger.error("Unhandled rejection:", reason);
-    const isTransient = TRANSIENT_REJECTION_PATTERNS.some((p) => msg.toLowerCase().includes(p.toLowerCase()));
-    if (isTransient || isReconnecting) {
-      logger.log(`Ignoring transient rejection (reconnecting=${isReconnecting}): ${msg.slice(0, 200)}`);
-      return;
-    }
-    unhandledRejectionCount++;
-    if (!unhandledRejectionResetTimer) {
-      unhandledRejectionResetTimer = setTimeout(() => {
-        unhandledRejectionCount = 0;
-        unhandledRejectionResetTimer = null;
-      }, UNHANDLED_REJECTION_WINDOW_MS);
-    }
-    if (unhandledRejectionCount >= UNHANDLED_REJECTION_THRESHOLD) {
-      logger.log(`Too many unhandled rejections (${unhandledRejectionCount} in ${UNHANDLED_REJECTION_WINDOW_MS / 1e3}s), shutting down`);
-      requestShutdown("exception", msg);
-    } else {
-      logger.log(`Unhandled rejection ${unhandledRejectionCount}/${UNHANDLED_REJECTION_THRESHOLD} (not crashing yet): ${msg.slice(0, 200)}`);
-    }
-  });
-  if (isDaemonAlive()) {
-    console.log("Svamp daemon is already running");
-    process.exit(0);
-  }
-  const hyphaServerUrl = process.env.HYPHA_SERVER_URL;
-  if (!hyphaServerUrl) {
-    console.error("HYPHA_SERVER_URL is required.");
-    console.error('Run "svamp login <server-url>" first, or set it in .env or environment.');
-    process.exit(1);
-  }
-  const hyphaToken = process.env.HYPHA_TOKEN;
-  const hyphaWorkspace = process.env.HYPHA_WORKSPACE;
-  const hyphaClientId = process.env.HYPHA_CLIENT_ID;
-  if (!hyphaToken) {
-    logger.log('Warning: No HYPHA_TOKEN set. Run "svamp login" to authenticate.');
-    logger.log("Connecting anonymously...");
-  }
-  const machineIdFile = join$1(SVAMP_HOME, "machine-id");
-  let machineId = process.env.SVAMP_MACHINE_ID;
-  if (!machineId) {
-    if (existsSync$1(machineIdFile)) {
-      machineId = readFileSync$1(machineIdFile, "utf-8").trim();
-    }
-    if (!machineId) {
-      machineId = `machine-${os.hostname()}-${randomUUID$1().slice(0, 8)}`;
-      try {
-        writeFileSync$1(machineIdFile, machineId, "utf-8");
-      } catch {
-      }
-    }
-  }
-  logger.log("Starting svamp daemon...");
-  logger.log(`  Server: ${hyphaServerUrl}`);
-  logger.log(`  Workspace: ${hyphaWorkspace || "(default)"}`);
-  logger.log(`  Machine ID: ${machineId}`);
-  let server = null;
-  try {
-    logger.log("Connecting to Hypha server...");
-    server = await connectToHypha({
-      serverUrl: hyphaServerUrl,
-      token: hyphaToken,
-      name: `svamp-machine-${machineId}`,
-      ...hyphaClientId ? { clientId: hyphaClientId } : {}
-    });
-    logger.log(`Connected to Hypha (workspace: ${server.config.workspace})`);
-    server.on("disconnected", (reason) => {
-      logger.log(`Hypha connection permanently lost: ${reason}`);
-      isReconnecting = false;
-      requestShutdown("hypha-disconnected", String(reason));
-    });
-    server.on("services_registered", () => {
-      if (isReconnecting) {
-        logger.log("Hypha reconnection successful \u2014 services re-registered");
-        isReconnecting = false;
-      }
-    });
-    const pidToTrackedSession = /* @__PURE__ */ new Map();
-    const getCurrentChildren = () => {
-      return Array.from(pidToTrackedSession.values()).map((s) => ({
-        sessionId: s.svampSessionId || `PID-${s.pid}`,
-        pid: s.pid,
-        startedBy: s.startedBy,
-        directory: s.directory,
-        active: !s.stopped && s.hyphaService != null
-      }));
-    };
-    const spawnSession = async (options) => {
-      logger.log("Spawning session:", JSON.stringify(options));
-      const { directory, approvedNewDirectoryCreation = true, resumeSessionId } = options;
-      if (resumeSessionId) {
-        for (const tracked of pidToTrackedSession.values()) {
-          if (!tracked.stopped && tracked.svampSessionId && tracked.resumeSessionId === resumeSessionId) {
-            logger.log(`Dedup: found existing active session ${tracked.svampSessionId} for resume ID ${resumeSessionId}`);
-            return { type: "success", sessionId: tracked.svampSessionId };
-          }
-        }
-      }
-      try {
-        await fs.access(directory);
-      } catch {
-        if (!approvedNewDirectoryCreation) {
-          return { type: "requestToApproveDirectoryCreation", directory };
-        }
-        try {
-          await fs.mkdir(directory, { recursive: true });
-        } catch (err) {
-          return { type: "error", errorMessage: `Failed to create directory: ${err.message}` };
-        }
-      }
-      const sessionId = options.sessionId || randomUUID$1();
-      const agentName = options.agent || agentConfig.agent_type || "claude";
-      if (agentName !== "claude" && (KNOWN_ACP_AGENTS[agentName] || KNOWN_MCP_AGENTS[agentName])) {
-        return await spawnAgentSession(sessionId, directory, agentName, options, resumeSessionId);
-      }
-      try {
-        let parseBashPermission2 = function(permission) {
-          if (permission === "Bash") return;
-          const match = permission.match(/^Bash\((.+?)\)$/);
-          if (!match) return;
-          const command = match[1];
-          if (command.endsWith(":*")) {
-            allowedBashPrefixes.add(command.slice(0, -2));
-          } else {
-            allowedBashLiterals.add(command);
-          }
-        }, shouldAutoAllow2 = function(toolName, toolInput) {
-          if (toolName === "Bash") {
-            const inputObj = toolInput;
-            if (inputObj?.command) {
-              if (allowedBashLiterals.has(inputObj.command)) return true;
-              for (const prefix of allowedBashPrefixes) {
-                if (inputObj.command.startsWith(prefix)) return true;
-              }
-            }
-          } else if (allowedTools.has(toolName)) {
-            return true;
-          }
-          if (currentPermissionMode === "bypassPermissions" || currentPermissionMode === "yolo") return true;
-          if ((currentPermissionMode === "acceptEdits" || currentPermissionMode === "safe-yolo") && EDIT_TOOLS.has(toolName)) return true;
-          return false;
-        }, killAndWaitForExit2 = function(proc, signal = "SIGTERM", timeoutMs = 1e4) {
-          return new Promise((resolve2) => {
-            if (!proc || proc.exitCode !== null) {
-              resolve2();
-              return;
-            }
-            const timeout = setTimeout(() => {
-              try {
-                proc.kill("SIGKILL");
-              } catch {
-              }
-              resolve2();
-            }, timeoutMs);
-            proc.on("exit", () => {
-              clearTimeout(timeout);
-              resolve2();
-            });
-            if (!proc.killed) {
-              proc.kill(signal);
-            }
-          });
-        }, buildIsolationConfig2 = function(dir) {
-          if (!sessionMetadata.sharing?.enabled) return null;
-          const method = isolationCapabilities.preferred;
-          if (!method) return null;
-          const detail = isolationCapabilities.details[method];
-          if (!detail.found || detail.verified === false) return null;
-          return {
-            method,
-            binaryPath: detail.path || method,
-            workspacePath: dir
-          };
-        };
-        var parseBashPermission = parseBashPermission2, shouldAutoAllow = shouldAutoAllow2, killAndWaitForExit = killAndWaitForExit2, buildIsolationConfig = buildIsolationConfig2;
-        let sessionMetadata = {
-          path: directory,
-          host: os.hostname(),
-          version: "0.1.0",
-          machineId,
-          homeDir: os.homedir(),
-          svampHomeDir: SVAMP_HOME,
-          svampLibDir: join$1(__dirname$1, ".."),
-          svampToolsDir: join$1(__dirname$1, "..", "tools"),
-          startedFromDaemon: true,
-          startedBy: "daemon",
-          lifecycleState: resumeSessionId ? "idle" : "starting",
-          sharing: options.sharing
-        };
-        let claudeProcess = null;
-        const allPersisted = loadPersistedSessions();
-        const persisted = allPersisted.find((p) => p.sessionId === sessionId) || (resumeSessionId ? allPersisted.find((p) => p.claudeResumeId === resumeSessionId) : void 0);
-        let claudeResumeId = persisted?.claudeResumeId || (resumeSessionId || void 0);
-        let currentPermissionMode = persisted?.permissionMode || "default";
-        if (claudeResumeId) {
-          sessionMetadata = { ...sessionMetadata, claudeSessionId: claudeResumeId };
-        }
-        if (persisted && persisted.sessionId !== sessionId) {
-          const oldDir = persisted.directory || directory;
-          const newSessionDir = getSessionDir(directory, sessionId);
-          if (!existsSync$1(newSessionDir)) mkdirSync$1(newSessionDir, { recursive: true });
-          const oldMsgFile = getSessionMessagesPath(oldDir, persisted.sessionId);
-          const newMsgFile = getSessionMessagesPath(directory, sessionId);
-          try {
-            if (existsSync$1(oldMsgFile) && !existsSync$1(newMsgFile)) {
-              copyFileSync(oldMsgFile, newMsgFile);
-              logger.log(`[Session ${sessionId}] Copied messages from old session ${persisted.sessionId}`);
-            }
-          } catch (err) {
-            logger.log(`[Session ${sessionId}] Failed to copy messages: ${err.message}`);
-          }
-        }
-        const allowedTools = /* @__PURE__ */ new Set();
-        const allowedBashLiterals = /* @__PURE__ */ new Set();
-        const allowedBashPrefixes = /* @__PURE__ */ new Set();
-        const EDIT_TOOLS = /* @__PURE__ */ new Set(["Edit", "MultiEdit", "Write", "NotebookEdit"]);
-        const pendingPermissions = /* @__PURE__ */ new Map();
-        let backgroundTaskCount = 0;
-        let backgroundTaskNames = [];
-        let userMessagePending = false;
-        let turnInitiatedByUser = true;
-        let isKillingClaude = false;
-        let checkSvampConfig;
-        const CLAUDE_PERMISSION_MODE_MAP = {
-          "auto-approve-all": "bypassPermissions"
-        };
-        const toClaudePermissionMode = (mode) => CLAUDE_PERMISSION_MODE_MAP[mode] || mode;
-        let isolationCleanupFiles = [];
-        const spawnClaude = (initialMessage, meta) => {
-          const rawPermissionMode = meta?.permissionMode || agentConfig.default_permission_mode || currentPermissionMode;
-          const permissionMode = toClaudePermissionMode(rawPermissionMode);
-          currentPermissionMode = permissionMode;
-          const model = meta?.model || agentConfig.default_model || void 0;
-          const appendSystemPrompt = meta?.appendSystemPrompt || agentConfig.append_system_prompt || void 0;
-          const args = [
-            "--output-format",
-            "stream-json",
-            "--input-format",
-            "stream-json",
-            "--verbose",
-            "--permission-prompt-tool",
-            "stdio",
-            "--permission-mode",
-            permissionMode
-          ];
-          if (model) args.push("--model", model);
-          if (appendSystemPrompt) args.push("--append-system-prompt", appendSystemPrompt);
-          if (claudeResumeId) args.push("--resume", claudeResumeId);
-          let spawnCommand = "claude";
-          let spawnArgs = args;
-          let extraEnv = {};
-          isolationCleanupFiles = [];
-          const isoConfig = buildIsolationConfig2(directory);
-          if (isoConfig) {
-            const wrapped = wrapWithIsolation(spawnCommand, spawnArgs, isoConfig);
-            spawnCommand = wrapped.command;
-            spawnArgs = wrapped.args;
-            if (wrapped.env) extraEnv = wrapped.env;
-            if (wrapped.cleanupFiles) isolationCleanupFiles = wrapped.cleanupFiles;
-            sessionMetadata = { ...sessionMetadata, isolationMethod: isoConfig.method };
-            logger.log(`[Session ${sessionId}] Isolation: ${isoConfig.method} (binary: ${isoConfig.binaryPath})`);
-          } else {
-            sessionMetadata = { ...sessionMetadata, isolationMethod: void 0 };
-          }
-          logger.log(`[Session ${sessionId}] Spawning Claude: ${spawnCommand} ${spawnArgs.join(" ")} (cwd: ${directory})`);
-          const spawnEnv = { ...process.env, ...extraEnv };
-          delete spawnEnv.CLAUDECODE;
-          const child = spawn$1(spawnCommand, spawnArgs, {
-            cwd: directory,
-            stdio: ["pipe", "pipe", "pipe"],
-            env: spawnEnv,
-            shell: process.platform === "win32"
-          });
-          claudeProcess = child;
-          logger.log(`[Session ${sessionId}] Claude PID: ${child.pid}, stdin: ${!!child.stdin}, stdout: ${!!child.stdout}, stderr: ${!!child.stderr}`);
-          child.on("error", (err) => {
-            logger.log(`[Session ${sessionId}] Claude process error: ${err.message}`);
-            sessionService.pushMessage(
-              { type: "message", message: `Agent process exited unexpectedly: ${err.message}. Please ensure Claude Code CLI is installed.` },
-              "event"
-            );
-            sessionService.sendSessionEnd();
-          });
-          let stdoutBuffer = "";
-          let lastErrorMessagePushed = false;
-          child.stdout?.on("data", (chunk) => {
-            stdoutBuffer += chunk.toString();
-            const lines = stdoutBuffer.split("\n");
-            stdoutBuffer = lines.pop() || "";
-            for (const line of lines) {
-              if (!line.trim()) continue;
-              logger.log(`[Session ${sessionId}] stdout line (${line.length} chars): ${line.slice(0, 500)}`);
-              try {
-                const msg = JSON.parse(line);
-                logger.log(`[Session ${sessionId}] Parsed type=${msg.type} subtype=${msg.subtype || "n/a"}`);
-                if (msg.type === "control_request" && msg.request?.subtype === "can_use_tool") {
-                  const requestId = msg.request_id;
-                  const toolName = msg.request.tool_name;
-                  const toolInput = msg.request.input;
-                  logger.log(`[Session ${sessionId}] Permission request: ${requestId} tool=${toolName}`);
-                  if (shouldAutoAllow2(toolName, toolInput)) {
-                    logger.log(`[Session ${sessionId}] Auto-allowing ${toolName} (mode=${currentPermissionMode})`);
-                    if (claudeProcess && !claudeProcess.killed && claudeProcess.stdin) {
-                      const controlResponse = JSON.stringify({
-                        type: "control_response",
-                        response: {
-                          subtype: "success",
-                          request_id: requestId,
-                          response: { behavior: "allow", updatedInput: toolInput || {} }
-                        }
-                      });
-                      claudeProcess.stdin.write(controlResponse + "\n");
-                    }
-                    continue;
-                  }
-                  const permissionPromise = new Promise((resolve2) => {
-                    pendingPermissions.set(requestId, { resolve: resolve2, toolName, input: toolInput });
-                  });
-                  const currentRequests = { ...sessionService._agentState?.requests };
-                  sessionService.updateAgentState({
-                    controlledByUser: false,
-                    requests: {
-                      ...currentRequests,
-                      [requestId]: {
-                        tool: toolName,
-                        arguments: toolInput,
-                        createdAt: Date.now()
-                      }
-                    }
-                  });
-                  permissionPromise.then((result) => {
-                    if (claudeProcess && !claudeProcess.killed && claudeProcess.stdin) {
-                      const controlResponse = JSON.stringify({
-                        type: "control_response",
-                        response: {
-                          subtype: "success",
-                          request_id: requestId,
-                          response: result
-                        }
-                      });
-                      logger.log(`[Session ${sessionId}] Sending control_response: ${controlResponse.slice(0, 200)}`);
-                      claudeProcess.stdin.write(controlResponse + "\n");
-                    }
-                    const reqs = { ...sessionService._agentState?.requests };
-                    delete reqs[requestId];
-                    sessionService.updateAgentState({
-                      controlledByUser: false,
-                      requests: reqs,
-                      completedRequests: {
-                        ...sessionService._agentState?.completedRequests,
-                        [requestId]: {
-                          tool: toolName,
-                          arguments: toolInput,
-                          completedAt: Date.now(),
-                          status: result.behavior === "allow" ? "approved" : "denied"
-                        }
-                      }
-                    });
-                  }).catch((err) => {
-                    logger.log(`[Session ${sessionId}] Permission handler error (request ${requestId}): ${err}`);
-                  });
-                } else if (msg.type === "control_cancel_request") {
-                  const requestId = msg.request_id;
-                  logger.log(`[Session ${sessionId}] Permission cancel: ${requestId}`);
-                  const pending = pendingPermissions.get(requestId);
-                  if (pending) {
-                    pending.resolve({ behavior: "deny", message: "Cancelled" });
-                    pendingPermissions.delete(requestId);
-                  }
-                } else if (msg.type === "control_response") {
-                  logger.log(`[Session ${sessionId}] Control response: ${JSON.stringify(msg).slice(0, 200)}`);
-                } else if (msg.type === "assistant" || msg.type === "result") {
-                  if (msg.type === "assistant" && Array.isArray(msg.content)) {
-                    for (const block of msg.content) {
-                      if (block.type === "tool_use" && block.input?.run_in_background === true) {
-                        backgroundTaskCount++;
-                        const label = block.tool_name || block.name || "unknown";
-                        backgroundTaskNames.push(label);
-                        logger.log(`[Session ${sessionId}] Background task launched: ${label} (count=${backgroundTaskCount})`);
-                      }
-                    }
-                  }
-                  if (msg.type === "result") {
-                    if (msg.is_error) {
-                      const resultText = msg.result || "";
-                      logger.error(`[Session ${sessionId}] Claude error (is_error=true, api_ms=${msg.duration_api_ms}): "${resultText}"`);
-                      const lower = resultText.toLowerCase();
-                      const isLoginIssue = lower.includes("login") || lower.includes("logged in") || lower.includes("auth") || lower.includes("api key") || lower.includes("unauthorized");
-                      const isResumeIssue = lower.includes("tool_use.name") || lower.includes("invalid_request") || lower.includes("messages.");
-                      let hint = "";
-                      if (isLoginIssue) {
-                        hint = "\n\nRun `claude login` in your terminal on the machine running the daemon to re-authenticate.";
-                      } else if (isResumeIssue) {
-                        hint = "\n\nThe conversation history may be corrupted. Try starting a fresh session.";
-                      } else {
-                        hint = "\n\nCheck that the Claude Code CLI is properly installed and configured.";
-                      }
-                      const displayMsg = resultText || "Claude Code exited with an error.";
-                      sessionService.pushMessage({
-                        type: "assistant",
-                        content: [{ type: "text", text: `**Error:** ${displayMsg}${hint}` }]
-                      }, "agent");
-                      lastErrorMessagePushed = true;
-                    }
-                  }
-                  if (msg.type === "result") {
-                    if (!turnInitiatedByUser) {
-                      logger.log(`[Session ${sessionId}] Skipping stale result from SDK-initiated turn`);
-                      const hasBackgroundTasks = backgroundTaskCount > 0;
-                      if (hasBackgroundTasks) {
-                        const taskInfo = `Background tasks still running (${backgroundTaskCount}): ${backgroundTaskNames.join(", ")}`;
-                        sessionService.pushMessage({ type: "session_event", message: taskInfo }, "session");
-                      }
-                      sessionService.sendKeepAlive(false);
-                      turnInitiatedByUser = true;
-                      continue;
-                    }
-                    sessionService.sendKeepAlive(false);
-                    checkSvampConfig?.();
-                    if (backgroundTaskCount > 0) {
-                      const taskInfo = `Background tasks still running (${backgroundTaskCount}): ${backgroundTaskNames.join(", ")}`;
-                      logger.log(`[Session ${sessionId}] ${taskInfo}`);
-                      sessionService.pushMessage({ type: "session_event", message: taskInfo }, "session");
-                    }
-                  }
-                  sessionService.pushMessage(msg, "agent");
-                  if (msg.session_id) {
-                    claudeResumeId = msg.session_id;
-                  }
-                } else if (msg.type === "system" && msg.subtype === "init") {
-                  if (!userMessagePending) {
-                    turnInitiatedByUser = false;
-                    logger.log(`[Session ${sessionId}] SDK-initiated turn (likely stale task_notification)`);
-                  }
-                  userMessagePending = false;
-                  if (msg.session_id) {
-                    claudeResumeId = msg.session_id;
-                    sessionMetadata = { ...sessionMetadata, claudeSessionId: msg.session_id };
-                    sessionService.updateMetadata(sessionMetadata);
-                    saveSession({
-                      sessionId,
-                      directory,
-                      claudeResumeId,
-                      permissionMode: currentPermissionMode,
-                      metadata: sessionMetadata,
-                      createdAt: Date.now(),
-                      machineId
-                    });
-                    artifactSync.scheduleDebouncedSync(sessionId, getSessionDir(directory, sessionId), sessionMetadata, machineId);
-                  }
-                  sessionService.pushMessage(msg, "session");
-                } else if (msg.type === "system" && msg.subtype === "task_notification" && msg.status === "completed") {
-                  backgroundTaskCount = Math.max(0, backgroundTaskCount - 1);
-                  if (backgroundTaskNames.length > 0) {
-                    const completed = backgroundTaskNames.shift();
-                    logger.log(`[Session ${sessionId}] Background task completed: ${completed} (remaining=${backgroundTaskCount})`);
-                  }
-                  sessionService.pushMessage(msg, "agent");
-                } else {
-                  sessionService.pushMessage(msg, "agent");
-                }
-              } catch {
-                logger.log(`[Session ${sessionId}] Claude stdout (non-JSON): ${line}`);
-              }
-            }
-          });
-          let stderrBuffer = "";
-          child.stderr?.on("data", (chunk) => {
-            const text = chunk.toString();
-            logger.log(`[Session ${sessionId}] Claude stderr: ${text.trim()}`);
-            stderrBuffer += text;
-          });
-          child.on("exit", (code, signal) => {
-            logger.log(`[Session ${sessionId}] Claude exited: code=${code}, signal=${signal}`);
-            claudeProcess = null;
-            for (const f of isolationCleanupFiles) {
-              fs.rm(f, { force: true }).catch(() => {
-              });
-            }
-            isolationCleanupFiles = [];
-            for (const [id, pending] of pendingPermissions) {
-              pending.resolve({ behavior: "deny", message: "Claude process exited" });
-            }
-            pendingPermissions.clear();
-            if (code !== 0 && code !== null && !lastErrorMessagePushed) {
-              sessionService.pushMessage(
-                { type: "message", message: `Agent process exited unexpectedly (code ${code}${signal ? `, signal: ${signal}` : ""})` },
-                "event"
-              );
-            }
-            lastErrorMessagePushed = false;
-            sessionMetadata = { ...sessionMetadata, lifecycleState: claudeResumeId ? "idle" : "stopped" };
-            sessionService.updateMetadata(sessionMetadata);
-            sessionService.sendSessionEnd();
-            if (claudeResumeId && !trackedSession.stopped) {
-              saveSession({
-                sessionId,
-                directory,
-                claudeResumeId,
-                permissionMode: currentPermissionMode,
-                metadata: sessionMetadata,
-                createdAt: Date.now(),
-                machineId
-              });
-              artifactSync.syncSession(sessionId, getSessionDir(directory, sessionId), sessionMetadata, machineId).catch(() => {
-              });
-            }
-          });
-          if (initialMessage && child.stdin) {
-            const stdinMsg = JSON.stringify({
-              type: "user",
-              message: { role: "user", content: initialMessage }
-            });
-            child.stdin.write(stdinMsg + "\n");
-          }
-          return child;
-        };
-        const sessionService = await registerSessionService(
-          server,
-          sessionId,
-          sessionMetadata,
-          { controlledByUser: false },
-          {
-            onUserMessage: (content, meta) => {
-              logger.log(`[Session ${sessionId}] User message received`);
-              userMessagePending = true;
-              turnInitiatedByUser = true;
-              let text;
-              let msgMeta = meta;
-              try {
-                let parsed = typeof content === "string" ? JSON.parse(content) : content;
-                if (parsed?.content && typeof parsed.content === "string") {
-                  try {
-                    const inner = JSON.parse(parsed.content);
-                    if (inner && typeof inner === "object") parsed = inner;
-                  } catch {
-                  }
-                }
-                text = parsed?.content?.text || parsed?.text || (typeof parsed === "string" ? parsed : JSON.stringify(parsed));
-                if (parsed?.meta) msgMeta = { ...msgMeta, ...parsed.meta };
-              } catch {
-                text = typeof content === "string" ? content : JSON.stringify(content);
-              }
-              if (msgMeta?.permissionMode) {
-                currentPermissionMode = toClaudePermissionMode(msgMeta.permissionMode);
-                logger.log(`[Session ${sessionId}] Permission mode updated to: ${currentPermissionMode}`);
-              }
-              if (isKillingClaude) {
-                logger.log(`[Session ${sessionId}] Message received while restarting Claude, ignoring to prevent ghost process`);
-                sessionService.sendKeepAlive(false);
-                return;
-              }
-              if (!claudeProcess || claudeProcess.exitCode !== null) {
-                spawnClaude(text, msgMeta);
-              } else {
-                const stdinMsg = JSON.stringify({
-                  type: "user",
-                  message: { role: "user", content: text }
-                });
-                claudeProcess.stdin?.write(stdinMsg + "\n");
-              }
-              sessionService.sendKeepAlive(true);
-            },
-            onAbort: () => {
-              logger.log(`[Session ${sessionId}] Abort requested`);
-              if (claudeProcess && !claudeProcess.killed) {
-                claudeProcess.kill("SIGINT");
-              }
-            },
-            onPermissionResponse: (params) => {
-              logger.log(`[Session ${sessionId}] Permission response:`, JSON.stringify(params));
-              const requestId = params.id;
-              const pending = pendingPermissions.get(requestId);
-              if (params.mode) {
-                currentPermissionMode = toClaudePermissionMode(params.mode);
-                logger.log(`[Session ${sessionId}] Permission mode changed to: ${currentPermissionMode}`);
-              }
-              if (params.allowTools && Array.isArray(params.allowTools)) {
-                for (const tool of params.allowTools) {
-                  if (tool.startsWith("Bash(") || tool === "Bash") {
-                    parseBashPermission2(tool);
-                  } else {
-                    allowedTools.add(tool);
-                  }
-                }
-                logger.log(`[Session ${sessionId}] Updated allowed tools: ${[...allowedTools].join(", ")}`);
-              }
-              if (pending) {
-                pendingPermissions.delete(requestId);
-                if (params.approved) {
-                  pending.resolve({
-                    behavior: "allow",
-                    updatedInput: pending.input || {}
-                  });
-                } else {
-                  pending.resolve({
-                    behavior: "deny",
-                    message: params.reason || "The user doesn't want to proceed with this tool use. The tool use was rejected (eg. if it was a file edit, the new_string was NOT written to the file). STOP what you are doing and wait for the user to tell you how to proceed."
-                  });
-                }
-              } else {
-                logger.log(`[Session ${sessionId}] No pending permission for id=${requestId}`);
-              }
-            },
-            onSwitchMode: async (mode) => {
-              logger.log(`[Session ${sessionId}] Switch mode: ${mode}`);
-              currentPermissionMode = mode;
-              if (claudeProcess && claudeProcess.exitCode === null) {
-                isKillingClaude = true;
-                await killAndWaitForExit2(claudeProcess);
-                isKillingClaude = false;
-                spawnClaude(void 0, { permissionMode: mode });
-              }
-            },
-            onRestartClaude: async () => {
-              logger.log(`[Session ${sessionId}] Restart Claude requested`);
-              try {
-                if (claudeProcess && claudeProcess.exitCode === null) {
-                  isKillingClaude = true;
-                  sessionMetadata = { ...sessionMetadata, lifecycleState: "restarting" };
-                  sessionService.updateMetadata(sessionMetadata);
-                  await killAndWaitForExit2(claudeProcess);
-                  isKillingClaude = false;
-                }
-                if (claudeResumeId) {
-                  spawnClaude(void 0, { permissionMode: currentPermissionMode });
-                  logger.log(`[Session ${sessionId}] Claude respawned with --resume ${claudeResumeId}`);
-                  return { success: true, message: "Claude process restarted successfully." };
-                } else {
-                  logger.log(`[Session ${sessionId}] No resume ID \u2014 cannot restart`);
-                  return { success: false, message: "No session to resume. Send a message to start a new session." };
-                }
-              } catch (err) {
-                isKillingClaude = false;
-                logger.log(`[Session ${sessionId}] Restart failed: ${err.message}`);
-                return { success: false, message: `Restart failed: ${err.message}` };
-              }
-            },
-            onKillSession: () => {
-              logger.log(`[Session ${sessionId}] Kill session requested`);
-              stopSession(sessionId);
-            },
-            onBash: async (command, cwd) => {
-              logger.log(`[Session ${sessionId}] Bash: ${command} (cwd: ${cwd || directory})`);
-              const { exec } = await import('child_process');
-              return new Promise((resolve2) => {
-                exec(command, { cwd: cwd || directory, timeout: 3e4, maxBuffer: 1024 * 1024 }, (err, stdout, stderr) => {
-                  if (err) {
-                    resolve2({ success: false, stdout: stdout || "", stderr: stderr || err.message, exitCode: err.code ?? 1 });
-                  } else {
-                    resolve2({ success: true, stdout, stderr: stderr || "", exitCode: 0 });
-                  }
-                });
-              });
-            },
-            onRipgrep: async (args, cwd) => {
-              const { exec } = await import('child_process');
-              const rgCwd = cwd || directory;
-              return new Promise((resolve2, reject) => {
-                exec(`rg ${args}`, { cwd: rgCwd, timeout: 3e4, maxBuffer: 5 * 1024 * 1024 }, (err, stdout) => {
-                  if (err && !stdout) {
-                    reject(new Error(err.message));
-                  } else {
-                    resolve2(stdout || "");
-                  }
-                });
-              });
-            },
-            onReadFile: async (path) => {
-              const resolvedPath = resolve(directory, path);
-              if (!resolvedPath.startsWith(resolve(directory))) {
-                throw new Error("Path outside working directory");
-              }
-              const buffer = await fs.readFile(resolvedPath);
-              return buffer.toString("base64");
-            },
-            onWriteFile: async (path, content) => {
-              const resolvedPath = resolve(directory, path);
-              if (!resolvedPath.startsWith(resolve(directory))) {
-                throw new Error("Path outside working directory");
-              }
-              await fs.mkdir(dirname(resolvedPath), { recursive: true });
-              await fs.writeFile(resolvedPath, Buffer.from(content, "base64"));
-            },
-            onListDirectory: async (path) => {
-              const resolvedDir = resolve(directory, path || ".");
-              if (!resolvedDir.startsWith(resolve(directory))) {
-                throw new Error("Path outside working directory");
-              }
-              const entries = await fs.readdir(resolvedDir, { withFileTypes: true });
-              return entries.map((e) => ({ name: e.name, isDirectory: e.isDirectory() }));
-            },
-            onGetDirectoryTree: async (treePath, maxDepth) => {
-              async function buildTree(p, name, depth) {
-                try {
-                  const stats = await fs.stat(p);
-                  const node = {
-                    name,
-                    path: p,
-                    type: stats.isDirectory() ? "directory" : "file",
-                    size: stats.size,
-                    modified: stats.mtime.getTime()
-                  };
-                  if (stats.isDirectory() && depth < maxDepth) {
-                    const entries = await fs.readdir(p, { withFileTypes: true });
-                    const children = [];
-                    await Promise.all(entries.map(async (entry) => {
-                      if (entry.isSymbolicLink()) return;
-                      const childPath = join$1(p, entry.name);
-                      const childNode = await buildTree(childPath, entry.name, depth + 1);
-                      if (childNode) children.push(childNode);
-                    }));
-                    children.sort((a, b) => {
-                      if (a.type === "directory" && b.type !== "directory") return -1;
-                      if (a.type !== "directory" && b.type === "directory") return 1;
-                      return a.name.localeCompare(b.name);
-                    });
-                    node.children = children;
-                  }
-                  return node;
-                } catch {
-                  return null;
-                }
-              }
-              const resolvedPath = resolve(directory, treePath);
-              const tree = await buildTree(resolvedPath, basename(resolvedPath), 0);
-              return { success: !!tree, tree };
-            }
-          },
-          { messagesDir: getSessionDir(directory, sessionId) }
-        );
-        checkSvampConfig = createSvampConfigChecker(
-          directory,
-          sessionId,
-          () => sessionMetadata,
-          (updater) => {
-            sessionMetadata = updater(sessionMetadata);
-            sessionService.updateMetadata(sessionMetadata);
-          },
-          sessionService,
-          logger
-        );
-        const trackedSession = {
-          startedBy: "daemon",
-          pid: process.pid,
-          svampSessionId: sessionId,
-          hyphaService: sessionService,
-          checkSvampConfig,
-          directory,
-          resumeSessionId: claudeResumeId,
-          get childProcess() {
-            return claudeProcess || void 0;
-          }
-        };
-        pidToTrackedSession.set(process.pid + Math.floor(Math.random() * 1e5), trackedSession);
-        sessionMetadata = { ...sessionMetadata, lifecycleState: "idle" };
-        sessionService.updateMetadata(sessionMetadata);
-        logger.log(`Session ${sessionId} registered on Hypha, waiting for first message to spawn Claude`);
-        return {
-          type: "success",
-          sessionId,
-          message: `Session registered on Hypha as svamp-session-${sessionId}`
-        };
-      } catch (err) {
-        logger.error(`Failed to spawn session:`, err);
-        return {
-          type: "error",
-          errorMessage: `Failed to register session service: ${err.message}`
-        };
-      }
-    };
-    const spawnAgentSession = async (sessionId, directory, agentName, options, resumeSessionId) => {
-      logger.log(`[Agent] Spawning ${agentName} session: ${sessionId}`);
-      try {
-        let parseBashPermission2 = function(permission) {
-          if (permission === "Bash") return;
-          const match = permission.match(/^Bash\((.+?)\)$/);
-          if (!match) return;
-          const command = match[1];
-          if (command.endsWith(":*")) {
-            allowedBashPrefixes.add(command.slice(0, -2));
-          } else {
-            allowedBashLiterals.add(command);
-          }
-        }, shouldAutoAllow2 = function(toolName, toolInput) {
-          if (toolName === "Bash") {
-            const inputObj = toolInput;
-            if (inputObj?.command) {
-              if (allowedBashLiterals.has(inputObj.command)) return true;
-              for (const prefix of allowedBashPrefixes) {
-                if (inputObj.command.startsWith(prefix)) return true;
-              }
-            }
-          } else if (allowedTools.has(toolName)) {
-            return true;
-          }
-          if (currentPermissionMode === "bypassPermissions" || currentPermissionMode === "yolo") return true;
-          if ((currentPermissionMode === "acceptEdits" || currentPermissionMode === "safe-yolo") && EDIT_TOOLS.has(toolName)) return true;
-          return false;
-        };
-        var parseBashPermission = parseBashPermission2, shouldAutoAllow = shouldAutoAllow2;
-        let sessionMetadata = {
-          path: directory,
-          host: os.hostname(),
-          version: "0.1.0",
-          machineId,
-          homeDir: os.homedir(),
-          svampHomeDir: SVAMP_HOME,
-          svampLibDir: join$1(__dirname$1, ".."),
-          svampToolsDir: join$1(__dirname$1, "..", "tools"),
-          startedFromDaemon: true,
-          startedBy: "daemon",
-          lifecycleState: "starting",
-          flavor: agentName,
-          sharing: options.sharing
-        };
-        let currentPermissionMode = "default";
-        const allowedTools = /* @__PURE__ */ new Set();
-        const allowedBashLiterals = /* @__PURE__ */ new Set();
-        const allowedBashPrefixes = /* @__PURE__ */ new Set();
-        const EDIT_TOOLS = /* @__PURE__ */ new Set(["Edit", "MultiEdit", "Write", "NotebookEdit"]);
-        const sessionService = await registerSessionService(
-          server,
-          sessionId,
-          sessionMetadata,
-          { controlledByUser: false },
-          {
-            onUserMessage: (content, meta) => {
-              logger.log(`[${agentName} Session ${sessionId}] User message received`);
-              let text;
-              let msgMeta = meta;
-              try {
-                let parsed = typeof content === "string" ? JSON.parse(content) : content;
-                if (parsed?.content && typeof parsed.content === "string") {
-                  try {
-                    const inner = JSON.parse(parsed.content);
-                    if (inner && typeof inner === "object") parsed = inner;
-                  } catch {
-                  }
-                }
-                text = parsed?.content?.text || parsed?.text || (typeof parsed === "string" ? parsed : JSON.stringify(parsed));
-                if (parsed?.meta) msgMeta = { ...msgMeta, ...parsed.meta };
-              } catch {
-                text = typeof content === "string" ? content : JSON.stringify(content);
-              }
-              if (msgMeta?.permissionMode) {
-                currentPermissionMode = msgMeta.permissionMode;
-              }
-              agentBackend.sendPrompt(sessionId, text).catch((err) => {
-                logger.error(`[${agentName} Session ${sessionId}] Error sending prompt:`, err);
-              });
-            },
-            onAbort: () => {
-              logger.log(`[${agentName} Session ${sessionId}] Abort requested`);
-              agentBackend.cancel(sessionId).catch(() => {
-              });
-            },
-            onPermissionResponse: (params) => {
-              logger.log(`[${agentName} Session ${sessionId}] Permission response:`, JSON.stringify(params));
-              const requestId = params.id;
-              if (params.mode) currentPermissionMode = params.mode;
-              if (params.allowTools && Array.isArray(params.allowTools)) {
-                for (const tool of params.allowTools) {
-                  if (tool.startsWith("Bash(") || tool === "Bash") {
-                    parseBashPermission2(tool);
-                  } else {
-                    allowedTools.add(tool);
-                  }
-                }
-              }
-              permissionHandler.resolvePermission(requestId, params.approved);
-              agentBackend.respondToPermission?.(requestId, params.approved);
-            },
-            onSwitchMode: (mode) => {
-              logger.log(`[${agentName} Session ${sessionId}] Switch mode: ${mode}`);
-              currentPermissionMode = mode;
-            },
-            onRestartClaude: async () => {
-              logger.log(`[${agentName} Session ${sessionId}] Restart agent requested`);
-              return { success: false, message: "Restart is not supported for this agent type." };
-            },
-            onKillSession: () => {
-              logger.log(`[${agentName} Session ${sessionId}] Kill session requested`);
-              stopSession(sessionId);
-            },
-            onBash: async (command, cwd) => {
-              const { exec } = await import('child_process');
-              return new Promise((resolve2) => {
-                exec(command, { cwd: cwd || directory, timeout: 3e4, maxBuffer: 1024 * 1024 }, (err, stdout, stderr) => {
-                  if (err) {
-                    resolve2({ success: false, stdout: stdout || "", stderr: stderr || err.message, exitCode: err.code ?? 1 });
-                  } else {
-                    resolve2({ success: true, stdout, stderr: stderr || "", exitCode: 0 });
-                  }
-                });
-              });
-            },
-            onRipgrep: async (args, cwd) => {
-              const { exec } = await import('child_process');
-              const rgCwd = cwd || directory;
-              return new Promise((resolve2, reject) => {
-                exec(`rg ${args}`, { cwd: rgCwd, timeout: 3e4, maxBuffer: 5 * 1024 * 1024 }, (err, stdout) => {
-                  if (err && !stdout) {
-                    reject(new Error(err.message));
-                  } else {
-                    resolve2(stdout || "");
-                  }
-                });
-              });
-            },
-            onReadFile: async (path) => {
-              const resolvedPath = resolve(directory, path);
-              if (!resolvedPath.startsWith(resolve(directory))) {
-                throw new Error("Path outside working directory");
-              }
-              const buffer = await fs.readFile(resolvedPath);
-              return buffer.toString("base64");
-            },
-            onWriteFile: async (path, content) => {
-              const resolvedPath = resolve(directory, path);
-              if (!resolvedPath.startsWith(resolve(directory))) {
-                throw new Error("Path outside working directory");
-              }
-              await fs.mkdir(dirname(resolvedPath), { recursive: true });
-              await fs.writeFile(resolvedPath, Buffer.from(content, "base64"));
-            },
-            onListDirectory: async (path) => {
-              const resolvedDir = resolve(directory, path || ".");
-              if (!resolvedDir.startsWith(resolve(directory))) {
-                throw new Error("Path outside working directory");
-              }
-              const entries = await fs.readdir(resolvedDir, { withFileTypes: true });
-              return entries.map((e) => ({ name: e.name, isDirectory: e.isDirectory() }));
-            },
-            onGetDirectoryTree: async (treePath, maxDepth) => {
-              async function buildTree(p, name, depth) {
-                try {
-                  const stats = await fs.stat(p);
-                  const node = {
-                    name,
-                    path: p,
-                    type: stats.isDirectory() ? "directory" : "file",
-                    size: stats.size,
-                    modified: stats.mtime.getTime()
-                  };
-                  if (stats.isDirectory() && depth < maxDepth) {
-                    const entries = await fs.readdir(p, { withFileTypes: true });
-                    const children = [];
-                    await Promise.all(entries.map(async (entry) => {
-                      if (entry.isSymbolicLink()) return;
-                      const childPath = join$1(p, entry.name);
-                      const childNode = await buildTree(childPath, entry.name, depth + 1);
-                      if (childNode) children.push(childNode);
-                    }));
-                    children.sort((a, b) => {
-                      if (a.type === "directory" && b.type !== "directory") return -1;
-                      if (a.type !== "directory" && b.type === "directory") return 1;
-                      return a.name.localeCompare(b.name);
-                    });
-                    node.children = children;
-                  }
-                  return node;
-                } catch {
-                  return null;
-                }
-              }
-              const resolvedPath = resolve(directory, treePath);
-              const tree = await buildTree(resolvedPath, basename(resolvedPath), 0);
-              return { success: !!tree, tree };
-            }
-          },
-          { messagesDir: getSessionDir(directory, sessionId) }
-        );
-        const checkSvampConfig = createSvampConfigChecker(
-          directory,
-          sessionId,
-          () => sessionMetadata,
-          (updater) => {
-            sessionMetadata = updater(sessionMetadata);
-            sessionService.updateMetadata(sessionMetadata);
-          },
-          sessionService,
-          logger
-        );
-        const permissionHandler = new HyphaPermissionHandler(shouldAutoAllow2, logger.log);
-        let agentIsoConfig;
-        if (sessionMetadata.sharing?.enabled && isolationCapabilities.preferred) {
-          const method = isolationCapabilities.preferred;
-          const detail = isolationCapabilities.details[method];
-          if (detail.found && detail.verified !== false) {
-            agentIsoConfig = {
-              method,
-              binaryPath: detail.path || method,
-              workspacePath: directory
-            };
-            sessionMetadata = { ...sessionMetadata, isolationMethod: method };
-            logger.log(`[Agent Session ${sessionId}] Isolation: ${method}`);
-          }
-        }
-        let agentBackend;
-        if (KNOWN_MCP_AGENTS[agentName]) {
-          agentBackend = new CodexMcpBackend({
-            cwd: directory,
-            env: options.environmentVariables,
-            log: logger.log,
-            isolationConfig: agentIsoConfig
-          });
-        } else {
-          const transportHandler = agentName === "gemini" ? new GeminiTransport() : new DefaultTransport(agentName);
-          const acpConfig = KNOWN_ACP_AGENTS[agentName];
-          agentBackend = new AcpBackend({
-            agentName,
-            cwd: directory,
-            command: acpConfig.command,
-            args: acpConfig.args,
-            env: options.environmentVariables,
-            permissionHandler,
-            transportHandler,
-            log: logger.log,
-            isolationConfig: agentIsoConfig
-          });
-        }
-        bridgeAcpToSession(
-          agentBackend,
-          sessionService,
-          () => sessionMetadata,
-          (updater) => {
-            sessionMetadata = updater(sessionMetadata);
-            sessionService.updateMetadata(sessionMetadata);
-          },
-          logger.log,
-          checkSvampConfig
-        );
-        const trackedSession = {
-          startedBy: "daemon",
-          pid: process.pid,
-          svampSessionId: sessionId,
-          hyphaService: sessionService,
-          checkSvampConfig,
-          directory,
-          resumeSessionId,
-          get childProcess() {
-            return agentBackend.getProcess?.() || void 0;
-          }
-        };
-        pidToTrackedSession.set(process.pid + Math.floor(Math.random() * 1e5), trackedSession);
-        logger.log(`[Agent Session ${sessionId}] Starting ${agentName} backend...`);
-        agentBackend.startSession().then(() => {
-          logger.log(`[Agent Session ${sessionId}] ${agentName} backend started, waiting for first message`);
-        }).catch((err) => {
-          logger.error(`[Agent Session ${sessionId}] Failed to start ${agentName}:`, err);
-          sessionService.pushMessage(
-            { type: "message", message: `Agent process exited unexpectedly: ${err.message}. Please ensure the ${agentName} CLI is installed.` },
-            "event"
-          );
-          sessionService.sendSessionEnd();
-        });
-        return {
-          type: "success",
-          sessionId,
-          message: `Agent session (${agentName}) registered as svamp-session-${sessionId}`
-        };
-      } catch (err) {
-        logger.error(`[Agent] Failed to spawn ${agentName} session:`, err);
-        return {
-          type: "error",
-          errorMessage: `Failed to spawn ${agentName} session: ${err.message}`
-        };
-      }
-    };
-    const stopSession = (sessionId) => {
-      logger.log(`Stopping session: ${sessionId}`);
-      for (const [pid, session] of pidToTrackedSession) {
-        if (session.svampSessionId === sessionId) {
-          session.stopped = true;
-          session.hyphaService?.disconnect().catch(() => {
-          });
-          if (session.childProcess) {
-            try {
-              session.childProcess.kill("SIGTERM");
-            } catch {
-            }
-          }
-          pidToTrackedSession.delete(pid);
-          deletePersistedSession(sessionId);
-          logger.log(`Session ${sessionId} stopped`);
-          return true;
-        }
-      }
-      logger.log(`Session ${sessionId} not found`);
-      return false;
-    };
-    let isolationCapabilities;
-    try {
-      isolationCapabilities = await detectIsolationCapabilities();
-      logger.log(`Isolation capabilities: ${isolationCapabilities.available.join(", ") || "none"} (preferred: ${isolationCapabilities.preferred || "none"})`);
-    } catch (err) {
-      logger.log(`Failed to detect isolation capabilities: ${err}`);
-      isolationCapabilities = { available: [], preferred: null, details: { srt: { found: false }, bwrap: { found: false }, docker: { found: false }, podman: { found: false } } };
-    }
-    const defaultHomeDir = existsSync$1("/data") ? "/data" : os.homedir();
-    const machineMetadata = {
-      host: os.hostname(),
-      platform: os.platform(),
-      svampVersion: "0.1.0 (hypha)",
-      homeDir: defaultHomeDir,
-      svampHomeDir: SVAMP_HOME,
-      svampLibDir: join$1(__dirname$1, ".."),
-      displayName: process.env.SVAMP_DISPLAY_NAME || void 0,
-      isolationCapabilities
-    };
-    const initialDaemonState = {
-      status: "running",
-      pid: process.pid,
-      startedAt: Date.now()
-    };
-    const machineService = await registerMachineService(
-      server,
-      machineId,
-      machineMetadata,
-      initialDaemonState,
-      {
-        spawnSession,
-        stopSession,
-        requestShutdown: () => requestShutdown("hypha-app"),
-        getTrackedSessions: getCurrentChildren
-      }
-    );
-    logger.log(`Machine service registered: svamp-machine-${machineId}`);
-    const artifactSync = new SessionArtifactSync(server, logger.log);
-    const debugService = await registerDebugService(server, machineId, {
-      machineId,
-      getTrackedSessions: getCurrentChildren,
-      getSessionService: (sessionId) => {
-        for (const [, session] of pidToTrackedSession) {
-          if (session.svampSessionId === sessionId) {
-            return session.hyphaService;
-          }
-        }
-        return null;
-      },
-      getArtifactSync: () => artifactSync,
-      getSessionsDir: () => SVAMP_HOME
-      // Legacy; debug service uses session index now
-    });
-    logger.log(`Debug service registered: svamp-debug-${machineId}`);
-    const persistedSessions = loadPersistedSessions();
-    if (persistedSessions.length > 0) {
-      logger.log(`Restoring ${persistedSessions.length} persisted session(s)...`);
-      for (const persisted of persistedSessions) {
-        try {
-          const isOrphaned = persisted.machineId && persisted.machineId !== machineId;
-          if (isOrphaned) {
-            logger.log(`Session ${persisted.sessionId} is from a different machine (${persisted.machineId} vs ${machineId}), marking as orphaned`);
-          }
-          const result = await spawnSession({
-            directory: persisted.directory,
-            sessionId: persisted.sessionId,
-            resumeSessionId: persisted.claudeResumeId
-          });
-          if (result.type === "success") {
-            logger.log(`Restored session ${persisted.sessionId} (resume=${persisted.claudeResumeId})`);
-            if (isOrphaned) {
-              for (const [, tracked] of pidToTrackedSession) {
-                if (tracked.svampSessionId === persisted.sessionId && tracked.hyphaService) {
-                  tracked.hyphaService.updateMetadata({
-                    ...persisted.metadata || {},
-                    isOrphaned: true,
-                    originalMachineId: persisted.machineId
-                  });
-                  break;
-                }
-              }
-            }
-          } else {
-            logger.log(`Failed to restore session ${persisted.sessionId}: ${result.type}`);
-          }
-        } catch (err) {
-          logger.error(`Error restoring session ${persisted.sessionId}:`, err.message);
-        }
-      }
-    }
-    (async () => {
-      try {
-        await artifactSync.init();
-        logger.log(`[ARTIFACT SYNC] Ready (upload-only, remote sessions stay in artifact store)`);
-      } catch (err) {
-        logger.log(`[ARTIFACT SYNC] Background init failed: ${err.message}`);
-      }
-    })();
-    let appToken;
-    try {
-      appToken = await server.generateToken({});
-      logger.log(`App connection token generated`);
-    } catch (err) {
-      logger.log("Could not generate token (server may not support it):", err);
-    }
-    const supervised = process.env.SVAMP_SUPERVISED === "1";
-    const localState = {
-      pid: process.pid,
-      startTime: (/* @__PURE__ */ new Date()).toISOString(),
-      version: DAEMON_VERSION,
-      hyphaServerUrl,
-      workspace: server.config.workspace,
-      machineId,
-      supervised
-    };
-    writeDaemonStateFile(localState);
-    console.log("Svamp daemon started successfully!");
-    console.log(`  Machine ID: ${machineId}`);
-    console.log(`  Hypha server: ${hyphaServerUrl}`);
-    console.log(`  Workspace: ${server.config.workspace}`);
-    if (appToken) {
-      console.log(`  App token: ${appToken}`);
-    }
-    console.log(`  Service: svamp-machine-${machineId}`);
-    console.log(`  Log file: ${logger.logFilePath}`);
-    let consecutiveHeartbeatFailures = 0;
-    const MAX_HEARTBEAT_FAILURES = 60;
-    const heartbeatInterval = setInterval(async () => {
-      try {
-        const state = readDaemonStateFile();
-        if (state && state.pid === process.pid) {
-          state.lastHeartbeat = (/* @__PURE__ */ new Date()).toISOString();
-          writeDaemonStateFile(state);
-        }
-      } catch {
-      }
-      try {
-        const installedVersion = readPackageVersion();
-        if (installedVersion !== "unknown" && installedVersion !== DAEMON_VERSION) {
-          logger.log(`svamp-cli version changed on disk: ${DAEMON_VERSION} \u2192 ${installedVersion}. Self-restarting...`);
-          const supervised2 = process.env.SVAMP_SUPERVISED === "1";
-          if (!supervised2) {
-            const { spawn: spawnSelf } = await import('child_process');
-            spawnSelf(process.argv[0], process.argv.slice(1), {
-              detached: true,
-              stdio: "ignore",
-              env: process.env
-            }).unref();
-            await new Promise((r) => setTimeout(r, 500));
-          }
-          requestShutdown("version-update", `Updated ${DAEMON_VERSION} \u2192 ${installedVersion}`);
-          return;
-        }
-      } catch {
-      }
-      for (const [key, session] of pidToTrackedSession) {
-        const child = session.childProcess;
-        if (child && child.pid) {
-          try {
-            process.kill(child.pid, 0);
-          } catch {
-            logger.log(`Removing stale session (child PID ${child.pid} dead): ${session.svampSessionId}`);
-            session.hyphaService?.disconnect().catch(() => {
-            });
-            pidToTrackedSession.delete(key);
-          }
-        }
-      }
-      const serverAny = server;
-      const rpcReconnecting = serverAny._connection?._reconnecting === true;
-      if (rpcReconnecting && !isReconnecting) {
-        isReconnecting = true;
-        logger.log("Detected hypha-rpc reconnection in progress");
-      }
-      if (isReconnecting) {
-        consecutiveHeartbeatFailures++;
-        logger.log(`Heartbeat skipped (reconnecting), failures=${consecutiveHeartbeatFailures}/${MAX_HEARTBEAT_FAILURES}`);
-        if (consecutiveHeartbeatFailures >= MAX_HEARTBEAT_FAILURES) {
-          logger.log("Too many consecutive heartbeat failures during reconnection. Shutting down.");
-          requestShutdown("heartbeat-timeout", "Reconnection taking too long");
-        }
-        return;
-      }
-      try {
-        await Promise.race([
-          server.echo("ping"),
-          new Promise((_, reject) => setTimeout(() => reject(new Error("Heartbeat ping timed out after 30s")), 3e4))
-        ]);
-        if (consecutiveHeartbeatFailures > 0) {
-          logger.log(`Heartbeat recovered after ${consecutiveHeartbeatFailures} failures`);
-        }
-        consecutiveHeartbeatFailures = 0;
-        isReconnecting = false;
-      } catch (err) {
-        consecutiveHeartbeatFailures++;
-        logger.log(`Hypha keep-alive ping failed (${consecutiveHeartbeatFailures}/${MAX_HEARTBEAT_FAILURES}): ${err.message}`);
-        if (!isReconnecting) {
-          isReconnecting = true;
-          logger.log("Entering reconnection state \u2014 hypha-rpc will attempt to reconnect");
-        }
-        if (consecutiveHeartbeatFailures >= MAX_HEARTBEAT_FAILURES) {
-          logger.log(`Heartbeat failed ${MAX_HEARTBEAT_FAILURES} consecutive times. Shutting down.`);
-          requestShutdown("heartbeat-timeout", err.message);
-        }
-      }
-    }, 6e4);
-    const cleanup = async (source) => {
-      logger.log(`Cleaning up (source: ${source})...`);
-      clearInterval(heartbeatInterval);
-      if (unhandledRejectionResetTimer) clearTimeout(unhandledRejectionResetTimer);
-      machineService.updateDaemonState({
-        ...initialDaemonState,
-        status: "shutting-down",
-        shutdownRequestedAt: Date.now(),
-        shutdownSource: source
-      });
-      await new Promise((r) => setTimeout(r, 200));
-      for (const [pid, session] of pidToTrackedSession) {
-        session.hyphaService?.disconnect().catch(() => {
-        });
-        if (session.childProcess) {
-          try {
-            session.childProcess.kill("SIGTERM");
-          } catch {
-          }
-        }
-      }
-      const shouldMarkStopped = source === "os-signal-cleanup";
-      if (shouldMarkStopped) {
-        try {
-          const index = loadSessionIndex();
-          for (const [sessionId, entry] of Object.entries(index)) {
-            const filePath = getSessionFilePath(entry.directory, sessionId);
-            if (existsSync$1(filePath)) {
-              const data = JSON.parse(readFileSync$1(filePath, "utf-8"));
-              writeFileSync$1(filePath, JSON.stringify({ ...data, stopped: true }, null, 2), "utf-8");
-            }
-          }
-          logger.log("Marked all sessions as stopped (--cleanup mode)");
-        } catch {
-        }
-      } else {
-        logger.log("Sessions preserved for auto-restore on next start");
-      }
-      try {
-        await machineService.disconnect();
-      } catch {
-      }
-      try {
-        await debugService.disconnect();
-      } catch {
-      }
-      artifactSync.destroy();
-      try {
-        await server.disconnect();
-      } catch {
-      }
-      cleanupDaemonStateFile();
-      logger.log("Cleanup complete");
-    };
-    const shutdownReq = await resolvesWhenShutdownRequested;
-    await cleanup(shutdownReq.source);
-    if (process.env.SVAMP_SUPERVISED === "1" && shutdownReq.source === "version-update") {
-      process.exit(1);
-    }
-    process.exit(0);
-  } catch (error) {
-    logger.error("Fatal error:", error);
-    cleanupDaemonStateFile();
-    if (server) {
-      try {
-        await server.disconnect();
-      } catch {
-      }
-    }
-    process.exit(1);
-  }
-}
-async function stopDaemon(options) {
-  const state = readDaemonStateFile();
-  if (!state) {
-    console.log("No daemon running");
-    return;
-  }
-  const signal = options?.cleanup ? "SIGUSR1" : "SIGTERM";
-  const mode = options?.cleanup ? "cleanup (sessions will be stopped)" : "quick (sessions preserved for auto-restore)";
-  try {
-    process.kill(state.pid, 0);
-    process.kill(state.pid, signal);
-    console.log(`Sent ${signal} to daemon PID ${state.pid} \u2014 ${mode}`);
-    for (let i = 0; i < 30; i++) {
-      await new Promise((r) => setTimeout(r, 100));
-      try {
-        process.kill(state.pid, 0);
-      } catch {
-        console.log("Daemon stopped");
-        cleanupDaemonStateFile();
-        return;
-      }
-    }
-    console.log("Daemon did not stop in time, sending SIGKILL");
-    process.kill(state.pid, "SIGKILL");
-  } catch {
-    console.log("Daemon is not running (stale state file)");
-  }
-  cleanupDaemonStateFile();
-}
-function daemonStatus() {
-  const state = readDaemonStateFile();
-  if (!state) {
-    const plistPath = join$1(os.homedir(), "Library", "LaunchAgents", "io.hypha.svamp.daemon.plist");
-    if (existsSync$1(plistPath)) {
-      console.log("Status: Not running (launchd service installed \u2014 may be starting)");
-    } else {
-      console.log("Status: Not running");
-    }
-    return;
-  }
-  const alive = isDaemonAlive();
-  console.log(`Status: ${alive ? "Running" : "Dead (stale state)"}`);
-  console.log(`  PID: ${state.pid}`);
-  console.log(`  Started: ${state.startTime}`);
-  console.log(`  Version: ${state.version || "unknown"}`);
-  console.log(`  Hypha server: ${state.hyphaServerUrl}`);
-  if (state.workspace) {
-    console.log(`  Workspace: ${state.workspace}`);
-  }
-  if (state.lastHeartbeat) {
-    console.log(`  Last heartbeat: ${state.lastHeartbeat}`);
-  }
-  if (state.supervised) {
-    console.log(`  Managed by: supervisor (auto-restart on crash enabled)`);
-  }
-  if (!alive) {
-    cleanupDaemonStateFile();
-  }
-}
-
-export { DefaultTransport$1 as D, GeminiTransport$1 as G, registerSessionService as a, stopDaemon as b, connectToHypha as c, daemonStatus as d, acpBackend as e, acpAgentConfig as f, getHyphaServerUrl as g, registerMachineService as r, startDaemon as s };