svamp-cli 0.2.224 → 0.2.225

package/dist/commands-DqvzIDMK.mjs

@@ -1,2762 +0,0 @@
-import { existsSync, readFileSync, writeFileSync } from 'node:fs';
-import { execSync } from 'node:child_process';
-import { basename, resolve, join, isAbsolute } from 'node:path';
-import os from 'node:os';
-import { Q as formatHandle, T as normalizeAllowedUser, U as loadSecurityContextConfig, V as resolveSecurityContext, W as buildSecurityContextFromFlags, X as mergeSecurityContexts, c as connectToHypha, Y as buildSessionShareUrl, Z as computeOutboundHop, A as shortId, _ as registerAwaitingReply, $ as buildMachineShareUrl, a0 as parseHandle, a1 as handleMatchesMetadata } from './run-C-9ZtEi4.mjs';
-import 'os';
-import 'fs/promises';
-import 'fs';
-import 'path';
-import 'url';
-import 'child_process';
-import 'crypto';
-import 'node:crypto';
-import 'util';
-import 'node:events';
-import '@agentclientprotocol/sdk';
-import '@modelcontextprotocol/sdk/client/index.js';
-import '@modelcontextprotocol/sdk/client/stdio.js';
-import '@modelcontextprotocol/sdk/types.js';
-import 'zod';
-import 'node:fs/promises';
-import 'node:util';
-
-function formatTime(ts) {
-  if (!ts) return "-";
-  const date = new Date(ts);
-  const now = /* @__PURE__ */ new Date();
-  const diffMs = now.getTime() - date.getTime();
-  const diffMin = Math.floor(diffMs / 6e4);
-  if (diffMin < 1) return "just now";
-  if (diffMin < 60) return `${diffMin}m ago`;
-  const diffHr = Math.floor(diffMin / 60);
-  if (diffHr < 24) return `${diffHr}h ago`;
-  const diffDay = Math.floor(diffHr / 24);
-  return `${diffDay}d ago`;
-}
-function resolveDisplayName(meta, directory) {
-  const m = meta || {};
-  const customTitle = typeof m.customTitle === "string" ? m.customTitle.trim() : "";
-  const summary = typeof m.summary?.text === "string" ? m.summary.text.trim() : "";
-  const name = typeof m.name === "string" ? m.name.trim() : "";
-  const dir = (directory || m.path || "").replace(/[/\\]+$/, "");
-  const dirName = dir ? basename(dir) : "";
-  return customTitle || summary || name || dirName || "untitled";
-}
-function resolveHandle(meta) {
-  const m = meta || {};
-  return formatHandle(m.projectName, m.friendlyName);
-}
-function toMarkdownInline(value) {
-  const escaped = value.replace(/`/g, "\\`");
-  return `\`${escaped}\``;
-}
-function formatSessionStatus(data) {
-  const lines = [
-    "## Session Status",
-    "",
-    `- Session ID: ${toMarkdownInline(data.sessionId)}`,
-    ...data.handle ? [`- Handle: ${toMarkdownInline(data.handle)}`] : [],
-    `- Agent: ${data.flavor}`
-  ];
-  if (data.name) lines.push(`- Title: ${data.name}`);
-  if (data.summary && data.summary !== data.name) lines.push(`- Topic: ${data.summary}`);
-  if (data.projectName) lines.push(`- Project: ${data.projectName}`);
-  if (data.projectDescription) lines.push(`- Project Description: ${data.projectDescription}`);
-  if (data.path) lines.push(`- Path: ${data.path}`);
-  if (data.host) lines.push(`- Host: ${data.host}`);
-  if (data.lifecycleState) lines.push(`- Lifecycle: ${data.lifecycleState}`);
-  lines.push(`- Active: ${data.active ? "yes" : "no"}`);
-  lines.push(`- Thinking: ${data.thinking ? "yes" : "no"}`);
-  lines.push(`- Agent Status: ${data.active ? "busy" : "idle"}`);
-  if (data.startedBy) lines.push(`- Started By: ${data.startedBy}`);
-  if (data.claudeSessionId) lines.push(`- Claude Session: ${data.claudeSessionId}`);
-  if (data.sessionLink) lines.push(`- Link: ${data.sessionLink}`);
-  if (data.pendingPermissions && data.pendingPermissions.length > 0) {
-    lines.push("");
-    lines.push("### Pending Permissions");
-    for (const p of data.pendingPermissions) {
-      const argsStr = JSON.stringify(p.arguments || {}).slice(0, 120);
-      lines.push(`  [${p.id.slice(0, 8)}] ${p.tool}(${argsStr})  ${formatTime(p.createdAt)}`);
-    }
-    lines.push("");
-    lines.push(`Use: svamp session approve ${data.sessionId.slice(0, 8)}`);
-  }
-  return lines.join("\n");
-}
-function formatJson(data) {
-  return JSON.stringify(data, null, 2);
-}
-
-const SESSION_RPC_PARAMS = {
-  getMessages: ["afterSeq", "limit"],
-  getMessageCount: [],
-  getLatestMessages: ["beforeSeq", "limit"],
-  sendMessage: ["content", "localId", "meta"],
-  btw: ["question"],
-  editMessage: ["messageId", "newText"],
-  refineLastReply: ["instruction"],
-  undoLastEdit: [],
-  getMetadata: [],
-  updateMetadata: ["newMetadata", "expectedVersion"],
-  updateConfig: ["patch"],
-  getAgentState: [],
-  updateAgentState: ["newState", "expectedVersion"],
-  abort: [],
-  permissionResponse: ["params"],
-  switchMode: ["mode"],
-  restartClaude: [],
-  archiveSession: [],
-  regenerateSummary: [],
-  keepAlive: ["thinking", "mode"],
-  sessionEnd: [],
-  getActivityState: [],
-  readFile: ["path"],
-  writeFile: ["path", "content"],
-  listDirectory: ["path"],
-  bash: ["command", "cwd", "timeout"],
-  ripgrep: ["args", "cwd"],
-  getDirectoryTree: ["path", "maxDepth"],
-  getSharing: [],
-  getEffectiveRole: [],
-  updateSharing: ["newSharing"],
-  updateSecurityContext: ["newSecurityContext"],
-  setClaudeChrome: ["enabled"],
-  applySystemPrompt: ["prompt"],
-  sendInboxMessage: ["message"],
-  getInbox: ["opts"],
-  markInboxRead: ["messageId"],
-  clearInbox: ["opts"],
-  registerListener: ["callback"]
-};
-function getSessionProxy(machine, sessionId) {
-  return new Proxy({}, {
-    get(_target, method) {
-      return (...args) => {
-        const paramNames = SESSION_RPC_PARAMS[method];
-        if (paramNames) {
-          const kwargs = {};
-          for (let i = 0; i < paramNames.length && i < args.length; i++) {
-            if (args[i] !== void 0) {
-              kwargs[paramNames[i]] = args[i];
-            }
-          }
-          return machine.sessionRPC(sessionId, method, kwargs);
-        }
-        return machine.sessionRPC(sessionId, method, {});
-      };
-    }
-  });
-}
-const SVAMP_HOME = process.env.SVAMP_HOME || join(os.homedir(), ".svamp");
-const DAEMON_STATE_FILE = join(SVAMP_HOME, "daemon.state.json");
-const ENV_FILE = join(SVAMP_HOME, ".env");
-function loadDotEnv() {
-  if (!existsSync(ENV_FILE)) return;
-  const lines = readFileSync(ENV_FILE, "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;
-    }
-  }
-}
-function readDaemonState() {
-  if (!existsSync(DAEMON_STATE_FILE)) return null;
-  try {
-    return JSON.parse(readFileSync(DAEMON_STATE_FILE, "utf-8"));
-  } catch {
-    return null;
-  }
-}
-function isDaemonAlive(state) {
-  try {
-    process.kill(state.pid, 0);
-    return true;
-  } catch {
-    return false;
-  }
-}
-async function connectAndGetMachine(machineId) {
-  loadDotEnv();
-  const state = readDaemonState();
-  if (!state || !isDaemonAlive(state)) {
-    console.error('Daemon is not running. Start it with "svamp daemon start".');
-    process.exit(1);
-  }
-  const serverUrl = process.env.HYPHA_SERVER_URL || state.hyphaServerUrl;
-  const token = process.env.HYPHA_TOKEN;
-  if (!serverUrl) {
-    console.error('No Hypha server URL. Run "svamp login <url>" first.');
-    process.exit(1);
-  }
-  const origLog = console.log;
-  const origWarn = console.warn;
-  const origInfo = console.info;
-  const origError = console.error;
-  const stdoutWrite = process.stdout.write.bind(process.stdout);
-  const stderrWrite = process.stderr.write.bind(process.stderr);
-  const isHyphaLog = (chunk) => typeof chunk === "string" && (chunk.includes("WebSocket connection") || chunk.includes("Connection established") || chunk.includes("registering service built-in") || chunk.includes("registered service") || chunk.includes("registered all") || chunk.includes("Subscribing to client_") || chunk.includes("subscribed to client_") || chunk.includes("subscribe to client_") || chunk.includes("Cleaning up all sessions") || chunk.includes("WebSocket connection disconnected") || chunk.includes("local RPC disconnection") || chunk.includes("Timeout registering service") || chunk.includes("Failed to subscribe to client_disconnected") || chunk.includes("Timeout subscribing to client_disconnected"));
-  console.log = () => {
-  };
-  console.warn = () => {
-  };
-  console.info = () => {
-  };
-  console.error = (...args) => {
-    if (args.some((a) => isHyphaLog(a))) return;
-    origError(...args);
-  };
-  process.stdout.write = (chunk, ...args) => {
-    if (isHyphaLog(chunk)) return true;
-    return stdoutWrite(chunk, ...args);
-  };
-  process.stderr.write = (chunk, ...args) => {
-    if (isHyphaLog(chunk)) return true;
-    return stderrWrite(chunk, ...args);
-  };
-  const restoreConsole = () => {
-    console.log = origLog;
-    console.warn = origWarn;
-    console.info = origInfo;
-    console.error = origError;
-  };
-  let server;
-  try {
-    server = await connectToHypha({
-      serverUrl,
-      token,
-      name: "svamp-session-cli"
-    });
-  } catch (err) {
-    restoreConsole();
-    console.error(`Failed to connect to Hypha: ${err.message}`);
-    process.exit(1);
-  }
-  let machine;
-  try {
-    const services = await server.listServices({ query: { type: "svamp-machine" }, include_unlisted: true, _rkwargs: true });
-    if (services.length === 0) {
-      restoreConsole();
-      console.error("No machine service found. Is the daemon registered on Hypha?");
-      await server.disconnect();
-      process.exit(1);
-    }
-    let selectedService;
-    if (machineId) {
-      const exact = services.find((s) => (s.id || s.name) === machineId);
-      if (exact) {
-        selectedService = exact;
-      } else {
-        const prefixMatches = services.filter((s) => {
-          const id = s.id || s.name;
-          return id.startsWith(machineId);
-        });
-        if (prefixMatches.length === 1) {
-          selectedService = prefixMatches[0];
-        }
-      }
-      if (!selectedService) {
-        const query = machineId.toLowerCase();
-        const resolved = [];
-        await Promise.all(services.map(async (svc) => {
-          const svcId2 = svc.id || svc.name;
-          try {
-            const machineSvc = await server.getService(svcId2);
-            const info = await machineSvc.getMachineInfo();
-            resolved.push({
-              svc,
-              machineId: (info.machineId || svcId2).toLowerCase(),
-              host: (info.metadata?.host || "").toLowerCase(),
-              displayName: (info.metadata?.displayName || "").toLowerCase()
-            });
-          } catch {
-          }
-        }));
-        let matches = resolved.filter(
-          (r) => r.machineId === query || r.host === query || r.displayName === query
-        );
-        if (matches.length === 0) {
-          matches = resolved.filter(
-            (r) => r.machineId.startsWith(query) || r.host.startsWith(query) || r.displayName.startsWith(query)
-          );
-        }
-        if (matches.length === 0) {
-          matches = resolved.filter(
-            (r) => r.machineId.includes(query) || r.host.includes(query) || r.displayName.includes(query)
-          );
-        }
-        if (matches.length === 1) {
-          selectedService = matches[0].svc;
-        } else if (matches.length > 1) {
-          restoreConsole();
-          console.error(`Ambiguous machine "${machineId}". Matches:`);
-          for (const m of matches) {
-            console.error(`  ${m.machineId}  (${m.host})`);
-          }
-          await server.disconnect();
-          process.exit(1);
-        } else {
-          restoreConsole();
-          console.error(`No machine found matching: ${machineId}`);
-          if (resolved.length > 0) {
-            console.error("Available machines:");
-            for (const r of resolved) {
-              console.error(`  ${r.machineId}  (${r.host})`);
-            }
-          }
-          await server.disconnect();
-          process.exit(1);
-        }
-      }
-    } else {
-      if (state.hyphaClientId) {
-        const localMatch = services.find((s) => {
-          const id = s.id || s.name || "";
-          return id.includes(state.hyphaClientId);
-        });
-        selectedService = localMatch || services[0];
-      } else if (state.machineId) {
-        const localMatch = services.find((s) => {
-          const id = s.id || s.name || "";
-          return id.includes(state.machineId);
-        });
-        selectedService = localMatch || services[0];
-      } else {
-        selectedService = services[0];
-      }
-    }
-    const svcId = selectedService.id || selectedService.name;
-    machine = await server.getService(svcId);
-  } catch (err) {
-    restoreConsole();
-    console.error(`Failed to discover machine service: ${err.message}`);
-    await server.disconnect();
-    process.exit(1);
-  }
-  restoreConsole();
-  return { server, machine };
-}
-async function connectAndGetAllMachines() {
-  loadDotEnv();
-  const state = readDaemonState();
-  if (!state || !isDaemonAlive(state)) {
-    console.error('Daemon is not running. Start it with "svamp daemon start".');
-    process.exit(1);
-  }
-  const serverUrl = process.env.HYPHA_SERVER_URL || state.hyphaServerUrl;
-  const token = process.env.HYPHA_TOKEN;
-  if (!serverUrl) {
-    console.error('No Hypha server URL. Run "svamp login <url>" first.');
-    process.exit(1);
-  }
-  const origLog = console.log;
-  const origWarn = console.warn;
-  const origInfo = console.info;
-  const origError = console.error;
-  const stdoutWrite = process.stdout.write.bind(process.stdout);
-  const stderrWrite = process.stderr.write.bind(process.stderr);
-  const isHyphaLog = (chunk) => typeof chunk === "string" && (chunk.includes("WebSocket connection") || chunk.includes("Connection established") || chunk.includes("registering service built-in") || chunk.includes("registered service") || chunk.includes("registered all") || chunk.includes("Subscribing to client_") || chunk.includes("subscribed to client_") || chunk.includes("subscribe to client_") || chunk.includes("Cleaning up all sessions") || chunk.includes("WebSocket connection disconnected") || chunk.includes("local RPC disconnection") || chunk.includes("Timeout registering service") || chunk.includes("Failed to subscribe to client_disconnected") || chunk.includes("Timeout subscribing to client_disconnected"));
-  console.log = () => {
-  };
-  console.warn = () => {
-  };
-  console.info = () => {
-  };
-  console.error = (...args) => {
-    if (!args.some((a) => isHyphaLog(a))) origError(...args);
-  };
-  process.stdout.write = (chunk, ...args) => {
-    if (isHyphaLog(chunk)) return true;
-    return stdoutWrite(chunk, ...args);
-  };
-  process.stderr.write = (chunk, ...args) => {
-    if (isHyphaLog(chunk)) return true;
-    return stderrWrite(chunk, ...args);
-  };
-  const restoreConsole = () => {
-    console.log = origLog;
-    console.warn = origWarn;
-    console.info = origInfo;
-    console.error = origError;
-  };
-  let server;
-  try {
-    server = await connectToHypha({ serverUrl, token, name: "svamp-session-cli" });
-  } catch (err) {
-    restoreConsole();
-    console.error(`Failed to connect to Hypha: ${err.message}`);
-    process.exit(1);
-  }
-  const machines = [];
-  try {
-    const services = await server.listServices({ query: { type: "svamp-machine" }, include_unlisted: true, _rkwargs: true });
-    const results = await Promise.allSettled(
-      services.map((svc) => server.getService(svc.id || svc.name))
-    );
-    for (const r of results) {
-      if (r.status === "fulfilled") machines.push(r.value);
-    }
-  } catch (err) {
-    restoreConsole();
-    console.error(`Failed to discover machine services: ${err.message}`);
-    await server.disconnect();
-    process.exit(1);
-  }
-  restoreConsole();
-  if (machines.length === 0) {
-    console.error("No machine service found. Is the daemon registered on Hypha?");
-    await server.disconnect();
-    process.exit(1);
-  }
-  return { server, machines };
-}
-async function sessionMachines() {
-  loadDotEnv();
-  const state = readDaemonState();
-  if (!state || !isDaemonAlive(state)) {
-    console.error('Daemon is not running. Start it with "svamp daemon start".');
-    process.exit(1);
-  }
-  const serverUrl = process.env.HYPHA_SERVER_URL || state.hyphaServerUrl;
-  const token = process.env.HYPHA_TOKEN;
-  if (!serverUrl) {
-    console.error('No Hypha server URL. Run "svamp login <url>" first.');
-    process.exit(1);
-  }
-  const origLog = console.log;
-  const origWarn = console.warn;
-  const origInfo = console.info;
-  const origError = console.error;
-  const stdoutWrite = process.stdout.write.bind(process.stdout);
-  const stderrWrite = process.stderr.write.bind(process.stderr);
-  const isHyphaLog = (chunk) => typeof chunk === "string" && (chunk.includes("WebSocket connection") || chunk.includes("Connection established") || chunk.includes("registering service built-in") || chunk.includes("registered service") || chunk.includes("registered all") || chunk.includes("Subscribing to client_") || chunk.includes("subscribed to client_") || chunk.includes("subscribe to client_") || chunk.includes("Cleaning up all sessions") || chunk.includes("WebSocket connection disconnected") || chunk.includes("local RPC disconnection") || chunk.includes("Timeout registering service") || chunk.includes("Failed to subscribe to client_disconnected") || chunk.includes("Timeout subscribing to client_disconnected"));
-  console.log = () => {
-  };
-  console.warn = () => {
-  };
-  console.info = () => {
-  };
-  console.error = (...args) => {
-    if (args.some((a) => isHyphaLog(a))) return;
-    origError(...args);
-  };
-  process.stdout.write = (chunk, ...args) => {
-    if (isHyphaLog(chunk)) return true;
-    return stdoutWrite(chunk, ...args);
-  };
-  process.stderr.write = (chunk, ...args) => {
-    if (isHyphaLog(chunk)) return true;
-    return stderrWrite(chunk, ...args);
-  };
-  const restoreConsole = () => {
-    console.log = origLog;
-    console.warn = origWarn;
-    console.info = origInfo;
-    console.error = origError;
-  };
-  let server;
-  try {
-    server = await connectToHypha({
-      serverUrl,
-      token,
-      name: "svamp-session-cli"
-    });
-  } catch (err) {
-    restoreConsole();
-    console.error(`Failed to connect to Hypha: ${err.message}`);
-    process.exit(1);
-  }
-  try {
-    const services = await server.listServices({ query: { type: "svamp-machine" }, include_unlisted: true, _rkwargs: true });
-    restoreConsole();
-    if (services.length === 0) {
-      console.log("No machines found.");
-      return;
-    }
-    const machines = await Promise.all(
-      services.map(async (svc) => {
-        const svcId = svc.id || svc.name;
-        try {
-          const machineSvc = await server.getService(svcId);
-          const [info, sessions] = await Promise.all([
-            machineSvc.getMachineInfo(),
-            machineSvc.listSessions()
-          ]);
-          return {
-            serviceId: svcId,
-            machineId: info.machineId || svcId,
-            displayName: info.metadata?.displayName || info.metadata?.host || "-",
-            platform: info.metadata?.platform || "-",
-            host: info.metadata?.host || "-",
-            sessions: sessions.length,
-            status: info.daemonState?.status || "unknown"
-          };
-        } catch {
-          return {
-            serviceId: svcId,
-            machineId: svcId,
-            displayName: "-",
-            platform: "-",
-            host: "-",
-            sessions: -1,
-            status: "unreachable"
-          };
-        }
-      })
-    );
-    const header = `${"MACHINE ID".padEnd(20)} ${"NAME".padEnd(20)} ${"PLATFORM".padEnd(12)} ${"HOST".padEnd(25)} ${"SESSIONS".padEnd(10)} ${"STATUS"}`;
-    console.log(header);
-    console.log("-".repeat(header.length));
-    for (const m of machines) {
-      const id = truncate(m.machineId, 18).padEnd(20);
-      const name = truncate(m.displayName, 18).padEnd(20);
-      const platform = m.platform.padEnd(12);
-      const host = truncate(m.host, 23).padEnd(25);
-      const sessions = m.sessions >= 0 ? String(m.sessions).padEnd(10) : "-".padEnd(10);
-      const status = m.status === "running" ? `\x1B[32m${m.status}\x1B[0m` : m.status === "unreachable" ? `\x1B[31m${m.status}\x1B[0m` : m.status;
-      console.log(`${id} ${name} ${platform} ${host} ${sessions} ${status}`);
-    }
-    console.log(`
-${machines.length} machine(s) found.`);
-    console.log("Use --machine <id> to target a specific machine.");
-  } finally {
-    await server.disconnect();
-  }
-}
-function matchByHandle(sessions, partial) {
-  const parsed = parseHandle(partial);
-  if (!parsed) return [];
-  return sessions.filter((s) => handleMatchesMetadata(parsed, s.metadata || {}));
-}
-function findSessionMatch(sessions, partial) {
-  const exact = sessions.find((s) => s.sessionId === partial);
-  if (exact) return exact;
-  const byHandle = matchByHandle(sessions, partial);
-  if (byHandle.length === 1) return byHandle[0];
-  const matches = sessions.filter((s) => s.sessionId.startsWith(partial));
-  if (matches.length === 1) return matches[0];
-  return void 0;
-}
-function resolveSessionId(sessions, partial) {
-  const exact = sessions.find((s) => s.sessionId === partial);
-  if (exact) return exact;
-  const byHandle = matchByHandle(sessions, partial);
-  if (byHandle.length === 1) return byHandle[0];
-  if (byHandle.length > 1) {
-    console.error(`Ambiguous handle "${partial}". Matches:`);
-    for (const s of byHandle) {
-      console.error(`  ${resolveHandle(s.metadata || {}) || s.sessionId}  (${s.sessionId})`);
-    }
-    process.exit(1);
-  }
-  const matches = sessions.filter((s) => s.sessionId.startsWith(partial));
-  if (matches.length === 1) return matches[0];
-  if (matches.length === 0) {
-    console.error(`No session found matching: ${partial}`);
-    console.error('Run "svamp session list" to see active sessions.');
-    process.exit(1);
-  }
-  console.error(`Ambiguous session ID "${partial}". Matches:`);
-  for (const s of matches) {
-    console.error(`  ${s.sessionId}`);
-  }
-  process.exit(1);
-}
-async function connectAndResolveSession(sessionId, machineId) {
-  if (sessionId === ".") {
-    const self = process.env.SVAMP_SESSION_ID;
-    if (!self) {
-      console.error("'.' means the current session, but SVAMP_SESSION_ID is not set here.");
-      console.error('In a workflow step, give the workflow an owner session (so the scheduler can resolve "."), or use an explicit session id/handle.');
-      process.exit(1);
-    }
-    sessionId = self;
-  }
-  let { server, machine } = await connectAndGetMachine(machineId);
-  const sessions = await machine.listSessions();
-  const localMatch = findSessionMatch(sessions, sessionId);
-  if (localMatch) {
-    return { server, machine, fullId: localMatch.sessionId };
-  }
-  if (!machineId) {
-    try {
-      const { server: allServer, machines } = await connectAndGetAllMachines();
-      for (const m of machines) {
-        try {
-          const mSessions = await m.listSessions();
-          const mMatch = findSessionMatch(mSessions, sessionId);
-          if (mMatch) {
-            await server.disconnect();
-            return { server: allServer, machine: m, fullId: mMatch.sessionId };
-          }
-        } catch {
-        }
-      }
-      await allServer.disconnect();
-    } catch {
-    }
-  }
-  resolveSessionId(sessions, sessionId);
-  process.exit(1);
-}
-function truncate(str, max) {
-  if (str.length <= max) return str;
-  return "..." + str.slice(str.length - max + 3);
-}
-function renderMessage(msg) {
-  const content = msg.content;
-  if (!content) return;
-  const role = content.role;
-  if (role === "user") {
-    const data = content.content;
-    let text;
-    if (typeof data === "string") {
-      try {
-        const parsed = JSON.parse(data);
-        text = parsed?.text || parsed?.content?.text || data;
-      } catch {
-        text = data;
-      }
-    } else if (data?.text) {
-      text = data.text;
-    } else if (data?.type === "text") {
-      text = data.text || "";
-    } else {
-      text = typeof data === "object" ? JSON.stringify(data) : String(data || "");
-    }
-    console.log(`\x1B[36m[user]\x1B[0m ${text}`);
-  } else if (role === "agent" || role === "assistant") {
-    const data = content.content?.data || content.content;
-    if (!data) return;
-    const getBlocks = (d) => {
-      if (d.type === "assistant") {
-        const blocks2 = d.message?.content || d.content;
-        return Array.isArray(blocks2) ? blocks2 : null;
-      }
-      return null;
-    };
-    const renderBlocks = (blocks2) => {
-      for (const block of blocks2) {
-        if (block.type === "text" && block.text) {
-          process.stdout.write(block.text);
-          if (!block.text.endsWith("\n")) process.stdout.write("\n");
-        } else if (block.type === "tool_use") {
-          const argsStr = JSON.stringify(block.input || {}).slice(0, 120);
-          console.log(`\x1B[33m[tool]\x1B[0m ${block.name}(${argsStr})`);
-        } else if (block.type === "tool_result") {
-          const resultStr = typeof block.content === "string" ? block.content : JSON.stringify(block.content || "");
-          console.log(`\x1B[90m[result]\x1B[0m ${resultStr.slice(0, 200)}${resultStr.length > 200 ? "..." : ""}`);
-        } else if (block.type === "thinking") {
-          const text = block.thinking || block.text || "";
-          if (text) console.log(`\x1B[90m[thinking] ${text.slice(0, 200)}\x1B[0m`);
-        }
-      }
-    };
-    const blocks = getBlocks(data);
-    if (blocks) {
-      renderBlocks(blocks);
-    } else if (data.type === "result") {
-      if (data.result) console.log(`\x1B[32m[done]\x1B[0m ${data.result}`);
-    } else if (data.type === "output") {
-      const inner = data.data;
-      const innerBlocks = inner ? getBlocks(inner) : null;
-      if (innerBlocks) {
-        renderBlocks(innerBlocks);
-      } else if (inner?.type === "result") {
-        if (inner.result) console.log(`\x1B[32m[done]\x1B[0m ${inner.result}`);
-      }
-    }
-  } else if (role === "session") {
-    const data = content.content?.data;
-    if (data?.type === "system" && data?.subtype === "init") {
-      console.log(`\x1B[90m[session init]\x1B[0m`);
-    }
-  }
-}
-function extractContentBlocks(blocks) {
-  const parts = [];
-  for (const block of blocks) {
-    if (block.type === "text" && block.text) {
-      parts.push(block.text);
-    } else if (block.type === "tool_use") {
-      const argsStr = JSON.stringify(block.input || {}).slice(0, 200);
-      parts.push(`[tool: ${block.name}](${argsStr})`);
-    } else if (block.type === "tool_result") {
-      const r = typeof block.content === "string" ? block.content : JSON.stringify(block.content || "");
-      parts.push(`[result: ${r.slice(0, 200)}]`);
-    } else if (block.type === "thinking") {
-      const t = block.thinking || block.text || "";
-      if (t) parts.push(`[thinking: ${t.slice(0, 200)}]`);
-    }
-  }
-  return parts;
-}
-function extractMessageText(msg) {
-  const content = msg.content;
-  if (!content) return null;
-  const role = content.role || "unknown";
-  let text = "";
-  if (role === "user") {
-    const data = content.content;
-    if (typeof data === "string") {
-      try {
-        const parsed = JSON.parse(data);
-        text = parsed?.text || parsed?.content?.text || data;
-      } catch {
-        text = data;
-      }
-    } else if (data?.text) {
-      text = data.text;
-    } else if (data?.type === "text") {
-      text = data.text || "";
-    } else {
-      text = typeof data === "object" ? JSON.stringify(data) : String(data || "");
-    }
-  } else if (role === "agent" || role === "assistant") {
-    const data = content.content?.data || content.content;
-    if (!data) return null;
-    const getBlocks = (d) => {
-      if (d.type === "assistant") {
-        const blocks2 = d.message?.content || d.content;
-        return Array.isArray(blocks2) ? blocks2 : null;
-      }
-      return null;
-    };
-    const blocks = getBlocks(data);
-    if (blocks) {
-      text = extractContentBlocks(blocks).join("\n");
-    } else if (data.type === "result") {
-      text = data.result || "";
-    } else if (data.type === "output") {
-      const inner = data.data;
-      const innerBlocks = inner ? getBlocks(inner) : null;
-      if (innerBlocks) {
-        text = extractContentBlocks(innerBlocks).join("\n");
-      } else if (inner?.type === "result") {
-        text = inner.result || "";
-      }
-    }
-  } else if (role === "session") {
-    text = "[session event]";
-  }
-  return {
-    id: msg.id || "",
-    seq: msg.seq || 0,
-    role,
-    text,
-    createdAt: msg.createdAt || 0
-  };
-}
-async function waitForIdle(machine, sessionId, timeoutMs) {
-  const pollInterval = 2e3;
-  const deadline = Date.now() + timeoutMs;
-  while (Date.now() < deadline) {
-    const activity = await machine.sessionRPC(sessionId, "getActivityState", {});
-    if (activity?.pendingPermissions?.length > 0) {
-      return { idle: false, pendingPermissions: activity.pendingPermissions };
-    }
-    if (activity && !activity.thinking) {
-      return { idle: true };
-    }
-    await new Promise((r) => setTimeout(r, pollInterval));
-  }
-  throw new Error("Timeout waiting for agent to become idle");
-}
-async function waitForBusyThenIdle(machine, sessionId, timeoutMs = 3e5, busyTimeoutMs = 1e4) {
-  const pollInterval = 2e3;
-  const deadline = Date.now() + timeoutMs;
-  const busyDeadline = Date.now() + busyTimeoutMs;
-  let sawBusy = false;
-  while (Date.now() < deadline) {
-    const activity = await machine.sessionRPC(sessionId, "getActivityState", {});
-    if (activity?.pendingPermissions?.length > 0) {
-      return { idle: false, pendingPermissions: activity.pendingPermissions };
-    }
-    const isBusy = activity?.thinking === true;
-    if (isBusy) {
-      sawBusy = true;
-    }
-    if (activity && !activity.active) {
-      return { idle: true };
-    }
-    if (sawBusy && !isBusy) {
-      return { idle: true };
-    }
-    if (!sawBusy && Date.now() > busyDeadline) {
-      return { idle: true };
-    }
-    await new Promise((r) => setTimeout(r, pollInterval));
-  }
-  throw new Error("Timeout waiting for agent to become idle");
-}
-async function sessionList(machineId, opts) {
-  if (machineId) {
-    const { server, machine } = await connectAndGetMachine(machineId);
-    try {
-      await listSessionsFromMachines(server, [machine], opts);
-    } finally {
-      await server.disconnect();
-    }
-  } else {
-    const { server, machines } = await connectAndGetAllMachines();
-    try {
-      await listSessionsFromMachines(server, machines, opts);
-    } finally {
-      await server.disconnect();
-    }
-  }
-}
-function formatPeerLine(s) {
-  const m = s.metadata || {};
-  const title = resolveDisplayName(m, s.directory);
-  const handle = resolveHandle(m);
-  const agent = m.flavor || "claude";
-  const status = s.active ? "\x1B[32mactive\x1B[0m" : "\x1B[90midle\x1B[0m";
-  const dir = m.path || s.directory || "-";
-  const label = handle ? `${handle} \xB7 ${truncate(title, 28)}` : truncate(title, 32);
-  return `  [${s.sessionId.slice(0, 8)}] ${label} \u2014 ${status} \xB7 ${agent} \xB7 ${dir}`;
-}
-async function sessionWhoami(opts) {
-  const currentSessionId = process.env.SVAMP_SESSION_ID;
-  const { server, machines } = await connectAndGetAllMachines();
-  try {
-    const perMachine = await Promise.allSettled(
-      machines.map(async (machine) => {
-        const [info, sessions] = await Promise.all([
-          machine.getMachineInfo(),
-          machine.listSessions()
-        ]);
-        return { info, sessions };
-      })
-    );
-    const gathered = perMachine.filter((r) => r.status === "fulfilled").map((r) => r.value);
-    const machineLabel = (info) => info?.metadata?.displayName || info?.metadata?.host || info?.metadata?.hostname || info?.machineId || "unknown";
-    let current = null;
-    let currentSession = null;
-    if (currentSessionId) {
-      for (const g of gathered) {
-        const match = g.sessions.find((s) => s.sessionId === currentSessionId || s.sessionId.startsWith(currentSessionId));
-        if (match) {
-          current = g;
-          currentSession = match;
-          break;
-        }
-      }
-    }
-    if (opts?.json) {
-      console.log(formatJson({
-        operator: server.config?.user?.email || gathered.find((g) => g.info?.metadata?.sharing?.owner)?.info?.metadata?.sharing?.owner || null,
-        workspace: server.config?.workspace || null,
-        currentSessionId: currentSession?.sessionId || currentSessionId || null,
-        currentMachine: current ? machineLabel(current.info) : null,
-        totalSessions: gathered.reduce((n, g) => n + g.sessions.length, 0),
-        machines: gathered.map((g) => ({
-          sessionCount: g.sessions.length,
-          activeCount: g.sessions.filter((s) => s.active).length,
-          machine: machineLabel(g.info),
-          isCurrent: g === current,
-          sessions: g.sessions.map((s) => ({
-            sessionId: s.sessionId,
-            handle: resolveHandle(s.metadata || {}) || null,
-            title: resolveDisplayName(s.metadata || {}, s.directory),
-            agent: s.metadata?.flavor || "claude",
-            active: s.active,
-            directory: s.metadata?.path || s.directory || null,
-            isSelf: s.sessionId === currentSession?.sessionId
-          }))
-        }))
-      }));
-      return;
-    }
-    const operatorUser = server.config?.user;
-    const operatorEmail = operatorUser?.email || gathered.find((g) => g.info?.metadata?.sharing?.owner)?.info?.metadata?.sharing?.owner;
-    const workspace = server.config?.workspace;
-    const lines = ["# Your environment", ""];
-    if (operatorEmail || workspace) {
-      lines.push(`Operator: ${operatorEmail || "unknown"}${workspace ? ` \xB7 workspace ${workspace}` : ""}`);
-      lines.push("");
-    }
-    if (currentSession && current) {
-      const m = currentSession.metadata || {};
-      lines.push("## This session");
-      lines.push(`- id:      ${currentSession.sessionId}`);
-      {
-        const h = resolveHandle(m);
-        if (h) lines.push(`- handle:  ${h}`);
-      }
-      lines.push(`- topic:   ${resolveDisplayName(m, currentSession.directory)}`);
-      lines.push(`- agent:   ${m.flavor || "claude"}`);
-      lines.push(`- dir:     ${m.path || currentSession.directory || "-"}`);
-      lines.push(`- machine: ${machineLabel(current.info)}`);
-      if (m.projectName || m.projectDescription) {
-        lines.push(`- project: ${m.projectName || "-"}${m.projectDescription ? ` \u2014 ${m.projectDescription}` : ""}`);
-      }
-    } else if (currentSessionId) {
-      lines.push("## This session");
-      lines.push(`- id: ${currentSessionId} (not yet visible in the machine registry)`);
-    } else {
-      lines.push("_Not running inside a Svamp session (SVAMP_SESSION_ID unset). Showing all reachable sessions._");
-    }
-    lines.push("");
-    const byActive = (a, b) => (b.active ? 1 : 0) - (a.active ? 1 : 0);
-    const activeOf = (arr) => arr.filter((s) => s.active).length;
-    const grandTotal = gathered.reduce((n, g) => n + g.sessions.length, 0);
-    const orderedMachines = [...gathered].sort((a, b) => {
-      if (a === current) return -1;
-      if (b === current) return 1;
-      return b.sessions.length - a.sessions.length;
-    });
-    lines.push(`## Machines (same user) \u2014 ${grandTotal} session${grandTotal === 1 ? "" : "s"} across ${gathered.length} machine${gathered.length === 1 ? "" : "s"}`);
-    for (const g of orderedMachines) {
-      const ms = [...g.sessions].sort(byActive);
-      const here = g === current ? " (this machine)" : "";
-      lines.push(`- ${machineLabel(g.info)}${here}: ${ms.length} session${ms.length === 1 ? "" : "s"} (${activeOf(ms)} active)`);
-      if (opts?.all) {
-        const peers = g === current ? ms.filter((s) => s.sessionId !== currentSession?.sessionId) : ms;
-        for (const s of peers) lines.push(formatPeerLine(s));
-      }
-    }
-    lines.push("- List sessions: `svamp session list` (add `--active`, or `-m <machine>` for one).");
-    if (!opts?.all && grandTotal > 1) {
-      lines.push("- Or `svamp session whoami --all` to list every session inline.");
-    }
-    lines.push("");
-    lines.push("## Reach a peer");
-    lines.push("- `svamp session list` \u2014 find a peer's handle (project:name) or id, then:");
-    lines.push("- `svamp session info <handle|id>` / `svamp session messages <handle|id>` \u2014 inspect before reaching out");
-    lines.push('- `svamp session send <handle|id> "<msg>"` \u2014 drop a message into a peer\'s inbox (e.g. `send hypha-cloud:brave-otter "\u2026"`)');
-    lines.push('- Reply to an inbox message: `svamp session inbox reply <message-id> "<body>"`');
-    lines.push("- Keep it purposeful: only initiate with a concrete reason, avoid ping-pong loops.");
-    console.log(lines.join("\n"));
-  } finally {
-    await server.disconnect();
-  }
-}
-async function listSessionsFromMachines(_server, machines, opts) {
-  const allSessions = [];
-  const machineResults = await Promise.allSettled(
-    machines.map(async (machine) => {
-      const [info, sessions] = await Promise.all([
-        machine.getMachineInfo(),
-        machine.listSessions()
-      ]);
-      const host = info.metadata?.displayName || info.metadata?.host || info.machineId;
-      for (const s of sessions) {
-        s.machineHost = host;
-      }
-      return sessions;
-    })
-  );
-  for (const r of machineResults) {
-    if (r.status === "fulfilled") allSessions.push(...r.value);
-  }
-  const filtered = opts?.active ? allSessions.filter((s) => s.active) : allSessions;
-  if (filtered.length === 0) {
-    if (opts?.json) {
-      console.log(formatJson([]));
-    } else {
-      console.log("No active sessions.");
-    }
-    return;
-  }
-  const enriched = filtered.map((s) => {
-    const m = s.metadata || {};
-    return {
-      ...s,
-      flavor: m.flavor || "claude",
-      name: resolveDisplayName(m, s.directory),
-      handle: resolveHandle(m),
-      path: m.path || s.directory || "",
-      host: m.host || s.machineHost || ""
-    };
-  });
-  if (opts?.json) {
-    console.log(formatJson(enriched.map((s) => ({
-      sessionId: s.sessionId,
-      handle: s.handle,
-      agent: s.flavor,
-      name: s.name,
-      path: s.path,
-      host: s.host,
-      active: s.active,
-      directory: s.directory
-    }))));
-  } else {
-    const header = `${"SESSION".padEnd(30)} ${"AGENT".padEnd(8)} ${"STATUS".padEnd(9)} ${"TITLE".padEnd(22)} ${"MACHINE".padEnd(16)} ${"DIRECTORY".padEnd(30)}`;
-    console.log(header);
-    console.log("-".repeat(header.length));
-    for (const s of enriched) {
-      const ref = truncate(s.handle || s.sessionId, 30).padEnd(30);
-      const agent = (s.flavor || "claude").padEnd(8);
-      const status = s.active ? "\x1B[32mactive\x1B[0m  " : "\x1B[90minactive\x1B[0m";
-      const name = truncate(s.name || "-", 22).padEnd(22);
-      const machine = truncate(s.host || "-", 14).padEnd(16);
-      const dir = truncate(s.directory || "-", 28).padEnd(30);
-      console.log(`${ref} ${agent} ${status} ${name} ${machine} ${dir}`);
-    }
-  }
-}
-const WORKTREE_ADJECTIVES = [
-  "clever",
-  "happy",
-  "swift",
-  "bright",
-  "calm",
-  "bold",
-  "quiet",
-  "brave",
-  "wise",
-  "eager",
-  "gentle",
-  "quick",
-  "sharp",
-  "smooth",
-  "fresh"
-];
-const WORKTREE_NOUNS = [
-  "ocean",
-  "forest",
-  "cloud",
-  "star",
-  "river",
-  "mountain",
-  "valley",
-  "bridge",
-  "beacon",
-  "harbor",
-  "garden",
-  "meadow",
-  "canyon",
-  "island",
-  "desert"
-];
-function generateWorktreeName() {
-  const adj = WORKTREE_ADJECTIVES[Math.floor(Math.random() * WORKTREE_ADJECTIVES.length)];
-  const noun = WORKTREE_NOUNS[Math.floor(Math.random() * WORKTREE_NOUNS.length)];
-  return `${adj}-${noun}`;
-}
-function ensureWorktreeExcludes(projectRoot) {
-  try {
-    const common = execSync("git rev-parse --git-common-dir", { cwd: projectRoot, stdio: "pipe" }).toString().trim();
-    const commonAbs = isAbsolute(common) ? common : join(projectRoot, common);
-    const excludeFile = join(commonAbs, "info", "exclude");
-    const existing = existsSync(excludeFile) ? readFileSync(excludeFile, "utf-8") : "";
-    const lines = existing.split("\n");
-    const want = [".svamp/", ".dev/"];
-    const missing = want.filter((w) => !lines.some((l) => l.trim() === w));
-    if (missing.length) {
-      const prefix = existing && !existing.endsWith("\n") ? "\n" : "";
-      writeFileSync(excludeFile, existing + prefix + missing.join("\n") + "\n");
-    }
-  } catch {
-  }
-}
-function createWorktree(baseDir) {
-  const absBase = resolve(baseDir);
-  const marker = "/.dev/worktree/";
-  const idx = absBase.indexOf(marker);
-  const projectRoot = idx !== -1 ? absBase.substring(0, idx) : absBase;
-  try {
-    execSync("git rev-parse --git-dir", { cwd: projectRoot, stdio: "pipe" });
-  } catch {
-    throw new Error(`Not a git repository: ${projectRoot}`);
-  }
-  ensureWorktreeExcludes(projectRoot);
-  const name = generateWorktreeName();
-  const relPath = `.dev/worktree/${name}`;
-  try {
-    execSync(`git worktree add -b ${name} ${relPath}`, { cwd: projectRoot, stdio: "pipe" });
-  } catch (err) {
-    for (let i = 2; i <= 4; i++) {
-      const suffixed = `${name}-${i}`;
-      const suffixedPath = `.dev/worktree/${suffixed}`;
-      try {
-        execSync(`git worktree add -b ${suffixed} ${suffixedPath}`, { cwd: projectRoot, stdio: "pipe" });
-        return { path: join(projectRoot, suffixedPath), branch: suffixed };
-      } catch {
-        continue;
-      }
-    }
-    throw new Error(`Failed to create worktree: ${err.stderr?.toString() || err.message}`);
-  }
-  return { path: join(projectRoot, relPath), branch: name };
-}
-function parseShareArg(arg) {
-  const parts = arg.split(":");
-  const email = parts[0];
-  const suppliedRole = parts[1];
-  if (suppliedRole) {
-    if (!["view", "interact", "admin"].includes(suppliedRole)) {
-      throw new Error(`Invalid role "${suppliedRole}" in --share ${arg}. Per-user roles are deprecated; omit the :role suffix.`);
-    }
-    if (suppliedRole !== "admin") {
-      console.warn(`Note: per-user role "${suppliedRole}" is deprecated. Added users have full (owner-equivalent) access.`);
-    }
-  }
-  return { email, role: "admin" };
-}
-async function sessionSpawn(agent, directory, machineId, opts) {
-  const { server, machine } = await connectAndGetMachine(machineId);
-  try {
-    let sharing;
-    if (opts?.share?.length) {
-      sharing = {
-        enabled: true,
-        owner: "",
-        // will be auto-set by machine service from Hypha context
-        allowedUsers: opts.share.map(
-          (s) => normalizeAllowedUser({ email: s.email, addedBy: "cli" }, "cli")
-        )
-      };
-    }
-    let securityContext;
-    if (opts?.securityContextPath) {
-      const configPath = resolve(opts.securityContextPath);
-      const config = loadSecurityContextConfig(configPath);
-      securityContext = resolveSecurityContext(config, void 0);
-    }
-    if (opts?.denyRead?.length || opts?.allowWrite?.length || opts?.denyNetwork || opts?.allowDomain?.length) {
-      const flagCtx = buildSecurityContextFromFlags({
-        denyRead: opts.denyRead,
-        allowWrite: opts.allowWrite,
-        denyNetwork: opts.denyNetwork,
-        allowDomain: opts.allowDomain
-      });
-      securityContext = mergeSecurityContexts(securityContext, flagCtx);
-    }
-    const forceIsolation = opts?.isolate || !!securityContext;
-    if (securityContext?.filesystem?.allowWrite?.length) {
-      const absDir = resolve(directory);
-      const writePaths = securityContext.filesystem.allowWrite;
-      const dirCovered = writePaths.some((p) => absDir.startsWith(resolve(p)) || resolve(p).startsWith(absDir));
-      if (!dirCovered) {
-        console.warn(`Warning: Working directory ${absDir} is not covered by allowWrite paths: ${writePaths.join(", ")}`);
-        console.warn(`  The agent may not be able to write files in the working directory.`);
-      }
-    }
-    if (opts?.worktree) {
-      try {
-        const wt = createWorktree(directory);
-        console.log(`Created worktree: ${wt.branch} \u2192 ${wt.path}`);
-        directory = wt.path;
-      } catch (err) {
-        console.error(`Failed to create worktree: ${err.message}`);
-        process.exit(1);
-      }
-    }
-    let effectiveParentSessionId = opts?.parentSessionId || process.env.SVAMP_SESSION_ID || void 0;
-    if (effectiveParentSessionId) {
-      try {
-        const sessions = await machine.listSessions();
-        if (opts?.parentSessionId) {
-          const match = resolveSessionId(sessions, effectiveParentSessionId);
-          effectiveParentSessionId = match.sessionId;
-        } else {
-          const found = sessions.find((s) => s.sessionId === effectiveParentSessionId);
-          if (!found) throw new Error("not found");
-        }
-      } catch (err) {
-        const source = opts?.parentSessionId ? "--parent" : "SVAMP_SESSION_ID";
-        console.error(`Error: Parent session ${effectiveParentSessionId} not found (from ${source}).`);
-        process.exit(1);
-      }
-    }
-    console.log(`Spawning ${agent} session in ${directory}...`);
-    if (effectiveParentSessionId) {
-      console.log(`Parent session: ${effectiveParentSessionId}${!opts?.parentSessionId ? " (auto-detected from SVAMP_SESSION_ID)" : ""}`);
-    }
-    if (opts?.tags?.length) {
-      console.log(`Tags: ${opts.tags.join(", ")}`);
-    }
-    if (forceIsolation) {
-      console.log(`Isolation: enabled (workspace: ${resolve(directory)})`);
-    }
-    if (securityContext) {
-      console.log(`Security context: ${JSON.stringify(securityContext, null, 2)}`);
-    }
-    if (sharing) {
-      console.log(`Sharing with: ${sharing.allowedUsers.map((u) => u.email).join(", ")} (full access)`);
-    }
-    const result = await machine.spawnSession({
-      directory,
-      agent,
-      sharing,
-      securityContext,
-      forceIsolation,
-      tags: opts?.tags,
-      parentSessionId: effectiveParentSessionId,
-      permissionMode: opts?.permissionMode
-    });
-    if (result.type === "success") {
-      console.log(`Session started: ${result.sessionId}`);
-      if (result.message) console.log(`  ${result.message}`);
-      const explicitPermMode = opts?.permissionMode;
-      if (explicitPermMode && explicitPermMode !== "bypassPermissions") {
-        console.log(`\x1B[33m\u26A0 Permission mode: ${explicitPermMode}. Agent will pause for tool approval.\x1B[0m`);
-        console.log(`\x1B[33m  Use \`svamp session approve <id>\` to unblock, or drop the flag to run autonomously.\x1B[0m`);
-      }
-      if (opts?.message && result.sessionId) {
-        const svc = getSessionProxy(machine, result.sessionId);
-        const sendResult = await svc.sendMessage(
-          JSON.stringify({
-            role: "user",
-            content: { type: "text", text: opts.message },
-            meta: { sentFrom: "svamp-cli" }
-          })
-        );
-        console.log(`Message sent (seq: ${sendResult.seq})`);
-        if (opts.wait) {
-          console.log("Waiting for agent to become idle...");
-          await waitForBusyThenIdle(machine, result.sessionId);
-          console.log("Agent is idle.");
-        }
-      }
-    } else if (result.type === "requestToApproveDirectoryCreation") {
-      console.error(`Directory ${result.directory} does not exist. Create it first or use an existing directory.`);
-      process.exit(1);
-    } else {
-      console.error(`Failed: ${result.errorMessage || "Unknown error"}`);
-      process.exit(1);
-    }
-  } finally {
-    await server.disconnect();
-  }
-}
-async function sessionArchive(sessionId, machineId) {
-  const { server, machine, fullId } = await connectAndResolveSession(sessionId, machineId);
-  try {
-    const success = await machine.archiveSession(fullId);
-    if (success) {
-      console.log(`Session ${fullId.slice(0, 8)} archived. Run \`svamp session resume ${fullId.slice(0, 8)}\` to bring it back.`);
-    } else {
-      console.error("Failed to archive session (not found on daemon).");
-      process.exit(1);
-    }
-  } finally {
-    await server.disconnect();
-  }
-}
-async function sessionResume(sessionId, machineId) {
-  const { server, machine, fullId } = await connectAndResolveSession(sessionId, machineId);
-  try {
-    const result = await machine.resumeSession(fullId);
-    if (result?.success) {
-      console.log(`Session ${fullId.slice(0, 8)} resumed.`);
-    } else {
-      console.error(`Failed to resume session: ${result?.message || "unknown error"}`);
-      process.exit(1);
-    }
-  } finally {
-    await server.disconnect();
-  }
-}
-async function sessionDelete(sessionId, machineId) {
-  const { server, machine, fullId } = await connectAndResolveSession(sessionId, machineId);
-  try {
-    const success = await machine.deleteSession(fullId);
-    if (success) {
-      console.log(`Session ${fullId.slice(0, 8)} deleted.`);
-    } else {
-      console.error("Failed to delete session.");
-      process.exit(1);
-    }
-  } finally {
-    await server.disconnect();
-  }
-}
-async function sessionInfo(sessionId, machineId, opts) {
-  const { server, machine, fullId } = await connectAndResolveSession(sessionId, machineId);
-  try {
-    let metadata = {};
-    let activity = {};
-    try {
-      const svc = getSessionProxy(machine, fullId);
-      const metaResult = await svc.getMetadata();
-      metadata = metaResult.metadata || {};
-      activity = await svc.getActivityState();
-    } catch {
-    }
-    const pendingPermissions = activity.pendingPermissions || [];
-    const statusData = {
-      sessionId: fullId,
-      flavor: metadata.flavor || "claude",
-      name: resolveDisplayName(metadata, metadata.path || void 0),
-      handle: resolveHandle(metadata),
-      path: metadata.path || "",
-      host: metadata.host || "",
-      lifecycleState: metadata.lifecycleState || "unknown",
-      active: activity.active ?? false,
-      thinking: activity.thinking ?? false,
-      startedBy: metadata.startedBy || "",
-      summary: metadata.summary?.text || void 0,
-      projectName: metadata.projectName || void 0,
-      projectDescription: metadata.projectDescription || void 0,
-      claudeSessionId: metadata.claudeSessionId || void 0,
-      sessionLink: metadata.sessionLink?.url || void 0,
-      tags: metadata.tags?.length ? metadata.tags : void 0,
-      parentSessionId: metadata.parentSessionId || void 0,
-      pendingPermissions: pendingPermissions.length > 0 ? pendingPermissions : void 0
-    };
-    if (opts?.json) {
-      console.log(formatJson(statusData));
-    } else {
-      console.log(formatSessionStatus(statusData));
-    }
-  } finally {
-    await server.disconnect();
-  }
-}
-async function sessionMessages(sessionId, machineId, opts) {
-  const { server, machine, fullId } = await connectAndResolveSession(sessionId, machineId);
-  try {
-    const svc = getSessionProxy(machine, fullId);
-    let messages;
-    if (opts?.after !== void 0) {
-      const apiLimit = opts?.limit ?? 500;
-      ({ messages } = await svc.getMessages(opts.after, apiLimit));
-    } else {
-      const tailCount = Math.min(opts?.last ?? opts?.limit ?? 50, 500);
-      ({ messages } = await svc.getLatestMessages(void 0, tailCount));
-    }
-    const toShow = opts?.last ? messages.slice(-opts.last) : messages;
-    if (toShow.length === 0) {
-      if (opts?.json) {
-        console.log(formatJson([]));
-      } else {
-        console.log("No messages yet.");
-      }
-      return;
-    }
-    if (opts?.json && opts?.raw) {
-      console.log(formatJson(toShow));
-    } else if (opts?.json) {
-      const formatted = [];
-      for (const msg of toShow) {
-        const extracted = extractMessageText(msg);
-        if (extracted) {
-          formatted.push(extracted);
-        }
-      }
-      formatted.sort((a, b) => a.createdAt - b.createdAt);
-      console.log(formatJson(formatted));
-    } else {
-      for (const msg of toShow) {
-        renderMessage(msg);
-      }
-    }
-  } finally {
-    await server.disconnect();
-  }
-}
-async function sessionEditMessage(sessionId, messageId, newText, machineId) {
-  const { server, machine, fullId } = await connectAndResolveSession(sessionId, machineId);
-  try {
-    const res = await machine.sessionRPC(fullId, "editMessage", { messageId, newText });
-    if (res?.success) {
-      console.log("\u2713 Message edited; Claude restarted with the rewritten history.");
-    } else {
-      console.error(`\u2717 Edit failed: ${res?.message || "unknown error"}`);
-      process.exitCode = 1;
-    }
-  } finally {
-    await server.disconnect();
-  }
-}
-async function sessionRefineLastReply(sessionId, instruction, machineId) {
-  const { server, machine, fullId } = await connectAndResolveSession(sessionId, machineId);
-  try {
-    const res = await machine.sessionRPC(fullId, "refineLastReply", { instruction });
-    if (res?.success) {
-      console.log("\u2713 Latest reply refined; Claude restarted with the rewritten history.");
-    } else {
-      console.error(`\u2717 Refine failed: ${res?.message || "unknown error"}`);
-      process.exitCode = 1;
-    }
-  } finally {
-    await server.disconnect();
-  }
-}
-async function sessionUndoEdit(sessionId, machineId) {
-  const { server, machine, fullId } = await connectAndResolveSession(sessionId, machineId);
-  try {
-    const res = await machine.sessionRPC(fullId, "undoLastEdit", {});
-    if (res?.success) {
-      console.log("\u2713 Last edit reverted; Claude restarted with the pre-edit history.");
-    } else {
-      console.error(`\u2717 Undo failed: ${res?.message || "unknown error"}`);
-      process.exitCode = 1;
-    }
-  } finally {
-    await server.disconnect();
-  }
-}
-async function sessionApprove(sessionId, requestId, machineId, opts) {
-  const { server, machine, fullId } = await connectAndResolveSession(sessionId, machineId);
-  try {
-    const svc = getSessionProxy(machine, fullId);
-    if (requestId) {
-      const activity = await svc.getActivityState();
-      const pending = activity.pendingPermissions || [];
-      const matched = pending.find((p) => p.id === requestId || p.id.startsWith(requestId));
-      if (!matched) {
-        console.error(`No pending permission matching "${requestId}".`);
-        process.exitCode = 1;
-        return;
-      }
-      await svc.permissionResponse({ id: matched.id, approved: true });
-      if (opts?.json) {
-        console.log(formatJson({ sessionId: fullId, approved: 1, requestIds: [matched.id] }));
-      } else {
-        console.log(`Approved: ${matched.tool} [${matched.id.slice(0, 8)}]`);
-      }
-    } else {
-      const activity = await svc.getActivityState();
-      const pending = activity.pendingPermissions || [];
-      if (pending.length === 0) {
-        if (opts?.json) {
-          console.log(formatJson({ sessionId: fullId, approved: 0, requestIds: [] }));
-        } else {
-          console.error("No pending permission requests.");
-        }
-        process.exitCode = 1;
-        return;
-      }
-      const approvedIds = [];
-      for (const p of pending) {
-        await svc.permissionResponse({ id: p.id, approved: true });
-        approvedIds.push(p.id);
-      }
-      if (opts?.json) {
-        console.log(formatJson({ sessionId: fullId, approved: approvedIds.length, requestIds: approvedIds }));
-      } else {
-        console.log(`Approved ${approvedIds.length} permission(s).`);
-      }
-    }
-  } finally {
-    await server.disconnect();
-  }
-}
-async function sessionDeny(sessionId, requestId, machineId, opts) {
-  const { server, machine, fullId } = await connectAndResolveSession(sessionId, machineId);
-  try {
-    const svc = getSessionProxy(machine, fullId);
-    if (requestId) {
-      const activity = await svc.getActivityState();
-      const pending = activity.pendingPermissions || [];
-      const matched = pending.find((p) => p.id === requestId || p.id.startsWith(requestId));
-      if (!matched) {
-        console.error(`No pending permission matching "${requestId}".`);
-        process.exitCode = 1;
-        return;
-      }
-      await svc.permissionResponse({ id: matched.id, approved: false });
-      if (opts?.json) {
-        console.log(formatJson({ sessionId: fullId, denied: 1, requestIds: [matched.id] }));
-      } else {
-        console.log(`Denied: ${matched.tool} [${matched.id.slice(0, 8)}]`);
-      }
-    } else {
-      const activity = await svc.getActivityState();
-      const pending = activity.pendingPermissions || [];
-      if (pending.length === 0) {
-        if (opts?.json) {
-          console.log(formatJson({ sessionId: fullId, denied: 0, requestIds: [] }));
-        } else {
-          console.error("No pending permission requests.");
-        }
-        process.exitCode = 1;
-        return;
-      }
-      const deniedIds = [];
-      for (const p of pending) {
-        await svc.permissionResponse({ id: p.id, approved: false });
-        deniedIds.push(p.id);
-      }
-      if (opts?.json) {
-        console.log(formatJson({ sessionId: fullId, denied: deniedIds.length, requestIds: deniedIds }));
-      } else {
-        console.log(`Denied ${deniedIds.length} permission(s).`);
-      }
-    }
-  } finally {
-    await server.disconnect();
-  }
-}
-async function sessionAttach(sessionId, machineId) {
-  const { server, machine, fullId } = await connectAndResolveSession(sessionId, machineId);
-  let svc;
-  try {
-    svc = getSessionProxy(machine, fullId);
-  } catch (err) {
-    console.error(`Could not find session service: ${err.message}`);
-    await server.disconnect();
-    process.exit(1);
-  }
-  const { metadata } = await svc.getMetadata();
-  const flavor = metadata?.flavor || "claude";
-  const name = metadata?.name || fullId.slice(0, 8);
-  console.log(`Attached to ${flavor} session "${name}". Commands: /quit /abort /kill
-`);
-  const seenMessageIds = /* @__PURE__ */ new Set();
-  let replayDone = false;
-  await svc.registerListener({
-    onUpdate: (update) => {
-      if (update.type === "new-message") {
-        const msg = update.message;
-        if (!msg?.id) return;
-        if (seenMessageIds.has(msg.id)) return;
-        seenMessageIds.add(msg.id);
-        if (!replayDone) return;
-        renderMessage(msg);
-      } else if (update.type === "activity") {
-        if (!replayDone) return;
-        if (update.thinking) {
-          process.stdout.write("\x1B[90m[thinking...]\x1B[0m\r");
-        } else if (!update.thinking) {
-          process.stdout.write("\n> ");
-        }
-      } else if (update.type === "update-session") ;
-    }
-  });
-  await new Promise((r) => setTimeout(r, 500));
-  replayDone = true;
-  console.log(`\x1B[90m(${seenMessageIds.size} messages in history)\x1B[0m`);
-  process.stdout.write("> ");
-  const readline = await import('readline');
-  const rl = readline.createInterface({
-    input: process.stdin,
-    output: process.stdout,
-    terminal: true
-  });
-  rl.on("line", async (line) => {
-    const trimmed = line.trim();
-    if (!trimmed) {
-      process.stdout.write("> ");
-      return;
-    }
-    if (trimmed === "/quit" || trimmed === "/detach") {
-      console.log("Detaching (session continues running)...");
-      rl.close();
-      await server.disconnect();
-      process.exit(0);
-    }
-    if (trimmed === "/abort" || trimmed === "/cancel") {
-      try {
-        await svc.abort();
-        console.log("Abort sent.");
-      } catch (err) {
-        console.error(`Abort failed: ${err.message}`);
-      }
-      process.stdout.write("> ");
-      return;
-    }
-    if (trimmed === "/archive") {
-      try {
-        await svc.archiveSession();
-        console.log("Session archived. Run `svamp session resume <id>` to bring it back.");
-      } catch (err) {
-        console.error(`Archive failed: ${err.message}`);
-      }
-      rl.close();
-      await server.disconnect();
-      process.exit(0);
-    }
-    if (trimmed === "/info") {
-      try {
-        const { metadata: m } = await svc.getMetadata();
-        const act = await svc.getActivityState();
-        console.log(`  Agent: ${m?.flavor || "claude"}, State: ${m?.lifecycleState || "?"}, Active: ${act?.active}, Thinking: ${act?.thinking}`);
-      } catch (err) {
-        console.error(`Info failed: ${err.message}`);
-      }
-      process.stdout.write("> ");
-      return;
-    }
-    try {
-      await svc.sendMessage(
-        JSON.stringify({
-          role: "user",
-          content: { type: "text", text: trimmed }
-        })
-      );
-    } catch (err) {
-      console.error(`Send failed: ${err.message}`);
-      process.stdout.write("> ");
-    }
-  });
-  rl.on("close", async () => {
-    await server.disconnect();
-    process.exit(0);
-  });
-  process.on("SIGINT", async () => {
-    console.log("\nDetaching (session continues running)...");
-    rl.close();
-    await server.disconnect();
-    process.exit(0);
-  });
-}
-async function snapshotLatestSeq(machine, fullId) {
-  try {
-    const r = await machine.sessionRPC(fullId, "getMessageCount", {});
-    return Math.max(0, Number(r?.latestSeq ?? 0));
-  } catch {
-    try {
-      const r = await machine.sessionRPC(fullId, "getLatestMessages", { limit: 1 });
-      const msgs = r?.messages || [];
-      return msgs.length > 0 ? Number(msgs[msgs.length - 1].seq || 0) : 0;
-    } catch {
-      return 0;
-    }
-  }
-}
-async function collectAssistantResponse(machine, fullId, afterSeq) {
-  const pageLimit = 500;
-  let cursor = afterSeq;
-  const collected = [];
-  const seqs = [];
-  const resultText = [];
-  const resultSeqs = [];
-  for (let i = 0; i < 20; i++) {
-    const { messages, hasMore } = await machine.sessionRPC(
-      fullId,
-      "getMessages",
-      { afterSeq: cursor, limit: pageLimit }
-    );
-    if (!messages || messages.length === 0) break;
-    for (const msg of messages) {
-      const role = msg?.content?.role;
-      if (role === "agent" || role === "assistant") {
-        const data = msg.content?.content?.data || msg.content?.content;
-        if (!data) continue;
-        let blocks = null;
-        if (data.type === "assistant") {
-          const b = data.message?.content || data.content;
-          blocks = Array.isArray(b) ? b : null;
-        } else if (data.type === "output" && data.data?.type === "assistant") {
-          const b = data.data.message?.content || data.data.content;
-          blocks = Array.isArray(b) ? b : null;
-        }
-        if (blocks) {
-          for (const block of blocks) {
-            if (block.type === "text" && typeof block.text === "string" && block.text) {
-              collected.push(block.text);
-              if (!seqs.includes(msg.seq)) seqs.push(msg.seq);
-            }
-          }
-        } else if (data.type === "result" && typeof data.result === "string" && data.result) {
-          resultText.push(data.result);
-          if (!resultSeqs.includes(msg.seq)) resultSeqs.push(msg.seq);
-        } else if (data.type === "output" && data.data?.type === "result" && typeof data.data.result === "string" && data.data.result) {
-          resultText.push(data.data.result);
-          if (!resultSeqs.includes(msg.seq)) resultSeqs.push(msg.seq);
-        }
-      }
-      cursor = Math.max(cursor, Number(msg.seq || 0));
-    }
-    if (!hasMore) break;
-  }
-  if (collected.length) return { text: collected.join("\n").trim(), messageSeqs: seqs };
-  return { text: resultText.join("\n").trim(), messageSeqs: resultSeqs };
-}
-function isSelfBtw(fullId, btw, selfSessionId) {
-  return !!btw && !!selfSessionId && fullId === selfSessionId;
-}
-function validateSendOptions(opts) {
-  if (opts?.plain) {
-    const bad = [];
-    if (opts.btw) bad.push("--btw");
-    if (opts.model) bad.push("--model");
-    if (bad.length) return bad.map((f) => `${f} (incompatible with --plain)`);
-  }
-  if (!opts?.btw) return [];
-  const incompatible = [];
-  if (opts.subject) incompatible.push("--subject");
-  if (opts.urgency) incompatible.push("--urgency");
-  if (opts.wait) incompatible.push("--wait");
-  if (opts.response) incompatible.push("--response");
-  if (opts.model) incompatible.push("--model");
-  if (opts.plain) incompatible.push("--plain");
-  return incompatible;
-}
-async function sendCore(machine, fullId, message, opts) {
-  if (opts?.btw) {
-    const btwResult = await machine.sessionRPC(fullId, "btw", { question: message });
-    if (!btwResult?.success) {
-      return {
-        sessionId: fullId,
-        mode: "btw",
-        sent: false,
-        waited: false,
-        status: "error",
-        error: btwResult?.error || "btw failed"
-      };
-    }
-    return {
-      sessionId: fullId,
-      mode: "btw",
-      sent: true,
-      waited: true,
-      status: "idle",
-      response: String(btwResult.answer || "")
-    };
-  }
-  if (opts?.asIssue) {
-    const issue = await machine.sessionRPC(fullId, "issue", {
-      op: "add",
-      body: message,
-      session: fullId,
-      rekick: true,
-      ...opts.issueTitle ? { title: opts.issueTitle } : {}
-    });
-    return {
-      sessionId: fullId,
-      mode: "send",
-      sent: true,
-      waited: false,
-      status: "sent",
-      messageId: issue?.id,
-      response: `Created issue #${issue?.id}: ${issue?.title || ""}`.trim()
-    };
-  }
-  const wantResponse = !!opts?.response;
-  const shouldWait = !!opts?.wait || wantResponse;
-  if (opts?.plain) {
-    const { randomUUID: ruuid } = await import('node:crypto');
-    if (shouldWait && !opts?.requireApproval) {
-      try {
-        await machine.sessionRPC(fullId, "switchMode", { mode: "bypassPermissions" });
-      } catch {
-      }
-    }
-    const preSeq2 = wantResponse ? await snapshotLatestSeq(machine, fullId) : 0;
-    const meta = { sentFrom: "svamp-cli-plain" };
-    const contentStr = JSON.stringify({ role: "user", content: { type: "text", text: message }, meta });
-    const sendRes = await machine.sessionRPC(fullId, "sendMessage", { content: contentStr, localId: ruuid(), meta });
-    let pWait;
-    if (shouldWait) pWait = await waitForBusyThenIdle(machine, fullId, (opts?.timeout || 300) * 1e3);
-    if (pWait?.pendingPermissions?.length) {
-      return { sessionId: fullId, mode: "send", sent: true, messageId: sendRes?.id, waited: true, status: "permission-pending", pendingPermissions: pWait.pendingPermissions };
-    }
-    let pResp;
-    if (wantResponse) pResp = await collectAssistantResponse(machine, fullId, preSeq2);
-    return {
-      sessionId: fullId,
-      mode: "send",
-      sent: true,
-      messageId: sendRes?.id,
-      waited: !!shouldWait,
-      status: shouldWait ? "idle" : "sent",
-      ...wantResponse && pResp ? { response: pResp.text, responseSeqs: pResp.messageSeqs } : {}
-    };
-  }
-  if (opts?.model) {
-    const { randomUUID: ruuid } = await import('node:crypto');
-    if (shouldWait && !opts?.requireApproval) {
-      try {
-        await machine.sessionRPC(fullId, "switchMode", { mode: "bypassPermissions" });
-      } catch {
-      }
-    }
-    try {
-      await machine.sessionRPC(fullId, "abort", {});
-    } catch {
-    }
-    await new Promise((r) => setTimeout(r, 2e3));
-    const meta = { model: opts.model, sentFrom: "svamp-cli" };
-    const contentStr = JSON.stringify({ role: "user", content: { type: "text", text: message }, meta });
-    const sendRes = await machine.sessionRPC(fullId, "sendMessage", {
-      content: contentStr,
-      localId: ruuid(),
-      meta
-    });
-    let mWait;
-    if (shouldWait) {
-      mWait = await waitForBusyThenIdle(machine, fullId, (opts?.timeout || 300) * 1e3);
-    }
-    if (mWait?.pendingPermissions?.length) {
-      return {
-        sessionId: fullId,
-        mode: "send",
-        sent: true,
-        messageId: sendRes?.id,
-        waited: true,
-        status: "permission-pending",
-        pendingPermissions: mWait.pendingPermissions
-      };
-    }
-    let mResponse;
-    if (wantResponse) {
-      mResponse = await collectAssistantResponse(machine, fullId, 0);
-    }
-    return {
-      sessionId: fullId,
-      mode: "send",
-      sent: true,
-      messageId: sendRes?.id,
-      waited: shouldWait,
-      status: shouldWait ? "idle" : "sent",
-      ...wantResponse && mResponse ? { response: mResponse.text, responseSeqs: mResponse.messageSeqs } : {}
-    };
-  }
-  let bypassEnsured = false;
-  if (shouldWait && !opts?.requireApproval) {
-    try {
-      await machine.sessionRPC(fullId, "switchMode", { mode: "bypassPermissions" });
-      bypassEnsured = true;
-    } catch {
-    }
-  }
-  const preSeq = wantResponse ? await snapshotLatestSeq(machine, fullId) : 0;
-  const callerSessionId = process.env.SVAMP_SESSION_ID;
-  const hop = computeOutboundHop(callerSessionId);
-  let urgency = opts?.urgency ? opts.urgency : shouldWait ? "urgent" : "normal";
-  if (hop.fromInboxTurn) urgency = "normal";
-  const inboxMessage = {
-    messageId: shortId(),
-    body: message,
-    timestamp: Date.now(),
-    read: false,
-    // Prefer the sender session's friendly handle (project:name) so the receiver —
-    // and a human watching the exchange — sees who's talking, not an opaque id.
-    // `fromSession` still carries the routable id for reply delivery.
-    from: callerSessionId ? process.env.SVAMP_SESSION_HANDLE || `agent:${callerSessionId}` : `cli:${os.userInfo().username}`,
-    ...callerSessionId ? { fromSession: callerSessionId } : {},
-    to: fullId,
-    subject: opts?.subject,
-    urgency,
-    hopCount: hop.hopCount,
-    ...hop.threadId ? { threadId: hop.threadId } : {}
-  };
-  const result = await machine.sessionRPC(fullId, "sendInboxMessage", { message: inboxMessage });
-  if (callerSessionId) {
-    try {
-      registerAwaitingReply(callerSessionId, hop.threadId || inboxMessage.messageId);
-    } catch {
-    }
-  }
-  let waitResult;
-  if (shouldWait) {
-    const timeoutMs = (opts?.timeout || 300) * 1e3;
-    waitResult = await waitForBusyThenIdle(machine, fullId, timeoutMs);
-  }
-  if (waitResult?.pendingPermissions?.length) {
-    return {
-      sessionId: fullId,
-      mode: "send",
-      sent: true,
-      messageId: result.messageId,
-      waited: true,
-      status: "permission-pending",
-      pendingPermissions: waitResult.pendingPermissions,
-      bypassEnsured
-    };
-  }
-  let response;
-  if (wantResponse) {
-    response = await collectAssistantResponse(machine, fullId, preSeq);
-  }
-  return {
-    sessionId: fullId,
-    mode: "send",
-    sent: true,
-    messageId: result.messageId,
-    waited: shouldWait,
-    status: shouldWait ? "idle" : "sent",
-    bypassEnsured,
-    ...wantResponse && response ? { response: response.text, responseSeqs: response.messageSeqs } : {}
-  };
-}
-async function sessionSend(sessionId, message, machineId, opts) {
-  const incompatible = validateSendOptions(opts);
-  if (incompatible.length) {
-    console.error(`Error: --btw is incompatible with: ${incompatible.join(", ")}`);
-    console.error("  --btw runs as a one-shot forked query that returns the answer directly.");
-    process.exit(1);
-  }
-  const { server, machine, fullId } = await connectAndResolveSession(sessionId, machineId);
-  if (isSelfBtw(fullId, opts?.btw, process.env.SVAMP_SESSION_ID)) {
-    console.error("Refusing to --btw your own session: a /btw forks a query that resumes this session, which would deadlock the active turn (and the watchdog would kill it). You are already inside this session \u2014 just answer/think directly, or send to a DIFFERENT session.");
-    try {
-      await server.disconnect();
-    } catch {
-    }
-    process.exit(1);
-  }
-  try {
-    const r = await sendCore(machine, fullId, message, opts);
-    if (r.mode === "btw") {
-      if (r.status === "error") {
-        if (opts?.json) {
-          console.log(formatJson({
-            sessionId: r.sessionId,
-            mode: "btw",
-            message,
-            success: false,
-            error: r.error
-          }));
-        } else {
-          console.error(`btw failed: ${r.error || "unknown error"}`);
-        }
-        process.exitCode = 1;
-        return;
-      }
-      if (opts?.json) {
-        console.log(formatJson({
-          sessionId: r.sessionId,
-          mode: "btw",
-          message,
-          success: true,
-          response: r.response || ""
-        }));
-      } else if (r.response) {
-        console.log(r.response);
-      }
-      return;
-    }
-    if (r.status === "permission-pending") {
-      if (opts?.json) {
-        console.log(formatJson({
-          sessionId: r.sessionId,
-          message,
-          sent: true,
-          messageId: r.messageId,
-          status: "permission-pending",
-          pendingPermissions: r.pendingPermissions
-        }));
-      } else {
-        console.log(`Message sent to session ${r.sessionId.slice(0, 8)} (id: ${(r.messageId || "").slice(0, 8)})`);
-        console.log("Agent is waiting for permission approval:");
-        for (const p of r.pendingPermissions || []) {
-          const argsStr = JSON.stringify(p.arguments || {}).slice(0, 120);
-          console.log(`  [${p.id.slice(0, 8)}] ${p.tool}(${argsStr})`);
-        }
-        console.log(`
-Use: svamp session approve ${r.sessionId.slice(0, 8)}`);
-      }
-      process.exitCode = 2;
-      return;
-    }
-    if (opts?.json) {
-      console.log(formatJson({
-        sessionId: r.sessionId,
-        message,
-        sent: true,
-        messageId: r.messageId,
-        waited: r.waited,
-        status: r.status,
-        ...r.bypassEnsured ? { bypassEnsured: true } : {},
-        ...opts.response ? { response: r.response || "", responseSeqs: r.responseSeqs || [] } : {}
-      }));
-    } else {
-      console.log(`Message sent to session ${r.sessionId.slice(0, 8)} (id: ${(r.messageId || "").slice(0, 8)})`);
-      if (r.waited) {
-        console.log("Agent is idle.");
-      }
-      if (opts?.response) {
-        if (r.response) {
-          console.log("");
-          console.log(r.response);
-        } else {
-          console.log("(no text response captured)");
-        }
-      }
-    }
-  } finally {
-    await server.disconnect();
-  }
-}
-async function queryCore(machine, directory, prompt, opts) {
-  const absDir = resolve(directory);
-  const spawnOpts = {
-    directory: absDir,
-    agent: "claude",
-    permissionMode: opts?.permissionMode || "bypassPermissions",
-    tags: opts?.tag ? [opts.tag] : ["svamp-query"]
-  };
-  const spawn = await machine.spawnSession(spawnOpts);
-  if (spawn.type !== "success" || !spawn.sessionId) {
-    return {
-      sessionId: "",
-      mode: "query",
-      sent: false,
-      waited: false,
-      status: "error",
-      error: spawn.errorMessage || `spawn returned type=${spawn.type}`,
-      directory: absDir
-    };
-  }
-  const spawnedId = spawn.sessionId;
-  const svc = getSessionProxy(machine, spawnedId);
-  await svc.sendMessage(
-    JSON.stringify({
-      role: "user",
-      content: { type: "text", text: prompt },
-      meta: { sentFrom: "svamp-cli-query" }
-    })
-  );
-  const timeoutMs = (opts?.timeout || 300) * 1e3;
-  const waitResult = await waitForBusyThenIdle(machine, spawnedId, timeoutMs);
-  if (waitResult.pendingPermissions?.length) {
-    return {
-      sessionId: spawnedId,
-      mode: "query",
-      sent: true,
-      waited: true,
-      status: "permission-pending",
-      pendingPermissions: waitResult.pendingPermissions,
-      error: `Agent paused for tool approval (${waitResult.pendingPermissions.length} pending). Pass --permission-mode bypassPermissions or approve the request manually.`,
-      directory: absDir
-    };
-  }
-  const response = await collectAssistantResponse(machine, spawnedId, 0);
-  return {
-    sessionId: spawnedId,
-    mode: "query",
-    sent: true,
-    waited: true,
-    status: "idle",
-    response: response.text,
-    responseSeqs: response.messageSeqs,
-    directory: absDir
-  };
-}
-async function sessionQuery(directory, prompt, machineId, opts) {
-  const { server, machine } = await connectAndGetMachine(machineId);
-  let spawnedId;
-  try {
-    const r = await queryCore(machine, directory, prompt, opts);
-    spawnedId = r.sessionId || void 0;
-    if (r.status === "error") {
-      if (opts?.json) {
-        console.log(formatJson({
-          success: false,
-          error: r.error,
-          directory: r.directory
-        }));
-      } else {
-        console.error(`Failed to spawn query session: ${r.error}`);
-      }
-      process.exitCode = 1;
-      return;
-    }
-    if (r.status === "permission-pending") {
-      if (opts?.json) {
-        console.log(formatJson({
-          success: false,
-          sessionId: r.sessionId,
-          directory: r.directory,
-          error: r.error,
-          pendingPermissions: r.pendingPermissions
-        }));
-      } else {
-        console.error(r.error);
-      }
-      process.exitCode = 2;
-      return;
-    }
-    if (opts?.json) {
-      console.log(formatJson({
-        success: true,
-        sessionId: r.sessionId,
-        directory: r.directory,
-        prompt,
-        response: r.response || "",
-        responseSeqs: r.responseSeqs || []
-      }));
-    } else {
-      if (r.response) {
-        console.log(r.response);
-      } else {
-        console.log("(no text response captured)");
-      }
-    }
-  } finally {
-    if (spawnedId && !opts?.keep) {
-      try {
-        await machine.deleteSession(spawnedId);
-      } catch (err) {
-        console.error(`Warning: failed to delete query session ${spawnedId}: ${err?.message || err}`);
-      }
-    }
-    await server.disconnect();
-  }
-}
-async function sessionWait(sessionId, machineId, opts) {
-  const { server, machine, fullId } = await connectAndResolveSession(sessionId, machineId);
-  try {
-    const timeoutMs = (opts?.timeout || 300) * 1e3;
-    const result = await waitForIdle(machine, fullId, timeoutMs);
-    if (result.pendingPermissions?.length) {
-      if (opts?.json) {
-        console.log(formatJson({
-          sessionId: fullId,
-          status: "permission-pending",
-          pendingPermissions: result.pendingPermissions
-        }));
-      } else {
-        console.log(`Session ${fullId.slice(0, 8)} is waiting for permission approval:`);
-        for (const p of result.pendingPermissions) {
-          const argsStr = JSON.stringify(p.arguments || {}).slice(0, 120);
-          console.log(`  [${p.id.slice(0, 8)}] ${p.tool}(${argsStr})`);
-        }
-        console.log(`
-Use: svamp session approve ${fullId.slice(0, 8)}`);
-      }
-      process.exitCode = 2;
-    } else {
-      if (opts?.json) {
-        console.log(formatJson({ sessionId: fullId, status: "idle" }));
-      } else {
-        console.log(`Session ${fullId.slice(0, 8)} is idle.`);
-      }
-    }
-  } catch (err) {
-    const msg = err instanceof Error ? err.message : String(err);
-    console.error(msg);
-    process.exitCode = 1;
-  } finally {
-    await server.disconnect();
-  }
-}
-async function sessionShare(sessionIdPartial, machineId, opts) {
-  const { server, machine, fullId } = await connectAndResolveSession(sessionIdPartial, machineId);
-  try {
-    const svc = getSessionProxy(machine, fullId);
-    if (opts.list) {
-      const metaResult = await svc.getMetadata();
-      const sharing = metaResult.metadata?.sharing;
-      if (!sharing || !sharing.enabled) {
-        console.log("Sharing is not enabled for this session.");
-        return;
-      }
-      console.log(`Owner: ${sharing.owner}`);
-      if (sharing.publicAccess) {
-        console.log(`Public access: ${sharing.publicAccess} (anyone with the link)`);
-      }
-      if (sharing.allowedUsers.length === 0) {
-        console.log("No shared users.");
-      } else {
-        console.log("Shared users (each has full access):");
-        for (const u of sharing.allowedUsers) {
-          console.log(`  ${u.email.padEnd(30)} (added ${new Date(u.addedAt).toISOString().slice(0, 10)})`);
-        }
-      }
-      const secCtx = metaResult.metadata?.securityContext;
-      if (secCtx) {
-        console.log(`
-Security context:`);
-        console.log(JSON.stringify(secCtx, null, 2));
-      }
-      console.log(`
-Share link: ${buildSessionShareUrl({
-        sessionId: fullId,
-        workspace: server.config?.workspace,
-        machineServiceId: machine.id || `${server.config?.workspace}/${server.config?.client_id}:default`
-      })}`);
-      return;
-    }
-    if (opts.add) {
-      const { email } = parseShareArg(opts.add);
-      const metaResult = await svc.getMetadata();
-      let sharing = metaResult.metadata?.sharing || {
-        enabled: true,
-        owner: "",
-        allowedUsers: []
-      };
-      sharing.enabled = true;
-      sharing.allowedUsers = sharing.allowedUsers.filter(
-        (u) => u.email.toLowerCase() !== email.toLowerCase()
-      );
-      sharing.allowedUsers.push(normalizeAllowedUser({ email, addedBy: "cli" }, "cli"));
-      await svc.updateSharing(sharing);
-      const shareUrl = buildSessionShareUrl({
-        sessionId: fullId,
-        workspace: server.config?.workspace,
-        machineServiceId: machine.id || `${server.config?.workspace}/${server.config?.client_id}:default`
-      });
-      console.log(`Shared session ${fullId.slice(0, 8)} with ${email} (full access).`);
-      console.log(`Share link: ${shareUrl}`);
-      return;
-    }
-    if (opts.remove) {
-      const email = opts.remove;
-      const metaResult = await svc.getMetadata();
-      const sharing = metaResult.metadata?.sharing;
-      if (!sharing) {
-        console.error("Sharing is not enabled for this session.");
-        process.exit(1);
-      }
-      const before = sharing.allowedUsers.length;
-      sharing.allowedUsers = sharing.allowedUsers.filter(
-        (u) => u.email.toLowerCase() !== email.toLowerCase()
-      );
-      if (sharing.allowedUsers.length === before) {
-        console.error(`User ${email} is not in the shared users list.`);
-        process.exit(1);
-      }
-      await svc.updateSharing(sharing);
-      console.log(`Removed ${email} from session ${fullId.slice(0, 8)}.`);
-      return;
-    }
-    if (opts.public !== void 0) {
-      const value = opts.public.toLowerCase();
-      if (value === "off" || value === "none" || value === "no") {
-        const metaResult = await svc.getMetadata();
-        const sharing = metaResult.metadata?.sharing || {
-          enabled: true,
-          owner: "",
-          allowedUsers: []
-        };
-        sharing.publicAccess = null;
-        await svc.updateSharing(sharing);
-        console.log(`Public access disabled for session ${fullId.slice(0, 8)}.`);
-      } else if (value === "view" || value === "interact") {
-        const metaResult = await svc.getMetadata();
-        const sharing = metaResult.metadata?.sharing || {
-          enabled: true,
-          owner: "",
-          allowedUsers: []
-        };
-        sharing.enabled = true;
-        sharing.publicAccess = value;
-        await svc.updateSharing(sharing);
-        console.log(`Public access set to '${value}' for session ${fullId.slice(0, 8)}.`);
-      } else {
-        console.error("Invalid --public value. Use: view, interact, or off");
-        process.exit(1);
-      }
-      return;
-    }
-    console.error("Usage: svamp session share <id> --add <email>[:<role>] | --remove <email> | --list | --public <view|interact|off>");
-    process.exit(1);
-  } finally {
-    await server.disconnect();
-  }
-}
-async function machineShare(machineId, opts) {
-  const { server, machine } = await connectAndGetMachine(machineId);
-  try {
-    if (opts.list) {
-      const info = await machine.getMachineInfo();
-      const sharing = info.metadata?.sharing;
-      if (!sharing || !sharing.enabled) {
-        console.log("Sharing is not enabled for this machine.");
-      } else {
-        console.log(`Owner: ${sharing.owner}`);
-        if (sharing.allowedUsers.length === 0) {
-          console.log("No shared users.");
-        } else {
-          console.log("Shared users (each has full machine access):");
-          for (const u of sharing.allowedUsers) {
-            console.log(`  ${u.email.padEnd(30)} (added ${new Date(u.addedAt).toISOString().slice(0, 10)})`);
-          }
-        }
-        console.log(`
-Share link: ${buildMachineShareUrl({
-          machineId: info.machineId,
-          workspace: server.config?.workspace
-        })}`);
-      }
-      const iso = info.metadata?.isolationCapabilities;
-      if (iso) {
-        console.log(`
-Isolation: ${iso.available.length > 0 ? iso.available.join(", ") : "none available"} (preferred: ${iso.preferred || "none"})`);
-      }
-      return;
-    }
-    if (opts.showConfig) {
-      const result = await machine.getSecurityContextConfig();
-      const config = result?.securityContextConfig;
-      if (!config) {
-        console.log("No security context config set for this machine.");
-      } else {
-        console.log(JSON.stringify(config, null, 2));
-      }
-      return;
-    }
-    if (opts.configPath) {
-      const configPath = resolve(opts.configPath);
-      const config = loadSecurityContextConfig(configPath);
-      await machine.updateSecurityContextConfig(config);
-      const userCount = config.users ? Object.keys(config.users).length : 0;
-      console.log(`Security context config applied to machine.`);
-      console.log(`  Default context: ${config.default ? "yes" : "none"}`);
-      console.log(`  User-specific entries: ${userCount}`);
-      if (config.users) {
-        for (const email of Object.keys(config.users)) {
-          const ctx = config.users[email];
-          console.log(`    ${email}: role=${ctx.role || "default"}`);
-        }
-      }
-      return;
-    }
-    if (opts.add) {
-      const { email } = parseShareArg(opts.add);
-      const info = await machine.getMachineInfo();
-      let sharing = info.metadata?.sharing || {
-        enabled: true,
-        owner: "",
-        allowedUsers: []
-      };
-      sharing.enabled = true;
-      sharing.allowedUsers = sharing.allowedUsers.filter(
-        (u) => u.email.toLowerCase() !== email.toLowerCase()
-      );
-      sharing.allowedUsers.push(normalizeAllowedUser({ email, addedBy: "cli" }, "cli"));
-      await machine.updateSharing(sharing);
-      const shareUrl = buildMachineShareUrl({
-        machineId: info.machineId,
-        workspace: server.config?.workspace
-      });
-      console.log(`Shared machine with ${email} (full access).`);
-      console.log(`Share link: ${shareUrl}`);
-      return;
-    }
-    if (opts.remove) {
-      const email = opts.remove;
-      const info = await machine.getMachineInfo();
-      const sharing = info.metadata?.sharing;
-      if (!sharing) {
-        console.error("Sharing is not enabled for this machine.");
-        process.exit(1);
-      }
-      const before = sharing.allowedUsers.length;
-      sharing.allowedUsers = sharing.allowedUsers.filter(
-        (u) => u.email.toLowerCase() !== email.toLowerCase()
-      );
-      if (sharing.allowedUsers.length === before) {
-        console.error(`User ${email} is not in the shared users list.`);
-        process.exit(1);
-      }
-      await machine.updateSharing(sharing);
-      console.log(`Removed ${email} from machine sharing.`);
-      return;
-    }
-    console.error("Usage: svamp machine share --add <email>[:<role>] | --remove <email> | --list | --config <path> | --show-config");
-    process.exit(1);
-  } finally {
-    await server.disconnect();
-  }
-}
-async function machineExec(machineId, command, cwd) {
-  if (!command) {
-    console.error("Usage: svamp machine exec <command> [--cwd <path>]");
-    process.exit(1);
-  }
-  const { server, machine } = await connectAndGetMachine(machineId);
-  try {
-    const result = await machine.bash(command, cwd || void 0);
-    if (result.stdout) process.stdout.write(result.stdout);
-    if (result.stderr) process.stderr.write(result.stderr);
-    process.exit(result.exitCode);
-  } finally {
-    await server.disconnect();
-  }
-}
-async function wiseAskCli(machineId, message, sessionId, opts) {
-  if (!message) {
-    console.error('Usage: svamp wise ask "<message>" [--session <id>] [-m <machine>]');
-    process.exit(1);
-  }
-  const { server, machine } = await connectAndGetMachine(machineId);
-  try {
-    const res = await machine.wiseAsk({ message, sessionId });
-    if (opts?.json) {
-      console.log(JSON.stringify(res, null, 2));
-      process.exit(res?.success ? 0 : 1);
-    }
-    if (res?.error) {
-      console.error(`\u2717 ${res.error}`);
-      process.exit(1);
-    }
-    console.log(res?.reply || `(${res?.status || "no reply"})`);
-    process.exit(0);
-  } finally {
-    await server.disconnect();
-  }
-}
-async function wiseJoinMeetingCli(machineId, url, sessionId, opts) {
-  if (!url) {
-    console.error('Usage: svamp wise join-meeting <zoom|meet|teams url> [--session <id>|--global] [--mode listen|text|voice] [--mission "<prompt>"] [-m <machine>]');
-    process.exit(1);
-  }
-  const mode = opts?.mode ? String(opts.mode).toLowerCase() : void 0;
-  if (mode && !["listen", "text", "voice"].includes(mode)) {
-    console.error(`\u2717 invalid --mode "${mode}" (use listen | text | voice)`);
-    process.exit(1);
-  }
-  const { server, machine } = await connectAndGetMachine(machineId);
-  try {
-    const res = await machine.wiseJoinMeeting({ meetingUrl: url, sessionId, mode, mission: opts?.mission });
-    if (opts?.json) {
-      console.log(JSON.stringify(res, null, 2));
-      process.exit(res?.success ? 0 : 1);
-    }
-    if (res?.error) {
-      console.error(`\u2717 ${res.error}`);
-      process.exit(1);
-    }
-    console.log(`\u2713 WISE joining ${res.platform} meeting ${res.nativeId} (${res.target}, ${res.mode || "voice"} mode)${res.meetingId ? ` \u2014 meeting #${res.meetingId}` : ""}`);
-    process.exit(0);
-  } finally {
-    await server.disconnect();
-  }
-}
-async function wiseLeaveMeetingCli(machineId, sessionId, opts) {
-  const { server, machine } = await connectAndGetMachine(machineId);
-  try {
-    const res = await machine.wiseLeaveMeeting({ sessionId });
-    if (opts?.json) {
-      console.log(JSON.stringify(res, null, 2));
-      process.exit(res?.success ? 0 : 1);
-    }
-    if (res?.error) {
-      console.error(`\u2717 ${res.error}`);
-      process.exit(1);
-    }
-    console.log("\u2713 WISE left the meeting");
-    process.exit(0);
-  } finally {
-    await server.disconnect();
-  }
-}
-async function wiseAnnounceCli(machineId, text, sessionId, opts) {
-  if (!text) {
-    console.error('Usage: svamp wise announce "<text>" [--session <id>] [-m <machine>]');
-    process.exit(1);
-  }
-  const { server, machine } = await connectAndGetMachine(machineId);
-  try {
-    const res = await machine.wiseAnnounce({ text, sessionId });
-    if (opts?.json) {
-      console.log(JSON.stringify(res, null, 2));
-      process.exit(res?.success ? 0 : 1);
-    }
-    if (res?.error) {
-      console.error(`\u2717 ${res.error}`);
-      process.exit(1);
-    }
-    console.log("\u2713 Announced to the meeting");
-    process.exit(0);
-  } finally {
-    await server.disconnect();
-  }
-}
-async function wiseMeetingsCli(machineId, opts) {
-  const { server, machine } = await connectAndGetMachine(machineId);
-  try {
-    const res = await machine.wiseMeetingStatus({});
-    if (opts?.json) {
-      console.log(JSON.stringify(res, null, 2));
-      process.exit(0);
-    }
-    const ms = res?.meetings || [];
-    if (!ms.length) console.log("No active meeting agents.");
-    else for (const m of ms) console.log(`\u2022 ${m.platform} ${m.nativeId} \u2014 ${m.target}${m.meetingId ? ` (#${m.meetingId})` : ""}`);
-    process.exit(0);
-  } finally {
-    await server.disconnect();
-  }
-}
-async function machineInfo(machineId) {
-  const { server, machine } = await connectAndGetMachine(machineId);
-  try {
-    const info = await machine.getMachineInfo();
-    const meta = info.metadata || {};
-    const ds = info.daemonState || {};
-    console.log(`Machine: ${info.machineId}`);
-    if (meta.hostname) console.log(`Host:    ${meta.hostname}`);
-    if (meta.platform) console.log(`OS:      ${meta.platform} ${meta.arch || ""}`);
-    console.log(`Status:  ${ds.status || "unknown"}`);
-    const iso = meta.isolationCapabilities;
-    if (iso) {
-      console.log(`Isolation: ${iso.available?.length > 0 ? iso.available.join(", ") : "none"} (preferred: ${iso.preferred || "none"})`);
-    }
-    const sessions = await machine.listSessions();
-    console.log(`Sessions: ${Array.isArray(sessions) ? sessions.length : 0} active`);
-    const sharing = meta.sharing;
-    if (sharing?.enabled) {
-      console.log(`Sharing: enabled (owner: ${sharing.owner}, ${sharing.allowedUsers?.length || 0} users)`);
-    } else {
-      console.log(`Sharing: disabled`);
-    }
-  } finally {
-    await server.disconnect();
-  }
-}
-async function machineLs(machineId, path, showHidden) {
-  const { server, machine } = await connectAndGetMachine(machineId);
-  try {
-    const result = await machine.listDirectory(path || "", { showHidden: showHidden || false });
-    if (!result.success) {
-      console.error(`Error: ${result.error || "Failed to list directory"}`);
-      process.exit(1);
-    }
-    console.log(`${result.path}/`);
-    for (const entry of result.entries || []) {
-      const prefix = entry.type === "directory" ? "d " : "  ";
-      console.log(`${prefix}${entry.name}${entry.type === "directory" ? "/" : ""}`);
-    }
-  } finally {
-    await server.disconnect();
-  }
-}
-async function sessionLoopStart(sessionIdPartial, task, machineId, opts) {
-  const { server, machine, fullId } = await connectAndResolveSession(sessionIdPartial, machineId);
-  try {
-    const svc = getSessionProxy(machine, fullId);
-    const until = opts?.until || opts?.criteria;
-    const isStart = !!(task || until);
-    const maxIterations = opts?.maxIterations ?? (isStart ? 1e4 : void 0);
-    const evaluator = opts?.agent ? true : opts?.evaluator !== false;
-    const budget = opts?.maxTokensPerHour || opts?.maxRuntimeSec ? {
-      ...opts?.maxTokensPerHour ? { max_tokens_per_hour: opts.maxTokensPerHour } : {},
-      ...opts?.maxRuntimeSec ? { max_runtime_sec: opts.maxRuntimeSec } : {}
-    } : void 0;
-    await svc.updateConfig({
-      loop: {
-        ...task ? { task } : {},
-        ...until ? { until } : {},
-        ...opts?.oracle ? { oracle: opts.oracle } : {},
-        ...opts?.parent ? { parent: opts.parent } : {},
-        ...maxIterations != null ? { max_iterations: maxIterations } : {},
-        ...budget ? { budget } : {},
-        ...opts?.engine ? { engine: opts.engine } : {},
-        evaluator
-      }
-    });
-    if (!isStart) {
-      console.log(`\u{1F501} Loop limit updated on session ${fullId.slice(0, 8)}${maxIterations != null ? ` \u2192 max ${maxIterations} iterations` : ""} (resumes the loop if it had stopped).`);
-    } else {
-      console.log(`\u{1F501} Loop ${task ? "started" : "attached"} on session ${fullId.slice(0, 8)}`);
-      if (task) console.log(`  Task: ${task.slice(0, 100)}${task.length > 100 ? "..." : ""}`);
-      if (until) console.log(`  Until: ${until.slice(0, 100)}${until.length > 100 ? "..." : ""}`);
-      console.log(`  Oracle: ${opts?.oracle || "(none)"}`);
-      console.log(`  Evaluator: ${evaluator ? "on" : "off"}`);
-      if (opts?.parent) console.log(`  Parent review: ${opts.parent.slice(0, 8)}`);
-      if (maxIterations != null) console.log(`  Max iterations: ${maxIterations}`);
-      if (!task) console.log(`  (hot-plug \u2014 gating the session's current work)`);
-    }
-  } finally {
-    await server.disconnect();
-  }
-}
-async function sessionLoopCancel(sessionIdPartial, machineId) {
-  const { server, machine, fullId } = await connectAndResolveSession(sessionIdPartial, machineId);
-  try {
-    const svc = getSessionProxy(machine, fullId);
-    await svc.updateConfig({ loop: null });
-    console.log(`Loop cancelled on session ${fullId.slice(0, 8)}`);
-  } finally {
-    await server.disconnect();
-  }
-}
-async function sessionLoopStatus(sessionIdPartial, machineId) {
-  const { server, machine, fullId } = await connectAndResolveSession(sessionIdPartial, machineId);
-  try {
-    const svc = getSessionProxy(machine, fullId);
-    const readJsonFile = async (relPath) => {
-      try {
-        const raw = await svc.readFile(relPath);
-        const content = typeof raw === "string" ? raw : raw?.content;
-        if (content) return JSON.parse(Buffer.from(content, "base64").toString("utf-8"));
-      } catch {
-      }
-      return null;
-    };
-    const loopRel = `.svamp/${fullId}/loop`;
-    let base = loopRel;
-    let state = await readJsonFile(`${loopRel}/loop-state.json`);
-    if (!state) {
-      base = ".claude/loop";
-      state = await readJsonFile(`${base}/loop-state.json`);
-    }
-    if (!state) {
-      console.log("No loop configured on this session.");
-      return;
-    }
-    const config = await readJsonFile(`${base}/loop.config.json`);
-    const verdict = await readJsonFile(`${base}/evaluator-verdict.json`);
-    console.log(`Loop on session ${fullId.slice(0, 8)}:`);
-    const maxN = config?.max_iterations;
-    console.log(`  Phase: ${state.phase || (state.active === false ? "inactive" : "running")}`);
-    console.log(`  Iteration: ${state.iteration ?? 0}${maxN ? ` / ${maxN}` : ""}`);
-    if (config?.oracle?.command) console.log(`  Oracle: ${config.oracle.command}`);
-    if (state.last_oracle) console.log(`  Last oracle: ${String(state.last_oracle).split("\n")[0]}`);
-    if (config && config.evaluator?.enabled !== false) {
-      console.log(`  Evaluator: ${verdict ? `${verdict.verdict}${verdict.reason ? ` \u2014 ${verdict.reason}` : ""}` : "on (no verdict yet)"}`);
-    }
-    if (state.gave_up_reason) console.log(`  Gave up: ${state.gave_up_reason}`);
-    if (state.started_at) console.log(`  Started at: ${state.started_at}`);
-  } finally {
-    await server.disconnect();
-  }
-}
-async function sessionInboxSend(sessionIdPartial, body, machineId, opts) {
-  const { server, machine, fullId } = await connectAndResolveSession(sessionIdPartial, machineId);
-  try {
-    const callerSessionId = process.env.SVAMP_SESSION_ID;
-    const hop = computeOutboundHop(callerSessionId);
-    let urgency = opts?.urgency || "normal";
-    if (hop.fromInboxTurn) urgency = "normal";
-    const message = {
-      messageId: shortId(),
-      body,
-      timestamp: Date.now(),
-      read: false,
-      from: callerSessionId ? `agent:${callerSessionId}` : `cli:${os.userInfo().username}`,
-      ...callerSessionId ? { fromSession: callerSessionId } : {},
-      to: fullId,
-      subject: opts?.subject,
-      urgency,
-      hopCount: hop.hopCount,
-      replyTo: opts?.replyTo,
-      threadId: opts?.threadId || hop.threadId
-    };
-    const result = await machine.sessionRPC(fullId, "sendInboxMessage", { message });
-    if (callerSessionId) {
-      try {
-        registerAwaitingReply(callerSessionId, opts?.threadId || hop.threadId || message.messageId);
-      } catch {
-      }
-    }
-    if (opts?.json) {
-      console.log(formatJson({ sessionId: fullId, messageId: result.messageId, sent: true }));
-    } else {
-      console.log(`Inbox message sent to session ${fullId.slice(0, 8)} (id: ${result.messageId.slice(0, 8)})`);
-    }
-  } finally {
-    await server.disconnect();
-  }
-}
-async function sessionInboxList(sessionIdPartial, machineId, opts) {
-  const { server, machine, fullId } = await connectAndResolveSession(sessionIdPartial, machineId);
-  try {
-    const result = await machine.sessionRPC(fullId, "getInbox", { opts: { unread: opts?.unread, limit: opts?.limit } });
-    const messages = result.messages;
-    if (opts?.json) {
-      console.log(formatJson({ sessionId: fullId, messages }));
-      return;
-    }
-    if (messages.length === 0) {
-      console.log(`Inbox for session ${fullId.slice(0, 8)} is empty.`);
-      return;
-    }
-    const unreadCount = messages.filter((m) => !m.read).length;
-    console.log(`Inbox for session ${fullId.slice(0, 8)} (${messages.length} message(s), ${unreadCount} unread):
-`);
-    for (const msg of messages) {
-      const status = msg.read ? " " : "\u25CF";
-      const from = msg.from ? ` from ${msg.from}` : "";
-      const subject = msg.subject ? ` \u2014 ${msg.subject}` : "";
-      const urgencyTag = msg.urgency === "urgent" ? " [URGENT]" : "";
-      const date = new Date(msg.timestamp).toLocaleString();
-      const preview = msg.body.length > 100 ? msg.body.slice(0, 97) + "..." : msg.body;
-      console.log(`  ${status} ${msg.messageId.slice(0, 8)}${urgencyTag}${from}${subject}`);
-      console.log(`    ${date}`);
-      console.log(`    ${preview}
-`);
-    }
-  } finally {
-    await server.disconnect();
-  }
-}
-async function sessionInboxRead(sessionIdPartial, messageId, machineId) {
-  const { server, machine, fullId } = await connectAndResolveSession(sessionIdPartial, machineId);
-  try {
-    const result = await machine.sessionRPC(fullId, "getInbox", {});
-    const msg = result.messages.find((m) => m.messageId === messageId || m.messageId.startsWith(messageId));
-    if (!msg) {
-      console.error(`Message ${messageId} not found in inbox.`);
-      process.exit(1);
-    }
-    if (!msg.read) {
-      await machine.sessionRPC(fullId, "markInboxRead", { messageId: msg.messageId });
-    }
-    console.log(`From: ${msg.from || "(unknown)"}`);
-    if (msg.subject) console.log(`Subject: ${msg.subject}`);
-    console.log(`Date: ${new Date(msg.timestamp).toLocaleString()}`);
-    if (msg.urgency === "urgent") console.log("Urgency: URGENT");
-    if (msg.replyTo) console.log(`Reply-To: ${msg.replyTo.slice(0, 8)}`);
-    if (msg.threadId) console.log(`Thread: ${msg.threadId.slice(0, 8)}`);
-    console.log(`
-${msg.body}`);
-  } finally {
-    await server.disconnect();
-  }
-}
-async function sessionInboxReply(sessionIdPartial, messageId, body, machineId) {
-  const { server, machine, fullId } = await connectAndResolveSession(sessionIdPartial, machineId);
-  try {
-    const result = await machine.sessionRPC(fullId, "getInbox", {});
-    const original = result.messages.find((m) => m.messageId === messageId || m.messageId.startsWith(messageId));
-    if (!original) {
-      console.error(`Message ${messageId} not found in inbox.`);
-      process.exit(1);
-    }
-    let channelDelivered = false;
-    if (original.channelId && original.correlationId) {
-      const rr = await machine.sessionRPC(fullId, "channelReply", { params: { channel: original.channelId, correlationId: original.correlationId, to: original.from, body } });
-      if (rr?.error) {
-        if (!original.fromSession) {
-          console.error(`Channel reply failed: ${rr.error}`);
-          process.exit(1);
-        }
-      } else {
-        channelDelivered = true;
-        console.log(`Reply queued to "${original.from}" on channel ${original.channelId} (correlation ${original.correlationId}).`);
-      }
-    }
-    if (original.fromSession) {
-      try {
-        const hop = computeOutboundHop(process.env.SVAMP_SESSION_ID || fullId);
-        const reply = {
-          messageId: shortId(),
-          body,
-          timestamp: Date.now(),
-          read: false,
-          from: process.env.SVAMP_SESSION_HANDLE || `session:${fullId}`,
-          fromSession: fullId,
-          to: original.fromSession,
-          subject: original.subject ? `Re: ${original.subject}` : void 0,
-          urgency: "normal",
-          hopCount: hop.hopCount,
-          replyTo: original.messageId,
-          threadId: original.threadId || original.messageId
-        };
-        const sendResult = await machine.sessionRPC(original.fromSession, "sendInboxMessage", { message: reply });
-        console.log(`Reply sent to session ${original.fromSession.slice(0, 8)} (id: ${sendResult.messageId.slice(0, 8)})`);
-      } catch (err) {
-        if (!channelDelivered) {
-          console.error(`Reply failed: ${err?.message || err}`);
-          process.exit(1);
-        }
-      }
-      return;
-    }
-    if (!channelDelivered) {
-      console.error("Cannot reply: original message has no fromSession (and not a channel message).");
-      process.exit(1);
-    }
-  } finally {
-    await server.disconnect();
-  }
-}
-async function sessionInboxClear(sessionIdPartial, machineId, opts) {
-  const { server, machine, fullId } = await connectAndResolveSession(sessionIdPartial, machineId);
-  try {
-    const result = await machine.sessionRPC(fullId, "clearInbox", { opts: { all: opts?.all, messageId: opts?.messageId } });
-    const what = opts?.messageId ? `message ${opts.messageId}` : opts?.all ? "all messages" : "read messages";
-    console.log(`Cleared ${what} on session ${fullId.slice(0, 8)} (removed ${result.removed ?? "?"}, ${result.remaining} remaining)`);
-  } finally {
-    await server.disconnect();
-  }
-}
-
-export { collectAssistantResponse, connectAndGetMachine, connectAndResolveSession, createWorktree, generateWorktreeName, isSelfBtw, machineExec, machineInfo, machineLs, machineShare, parseShareArg, queryCore, renderMessage, resolveSessionId, sendCore, sessionApprove, sessionArchive, sessionAttach, sessionDelete, sessionDeny, sessionEditMessage, sessionInboxClear, sessionInboxList, sessionInboxRead, sessionInboxReply, sessionInboxSend, sessionInfo, sessionList, sessionLoopCancel, sessionLoopStart, sessionLoopStatus, sessionMachines, sessionMessages, sessionQuery, sessionRefineLastReply, sessionResume, sessionSend, sessionShare, sessionSpawn, sessionUndoEdit, sessionWait, sessionWhoami, snapshotLatestSeq, validateSendOptions, wiseAnnounceCli, wiseAskCli, wiseJoinMeetingCli, wiseLeaveMeetingCli, wiseMeetingsCli };