svamp-cli 0.1.21 → 0.1.22

package/dist/run-DwK3dfHd.mjs

@@ -0,0 +1,3875 @@
+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 } from 'node:child_process';
+import { ndJsonStream, ClientSideConnection } from '@agentclientprotocol/sdk';
+
+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";
+}
+
+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" },
+      // Machine info
+      getMachineInfo: async () => ({
+        machineId,
+        metadata: currentMetadata,
+        metadataVersion,
+        daemonState: currentDaemonState,
+        daemonStateVersion
+      }),
+      // Heartbeat
+      heartbeat: async () => ({
+        time: Date.now(),
+        status: currentDaemonState.status,
+        machineId
+      }),
+      // List active sessions on this machine
+      listSessions: async () => {
+        return handlers.getTrackedSessions();
+      },
+      // Spawn a new session
+      spawnSession: async (options) => {
+        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) => {
+        const result = handlers.stopSession(sessionId);
+        notifyListeners({
+          type: "session-stopped",
+          sessionId,
+          machineId
+        });
+        return result;
+      },
+      // Stop the daemon
+      stopDaemon: async () => {
+        handlers.requestShutdown();
+        return { success: true };
+      },
+      // Metadata management (with optimistic concurrency)
+      getMetadata: async () => ({
+        metadata: currentMetadata,
+        version: metadataVersion
+      }),
+      updateMetadata: async (newMetadata, expectedVersion) => {
+        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 () => ({
+        daemonState: currentDaemonState,
+        version: daemonStateVersion
+      }),
+      updateDaemonState: async (newState, expectedVersion) => {
+        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
+        };
+      },
+      // Register a listener for real-time updates (app calls this with _rintf callback)
+      registerListener: async (callback) => {
+        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) => {
+        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) => {
+        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 === "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 (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" },
+      // ── Messages ──
+      getMessages: async (afterSeq, limit) => {
+        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) => {
+        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 (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 () => ({
+        metadata,
+        version: metadataVersion
+      }),
+      updateMetadata: async (newMetadata, expectedVersion) => {
+        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 () => ({
+        agentState,
+        version: agentStateVersion
+      }),
+      updateAgentState: async (newState, expectedVersion) => {
+        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 () => {
+        callbacks.onAbort();
+        return { success: true };
+      },
+      permissionResponse: async (params) => {
+        callbacks.onPermissionResponse(params);
+        return { success: true };
+      },
+      switchMode: async (mode) => {
+        callbacks.onSwitchMode(mode);
+        return { success: true };
+      },
+      restartClaude: async () => {
+        return await callbacks.onRestartClaude();
+      },
+      killSession: async () => {
+        callbacks.onKillSession();
+        return { success: true };
+      },
+      // ── Activity ──
+      keepAlive: async (thinking, mode) => {
+        lastActivity = { active: true, thinking: thinking || false, mode: mode || "remote", time: Date.now() };
+        notifyListeners({
+          type: "activity",
+          sessionId,
+          ...lastActivity
+        });
+      },
+      sessionEnd: async () => {
+        lastActivity = { active: false, thinking: false, mode: "remote", time: Date.now() };
+        notifyListeners({
+          type: "activity",
+          sessionId,
+          ...lastActivity
+        });
+      },
+      // ── Activity State Query ──
+      getActivityState: async () => {
+        return { ...lastActivity, sessionId };
+      },
+      // ── File Operations (optional) ──
+      readFile: async (path) => {
+        if (!callbacks.onReadFile) throw new Error("readFile not supported");
+        return await callbacks.onReadFile(path);
+      },
+      writeFile: async (path, content) => {
+        if (!callbacks.onWriteFile) throw new Error("writeFile not supported");
+        await callbacks.onWriteFile(path, content);
+        return { success: true };
+      },
+      listDirectory: async (path) => {
+        if (!callbacks.onListDirectory) throw new Error("listDirectory not supported");
+        return await callbacks.onListDirectory(path);
+      },
+      bash: async (command, cwd) => {
+        if (!callbacks.onBash) throw new Error("bash not supported");
+        return await callbacks.onBash(command, cwd);
+      },
+      ripgrep: async (args, cwd) => {
+        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) => {
+        if (!callbacks.onGetDirectoryTree) throw new Error("getDirectoryTree not supported");
+        return await callbacks.onGetDirectoryTree(path, maxDepth ?? 3);
+      },
+      // ── Listener Registration ──
+      registerListener: async (callback) => {
+        listeners.push(callback);
+        console.log(`[HYPHA SESSION ${sessionId}] Listener registered (total: ${listeners.length}), replaying ${messages.length} messages`);
+        for (const msg of messages) {
+          try {
+            const result = callback.onUpdate({
+              type: "new-message",
+              sessionId,
+              message: msg
+            });
+            if (result && typeof result.catch === "function") {
+              result.catch((err) => {
+                console.error(`[HYPHA SESSION ${sessionId}] Replay listener error:`, err);
+              });
+            }
+          } catch (err) {
+            console.error(`[HYPHA SESSION ${sessionId}] Replay listener error:`, err);
+          }
+        }
+        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 || {}
+          },
+          _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 || {}
+          },
+          _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 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 || [];
+      if (process.platform === "win32") {
+        const fullCommand = [this.options.command, ...args].join(" ");
+        this.process = spawn("cmd.exe", ["/c", fullCommand], {
+          cwd: this.options.cwd,
+          env: { ...process.env, ...this.options.env },
+          stdio: ["pipe", "pipe", "pipe"],
+          windowsHide: true
+        });
+      } else {
+        this.process = spawn(this.options.command, args, {
+          cwd: this.options.cwd,
+          env: { ...process.env, ...this.options.env },
+          stdio: ["pipe", "pipe", "pipe"]
+        });
+      }
+      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"] }
+};
+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 known = KNOWN_ACP_AGENTS[agentName];
+  if (known) {
+    const passthroughArgs = cliArgs.slice(1).filter((arg) => !(agentName === "opencode" && arg === "--acp"));
+    return {
+      agentName,
+      command: known.command,
+      args: [...known.args, ...passthroughArgs]
+    };
+  }
+  return {
+    agentName,
+    command: agentName,
+    args: cliArgs.slice(1)
+  };
+}
+
+var acpAgentConfig = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    KNOWN_ACP_AGENTS: KNOWN_ACP_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: "assistant",
+            content: [{ type: "text", text: `Error: ${msg.detail || "Unknown error"}` }]
+          }, "agent");
+          sessionService.sendKeepAlive(false);
+          setMetadata((m) => ({ ...m, lifecycleState: "error" }));
+        } else if (msg.status === "stopped") {
+          flushText();
+          sessionService.sendKeepAlive(false);
+          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 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 __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 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 getLegacySvampConfigPath(directory) {
+  return join$1(getSessionSvampDir(directory), "svamp-config.json");
+}
+function createSvampConfigChecker(directory, sessionId, getMetadata, setMetadata, sessionService, logger) {
+  const configPath = getSvampConfigPath(directory, sessionId);
+  const legacyConfigPath = getLegacySvampConfigPath(directory);
+  let lastContent = "";
+  let lastLegacyContent = "";
+  if (existsSync$1(configPath)) {
+    try {
+      lastContent = readFileSync$1(configPath, "utf-8");
+    } catch {
+    }
+  }
+  if (existsSync$1(legacyConfigPath)) {
+    try {
+      lastLegacyContent = readFileSync$1(legacyConfigPath, "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);
+          return;
+        }
+      }
+      if (existsSync$1(legacyConfigPath)) {
+        const content = readFileSync$1(legacyConfigPath, "utf-8");
+        if (content !== lastLegacyContent) {
+          lastLegacyContent = 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();
+  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) {
+        sessions.push(data);
+      }
+    } catch {
+      delete index[sessionId];
+    }
+  }
+  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("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]) {
+        return await spawnAcpSession(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") return true;
+          if (currentPermissionMode === "acceptEdits" && 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);
+            }
+          });
+        };
+        var parseBashPermission = parseBashPermission2, shouldAutoAllow = shouldAutoAllow2, killAndWaitForExit = killAndWaitForExit2;
+        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"
+        };
+        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 spawnClaude = (initialMessage, meta) => {
+          const permissionMode = meta?.permissionMode || agentConfig.default_permission_mode || currentPermissionMode;
+          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);
+          logger.log(`[Session ${sessionId}] Spawning Claude: claude ${args.join(" ")} (cwd: ${directory})`);
+          const spawnEnv = { ...process.env };
+          delete spawnEnv.CLAUDECODE;
+          const child = spawn$1("claude", args, {
+            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: "assistant",
+              content: [{
+                type: "text",
+                text: `Error: Failed to start Claude Code CLI: ${err.message}
+
+Please ensure Claude Code CLI is installed on this machine. You can install it with:
+\`npm install -g @anthropic-ai/claude-code\``
+              }]
+            }, "agent");
+            sessionService.sendKeepAlive(false);
+          });
+          let stdoutBuffer = "";
+          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, 100)}`);
+              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 (!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;
+                    sessionService.updateMetadata({
+                      ...sessionMetadata,
+                      claudeSessionId: msg.session_id
+                    });
+                    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}`);
+              }
+            }
+          });
+          child.stderr?.on("data", (chunk) => {
+            logger.log(`[Session ${sessionId}] Claude stderr: ${chunk.toString().trim()}`);
+          });
+          child.on("exit", (code, signal) => {
+            logger.log(`[Session ${sessionId}] Claude exited: code=${code}, signal=${signal}`);
+            claudeProcess = null;
+            for (const [id, pending] of pendingPermissions) {
+              pending.resolve({ behavior: "deny", message: "Claude process exited" });
+            }
+            pendingPermissions.clear();
+            if (code !== 0 && code !== null && !claudeResumeId) {
+              sessionService.pushMessage({
+                type: "assistant",
+                content: [{
+                  type: "text",
+                  text: `Error: Claude process exited with code ${code}${signal ? ` (signal: ${signal})` : ""}.
+
+This may indicate that Claude Code CLI is not properly installed or configured.`
+                }]
+              }, "agent");
+            }
+            sessionService.updateMetadata({
+              ...sessionMetadata,
+              lifecycleState: claudeResumeId ? "idle" : "stopped"
+            });
+            sessionService.sendKeepAlive(false);
+            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 = 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) {
+                logger.log(`[Session ${sessionId}] Permission mode changed to: ${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);
+                  }
+                }
+                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;
+                  sessionService.updateMetadata({
+                    ...sessionMetadata,
+                    lifecycleState: "restarting"
+                  });
+                  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);
+        sessionService.updateMetadata({
+          ...sessionMetadata,
+          lifecycleState: "idle"
+        });
+        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 spawnAcpSession = async (sessionId, directory, agentName, options, resumeSessionId) => {
+      logger.log(`[ACP] 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") return true;
+          if (currentPermissionMode === "acceptEdits" && 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
+        };
+        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(`[ACP 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;
+              }
+              acpBackend.sendPrompt(sessionId, text).catch((err) => {
+                logger.error(`[ACP Session ${sessionId}] Error sending prompt:`, err);
+              });
+            },
+            onAbort: () => {
+              logger.log(`[ACP Session ${sessionId}] Abort requested`);
+              acpBackend.cancel(sessionId).catch(() => {
+              });
+            },
+            onPermissionResponse: (params) => {
+              logger.log(`[ACP 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);
+            },
+            onSwitchMode: (mode) => {
+              logger.log(`[ACP Session ${sessionId}] Switch mode: ${mode}`);
+              currentPermissionMode = mode;
+            },
+            onRestartClaude: async () => {
+              logger.log(`[ACP Session ${sessionId}] Restart agent requested`);
+              return { success: false, message: "Restart is not supported for this agent type." };
+            },
+            onKillSession: () => {
+              logger.log(`[ACP 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 transportHandler = agentName === "gemini" ? new GeminiTransport() : new DefaultTransport(agentName);
+        const permissionHandler = new HyphaPermissionHandler(shouldAutoAllow2, logger.log);
+        const acpConfig = KNOWN_ACP_AGENTS[agentName];
+        const acpBackend = new AcpBackend({
+          agentName,
+          cwd: directory,
+          command: acpConfig.command,
+          args: acpConfig.args,
+          env: options.environmentVariables,
+          permissionHandler,
+          transportHandler,
+          log: logger.log
+        });
+        bridgeAcpToSession(
+          acpBackend,
+          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 acpBackend.getProcess() || void 0;
+          }
+        };
+        pidToTrackedSession.set(process.pid + Math.floor(Math.random() * 1e5), trackedSession);
+        logger.log(`[ACP Session ${sessionId}] Starting ${agentName} backend...`);
+        acpBackend.startSession().then(() => {
+          logger.log(`[ACP Session ${sessionId}] ${agentName} backend started, waiting for first message`);
+        }).catch((err) => {
+          logger.error(`[ACP Session ${sessionId}] Failed to start ${agentName}:`, err);
+          sessionService.pushMessage({
+            type: "assistant",
+            content: [{
+              type: "text",
+              text: `Error: Failed to start ${agentName} agent: ${err.message}
+
+Please ensure the ${agentName} CLI is installed.`
+            }]
+          }, "agent");
+          sessionService.sendKeepAlive(false);
+        });
+        return {
+          type: "success",
+          sessionId,
+          message: `ACP session (${agentName}) registered as svamp-session-${sessionId}`
+        };
+      } catch (err) {
+        logger.error(`[ACP] 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;
+    };
+    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
+    };
+    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 localState = {
+      pid: process.pid,
+      startTime: (/* @__PURE__ */ new Date()).toISOString(),
+      version: "0.1.0",
+      hyphaServerUrl,
+      workspace: server.config.workspace,
+      machineId
+    };
+    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 = 5;
+    const heartbeatInterval = setInterval(async () => {
+      try {
+        const state = readDaemonStateFile();
+        if (state && state.pid === process.pid) {
+          state.lastHeartbeat = (/* @__PURE__ */ new Date()).toISOString();
+          writeDaemonStateFile(state);
+        }
+      } 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.listServices({}),
+          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 {
+          }
+        }
+      }
+      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);
+    process.exit(0);
+  } catch (error) {
+    logger.error("Fatal error:", error);
+    cleanupDaemonStateFile();
+    if (server) {
+      try {
+        await server.disconnect();
+      } catch {
+      }
+    }
+    process.exit(1);
+  }
+}
+async function stopDaemon() {
+  const state = readDaemonStateFile();
+  if (!state) {
+    console.log("No daemon running");
+    return;
+  }
+  try {
+    process.kill(state.pid, 0);
+    process.kill(state.pid, "SIGTERM");
+    console.log(`Sent SIGTERM to daemon PID ${state.pid}`);
+    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) {
+    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(`  Hypha server: ${state.hyphaServerUrl}`);
+  if (state.workspace) {
+    console.log(`  Workspace: ${state.workspace}`);
+  }
+  if (state.lastHeartbeat) {
+    console.log(`  Last heartbeat: ${state.lastHeartbeat}`);
+  }
+  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 };