svamp-cli 0.2.299 → 0.2.301

package/dist/{run-C_5djiX4.mjs → run-C0GhrtVf.mjs}

@@ -2973,7 +2973,7 @@ Connection: close\r
     const mount = this.mounts.get(mountName);
     const subdomainOverride = mount?.access === "link" && mount.linkToken ? /* @__PURE__ */ new Map([[this.port, buildLinkSubdomain(subdomainSafe, mount.linkToken)]]) : void 0;
     try {
-      const { FrpcTunnel } = await import('./frpc-BqfCBMke.mjs');
+      const { FrpcTunnel } = await import('./frpc-Cb6jUvED.mjs');
       let tunnel;
       tunnel = new FrpcTunnel({
         name: tunnelName,
@@ -4343,6 +4343,9 @@ const MAX_BODY = 16 * 1024;
 function xmlEscape(s) {
   return String(s ?? "").replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&#39;");
 }
+function xmlEscapeContent(s) {
+  return String(s ?? "").replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+}
 const stripControl = (s) => String(s ?? "").replace(/[\x00-\x1f\x7f]/g, " ");
 function neutralizeForgedEnvelope(text) {
   const s = String(text ?? "");
@@ -4350,7 +4353,7 @@ function neutralizeForgedEnvelope(text) {
 }
 function renderMessage(channel, { sender = {}, body = {}, query = {}, callId, now }) {
   const obj = (v) => typeof v === "object" && v !== null ? JSON.stringify(v) : v;
-  const escVal = (v) => xmlEscape(obj(v));
+  const escVal = (v) => xmlEscapeContent(obj(v));
   const escAttr = (v) => xmlEscape(stripControl(obj(v)));
   const bodyEsc = {};
   for (const [k, v] of Object.entries(body)) bodyEsc[k] = k === "message" ? escVal(String(v ?? "").slice(0, MAX_BODY)) : escAttr(v);
@@ -4636,11 +4639,6 @@ class ChannelOutbox {
   }
 }
 
-var outbox = /*#__PURE__*/Object.freeze({
-    __proto__: null,
-    ChannelOutbox: ChannelOutbox
-});
-
 function getParamNames(fn) {
   const src = fn.toString();
   const match = src.match(/^(?:async\s+)?(?:function\s*\w*)?\s*\(([^)]*)\)/);
@@ -5869,7 +5867,7 @@ async function registerMachineService(server, machineId, metadata, daemonState,
         const tunnels = handlers.tunnels;
         if (!tunnels) throw new Error("Tunnel management not available");
         if (tunnels.has(params.name)) throw new Error(`Tunnel '${params.name}' already running`);
-        const { FrpcTunnel } = await import('./frpc-BqfCBMke.mjs');
+        const { FrpcTunnel } = await import('./frpc-Cb6jUvED.mjs');
         const tunnel = new FrpcTunnel({
           name: params.name,
           ports: params.ports,
@@ -6345,7 +6343,7 @@ QUESTION: ${params.question || "Summarize this concisely."}` }
           }
           const deps = buildSessionDeps(rpc, { cwd, ownerEmail: owner });
           const sender = { name: context?.user?.email || context?.user?.id || "user", kind: "user", verified: true };
-          const { toolsForRole } = await import('./sideband-BVmN7F-h.mjs');
+          const { toolsForRole } = await import('./sideband-BlZBmbji.mjs');
           const r2 = await runWiseAgent({ message: params.message, sender, config: { tools: toolsForRole(role2) }, deps, transport, model: resolved.model });
           return fmt(r2);
         }
@@ -6450,7 +6448,7 @@ QUESTION: ${params.question || "Summarize this concisely."}` }
       return { ok: false, call_id: callId, status: "busy", error: "channel is busy (too many concurrent requests) \u2014 retry shortly" };
     }
     const rendered = renderMessage(c, { sender: r.sender, body: { message: kwargs.message }, callId });
-    const { queryCore } = await import('./commands-C60tZyej.mjs');
+    const { queryCore } = await import('./commands-BAlaK67Y.mjs');
     const timeout = c.reply?.timeout_sec || 120;
     let result;
     try {
@@ -6602,6 +6600,44 @@ ${d?.error || "not found"}`;
     { overwrite: true }
   );
   console.log(`[HYPHA MACHINE] Channels service registered: ${channelsServiceInfo.id} (type svamp-channels)`);
+  const OUTPOST_MISSING_SESSION = 'missing "session" \u2014 the outpost gateway routes by session id. Over HTTP wrap args: POST {"kwargs": {"session": "<id>", "token": "<token>", "machine": "<name>"}}.';
+  const routeOutpost = (session) => {
+    const sid = String(session || "").trim();
+    if (!sid) return { error: OUTPOST_MISSING_SESSION };
+    const rpc = handlers.getSessionRPCHandlers?.(sid);
+    if (!rpc?.outpostHello) return { error: `session ${sid.slice(0, 12)} is not connected on this machine` };
+    return { rpc };
+  };
+  const outpostServiceInfo = await server.registerService(
+    {
+      id: "outpost",
+      name: `Svamp Outpost (${currentMetadata.displayName || machineId})`,
+      type: "svamp-outpost",
+      // Public so a remote machine (possibly anonymous) can dial in; token-authed per call,
+      // so no Hypha identity/context is needed (the handlers ignore context entirely).
+      config: { visibility: "public", require_context: false },
+      hello: async (kwargs = {}) => {
+        trackInbound();
+        const r = routeOutpost(kwargs?.session);
+        if ("error" in r) return { error: r.error };
+        return r.rpc.outpostHello(kwargs);
+      },
+      poll: async (kwargs = {}) => {
+        trackInbound();
+        const r = routeOutpost(kwargs?.session);
+        if ("error" in r) return { error: r.error };
+        return r.rpc.outpostPoll(kwargs);
+      },
+      result: async (kwargs = {}) => {
+        trackInbound();
+        const r = routeOutpost(kwargs?.session);
+        if ("error" in r) return { error: r.error };
+        return r.rpc.outpostResult(kwargs);
+      }
+    },
+    { overwrite: true }
+  );
+  console.log(`[HYPHA MACHINE] Outpost service registered: ${outpostServiceInfo.id} (type svamp-outpost)`);
   return {
     serviceInfo,
     notifySessionEvent: notifyListeners,
@@ -6636,6 +6672,8 @@ ${d?.error || "not found"}`;
       await server.unregisterService(serviceInfo.id);
       await server.unregisterService(channelsServiceInfo.id).catch(() => {
       });
+      await server.unregisterService(outpostServiceInfo.id).catch(() => {
+      });
     }
   };
 }
@@ -6917,6 +6955,52 @@ function nextBackoffMs(prevMs) {
   if (!prevMs || prevMs <= 0) return RL_BACKOFF_MIN_MS;
   return Math.min(prevMs * 2, RL_BACKOFF_MAX_MS);
 }
+function retryDecision(listenerPresent, now, backoffUntil) {
+  if (!listenerPresent) return "drop";
+  if (backoffUntil !== void 0 && now < backoffUntil) return "reschedule";
+  return "deliver";
+}
+function retryDelayMs(now, backoffUntil) {
+  if (backoffUntil === void 0) return 0;
+  return Math.max(0, backoffUntil - now);
+}
+
+function tokenPath(projectDir, session) {
+  return join$1(projectDir, ".svamp", session, "outpost.json");
+}
+function genToken() {
+  return randomBytes(24).toString("base64").replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/, "");
+}
+function loadOutpostToken(projectDir, session) {
+  const file = tokenPath(projectDir, session);
+  if (!existsSync(file)) return null;
+  try {
+    const parsed = JSON.parse(readFileSync(file, "utf-8"));
+    if (!parsed || typeof parsed.token !== "string" || !parsed.token) return null;
+    return parsed;
+  } catch {
+    return null;
+  }
+}
+function ensureOutpostToken(projectDir, session) {
+  const existing = loadOutpostToken(projectDir, session);
+  if (existing) return existing;
+  const rec = { version: 1, session, token: genToken(), createdAt: Date.now() };
+  const file = tokenPath(projectDir, session);
+  mkdirSync$1(dirname(file), { recursive: true });
+  writeFileSync$1(file, JSON.stringify(rec, null, 2) + "\n", { encoding: "utf-8", mode: 384 });
+  try {
+    chmodSync(file, 384);
+  } catch {
+  }
+  return rec;
+}
+function outpostTokenMatches(rec, presented) {
+  if (!rec || typeof presented !== "string" || presented.length !== rec.token.length) return false;
+  let diff = 0;
+  for (let i = 0; i < rec.token.length; i++) diff |= rec.token.charCodeAt(i) ^ presented.charCodeAt(i);
+  return diff === 0;
+}
 
 const DEFAULT_DOWNLOAD_BASE = "https://github.com/amun-ai/hypha-cloud/releases/latest/download";
 function shq(v) {
@@ -6928,10 +7012,10 @@ function psq(v) {
 function buildOutpostInstall(params) {
   const base = params.serverBase.replace(/\/$/, "");
   const dl = (params.downloadBase || DEFAULT_DOWNLOAD_BASE).replace(/\/$/, "");
-  const session = params.session || params.channel;
-  const unix = `curl -fsSL ${shq(`${dl}/install.sh`)} | SVAMP_OUTPOST_SERVER=${shq(base)} SVAMP_OUTPOST_CHANNEL=${shq(params.channel)} SVAMP_OUTPOST_TOKEN=${shq(params.token)} SVAMP_OUTPOST_SESSION=${shq(session)} SVAMP_OUTPOST_DL=${shq(dl)} sh`;
-  const windows = `$env:SVAMP_OUTPOST_SERVER=${psq(base)}; $env:SVAMP_OUTPOST_CHANNEL=${psq(params.channel)}; $env:SVAMP_OUTPOST_TOKEN=${psq(params.token)}; $env:SVAMP_OUTPOST_SESSION=${psq(session)}; $env:SVAMP_OUTPOST_DL=${psq(dl)}; irm ${psq(`${dl}/install.ps1`)} | iex`;
-  const direct = `svamp-outpost --server ${shq(base)} --channel ${shq(params.channel)} --token ${shq(params.token)} --session ${shq(session)}`;
+  const session = params.session;
+  const unix = `curl -fsSL ${shq(`${dl}/install.sh`)} | SVAMP_OUTPOST_SERVER=${shq(base)} SVAMP_OUTPOST_TOKEN=${shq(params.token)} SVAMP_OUTPOST_SESSION=${shq(session)} SVAMP_OUTPOST_DL=${shq(dl)} sh`;
+  const windows = `$env:SVAMP_OUTPOST_SERVER=${psq(base)}; $env:SVAMP_OUTPOST_TOKEN=${psq(params.token)}; $env:SVAMP_OUTPOST_SESSION=${psq(session)}; $env:SVAMP_OUTPOST_DL=${psq(dl)}; irm ${psq(`${dl}/install.ps1`)} | iex`;
+  const direct = `svamp-outpost --server ${shq(base)} --token ${shq(params.token)} --session ${shq(session)}`;
   return { unix, windows, direct };
 }
 
@@ -6943,37 +7027,19 @@ const OUTPOST_BINARIES = [
   { label: "Linux (arm64)", file: "svamp-outpost-linux-arm64" },
   { label: "Windows (x86-64)", file: "svamp-outpost-windows-amd64.exe" }
 ];
-function setupOutpostChannel(params) {
+function setupOutpost(params) {
   const serverUrl = params.serverUrl || "https://hypha.aicell.io";
   const downloadBase = (params.downloadBase || DEFAULT_OUTPOST_DOWNLOAD_BASE).replace(/\/$/, "");
-  const serverBase = gatewayBase(params.channelsServiceId, serverUrl);
-  const channelId = `outpost-${params.session}`;
-  const store = new ChannelStore(params.projectDir);
-  const existing = store.get(channelId);
-  let token = existing?.identity?.callers?.find((c) => c.name === "outpost")?.key;
-  if (!token) token = genKey();
-  const channel = {
-    id: channelId,
-    name: `Remote outpost \u2014 ${params.session}`,
-    description: "FDE remote machine: a svamp-outpost binary connects here and the agent runs commands on it.",
-    enabled: true,
-    bind: { session: params.session },
-    identity: { mode: "per-key", callers: [{ name: "outpost", kind: "agent", key: token }] },
-    action: { kind: "message" },
-    reply: { mode: "queue" },
-    skill: { name: "remote-outpost", description: "Run commands on the connected remote machine." }
-  };
-  store.save(channel);
-  const install = buildOutpostInstall({ serverBase, channel: channelId, token, session: params.session, downloadBase });
-  const connectedCount = (store.get(channelId)?.last_calls || []).filter((c) => c.sender === "outpost").length;
+  const serverBase = gatewayBase(params.outpostServiceId, serverUrl);
+  const { token } = ensureOutpostToken(params.projectDir, params.session);
+  const install = buildOutpostInstall({ serverBase, session: params.session, token, downloadBase });
   return {
-    channelId,
     token,
     serverBase,
     downloadBase,
     install,
     binaries: OUTPOST_BINARIES.map((b) => ({ label: b.label, url: `${downloadBase}/${b.file}` })),
-    connectedCount
+    connectedCount: params.connectedCount || 0
   };
 }
 
@@ -7058,7 +7124,6 @@ async function mintPairingCode(opts) {
   const expiresAt = now + ttlMs;
   const pairJson = JSON.stringify({
     server: payload.server,
-    channel: payload.channel,
     token: payload.token,
     session: payload.session,
     expiresAt
@@ -7095,6 +7160,157 @@ async function mintPairingCode(opts) {
   return { code, resolver, expiresAt };
 }
 
+const OUTPOST_STALE_MS = 9e4;
+const OUTPOST_EXEC_TIMEOUT_MS = 10 * 6e4;
+class OutpostCoordinator {
+  conns = /* @__PURE__ */ new Map();
+  queue = /* @__PURE__ */ new Map();
+  pending = /* @__PURE__ */ new Map();
+  seq = 0;
+  now;
+  setTimer;
+  clearTimer;
+  execTimeoutMs;
+  staleMs;
+  constructor(opts = {}) {
+    this.now = opts.now || (() => Date.now());
+    this.setTimer = opts.setTimer || ((fn, ms) => setTimeout(fn, ms));
+    this.clearTimer = opts.clearTimer || ((t) => clearTimeout(t));
+    this.execTimeoutMs = opts.execTimeoutMs ?? OUTPOST_EXEC_TIMEOUT_MS;
+    this.staleMs = opts.staleMs ?? OUTPOST_STALE_MS;
+  }
+  isStale(c, at) {
+    return at - c.lastSeen > this.staleMs;
+  }
+  /** Drop dead connections; fail any in-flight execs bound to them so callers never hang. */
+  prune(at = this.now()) {
+    for (const [machine, c] of [...this.conns]) {
+      if (this.isStale(c, at)) {
+        this.conns.delete(machine);
+        this.queue.delete(machine);
+        this.failMachine(machine, "the remote outpost disconnected");
+      }
+    }
+  }
+  /** Reject every pending exec on a machine with a synthetic disconnect result (exitCode -1). */
+  failMachine(machine, reason) {
+    for (const [id, p] of [...this.pending]) {
+      if (p.machine !== machine) continue;
+      this.clearTimer(p.timer);
+      this.pending.delete(id);
+      p.resolve({ id, stdout: "", stderr: reason, exitCode: -1, synthetic: true, ts: this.now() });
+    }
+  }
+  /**
+   * A remote said hello (first connect OR reconnect after an outage). Upserts the connection and
+   * returns `isNew` = true when it should trigger the ONE-TIME inbox announce — true on the first
+   * appearance and on a reconnect after the connection had gone stale/pruned.
+   */
+  registerConnection(machine, meta = {}) {
+    const at = this.now();
+    this.prune(at);
+    const existing = this.conns.get(machine);
+    const isNew = !existing;
+    const connection = {
+      machine,
+      label: meta.label ?? existing?.label,
+      os: meta.os ?? existing?.os,
+      arch: meta.arch ?? existing?.arch,
+      version: meta.version ?? existing?.version,
+      connectedAt: existing?.connectedAt ?? at,
+      lastSeen: at
+    };
+    this.conns.set(machine, connection);
+    return { isNew, connection };
+  }
+  /** Refresh liveness for an active poll (keeps the connection "always on"). */
+  touch(machine) {
+    const c = this.conns.get(machine);
+    if (!c) return false;
+    c.lastSeen = this.now();
+    return true;
+  }
+  /** Live connections only (prunes first). */
+  listConnections() {
+    this.prune();
+    return [...this.conns.values()].sort((a, b) => a.connectedAt - b.connectedAt);
+  }
+  isConnected(machine) {
+    this.prune();
+    return this.conns.has(machine);
+  }
+  /**
+   * Pick the machine an exec should target: an explicit live target, or the sole live outpost.
+   * Ambiguity (0 or >1 without a target) is a clear error, never a silent guess.
+   */
+  resolveTarget(target) {
+    const live = this.listConnections();
+    if (target) {
+      const hit = live.find((c) => c.machine === target || c.label === target);
+      if (!hit) return { error: `no connected outpost named "${target}" (connected: ${live.map((c) => c.machine).join(", ") || "none"})` };
+      return { machine: hit.machine };
+    }
+    if (live.length === 0) return { error: "no remote outpost is connected \u2014 run the install one-liner on the remote machine first" };
+    if (live.length > 1) return { error: `multiple outposts connected (${live.map((c) => c.machine).join(", ")}) \u2014 pass a target` };
+    return { machine: live[0].machine };
+  }
+  /**
+   * Enqueue a command for a machine and return a promise that resolves with the REAL result once
+   * the outpost posts it back (or a synthetic exitCode -1 on disconnect/timeout). Fails fast if the
+   * machine is not connected.
+   */
+  enqueueExec(machine, cmd, cwd) {
+    const id = `x${(++this.seq).toString(36)}_${this.now().toString(36)}`;
+    if (!this.isConnected(machine)) {
+      return {
+        id,
+        promise: Promise.resolve({ id, stdout: "", stderr: `outpost "${machine}" is not connected`, exitCode: -1, synthetic: true, ts: this.now() })
+      };
+    }
+    const command = { id, cmd, cwd, ts: this.now() };
+    const q = this.queue.get(machine) || [];
+    q.push(command);
+    this.queue.set(machine, q);
+    const promise = new Promise((resolve) => {
+      const timer = this.setTimer(() => {
+        if (!this.pending.has(id)) return;
+        this.pending.delete(id);
+        resolve({ id, stdout: "", stderr: `command timed out after ${Math.round(this.execTimeoutMs / 1e3)}s`, exitCode: -1, synthetic: true, ts: this.now() });
+      }, this.execTimeoutMs);
+      this.pending.set(id, { machine, resolve, timer, enqueuedAt: this.now() });
+    });
+    return { id, promise };
+  }
+  /** Long-poll drain: return (and clear) the commands queued for a machine; refreshes liveness. */
+  pollCommands(machine) {
+    this.touch(machine);
+    const q = this.queue.get(machine);
+    if (!q || q.length === 0) return [];
+    this.queue.set(machine, []);
+    return q;
+  }
+  /** Deliver a result from the outpost to the waiting exec. Returns false if unknown/expired. */
+  resolveResult(result) {
+    const p = this.pending.get(result.id);
+    if (!p) return false;
+    this.clearTimer(p.timer);
+    this.pending.delete(result.id);
+    this.touch(p.machine);
+    p.resolve({
+      id: result.id,
+      stdout: result.stdout ?? "",
+      stderr: result.stderr ?? "",
+      exitCode: typeof result.exitCode === "number" ? result.exitCode : 0,
+      ts: this.now()
+    });
+    return true;
+  }
+  /** Test/introspection: how many execs are awaiting a result. */
+  pendingCount() {
+    return this.pending.size;
+  }
+}
+
 const PARTICIPANTS_CHANNEL_ID = "sys-participants";
 function channelPublicView(c) {
   const u = c.upload;
@@ -7375,11 +7591,17 @@ function createSessionStore(server, sessionId, initialMetadata, initialAgentStat
   };
   const listeners = [];
   const rateLimitBackoff = /* @__PURE__ */ new Map();
+  const rateLimitRetry = /* @__PURE__ */ new Map();
   const removeListener = (listener, reason) => {
     const idx = listeners.indexOf(listener);
     if (idx >= 0) {
       listeners.splice(idx, 1);
       rateLimitBackoff.delete(listener);
+      const t = rateLimitRetry.get(listener);
+      if (t) {
+        clearTimeout(t);
+        rateLimitRetry.delete(listener);
+      }
       console.log(`[HYPHA SESSION ${sessionId}] Listener removed (${reason}), remaining: ${listeners.length}`);
       const rintfId = listener._rintf_service_id;
       if (rintfId) {
@@ -7388,6 +7610,50 @@ function createSessionStore(server, sessionId, initialMetadata, initialAgentStat
       }
     }
   };
+  const handleListenerRejection = (listener, err) => {
+    const msg = String(err?.message || err || "");
+    const kind = classifyListenerError(msg);
+    if (kind === "rate-limit") {
+      const ms = nextBackoffMs(rateLimitBackoff.get(listener)?.ms);
+      rateLimitBackoff.set(listener, { until: Date.now() + ms, ms });
+      console.warn(`[HYPHA SESSION ${sessionId}] 429 rate-limited; backing off ${ms}ms (listener kept)`);
+      scheduleBackoffRetry(listener);
+    } else if (kind === "stale") {
+      removeListener(listener, "stale connection");
+    } else {
+      console.error(`[HYPHA SESSION ${sessionId}] Async listener error:`, err);
+      removeListener(listener, "async error");
+    }
+  };
+  const scheduleBackoffRetry = (listener) => {
+    if (rateLimitRetry.has(listener)) return;
+    const bo = rateLimitBackoff.get(listener);
+    const delay = retryDelayMs(Date.now(), bo?.until);
+    const timer = setTimeout(() => {
+      rateLimitRetry.delete(listener);
+      const decision = retryDecision(listeners.indexOf(listener) >= 0, Date.now(), rateLimitBackoff.get(listener)?.until);
+      if (decision === "drop") return;
+      if (decision === "reschedule") {
+        scheduleBackoffRetry(listener);
+        return;
+      }
+      void (async () => {
+        const tail = messages.slice(-50);
+        for (const m of tail) {
+          if (listeners.indexOf(listener) < 0) return;
+          try {
+            const r = listener.onUpdate({ type: "new-message", sessionId, message: m });
+            if (r && typeof r.catch === "function") await r;
+          } catch (err) {
+            handleListenerRejection(listener, err);
+            return;
+          }
+        }
+        rateLimitBackoff.delete(listener);
+      })();
+    }, delay);
+    rateLimitRetry.set(listener, timer);
+  };
   const notifyListeners = (update) => {
     options?.onSessionEvent?.(update);
     const now = Date.now();
@@ -7395,26 +7661,16 @@ function createSessionStore(server, sessionId, initialMetadata, initialAgentStat
     for (let i = snapshot.length - 1; i >= 0; i--) {
       const listener = snapshot[i];
       const bo = rateLimitBackoff.get(listener);
-      if (bo && now < bo.until) continue;
+      if (bo && now < bo.until) {
+        scheduleBackoffRetry(listener);
+        continue;
+      }
       try {
         const result = listener.onUpdate(update);
         if (result && typeof result.catch === "function") {
           result.then(() => {
             rateLimitBackoff.delete(listener);
-          }).catch((err) => {
-            const msg = String(err?.message || err || "");
-            const kind = classifyListenerError(msg);
-            if (kind === "rate-limit") {
-              const ms = nextBackoffMs(rateLimitBackoff.get(listener)?.ms);
-              rateLimitBackoff.set(listener, { until: Date.now() + ms, ms });
-              console.warn(`[HYPHA SESSION ${sessionId}] 429 rate-limited; backing off ${ms}ms (listener kept)`);
-            } else if (kind === "stale") {
-              removeListener(listener, "stale connection");
-            } else {
-              console.error(`[HYPHA SESSION ${sessionId}] Async listener error:`, err);
-              removeListener(listener, "async error");
-            }
-          });
+          }).catch((err) => handleListenerRejection(listener, err));
         }
       } catch (err) {
         console.error(`[HYPHA SESSION ${sessionId}] Listener error:`, err);
@@ -7461,8 +7717,28 @@ function createSessionStore(server, sessionId, initialMetadata, initialAgentStat
   const channelStore = new ChannelStore(initialMetadata.path);
   const meetingActivity = [];
   const channelOutbox = new ChannelOutbox(initialMetadata.path);
+  const outpostCoordinator = new OutpostCoordinator();
+  const outpostProjectDir = () => metadata.path || process.cwd();
+  const announceOutpost = (conn) => {
+    const who = conn.label || conn.machine;
+    const plat = [conn.os, conn.arch].filter(Boolean).join("/") || "unknown platform";
+    const msg = {
+      messageId: "op_" + Math.random().toString(16).slice(2, 10),
+      body: `A remote machine connected as an outpost: ${xmlEscape(who)} (${xmlEscape(plat)}). You can now run shell commands on it \u2014 its output returns synchronously, like a local command. Run one with: svamp outpost exec "uname -a"`,
+      timestamp: Date.now(),
+      read: false,
+      from: "outpost",
+      subject: `Remote outpost connected: ${who}`
+    };
+    inbox.push(msg);
+    while (inbox.length > INBOX_MAX) inbox.shift();
+    syncInboxToMetadata();
+    callbacks.onInboxMessage?.(msg);
+    notifyListeners({ type: "inbox-update", sessionId, message: msg });
+  };
   const cfg = server?.config || {};
   const channelsServiceId = cfg.workspace && cfg.client_id ? `${cfg.workspace}/${cfg.client_id}:channels` : void 0;
+  const outpostServiceId = cfg.workspace && cfg.client_id ? `${cfg.workspace}/${cfg.client_id}:outpost` : void 0;
   const channelsBaseUrl = cfg.public_base_url || process.env.HYPHA_SERVER_URL || "https://hypha.aicell.io";
   const skillCtxFor = (c) => ({
     channelsServiceId,
@@ -7846,34 +8122,36 @@ function createSessionStore(server, sessionId, initialMetadata, initialAgentStat
       syncChannelsToMetadata();
       return { success: !!caller, caller };
     },
-    // FDE outpost (#0589): provision (idempotently) this session's outpost channel and return the
-    // install one-liners + direct binary download links + a best-effort connected count. The app's
-    // "Connect a remote machine" panel calls this; it reuses the SAME setupOutpostChannel core as
-    // `svamp outpost up`, so the channel shape + install command never drift. Admin-gated: the
-    // returned token is a capability to run commands on whatever machine connects.
+    // FDE outpost (#0565 redesign): provision (idempotently) this session's durable outpost TOKEN
+    // and return the install one-liners + direct binary download links + a LIVE connected count.
+    // The app's "Connect a remote machine" panel calls this; it reuses the SAME setupOutpost core as
+    // `svamp outpost up`, so the install command never drifts. NO channel is created — the remote
+    // dials the machine's public `:outpost` gateway and this session's token authenticates it.
+    // Admin-gated: the returned token is a capability to run commands on whatever machine connects.
     outpostConnectInfo: async (params, context) => {
       authorizeRequest(context, metadata.sharing, "admin");
-      if (!channelsServiceId) return { error: "the channels service is not available on this machine" };
+      if (!outpostServiceId) return { error: "the outpost service is not available on this machine" };
       try {
-        const info = setupOutpostChannel({
+        const connectedCount = outpostCoordinator.listConnections().length;
+        const info = setupOutpost({
           session: sessionId,
-          projectDir: metadata.path || process.cwd(),
-          channelsServiceId,
+          projectDir: outpostProjectDir(),
+          outpostServiceId,
           serverUrl: channelsBaseUrl,
-          downloadBase: params?.downloadBase || process.env.SVAMP_OUTPOST_DL
+          downloadBase: params?.downloadBase || process.env.SVAMP_OUTPOST_DL,
+          connectedCount
         });
-        syncChannelsToMetadata();
         let pairing = {};
         try {
           const am = await server.getService("public/artifact-manager");
           if (am) {
-            if (info.connectedCount > 0) {
+            if (connectedCount > 0) {
               await burnSessionPairings(am, sessionId, void 0, (m) => console.log(m));
             } else {
               const r = await mintPairingCode({
                 am,
                 session: sessionId,
-                payload: { server: info.serverBase, channel: info.channelId, token: info.token, session: sessionId },
+                payload: { server: info.serverBase, token: info.token, session: sessionId },
                 resolverBase: channelsBaseUrl,
                 log: (m) => console.log(m)
               });
@@ -7888,6 +8166,69 @@ function createSessionStore(server, sessionId, initialMetadata, initialAgentStat
         return { error: e?.message || String(e) };
       }
     },
+    // ── FDE outpost transport (#0565): token-authed remote endpoints + owner-facing exec/list ──
+    // hello/poll/result carry NO session-sharing auth (the remote is anonymous); the per-session
+    // capability token IS the auth (checked against the durable on-disk token). Routed here by the
+    // machine's public `:outpost` gateway, which passes the remote-supplied `session` as the key.
+    outpostHello: async (params) => {
+      const rec = loadOutpostToken(outpostProjectDir(), sessionId);
+      if (!outpostTokenMatches(rec, params?.token)) return { error: "unauthorized" };
+      const machine = (String(params?.machine || "").trim() || "outpost").slice(0, 128);
+      const { isNew, connection } = outpostCoordinator.registerConnection(machine, {
+        label: params?.label ? String(params.label).slice(0, 128) : void 0,
+        os: params?.os ? String(params.os).slice(0, 64) : void 0,
+        arch: params?.arch ? String(params.arch).slice(0, 64) : void 0,
+        version: params?.version ? String(params.version).slice(0, 64) : void 0
+      });
+      if (isNew) {
+        announceOutpost(connection);
+        try {
+          const am = await server.getService("public/artifact-manager");
+          if (am) await burnSessionPairings(am, sessionId, void 0, (m) => console.log(m));
+        } catch {
+        }
+      }
+      return { ok: true, machine: connection.machine };
+    },
+    outpostPoll: async (params) => {
+      const rec = loadOutpostToken(outpostProjectDir(), sessionId);
+      if (!outpostTokenMatches(rec, params?.token)) return { error: "unauthorized" };
+      const machine = (String(params?.machine || "").trim() || "outpost").slice(0, 128);
+      if (!outpostCoordinator.isConnected(machine)) {
+        const { isNew, connection } = outpostCoordinator.registerConnection(machine, {});
+        if (isNew) announceOutpost(connection);
+      }
+      const waitRaw = Number(params?.wait ?? 25);
+      const waitSec = Number.isFinite(waitRaw) ? waitRaw : 25;
+      const waitMs = Math.min(Math.max(0, waitSec * 1e3), 6e4);
+      const deadline = Date.now() + waitMs;
+      for (; ; ) {
+        const commands = outpostCoordinator.pollCommands(machine);
+        if (commands.length || Date.now() >= deadline) return { ok: true, commands };
+        await new Promise((resolve) => setTimeout(resolve, 300));
+      }
+    },
+    outpostResult: async (params) => {
+      const rec = loadOutpostToken(outpostProjectDir(), sessionId);
+      if (!outpostTokenMatches(rec, params?.token)) return { error: "unauthorized" };
+      if (!params?.id) return { error: "missing result id" };
+      const ok = outpostCoordinator.resolveResult({ id: params.id, stdout: params.stdout, stderr: params.stderr, exitCode: params.exitCode });
+      return { ok };
+    },
+    outpostExec: async (params, context) => {
+      authorizeRequest(context, metadata.sharing, "admin");
+      const cmd = String(params?.cmd || "").trim();
+      if (!cmd) return { error: "cmd is required" };
+      const t = outpostCoordinator.resolveTarget(params?.target ? String(params.target) : void 0);
+      if ("error" in t) return { error: t.error };
+      const { promise } = outpostCoordinator.enqueueExec(t.machine, cmd, params?.cwd ? String(params.cwd) : void 0);
+      const r = await promise;
+      return { ok: r.exitCode === 0, stdout: r.stdout, stderr: r.stderr, exitCode: r.exitCode, machine: t.machine };
+    },
+    outpostList: async (context) => {
+      authorizeRequest(context, metadata.sharing, "view");
+      return { ok: true, outposts: outpostCoordinator.listConnections() };
+    },
     getChannelSkill: async (id, context) => {
       authorizeRequest(context, metadata.sharing, "view");
       const c = channelStore.get(id);
@@ -9001,6 +9342,13 @@ function handleMatchesMetadata(parsed, metadata) {
   return true;
 }
 
+function buildSessionIdentityEnv(identity) {
+  const env = { SVAMP_SESSION_ID: identity.sessionId };
+  if (identity.handle) env.SVAMP_SESSION_HANDLE = identity.handle;
+  if (identity.machineId) env.SVAMP_MACHINE_ID = identity.machineId;
+  return env;
+}
+
 const HOTRELOAD_ENV = "SVAMP_DEV_HOTRELOAD";
 function isHotReloadEnabled(env = process.env) {
   const v = env[HOTRELOAD_ENV];
@@ -16634,7 +16982,7 @@ async function startDaemon(options) {
     try {
       const dir = loadSessionIndex()[sessionId]?.directory;
       if (!dir) return;
-      const { reconcileServiceLinks } = await import('./agentCommands-DLpNORpD.mjs');
+      const { reconcileServiceLinks } = await import('./agentCommands-BCkWdFFW.mjs');
       const configPath = getSvampConfigPath(dir, sessionId);
       const config = readSvampConfig(configPath);
       const entries = Array.from(urls.entries());
@@ -16652,7 +17000,7 @@ async function startDaemon(options) {
     }
   }
   async function createExposedTunnel(spec) {
-    const { FrpcTunnel } = await import('./frpc-BqfCBMke.mjs');
+    const { FrpcTunnel } = await import('./frpc-Cb6jUvED.mjs');
     const tunnel = new FrpcTunnel({
       name: spec.name,
       ports: spec.ports,
@@ -18868,11 +19216,11 @@ ${capturedError}${buildClaudeErrorHint(capturedError)}`;
               });
             },
             onIssue: async (params) => {
-              const { issueRpc } = await import('./rpc-BJySEOZA.mjs');
+              const { issueRpc } = await import('./rpc-B-bxS-Pv.mjs');
               return issueRpc(params?.cwd || directory, params || {}, { notifySession: notifyIssueOwner, rekickLoopOwner });
             },
             onWorkflow: async (params) => {
-              const { workflowRpc } = await import('./rpc-DZekVCXH.mjs');
+              const { workflowRpc } = await import('./rpc-CNkfUlz1.mjs');
               return workflowRpc(params?.cwd || directory, params || {});
             },
             onRipgrep: async (args, cwd) => {
@@ -19485,11 +19833,11 @@ ${capturedError}${buildClaudeErrorHint(capturedError)}`;
               });
             },
             onIssue: async (params) => {
-              const { issueRpc } = await import('./rpc-BJySEOZA.mjs');
+              const { issueRpc } = await import('./rpc-B-bxS-Pv.mjs');
               return issueRpc(params?.cwd || directory, params || {}, { notifySession: notifyIssueOwner, rekickLoopOwner });
             },
             onWorkflow: async (params) => {
-              const { workflowRpc } = await import('./rpc-DZekVCXH.mjs');
+              const { workflowRpc } = await import('./rpc-CNkfUlz1.mjs');
               return workflowRpc(params?.cwd || directory, params || {});
             },
             onRipgrep: async (args, cwd) => {
@@ -19637,6 +19985,11 @@ ${capturedError}${buildClaudeErrorHint(capturedError)}`;
           }
         }
         let agentBackend;
+        const sessionIdentityEnv = buildSessionIdentityEnv({
+          sessionId,
+          handle: formatHandle(sessionMetadata.projectName, sessionMetadata.friendlyName),
+          machineId
+        });
         if (KNOWN_CODEX_AGENTS[agentName]) {
           const avail = codexAppServerAvailable();
           if (avail === null) throw new Error("Codex CLI not found \u2014 install it (`npm i -g @openai/codex`) and authenticate (`svamp daemon codex-auth`).");
@@ -19681,8 +20034,9 @@ ${capturedError}${buildClaudeErrorHint(capturedError)}`;
             model: codexModel,
             provider,
             // Account extra env (OPENAI_API_KEY / SVAMP_CODEX_API_KEY / CODEX_HOME) layered
-            // over any per-session environmentVariables from the composer.
-            env: { ...options2.environmentVariables || {}, ...accountCodexEnv || {} },
+            // over any per-session environmentVariables from the composer; session identity
+            // (#0599) applied LAST so it can't be shadowed by composer/account vars.
+            env: { ...options2.environmentVariables || {}, ...accountCodexEnv || {}, ...sessionIdentityEnv },
             log: logger.log,
             isolationConfig: agentIsoConfig,
             approvalPolicy: codexPerm.approvalPolicy,
@@ -19698,7 +20052,9 @@ ${capturedError}${buildClaudeErrorHint(capturedError)}`;
             cwd: directory,
             command: acpConfig.command,
             args: acpConfig.args,
-            env: options2.environmentVariables,
+            // #0599: session identity (SVAMP_SESSION_ID/HANDLE/MACHINE_ID) so ACP terminal
+            // tools self-identify like Claude's do; applied last (identity wins).
+            env: { ...options2.environmentVariables || {}, ...sessionIdentityEnv },
             permissionHandler,
             transportHandler,
             log: logger.log,
@@ -20616,7 +20972,7 @@ ${oracle.output.trim().slice(0, 500)}`, "\u{1F501} Continuing loop");
     const PING_TIMEOUT_MS = 15e3;
     const POST_RECONNECT_GRACE_MS = 2e4;
     const RECONNECT_JITTER_MS = 2500;
-    const { WorkflowScheduler } = await import('./scheduler-CJ4qyaq2.mjs');
+    const { WorkflowScheduler } = await import('./scheduler-DT1_BBdZ.mjs');
     const workflowScheduler = new WorkflowScheduler({
       projectRoots: () => {
         const dirs = /* @__PURE__ */ new Set();
@@ -21240,4 +21596,4 @@ var run = /*#__PURE__*/Object.freeze({
     writeStopMarker: writeStopMarker
 });
 
-export { searchSkills as $, removeWorkflow as A, saveWorkflow as B, rawWorkflow as C, listWorkflows as D, isWorkflowEnabled as E, workflowCrons as F, cronMatches as G, buildOutpostInstall as H, ChannelStore as I, DEFAULT_OUTPOST_DOWNLOAD_BASE as J, setupOutpostChannel as K, summarize as L, workflowSteps as M, parseJwtEmail as N, computeCollectionConfigUpdate as O, SYSTEM_COLLECTION_CONFIG as P, loadMachineContext as Q, READ_ONLY_TOOLS as R, SharingNotificationSync as S, buildMachineInstructions as T, machineToolsForRole as U, buildMachineTools as V, parseFrontmatter as W, getSkillsServer as X, getSkillsWorkspaceName as Y, getSkillsCollectionName as Z, fetchWithTimeout as _, createSessionStore as a, SKILLS_DIR as a0, getSkillInfo as a1, downloadSkillFile as a2, listSkillFiles as a3, resolveModel as a4, clearStopMarker as a5, stopMarkerExists as a6, formatHandle as a7, normalizeAllowedUser as a8, loadSecurityContextConfig as a9, api as aA, run as aB, resolveSecurityContext as aa, buildSecurityContextFromFlags as ab, mergeSecurityContexts as ac, buildSessionShareUrl as ad, computeOutboundHop as ae, registerAwaitingReply as af, buildMachineShareUrl as ag, parseHandle as ah, handleMatchesMetadata as ai, describeMisconfiguration as aj, buildMachineDeps as ak, applyClaudeProxyEnv as al, composeSessionId as am, generateFriendlyName as an, generateHookSettings as ao, staticFileServer as ap, instanceConfig as aq, claudeAuth as ar, codexProvider as as, outbox as at, projectInfo as au, DefaultTransport$1 as av, acpBackend as aw, acpAgentConfig as ax, codexAppServerBackend as ay, GeminiTransport$1 as az, stopDaemon as b, connectToHypha as c, daemonStatus as d, getFrpsSubdomainHost as e, getFrpsServerPort as f, getHyphaServerUrl$1 as g, getFrpsServerAddr as h, shortId as i, resolveProjectRoot as j, getIssue as k, resumeIssue as l, addComment as m, addIssue as n, listIssues as o, pauseIssue as p, searchIssues as q, registerMachineService as r, startDaemon as s, isVisibleTo as t, updateIssue as u, getRun as v, listRuns as w, getWorkflow as x, runWorkflow as y, setWorkflowEnabled as z };
+export { listSkillFiles as $, removeWorkflow as A, saveWorkflow as B, rawWorkflow as C, listWorkflows as D, isWorkflowEnabled as E, workflowCrons as F, cronMatches as G, summarize as H, workflowSteps as I, parseJwtEmail as J, computeCollectionConfigUpdate as K, SYSTEM_COLLECTION_CONFIG as L, loadMachineContext as M, buildMachineInstructions as N, machineToolsForRole as O, buildMachineTools as P, parseFrontmatter as Q, READ_ONLY_TOOLS as R, SharingNotificationSync as S, getSkillsServer as T, getSkillsWorkspaceName as U, getSkillsCollectionName as V, fetchWithTimeout as W, searchSkills as X, SKILLS_DIR as Y, getSkillInfo as Z, downloadSkillFile as _, createSessionStore as a, resolveModel as a0, clearStopMarker as a1, stopMarkerExists as a2, formatHandle as a3, normalizeAllowedUser as a4, loadSecurityContextConfig as a5, resolveSecurityContext as a6, buildSecurityContextFromFlags as a7, mergeSecurityContexts as a8, buildSessionShareUrl as a9, computeOutboundHop as aa, registerAwaitingReply as ab, buildMachineShareUrl as ac, parseHandle as ad, handleMatchesMetadata as ae, describeMisconfiguration as af, buildMachineDeps as ag, applyClaudeProxyEnv as ah, composeSessionId as ai, generateFriendlyName as aj, generateHookSettings as ak, staticFileServer as al, instanceConfig as am, claudeAuth as an, codexProvider as ao, projectInfo as ap, DefaultTransport$1 as aq, acpBackend as ar, acpAgentConfig as as, codexAppServerBackend as at, GeminiTransport$1 as au, api as av, run as aw, stopDaemon as b, connectToHypha as c, daemonStatus as d, getFrpsSubdomainHost as e, getFrpsServerPort as f, getHyphaServerUrl$1 as g, getFrpsServerAddr as h, shortId as i, resolveProjectRoot as j, getIssue as k, resumeIssue as l, addComment as m, addIssue as n, listIssues as o, pauseIssue as p, searchIssues as q, registerMachineService as r, startDaemon as s, isVisibleTo as t, updateIssue as u, getRun as v, listRuns as w, getWorkflow as x, runWorkflow as y, setWorkflowEnabled as z };