svamp-cli 0.1.29 → 0.1.30

package/dist/run-BQHneHfW.mjs

@@ -1,3834 +0,0 @@
-import os from 'os';
-import fs from 'fs/promises';
-import { existsSync as existsSync$1, readFileSync as readFileSync$1, writeFileSync as writeFileSync$1, mkdirSync as mkdirSync$1, copyFileSync, readdirSync, unlinkSync } 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, `${sessionId}.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, `${sessionId}.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, sessionId) : [];
-  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");
-        return await callbacks.onRipgrep(args, cwd);
-      },
-      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, `${sessionId}.json`);
-      const messagesPath = join(sessionsDir, `${sessionId}.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, `${sessionId}.json`), data);
-        }
-      } catch {
-      }
-      try {
-        const data = await this.downloadFile(artifact.id, "messages.jsonl");
-        if (data) {
-          writeFileSync(join(targetDir, `${sessionId}.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 svampDir = join(entry.directory, ".svamp");
-        if (existsSync(join(svampDir, `${sessionId}.json`))) {
-          await this.syncSession(sessionId, svampDir, 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 SESSIONS_DIR = join$1(SVAMP_HOME, "sessions");
-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 getSessionFilePath(directory, sessionId) {
-  return join$1(getSessionSvampDir(directory), `${sessionId}.json`);
-}
-function getSessionMessagesPath(directory, sessionId) {
-  return join$1(getSessionSvampDir(directory), `${sessionId}.messages.jsonl`);
-}
-function getSvampConfigPath(directory) {
-  return join$1(getSessionSvampDir(directory), "svamp-config.json");
-}
-function createSvampConfigChecker(directory, getMetadata, setMetadata, sessionService, logger) {
-  const configPath = getSvampConfigPath(directory);
-  let lastContent = "";
-  if (existsSync$1(configPath)) {
-    try {
-      lastContent = readFileSync$1(configPath, "utf-8");
-    } catch {
-    }
-  }
-  return () => {
-    try {
-      if (!existsSync$1(configPath)) return;
-      const content = readFileSync$1(configPath, "utf-8");
-      if (content === lastContent) return;
-      lastContent = content;
-      const config = JSON.parse(content);
-      const meta = getMetadata();
-      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}`);
-        }
-      }
-    } 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 svampDir = getSessionSvampDir(session.directory);
-  if (!existsSync$1(svampDir)) {
-    mkdirSync$1(svampDir, { 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 {
-    }
-    delete index[sessionId];
-    saveSessionIndex(index);
-  }
-  const legacySession = join$1(SESSIONS_DIR, `${sessionId}.json`);
-  try {
-    if (existsSync$1(legacySession)) unlinkSync(legacySession);
-  } catch {
-  }
-  const legacyMessages = join$1(SESSIONS_DIR, `${sessionId}.messages.jsonl`);
-  try {
-    if (existsSync$1(legacyMessages)) unlinkSync(legacyMessages);
-  } catch {
-  }
-}
-function loadPersistedSessions() {
-  const sessions = [];
-  const seen = /* @__PURE__ */ new Set();
-  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);
-        seen.add(sessionId);
-      }
-    } catch {
-      delete index[sessionId];
-    }
-  }
-  if (existsSync$1(SESSIONS_DIR)) {
-    for (const file of readdirSync(SESSIONS_DIR)) {
-      if (!file.endsWith(".json")) continue;
-      try {
-        const data = JSON.parse(readFileSync$1(join$1(SESSIONS_DIR, file), "utf-8"));
-        if (data.sessionId && data.directory && !seen.has(data.sessionId)) {
-          const svampDir = getSessionSvampDir(data.directory);
-          try {
-            if (!existsSync$1(svampDir)) mkdirSync$1(svampDir, { recursive: true });
-            writeFileSync$1(getSessionFilePath(data.directory, data.sessionId), JSON.stringify(data, null, 2), "utf-8");
-            const legacyMsg = join$1(SESSIONS_DIR, `${data.sessionId}.messages.jsonl`);
-            const newMsg = getSessionMessagesPath(data.directory, data.sessionId);
-            if (existsSync$1(legacyMsg) && !existsSync$1(newMsg)) {
-              copyFileSync(legacyMsg, newMsg);
-            }
-            index[data.sessionId] = { directory: data.directory, createdAt: data.createdAt };
-          } catch {
-          }
-          sessions.push(data);
-          seen.add(data.sessionId);
-        }
-      } catch {
-      }
-    }
-  }
-  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 oldMsgFile = existsSync$1(getSessionMessagesPath(oldDir, persisted.sessionId)) ? getSessionMessagesPath(oldDir, persisted.sessionId) : join$1(SESSIONS_DIR, `${persisted.sessionId}.messages.jsonl`);
-          const svampDir = getSessionSvampDir(directory);
-          if (!existsSync$1(svampDir)) mkdirSync$1(svampDir, { recursive: true });
-          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, getSessionSvampDir(directory), 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, getSessionSvampDir(directory), 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 });
-                  }
-                });
-              });
-            },
-            onReadFile: async (path) => {
-              const resolvedPath = resolve(directory, path);
-              if (!resolvedPath.startsWith(resolve(directory))) {
-                throw new Error("Path outside working directory");
-              }
-              return await fs.readFile(resolvedPath, "utf-8");
-            },
-            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 entries = await fs.readdir(path, { 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: getSessionSvampDir(directory) }
-        );
-        checkSvampConfig = createSvampConfigChecker(
-          directory,
-          () => 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 });
-                  }
-                });
-              });
-            },
-            onReadFile: async (path) => {
-              const resolvedPath = resolve(directory, path);
-              if (!resolvedPath.startsWith(resolve(directory))) {
-                throw new Error("Path outside working directory");
-              }
-              return await fs.readFile(resolvedPath, "utf-8");
-            },
-            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 entries = await fs.readdir(path, { 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: getSessionSvampDir(directory) }
-        );
-        const checkSvampConfig = createSvampConfigChecker(
-          directory,
-          () => 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 };