svamp-cli 0.2.315 → 0.2.318

package/dist/{run-vEbmTx6x.mjs → run-CC2ckdDX.mjs}

@@ -1,20 +1,21 @@
-import{createRequire as _pkgrollCR}from"node:module";const require=_pkgrollCR(import.meta.url);import os$1, { homedir } from 'os';
+import{createRequire as _pkgrollCR}from"node:module";const require=_pkgrollCR(import.meta.url);import os$1, { homedir, platform, arch } from 'os';
 import fs$1, { mkdir as mkdir$1, readdir as readdir$1, readFile, writeFile as writeFile$1, rename, unlink } from 'fs/promises';
 import * as fs from 'fs';
-import fs__default, { existsSync as existsSync$1, rmSync, readFileSync as readFileSync$1, mkdirSync, writeFileSync, renameSync as renameSync$1, realpathSync as realpathSync$1, copyFileSync, unlinkSync as unlinkSync$1, readdirSync as readdirSync$1, watch, rmdirSync } from 'fs';
+import fs__default, { existsSync as existsSync$1, rmSync, readFileSync as readFileSync$1, mkdirSync, writeFileSync, chmodSync, unlinkSync, renameSync as renameSync$1, realpathSync as realpathSync$1, copyFileSync, readdirSync as readdirSync$1, watch, rmdirSync, statSync as statSync$1 } from 'fs';
 import * as path from 'path';
 import path__default, { join, delimiter, resolve as resolve$1, dirname as dirname$1, basename as basename$1 } from 'path';
 import { fileURLToPath } from 'url';
-import { execFile, spawn, execSync, exec as exec$1 } from 'child_process';
+import { execFile, execSync, spawn, exec as exec$1 } from 'child_process';
 import * as crypto from 'crypto';
-import { randomUUID as randomUUID$1 } from 'crypto';
-import { randomUUID, randomBytes, createHash, timingSafeEqual } from 'node:crypto';
-import { existsSync, readFileSync, mkdirSync as mkdirSync$1, writeFileSync as writeFileSync$1, chmodSync, rmSync as rmSync$1, cpSync, statSync, realpathSync, readdirSync, renameSync, appendFileSync, unlinkSync } from 'node:fs';
+import { randomUUID, createHash } from 'crypto';
+import { randomUUID as randomUUID$1, randomBytes, createHash as createHash$1, timingSafeEqual } from 'node:crypto';
+import { existsSync, readFileSync, mkdirSync as mkdirSync$1, writeFileSync as writeFileSync$1, chmodSync as chmodSync$1, rmSync as rmSync$1, cpSync, statSync, realpathSync, readdirSync, renameSync, appendFileSync, openSync, readSync, closeSync, unlinkSync as unlinkSync$1 } from 'node:fs';
 import { exec, spawn as spawn$1, execSync as execSync$1, execFile as execFile$1, execFileSync } from 'node:child_process';
 import { promisify } from 'util';
 import * as http from 'http';
 import * as net from 'net';
-import os, { homedir as homedir$1, platform } from 'node:os';
+import { createServer } from 'net';
+import os, { homedir as homedir$1, platform as platform$1 } from 'node:os';
 import { join as join$1, extname, resolve, sep, basename, dirname } from 'node:path';
 import { EventEmitter } from 'node:events';
 import { ndJsonStream, ClientSideConnection } from '@agentclientprotocol/sdk';
@@ -321,7 +322,26 @@ function buildSecurityContextFromFlags(flags) {
   }
   return ctx;
 }
+function unenforceableRules(method, context) {
+  const unsupported = [];
+  const fs = context.filesystem;
+  if (fs?.denyRead?.length) unsupported.push("filesystem.denyRead");
+  if (fs?.denyWrite?.length) unsupported.push("filesystem.denyWrite");
+  if (context.network?.deniedDomains?.length) unsupported.push("network.deniedDomains");
+  if (method === "docker" || method === "podman") {
+    if (fs?.allowWrite?.length) unsupported.push("filesystem.allowWrite");
+    if (context.network?.allowedDomains?.length) unsupported.push("network.allowedDomains");
+  }
+  return unsupported;
+}
+function describeUnenforceable(method, context) {
+  const unsupported = unenforceableRules(method, context);
+  if (!unsupported.length) return null;
+  return `securityContext: ${unsupported.join(", ")} is NOT ENFORCED by the "${method}" sandbox \u2014 these rules are accepted but have no effect (#0878). ` + (method === "nono" ? `nono is allow-list based and the workspace is granted via --allow-cwd, so a deny rule for a path inside the workspace does nothing. Use allowedDirectories / filesystem.allowWrite, or keep the sensitive path outside the workspace.` : `The container backend maps only allowedDirectories and denyAllNetwork. Use those, or run the machine under the nono sandbox.`);
+}
 function applySecurityContext(baseConfig, context) {
+  const warning = describeUnenforceable(baseConfig.method, context);
+  if (warning) console.warn(`[security] ${warning}`);
   const config = { ...baseConfig };
   if (config.method === "nono") {
     const nonoConfig = { ...config.nonoConfig };
@@ -439,6 +459,7 @@ function buildSkillsPromptSection(skills) {
 }
 
 const READ_ONLY_TOOLS = ["get_context", "ask_session", "summarize_session", "use_skill"];
+const MUTATING_TOOLS = ["run_bash", "send_to_session", "create_loop", "set_checklist", "stop_loop", "create_channel"];
 const str$1 = (v) => v == null ? "" : String(v);
 function buildTools(deps, skills) {
   return [
@@ -1240,202 +1261,1223 @@ async function killDescendant(rootPid, targetPid, signal = "SIGTERM") {
   }
 }
 
-const MIME = {
-  ".html": "text/html; charset=utf-8",
-  ".htm": "text/html; charset=utf-8",
-  ".js": "text/javascript; charset=utf-8",
-  ".mjs": "text/javascript; charset=utf-8",
-  ".css": "text/css; charset=utf-8",
-  ".json": "application/json; charset=utf-8",
-  ".map": "application/json; charset=utf-8",
-  ".txt": "text/plain; charset=utf-8",
-  ".md": "text/plain; charset=utf-8",
-  ".xml": "application/xml; charset=utf-8",
-  ".csv": "text/csv; charset=utf-8",
-  ".svg": "image/svg+xml",
-  ".png": "image/png",
-  ".jpg": "image/jpeg",
-  ".jpeg": "image/jpeg",
-  ".gif": "image/gif",
-  ".webp": "image/webp",
-  ".avif": "image/avif",
-  ".ico": "image/x-icon",
-  ".bmp": "image/bmp",
-  ".mp4": "video/mp4",
-  ".webm": "video/webm",
-  ".mov": "video/quicktime",
-  ".m4v": "video/mp4",
-  ".mp3": "audio/mpeg",
-  ".wav": "audio/wav",
-  ".ogg": "audio/ogg",
-  ".m4a": "audio/mp4",
-  ".flac": "audio/flac",
-  ".pdf": "application/pdf",
-  ".wasm": "application/wasm",
-  ".zip": "application/zip",
-  ".gz": "application/gzip",
-  ".tar": "application/x-tar",
-  ".woff": "font/woff",
-  ".woff2": "font/woff2",
-  ".ttf": "font/ttf",
-  ".otf": "font/otf",
-  ".docx": "application/vnd.openxmlformats-officedocument.wordprocessingml.document",
-  ".xlsx": "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
-  ".pptx": "application/vnd.openxmlformats-officedocument.presentationml.presentation"
-};
-function contentTypeFor(filePath) {
-  return MIME[path.extname(filePath).toLowerCase()] || "application/octet-stream";
+function svampHome() {
+  return process.env.SVAMP_HOME || join(homedir(), ".svamp");
 }
-function hasBlockedDotSegment(relPath) {
-  const decoded = safeDecode(relPath.replace(/^\/+/, ""));
-  for (const seg of decoded.split("/")) {
-    if (!seg || seg === "." || seg === "..") continue;
-    if (seg.startsWith(".") && seg !== ".well-known") return true;
-  }
-  return false;
+function cacheFile() {
+  return join(svampHome(), "instance-config.json");
 }
-function containedPath(rootDir, relPath) {
-  const base = path.resolve(rootDir);
-  const decoded = safeDecode(relPath);
-  const fp = path.resolve(path.join(base, decoded));
-  if (fp !== base && !fp.startsWith(base + path.sep)) return null;
-  return fp;
+const CONFIG_FILENAME = "svamp.json";
+let _config = null;
+let _loaded = false;
+let _cacheChecked = false;
+function stripSlash$1(u) {
+  return u.replace(/\/+$/, "");
 }
-function realContainedPath(rootDir, candidate) {
-  try {
-    const realRoot = fs.realpathSync(path.resolve(rootDir));
-    const real = fs.realpathSync(candidate);
-    if (real === realRoot || real.startsWith(realRoot + path.sep)) return real;
-    return null;
-  } catch {
-    return null;
+function getInstanceUrl() {
+  const raw = (process.env.SVAMP_INSTANCE_URL || "").trim();
+  return raw ? stripSlash$1(raw) : void 0;
+}
+function configUrlsFor(anchor) {
+  const base = stripSlash$1(anchor);
+  return [`${base}/${CONFIG_FILENAME}`, `${base}/.well-known/${CONFIG_FILENAME}`];
+}
+async function fetchConfig(anchor) {
+  for (const url of configUrlsFor(anchor)) {
+    try {
+      const resp = await fetch(url, { signal: AbortSignal.timeout(8e3) });
+      if (!resp.ok) continue;
+      const data = await resp.json();
+      if (data && typeof data === "object" && !Array.isArray(data)) {
+        return data;
+      }
+    } catch {
+    }
   }
+  return null;
 }
-function safeDecode(p) {
+function readCache() {
   try {
-    return decodeURIComponent(p);
+    if (existsSync$1(cacheFile())) {
+      const data = JSON.parse(readFileSync$1(cacheFile(), "utf-8"));
+      if (data && typeof data === "object" && !Array.isArray(data)) return data;
+    }
   } catch {
-    return p;
-  }
-}
-function parseRange(header, size) {
-  if (!header) return null;
-  const m = /^bytes=(\d*)-(\d*)$/.exec(header.trim());
-  if (!m) return null;
-  const [, s, e] = m;
-  if (s === "" && e === "") return null;
-  let start, end;
-  if (s === "") {
-    const n = parseInt(e, 10);
-    if (n <= 0) return "unsatisfiable";
-    start = Math.max(0, size - n);
-    end = size - 1;
-  } else {
-    start = parseInt(s, 10);
-    end = e === "" ? size - 1 : parseInt(e, 10);
   }
-  if (Number.isNaN(start) || Number.isNaN(end) || start > end || start >= size) return "unsatisfiable";
-  if (end >= size) end = size - 1;
-  return { start, end };
-}
-function directoryListingHtml(mountRelUrl, entries) {
-  const esc = (s) => s.replace(/[&<>"']/g, (c) => ({ "&": "&amp;", "<": "&lt;", ">": "&gt;", '"': "&quot;", "'": "&#39;" })[c]);
-  const base = mountRelUrl.endsWith("/") ? mountRelUrl : mountRelUrl + "/";
-  const rows = entries.sort((a, b) => a.isDir === b.isDir ? a.name.localeCompare(b.name) : a.isDir ? -1 : 1).map((e) => {
-    const href = base + encodeURIComponent(e.name) + (e.isDir ? "/" : "");
-    return `<li><a href="${esc(href)}">${esc(e.name)}${e.isDir ? "/" : ""}</a></li>`;
-  }).join("\n");
-  return `<!DOCTYPE html><html><head><meta charset="utf-8"><title>${esc(base)}</title>
-<style>body{font-family:system-ui,sans-serif;max-width:760px;margin:40px auto;padding:0 20px;color:#333}
-h1{font-size:1.15rem;word-break:break-all}ul{list-style:none;padding:0}li{padding:6px 0;border-bottom:1px solid #eee}
-a{color:#0969da;text-decoration:none}a:hover{text-decoration:underline}</style></head>
-<body><h1>${esc(base)}</h1><ul>${rows || "<li>(empty)</li>"}</ul></body></html>`;
+  return null;
 }
-const CORS = {
-  "Access-Control-Allow-Origin": "*",
-  "Access-Control-Allow-Methods": "GET, HEAD, OPTIONS",
-  "Access-Control-Allow-Headers": "*"
-};
-function serveStaticMount(req, res, opts) {
-  const { rootDir, relPath, mountUrlPrefix } = opts;
-  const browse = opts.browse !== false;
-  const method = (req.method || "GET").toUpperCase();
-  if (method === "OPTIONS") {
-    res.writeHead(204, CORS);
-    res.end();
-    return;
-  }
-  if (method !== "GET" && method !== "HEAD") {
-    res.writeHead(405, { ...CORS, Allow: "GET, HEAD, OPTIONS" });
-    res.end("Method Not Allowed");
-    return;
-  }
-  let rootStat;
+function writeCache(cfg) {
   try {
-    rootStat = fs.statSync(rootDir);
+    mkdirSync(svampHome(), { recursive: true });
+    writeFileSync(cacheFile(), JSON.stringify(cfg, null, 2) + "\n", "utf-8");
   } catch {
-    res.writeHead(404, CORS);
-    res.end("Not Found");
-    return;
   }
-  if (rootStat.isFile()) {
-    sendFile(req, res, rootDir, rootStat);
-    return;
-  }
-  if (hasBlockedDotSegment(relPath)) {
-    res.writeHead(404, CORS);
-    res.end("Not Found");
-    return;
+}
+function applyConfig(cfg) {
+  _config = cfg;
+  if (cfg.hyphaServerUrl && typeof cfg.hyphaServerUrl === "string") {
+    process.env.HYPHA_SERVER_URL = stripSlash$1(cfg.hyphaServerUrl.trim());
   }
-  const lexTarget = containedPath(rootDir, relPath.replace(/^\/+/, ""));
-  if (!lexTarget) {
-    res.writeHead(403, { ...CORS, "Content-Type": "text/plain" });
-    res.end("Forbidden");
-    return;
+}
+async function loadInstanceConfig(opts = {}) {
+  if (_loaded && !opts.force) return _config;
+  const anchor = opts.anchor ? stripSlash$1(opts.anchor) : getInstanceUrl();
+  if (anchor) {
+    const fetched = await fetchConfig(anchor);
+    if (fetched) {
+      applyConfig(fetched);
+      writeCache(fetched);
+      _loaded = true;
+      _cacheChecked = true;
+      return _config;
+    }
   }
-  const target = realContainedPath(rootDir, lexTarget);
-  if (!target) {
-    res.writeHead(404, { ...CORS, "Content-Type": "text/plain" });
-    res.end("Not Found");
-    return;
+  const cached = readCache();
+  if (cached) applyConfig(cached);
+  _loaded = true;
+  _cacheChecked = true;
+  return _config;
+}
+function getLoadedConfig() {
+  if (!_loaded && !_cacheChecked) {
+    const cached = readCache();
+    if (cached) applyConfig(cached);
+    _cacheChecked = true;
   }
-  let st;
+  return _config;
+}
+function clearInstanceConfigCache() {
+  _config = null;
+  _loaded = false;
+  _cacheChecked = false;
   try {
-    st = fs.statSync(target);
+    if (existsSync$1(cacheFile())) rmSync(cacheFile());
   } catch {
-    res.writeHead(404, { ...CORS, "Content-Type": "text/plain" });
-    res.end("Not Found");
-    return;
   }
-  if (st.isDirectory()) {
-    const reqPath = (req.url || "/").split("?")[0];
-    if (!reqPath.endsWith("/")) {
-      res.writeHead(302, { ...CORS, Location: reqPath + "/" });
-      res.end();
-      return;
-    }
-    const indexPath = realContainedPath(rootDir, path.join(target, "index.html"));
-    if (indexPath) {
-      try {
-        const ist = fs.statSync(indexPath);
-        if (ist.isFile()) {
-          sendFile(req, res, indexPath, ist);
-          return;
-        }
-      } catch {
-      }
-    }
-    if (!browse) {
-      res.writeHead(403, { ...CORS, "Content-Type": "text/plain" });
-      res.end("Directory listing disabled");
-      return;
-    }
-    let entries;
-    try {
-      entries = fs.readdirSync(target, { withFileTypes: true }).filter((d) => !d.name.startsWith(".")).map((d) => ({ name: d.name, isDir: d.isDirectory() }));
-    } catch {
-      res.writeHead(500, CORS);
-      res.end("Listing failed");
+}
+function __setConfigForTest(cfg) {
+  _config = cfg;
+  _loaded = true;
+  _cacheChecked = true;
+  if (cfg) applyConfig(cfg);
+}
+function __resetForTest() {
+  _config = null;
+  _loaded = false;
+  _cacheChecked = false;
+}
+
+var instanceConfig = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    CONFIG_FILENAME: CONFIG_FILENAME,
+    __resetForTest: __resetForTest,
+    __setConfigForTest: __setConfigForTest,
+    clearInstanceConfigCache: clearInstanceConfigCache,
+    configUrlsFor: configUrlsFor,
+    getInstanceUrl: getInstanceUrl,
+    getLoadedConfig: getLoadedConfig,
+    loadInstanceConfig: loadInstanceConfig
+});
+
+function stripSlash(u) {
+  return u.replace(/\/+$/, "");
+}
+function getHyphaServerUrl() {
+  const fromCfg = getLoadedConfig()?.hyphaServerUrl;
+  if (typeof fromCfg === "string" && fromCfg.trim()) return stripSlash(fromCfg.trim());
+  const env = (process.env.HYPHA_SERVER_URL || "").trim();
+  return env ? stripSlash(env) : void 0;
+}
+function getFrpsSubdomainHost() {
+  const fromCfg = getLoadedConfig()?.frps?.subdomainHost;
+  if (typeof fromCfg === "string" && fromCfg.trim()) return fromCfg.trim();
+  const env = (process.env.FRPS_SUBDOMAIN_HOST || "").trim();
+  if (env) return env;
+  throw new Error(
+    'frps subdomain host is not configured. Serve a svamp.json with "frps.subdomainHost" at your frontend URL (svamp login <frontend-url>), or set FRPS_SUBDOMAIN_HOST (legacy). It is deployment-specific and never guessed.'
+  );
+}
+function getFrpsServerAddr() {
+  const fromCfg = getLoadedConfig()?.frps?.serverAddr;
+  if (typeof fromCfg === "string" && fromCfg.trim()) return fromCfg.trim();
+  const env = (process.env.FRPS_SERVER_ADDR || "").trim();
+  if (env) return env;
+  return `frps-ctrl.${getFrpsSubdomainHost()}`;
+}
+function getFrpsServerPort() {
+  const fromCfg = getLoadedConfig()?.frps?.serverPort;
+  if (typeof fromCfg === "number" && Number.isFinite(fromCfg)) return fromCfg;
+  const env = parseInt(process.env.FRPS_SERVER_PORT || "", 10);
+  return Number.isFinite(env) ? env : void 0;
+}
+function getSvampWebBaseUrl() {
+  const fromCfg = getLoadedConfig()?.web?.baseUrl;
+  if (typeof fromCfg === "string" && fromCfg.trim()) return stripSlash(fromCfg.trim());
+  const env = (process.env.SVAMP_WEB_URL || "").trim();
+  if (env) return stripSlash(env);
+  const instance = getInstanceUrl();
+  if (instance) return instance;
+  throw new Error(
+    'Svamp web base URL is not configured. Serve a svamp.json with "web.baseUrl", log in with your frontend URL (svamp login <frontend-url>), or set SVAMP_WEB_URL (legacy).'
+  );
+}
+function getSkillsServerUrl() {
+  const fromCfg = getLoadedConfig()?.skills?.server;
+  if (typeof fromCfg === "string" && fromCfg.trim()) return stripSlash(fromCfg.trim());
+  const env = (process.env.HYPHA_SKILLS_SERVER || "").trim();
+  if (env) return stripSlash(env);
+  const server = getHyphaServerUrl();
+  if (server) return server;
+  throw new Error(
+    "Cannot determine skills marketplace server. Serve a svamp.json or set HYPHA_SERVER_URL."
+  );
+}
+function getSkillsWorkspace() {
+  const fromCfg = getLoadedConfig()?.skills?.workspace;
+  if (typeof fromCfg === "string" && fromCfg.trim()) return fromCfg.trim();
+  return (process.env.HYPHA_SKILLS_WORKSPACE || "").trim() || "hypha-cloud";
+}
+function getSkillsCollection() {
+  const fromCfg = getLoadedConfig()?.skills?.collection;
+  if (typeof fromCfg === "string" && fromCfg.trim()) return fromCfg.trim();
+  return (process.env.HYPHA_SKILLS_COLLECTION || "").trim() || "marketplace";
+}
+
+function getMachineFingerprint() {
+  const idFile = join(homedir(), ".svamp", "machine-id");
+  try {
+    const existing = readFileSync$1(idFile, "utf-8").trim();
+    if (existing) return existing;
+  } catch {
+  }
+  const id = randomUUID();
+  try {
+    mkdirSync(join(homedir(), ".svamp"), { recursive: true });
+    writeFileSync(idFile, id + "\n");
+  } catch {
+  }
+  return id;
+}
+const FRP_VERSION = "0.68.0";
+const BIN_DIR = join(homedir(), ".svamp", "bin");
+const FRPC_BIN = join(BIN_DIR, platform() === "win32" ? "frpc.exe" : "frpc");
+const _livingFrpcPids = /* @__PURE__ */ new Set();
+function isFrpcSubdomainConflict(errorLine) {
+  return /router config conflict|already exists/i.test(errorLine);
+}
+function shouldGiveUpOnConflict(args) {
+  if (args.everStartedProxy) return false;
+  return args.conflictCount >= args.minAttempts && args.elapsedMs >= args.minElapsedMs;
+}
+function selectOrphanedFrpcPids(psOutput, selfPid, livingPids) {
+  const pids = [];
+  for (const line of psOutput.split("\n")) {
+    const m = /^\s*(\d+)\s+(.*)$/.exec(line);
+    if (!m) continue;
+    const pid = Number(m[1]);
+    const cmd = m[2];
+    if (!cmd.includes(".svamp/bin/frpc")) continue;
+    if (pid === selfPid || livingPids.has(pid)) continue;
+    pids.push(pid);
+  }
+  return pids;
+}
+function killOrphanedFrpc(log) {
+  if (process.platform === "win32") return;
+  try {
+    const out = execSync("ps -axo pid=,command=", { encoding: "utf-8" });
+    const pids = selectOrphanedFrpcPids(out, process.pid, _livingFrpcPids);
+    for (const pid of pids) {
+      try {
+        process.kill(pid, "SIGKILL");
+      } catch {
+      }
+    }
+    if (pids.length) {
+      log(`Reaped ${pids.length} orphaned frpc process(es) from a prior daemon generation \u2014 they were retrying stale subdomains and causing frps router-config-conflict churn.`);
+    }
+  } catch {
+  }
+}
+function isInCluster() {
+  return !!(process.env.KUBERNETES_SERVICE_HOST || process.env.SANDBOX_ID);
+}
+const FRPS_CLUSTER_ADDR = "frps.hypha.svc.cluster.local";
+const DEFAULT_FRPS_PORT = isInCluster() ? 7e3 : 443;
+const FRPS_PUBLIC_TOKEN = "hypha-frps-public";
+function getFrpcDownloadUrl() {
+  const os = platform();
+  const a = arch();
+  let osStr;
+  let archStr;
+  switch (os) {
+    case "darwin":
+      osStr = "darwin";
+      break;
+    case "linux":
+      osStr = "linux";
+      break;
+    case "win32":
+      osStr = "windows";
+      break;
+    default:
+      throw new Error(`Unsupported platform: ${os}`);
+  }
+  switch (a) {
+    case "x64":
+      archStr = "amd64";
+      break;
+    case "arm64":
+      archStr = "arm64";
+      break;
+    case "arm":
+      archStr = "arm";
+      break;
+    default:
+      throw new Error(`Unsupported architecture: ${a}`);
+  }
+  const ext = os === "win32" ? "zip" : "tar.gz";
+  const filename = `frp_${FRP_VERSION}_${osStr}_${archStr}`;
+  return `https://github.com/fatedier/frp/releases/download/v${FRP_VERSION}/${filename}.${ext}`;
+}
+let _frpcDownloadInFlight = null;
+async function ensureFrpc(log) {
+  if (existsSync$1(FRPC_BIN)) {
+    try {
+      const out = execSync(`"${FRPC_BIN}" --version`, { stdio: "pipe", timeout: 5e3 }).toString().trim();
+      if (out === FRP_VERSION) return FRPC_BIN;
+      (log || console.log)(`frpc version mismatch: ${out} \u2260 ${FRP_VERSION}, re-downloading...`);
+    } catch {
+      (log || console.log)("frpc binary broken or invalid signature, re-downloading...");
+    }
+  }
+  if (_frpcDownloadInFlight) return _frpcDownloadInFlight;
+  _frpcDownloadInFlight = downloadFrpc(log).finally(() => {
+    _frpcDownloadInFlight = null;
+  });
+  return _frpcDownloadInFlight;
+}
+async function downloadFrpc(log) {
+  try {
+    if (existsSync$1(FRPC_BIN)) unlinkSync(FRPC_BIN);
+  } catch {
+  }
+  const logger = log || console.log;
+  mkdirSync(BIN_DIR, { recursive: true });
+  const url = getFrpcDownloadUrl();
+  logger(`Downloading frpc ${FRP_VERSION} from ${url}...`);
+  const ctrl = new AbortController();
+  const timer = setTimeout(() => ctrl.abort(), 6e4);
+  let response;
+  try {
+    response = await fetch(url, { signal: ctrl.signal });
+  } catch (err) {
+    const why = err?.name === "AbortError" ? "timed out after 60s" : err?.message ?? String(err);
+    throw new Error(`Failed to download frpc from ${url}: ${why}`);
+  } finally {
+    clearTimeout(timer);
+  }
+  if (!response.ok) {
+    throw new Error(`Failed to download frpc: ${response.status} ${response.statusText}`);
+  }
+  const buffer = Buffer.from(await response.arrayBuffer());
+  if (platform() === "win32") {
+    throw new Error("Windows ZIP extraction not implemented \u2014 please install frpc manually");
+  }
+  const tmpTar = join(BIN_DIR, `frpc-${FRP_VERSION}-${process.pid}-${Math.random().toString(36).slice(2, 8)}.tar.gz`);
+  writeFileSync(tmpTar, buffer);
+  try {
+    const dirName = `frp_${FRP_VERSION}_${platform() === "darwin" ? "darwin" : "linux"}_${arch() === "x64" ? "amd64" : arch()}`;
+    execSync(
+      `tar -xzf "${tmpTar}" -C "${BIN_DIR}" --strip-components=1 "${dirName}/frpc"`,
+      { stdio: "pipe" }
+    );
+    chmodSync(FRPC_BIN, 493);
+    logger(`frpc installed at ${FRPC_BIN}`);
+  } finally {
+    try {
+      unlinkSync(tmpTar);
+    } catch {
+    }
+  }
+  return FRPC_BIN;
+}
+function tomlStr(v) {
+  return String(v).replace(/\\/g, "\\\\").replace(/"/g, '\\"').replace(/\n/g, "\\n").replace(/\r/g, "\\r").replace(/\t/g, "\\t");
+}
+function generateFrpcConfig(config, proxies, admin) {
+  const useWSS = config.serverPort === 443;
+  const lines = [
+    "# Auto-generated by svamp \u2014 do not edit",
+    `serverAddr = "${tomlStr(config.serverAddr)}"`,
+    `serverPort = ${config.serverPort}`,
+    "",
+    'auth.method = "token"',
+    `auth.token = "${tomlStr(config.authToken)}"`,
+    "",
+    "# Hypha JWT token for server-side authentication",
+    ...config.hyphaToken ? [`metadatas.token = "${tomlStr(config.hyphaToken)}"`] : [],
+    "",
+    "# Transport",
+    ...useWSS ? ['transport.protocol = "wss"'] : [],
+    // 15s/45s heartbeat — 2x faster failure detection than the frpc default
+    // (30s/90s). With matching server-side frps 0.68.x, dead-peer detection
+    // settles in well under a minute, so the daemon-side recreate threshold
+    // can be tightened too.
+    "transport.heartbeatInterval = 15",
+    "transport.heartbeatTimeout = 45",
+    "transport.poolCount = 5",
+    "",
+    "# Don't exit on login failure \u2014 let frpc keep retrying",
+    "loginFailExit = false",
+    "",
+    'log.to = "console"',
+    'log.level = "info"',
+    ""
+  ];
+  if (admin) {
+    lines.push("# Local admin/status API (loopback only \u2014 polled by the svamp daemon)");
+    lines.push('webServer.addr = "127.0.0.1"');
+    lines.push(`webServer.port = ${admin.port}`);
+    lines.push(`webServer.user = "${tomlStr(admin.user)}"`);
+    lines.push(`webServer.password = "${tomlStr(admin.password)}"`);
+    lines.push("");
+  }
+  for (const proxy of proxies) {
+    lines.push(`[[proxies]]`);
+    lines.push(`name = "${tomlStr(proxy.name)}"`);
+    lines.push(`type = "${tomlStr(proxy.type)}"`);
+    lines.push(`localIP = "${tomlStr(proxy.localIP || "127.0.0.1")}"`);
+    lines.push(`localPort = ${proxy.localPort}`);
+    if (proxy.subdomain) {
+      lines.push(`subdomain = "${tomlStr(proxy.subdomain)}"`);
+    }
+    if (proxy.customDomains && proxy.customDomains.length > 0) {
+      lines.push(`customDomains = [${proxy.customDomains.map((d) => `"${tomlStr(d)}"`).join(", ")}]`);
+    }
+    if (proxy.group) {
+      lines.push(`loadBalancer.group = "${tomlStr(proxy.group)}"`);
+      if (proxy.groupKey) {
+        lines.push(`loadBalancer.groupKey = "${tomlStr(proxy.groupKey)}"`);
+      }
+    }
+    if (proxy.healthCheckType) {
+      lines.push(`healthCheck.type = "${tomlStr(proxy.healthCheckType)}"`);
+      if (proxy.healthCheckType === "http" && proxy.healthCheckPath) {
+        lines.push(`healthCheck.path = "${tomlStr(proxy.healthCheckPath)}"`);
+      }
+      lines.push(`healthCheck.intervalSeconds = ${proxy.healthCheckInterval || 10}`);
+      lines.push(`healthCheck.timeoutSeconds = ${proxy.healthCheckTimeout || 3}`);
+      lines.push(`healthCheck.maxFailed = ${proxy.healthCheckMaxFailed || 3}`);
+    }
+    if (proxy.type === "http") {
+      lines.push("transport.useEncryption = false");
+      lines.push("transport.useCompression = false");
+    }
+    lines.push("");
+  }
+  return lines.join("\n");
+}
+function getFreePort() {
+  return new Promise((resolve, reject) => {
+    const srv = createServer();
+    srv.unref();
+    srv.on("error", reject);
+    srv.listen(0, "127.0.0.1", () => {
+      const addr = srv.address();
+      const port = typeof addr === "object" && addr ? addr.port : 0;
+      srv.close(() => port ? resolve(port) : reject(new Error("no port")));
+    });
+  });
+}
+function parseFrpcStatus(payload, proxyNames) {
+  const byName = /* @__PURE__ */ new Map();
+  if (payload && typeof payload === "object") {
+    for (const group of Object.values(payload)) {
+      if (!Array.isArray(group)) continue;
+      for (const p of group) {
+        if (p && typeof p.name === "string") {
+          byName.set(p.name, { status: String(p.status ?? ""), err: p.err ? String(p.err) : void 0 });
+        }
+      }
+    }
+  }
+  const missing = [];
+  const failed = [];
+  for (const name of proxyNames) {
+    const entry = byName.get(name);
+    if (!entry) {
+      missing.push(name);
+      continue;
+    }
+    if (entry.status !== "running") failed.push({ name, status: entry.status, err: entry.err });
+  }
+  return { allRunning: missing.length === 0 && failed.length === 0, missing, failed };
+}
+class FrpcTunnel {
+  process = null;
+  _connected = false;
+  _destroyed = false;
+  // #0460: in-flight guard. `this.process` is only set AFTER the `await ensureFrpc()`
+  // inside connect(), so two connect() calls interleaved across that await (e.g. the
+  // auto-restart timer firing while an external caller also connects) both pass the
+  // `if (this.process) return` null-check and spawn a duplicate frpc child — the first
+  // is overwritten and never killed, leaving a ghost tunnel registration. This flag is
+  // set synchronously before the await and makes connect() idempotent across it.
+  _connecting = false;
+  configPath;
+  options;
+  serverConfig;
+  log;
+  logBuffer = [];
+  maxLogLines = 200;
+  proxies = [];
+  // Health tracking
+  _consecutiveErrors = 0;
+  _lastConnectedAt = 0;
+  _lastErrorAt = 0;
+  _firstErrorAt = 0;
+  _restartAttempts = 0;
+  // Persistent-conflict give-up (kth-k8s nightly review 2026-08-09). A generation that has NEVER
+  // brought a proxy online and only ever gets `router config conflict` / `already exists` has lost
+  // the vhost race to another live generation — it must STOP hammering frps ~2/min forever rather
+  // than retry indefinitely. Reset on any real `start proxy success`; only fires when a proxy was
+  // never started (so a live tunnel riding out an frps failover is never torn down).
+  _everStartedProxy = false;
+  _conflictCount = 0;
+  _conflictSince = 0;
+  _restartTimer = null;
+  // #0583: pending reconnect timer (cancelled on destroy)
+  // End-to-end probe state (set when options.probeUrl is provided).
+  _probeTimer = null;
+  _burstTimer = null;
+  // #0622: probe burst timer (cancelled on stopProbeLoop/destroy)
+  _connectTimeoutTimer = null;
+  // #0622: connect() 30s fallback (unref'd + cleared)
+  _lastProbeOkAt = 0;
+  _lastProbeFailAt = 0;
+  _probeOk = false;
+  // frpc admin/status API state (set when options.adminStatus is true).
+  _adminPort = 0;
+  _adminUser = "svamp";
+  _adminPassword = randomUUID();
+  _statusTimer = null;
+  constructor(options) {
+    this.options = options;
+    this.log = options.log || ((msg) => console.log(`[FRPC] ${msg}`));
+    const hyphaToken = options.serverConfig?.hyphaToken || process.env.HYPHA_TOKEN || "";
+    this.serverConfig = {
+      serverAddr: options.serverConfig?.serverAddr || process.env.FRPS_SERVER_ADDR || (isInCluster() ? FRPS_CLUSTER_ADDR : getFrpsServerAddr()),
+      serverPort: options.serverConfig?.serverPort || getFrpsServerPort() || DEFAULT_FRPS_PORT,
+      authToken: options.serverConfig?.authToken || process.env.FRPS_AUTH_TOKEN || FRPS_PUBLIC_TOKEN,
+      hyphaToken,
+      subDomainHost: options.serverConfig?.subDomainHost || process.env.FRPS_SUBDOMAIN_HOST || getFrpsSubdomainHost()
+    };
+    if (!this.serverConfig.hyphaToken) {
+      throw new Error(
+        'Hypha token required for frpc authentication. Run "svamp login" or set HYPHA_TOKEN.'
+      );
+    }
+    const machineFingerprint = getMachineFingerprint();
+    const machineHash = createHash("sha256").update(machineFingerprint).digest("hex").slice(0, 6);
+    const multiPort = options.ports.length > 1;
+    this.proxies = options.ports.map((port) => {
+      const standaloneHash = createHash("sha256").update(multiPort ? `${options.name}|${port}|${machineFingerprint}` : `${options.name}|${machineFingerprint}`).digest("hex").slice(0, 8);
+      const groupSubdomainKey = multiPort ? `${options.group}|${port}` : `${options.group}`;
+      const subdomain = options.subdomains?.get(port) || (options.group ? `${options.group}-${createHash("sha256").update(groupSubdomainKey).digest("hex").slice(0, 8)}` : `${options.name}-${standaloneHash}`);
+      const proxyName = `${options.name}-${port}-${machineHash}`;
+      return {
+        name: proxyName,
+        type: "http",
+        localIP: options.localHost || "127.0.0.1",
+        localPort: port,
+        subdomain,
+        group: options.group,
+        groupKey: options.groupKey,
+        healthCheckType: options.healthCheckType,
+        healthCheckPath: options.healthCheckPath,
+        healthCheckInterval: options.healthCheckInterval
+      };
+    });
+    const configDir = join(homedir(), ".svamp", "frpc");
+    mkdirSync(configDir, { recursive: true, mode: 448 });
+    try {
+      chmodSync(configDir, 448);
+    } catch {
+    }
+    this.configPath = join(configDir, `${options.name}.toml`);
+  }
+  /**
+   * #0583: schedule a backoff reconnect after the child went down (spawn error OR exit).
+   * Extracted from the exit handler so BOTH the spawn-'error' and 'exit' paths share it, and
+   * so it is unit-testable without a real spawn. No-op once destroyed.
+   */
+  _reconnectAfterDown(reason) {
+    if (this._destroyed) return;
+    const STABILITY_WINDOW_MS = 3e4;
+    if (this._lastConnectedAt > 0 && Date.now() - this._lastConnectedAt >= STABILITY_WINDOW_MS) {
+      this._restartAttempts = 0;
+    }
+    this._restartAttempts++;
+    const delay = Math.min(3e3 * Math.pow(2, this._restartAttempts - 1), 6e4);
+    this.log(`frpc down (${reason}), restarting in ${Math.round(delay / 1e3)}s (attempt ${this._restartAttempts})...`);
+    this._restartTimer = setTimeout(() => {
+      this._restartTimer = null;
+      if (!this._destroyed) {
+        this.connect().catch((err) => {
+          this.options.onError?.(err);
+          if (!this._destroyed && !this._restartTimer && !this.process) {
+            this._reconnectAfterDown(`reconnect setup failed: ${err?.message ?? err}`);
+          }
+        });
+      }
+    }, delay);
+  }
+  /** Connect to frps by starting the frpc process. */
+  async connect() {
+    if (this._destroyed) return;
+    if (this.process) return;
+    if (this._connecting) return;
+    this._connecting = true;
+    let frpcPath;
+    let admin;
+    try {
+      frpcPath = await ensureFrpc(this.log);
+      if (this.options.adminStatus) {
+        if (!this._adminPort) {
+          try {
+            this._adminPort = await getFreePort();
+          } catch (err) {
+            this.log(`admin port alloc failed: ${err?.message ?? err}`);
+          }
+        }
+        if (this._adminPort) admin = { port: this._adminPort, user: this._adminUser, password: this._adminPassword };
+      }
+      const configContent = generateFrpcConfig(this.serverConfig, this.proxies, admin);
+      writeFileSync(this.configPath, configContent, { mode: 384 });
+      this.log(`Config written to ${this.configPath}`);
+    } catch (err) {
+      this._connecting = false;
+      throw err;
+    }
+    if (this._destroyed) {
+      this._connecting = false;
+      return;
+    }
+    return new Promise((resolve, reject) => {
+      const child = spawn(frpcPath, ["-c", this.configPath], {
+        stdio: ["ignore", "pipe", "pipe"],
+        env: { ...process.env }
+      });
+      this.process = child;
+      if (child.pid) _livingFrpcPids.add(child.pid);
+      this._connecting = false;
+      let resolved = false;
+      const onOutput = (data) => {
+        const text = data.toString().trim();
+        if (!text) return;
+        for (const line of text.split("\n")) {
+          this.logBuffer.push(line);
+          if (this.logBuffer.length > this.maxLogLines) {
+            this.logBuffer.shift();
+          }
+        }
+        if (text.includes("start proxy success")) {
+          this._everStartedProxy = true;
+          this._conflictCount = 0;
+          this._conflictSince = 0;
+        }
+        if (text.includes("start proxy success") || text.includes("login to server success")) {
+          if (!this._connected) {
+            this._connected = true;
+            this._lastConnectedAt = Date.now();
+            this._consecutiveErrors = 0;
+            this._firstErrorAt = 0;
+            this.options.onConnect?.();
+            const probeConfigured = !!(this.options.probeUrl || this.options.probePath);
+            if (!resolved && !probeConfigured) {
+              resolved = true;
+              resolve();
+            }
+          }
+        }
+        const errorLine = text.split("\n").find((line) => line.includes("[E]"));
+        if (errorLine) {
+          this._consecutiveErrors++;
+          this._lastErrorAt = Date.now();
+          if (this._firstErrorAt === 0) this._firstErrorAt = Date.now();
+          this.options.onError?.(new Error(errorLine));
+          if (isFrpcSubdomainConflict(errorLine) && !this._everStartedProxy) {
+            if (this._conflictSince === 0) this._conflictSince = Date.now();
+            this._conflictCount++;
+            const CONFLICT_GIVEUP_ATTEMPTS = Number(process.env.SVAMP_FRPC_CONFLICT_GIVEUP_ATTEMPTS || 6);
+            const CONFLICT_GIVEUP_MS = Number(process.env.SVAMP_FRPC_CONFLICT_GIVEUP_MS || 6e4);
+            const elapsed = Date.now() - this._conflictSince;
+            if (shouldGiveUpOnConflict({
+              everStartedProxy: this._everStartedProxy,
+              conflictCount: this._conflictCount,
+              elapsedMs: elapsed,
+              minAttempts: CONFLICT_GIVEUP_ATTEMPTS,
+              minElapsedMs: CONFLICT_GIVEUP_MS
+            })) {
+              this.log(
+                `Giving up: ${this._conflictCount} subdomain conflicts over ${Math.round(elapsed / 1e3)}s with no proxy ever online \u2014 another generation owns this vhost. Stopping to avoid endless frps churn.`
+              );
+              this.options.onError?.(new Error(`frpc persistent subdomain conflict (${this._conflictCount}x) \u2014 giving up`));
+              this.destroy();
+            }
+          }
+        }
+      };
+      child.stdout?.on("data", onOutput);
+      child.stderr?.on("data", onOutput);
+      let downHandled = false;
+      const onChildDown = (rejectErr) => {
+        if (downHandled) return;
+        downHandled = true;
+        this._connected = false;
+        if (child.pid) _livingFrpcPids.delete(child.pid);
+        this.process = null;
+        this.options.onDisconnect?.();
+        if (!resolved) {
+          resolved = true;
+          reject(rejectErr);
+        }
+        this._reconnectAfterDown(rejectErr.message);
+      };
+      child.on("error", (err) => {
+        this.options.onError?.(err);
+        onChildDown(err instanceof Error ? err : new Error(String(err)));
+      });
+      child.on("exit", (code) => {
+        onChildDown(new Error(`frpc exited with code ${code}`));
+      });
+      if (this.options.probeUrl || this.options.probePath) {
+        this.startProbeLoop({
+          onFirstOk: () => {
+            if (!resolved) {
+              resolved = true;
+              resolve();
+            }
+          }
+        });
+      } else if (this.options.adminStatus && this._adminPort) {
+        this.startAdminStatusLoop();
+      }
+      if (this._connectTimeoutTimer) {
+        clearTimeout(this._connectTimeoutTimer);
+        this._connectTimeoutTimer = null;
+      }
+      this._connectTimeoutTimer = setTimeout(() => {
+        this._connectTimeoutTimer = null;
+        if (!resolved) {
+          resolved = true;
+          this.log("frpc connection timeout \u2014 continuing (may still connect)");
+          resolve();
+        }
+      }, 3e4);
+      this._connectTimeoutTimer.unref?.();
+    });
+  }
+  /** Resolve the effective probe URL, honoring probeUrl > probePath. */
+  resolveProbeUrl() {
+    if (this.options.probeUrl) return this.options.probeUrl;
+    if (this.options.probePath) {
+      const base = this.getUrls().get(this.options.ports[0]);
+      if (!base) return null;
+      const sep = this.options.probePath.startsWith("/") ? "" : "/";
+      return `${base}${sep}${this.options.probePath}`;
+    }
+    return null;
+  }
+  /**
+   * Start an end-to-end probe loop against the resolved probe URL.
+   * Updates _probeOk + timestamps and fires onProbeFail on transitions.
+   * Called from connect(); cleaned up in destroy().
+   */
+  startProbeLoop(opts = {}) {
+    const probeUrl = this.resolveProbeUrl();
+    if (!probeUrl) return;
+    this.stopProbeLoop();
+    const intervalMs = this.options.probeIntervalMs ?? 3e4;
+    let firstOkFired = false;
+    let inFlight = false;
+    const runProbe = async () => {
+      if (this._destroyed || inFlight) return;
+      inFlight = true;
+      try {
+        const ctrl = new AbortController();
+        const timer = setTimeout(() => ctrl.abort(), 1e4);
+        let resp;
+        try {
+          resp = await fetch(probeUrl, {
+            method: "GET",
+            signal: ctrl.signal,
+            // Don't follow redirects — we just want any 2xx/3xx.
+            redirect: "manual",
+            headers: { "User-Agent": "svamp-frpc-probe/1" }
+          });
+        } finally {
+          clearTimeout(timer);
+        }
+        if (resp.status < 400) {
+          const wasFailing = !this._probeOk;
+          this._probeOk = true;
+          this._lastProbeOkAt = Date.now();
+          if (wasFailing) {
+            this.log(`probe ok: ${probeUrl} (${resp.status})`);
+          }
+          if (!firstOkFired && opts.onFirstOk) {
+            firstOkFired = true;
+            opts.onFirstOk();
+          }
+        } else {
+          throw new Error(`probe got ${resp.status}`);
+        }
+      } catch (err) {
+        const wasOk = this._probeOk;
+        this._probeOk = false;
+        this._lastProbeFailAt = Date.now();
+        if (wasOk) {
+          this.log(`probe failed: ${err?.message || err}`);
+          this.options.onProbeFail?.(err instanceof Error ? err : new Error(String(err)));
+        }
+      } finally {
+        inFlight = false;
+      }
+    };
+    const initialDelays = [500, 2e3, 5e3, 1e4];
+    let burstIdx = 0;
+    if (this._burstTimer) clearInterval(this._burstTimer);
+    this._burstTimer = setInterval(() => {
+      if (this._destroyed || firstOkFired || burstIdx >= initialDelays.length) {
+        if (this._burstTimer) {
+          clearInterval(this._burstTimer);
+          this._burstTimer = null;
+        }
+        return;
+      }
+      burstIdx++;
+      void runProbe();
+    }, 1500);
+    if (intervalMs > 0) {
+      this._probeTimer = setInterval(runProbe, intervalMs);
+    }
+    void runProbe();
+  }
+  stopProbeLoop() {
+    if (this._probeTimer) {
+      clearInterval(this._probeTimer);
+      this._probeTimer = null;
+    }
+    if (this._burstTimer) {
+      clearInterval(this._burstTimer);
+      this._burstTimer = null;
+    }
+  }
+  /**
+   * Poll frpc's loopback admin API (`/api/status`) to track whether this
+   * tunnel's proxies are registered ("running"). Feeds the same `_probeOk` /
+   * staleness fields the daemon health loop watches, so a ghosted/stuck proxy
+   * is detected and recreated even with no HTTP health endpoint on the backend.
+   *
+   * Conservative semantics (critical infra — must not churn healthy tunnels):
+   *  - all proxies "running"        → ok (refresh lastProbeOkAt)
+   *  - a proxy present but not running, or missing after a grace period
+   *                                 → fail (sets lastProbeFailAt; daemon recreates after staleness)
+   *  - admin API unreachable        → INCONCLUSIVE: leave _probeOk untouched
+   *                                   (a transient blip can't flip ok→fail)
+   */
+  startAdminStatusLoop() {
+    this.stopAdminStatusLoop();
+    if (!this._adminPort) return;
+    const proxyNames = this.proxies.map((p) => p.name);
+    const intervalMs = this.options.probeIntervalMs ?? 3e4;
+    const startedAt = Date.now();
+    const auth = "Basic " + Buffer.from(`${this._adminUser}:${this._adminPassword}`).toString("base64");
+    this._probeOk = true;
+    this._lastProbeOkAt = Date.now();
+    let inFlight = false;
+    const poll = async () => {
+      if (this._destroyed || inFlight || !this.process) return;
+      inFlight = true;
+      try {
+        const ctrl = new AbortController();
+        const timer = setTimeout(() => ctrl.abort(), 5e3);
+        let payload;
+        try {
+          const resp = await fetch(`http://127.0.0.1:${this._adminPort}/api/status`, {
+            headers: { Authorization: auth },
+            signal: ctrl.signal
+          });
+          if (!resp.ok) throw new Error(`admin status ${resp.status}`);
+          payload = await resp.json();
+        } finally {
+          clearTimeout(timer);
+        }
+        const { allRunning, missing, failed } = parseFrpcStatus(payload, proxyNames);
+        const graceElapsed = Date.now() - startedAt > 2e4;
+        if (allRunning || !failed.length && !graceElapsed) {
+          const wasFailing = !this._probeOk;
+          this._probeOk = true;
+          this._lastProbeOkAt = Date.now();
+          if (wasFailing) this.log(`admin status ok: all proxies running`);
+        } else {
+          const wasOk = this._probeOk;
+          this._probeOk = false;
+          this._lastProbeFailAt = Date.now();
+          if (wasOk) {
+            const detail = [
+              ...failed.map((f) => `${f.name}=${f.status}${f.err ? ` (${f.err})` : ""}`),
+              ...missing.map((m) => `${m}=missing`)
+            ].join(", ");
+            this.log(`admin status fail: ${detail}`);
+            this.options.onProbeFail?.(new Error(`frpc proxy not running: ${detail}`));
+          }
+        }
+      } catch {
+      } finally {
+        inFlight = false;
+      }
+    };
+    if (intervalMs > 0) this._statusTimer = setInterval(poll, intervalMs);
+    setTimeout(() => void poll(), 3e3);
+  }
+  stopAdminStatusLoop() {
+    if (this._statusTimer) {
+      clearInterval(this._statusTimer);
+      this._statusTimer = null;
+    }
+  }
+  /** Disconnect and stop the frpc process. */
+  destroy() {
+    this._destroyed = true;
+    this._connected = false;
+    this.stopProbeLoop();
+    this.stopAdminStatusLoop();
+    if (this._restartTimer) {
+      clearTimeout(this._restartTimer);
+      this._restartTimer = null;
+    }
+    if (this._connectTimeoutTimer) {
+      clearTimeout(this._connectTimeoutTimer);
+      this._connectTimeoutTimer = null;
+    }
+    if (this.process) {
+      if (this.process.pid) _livingFrpcPids.delete(this.process.pid);
+      this.process.kill("SIGTERM");
+      const p = this.process;
+      const killTimer = setTimeout(() => {
+        try {
+          if (p.exitCode === null && p.signalCode === null) p.kill("SIGKILL");
+        } catch {
+        }
+      }, 5e3);
+      killTimer.unref?.();
+      p.once("exit", () => clearTimeout(killTimer));
+      this.process = null;
+    }
+    try {
+      unlinkSync(this.configPath);
+    } catch {
+    }
+  }
+  /** Whether the frpc tunnel is connected. */
+  get isConnected() {
+    return this._connected && this.process !== null;
+  }
+  /** Snapshot of tunnel health for monitoring. */
+  get status() {
+    return {
+      connected: this.isConnected,
+      pid: this.process?.pid ?? null,
+      name: this.options.name,
+      ports: this.options.ports,
+      serverAddr: this.serverConfig.serverAddr,
+      recentLogs: this.logBuffer.slice(-10),
+      consecutiveErrors: this._consecutiveErrors,
+      lastConnectedAt: this._lastConnectedAt,
+      lastErrorAt: this._lastErrorAt,
+      firstErrorAt: this._firstErrorAt,
+      restartAttempts: this._restartAttempts,
+      failingDurationMs: this._firstErrorAt > 0 ? Date.now() - this._firstErrorAt : 0,
+      probe: this.resolveProbeUrl() || this.options.adminStatus && this._adminPort ? {
+        url: this.resolveProbeUrl() || `frpc-admin:${this._adminPort}/api/status`,
+        ok: this._probeOk,
+        lastOkAt: this._lastProbeOkAt,
+        lastFailAt: this._lastProbeFailAt,
+        stalenessMs: this._lastProbeOkAt > 0 ? Date.now() - this._lastProbeOkAt : 0
+      } : void 0
+    };
+  }
+  /** Update the Hypha token. Rewrites config; takes effect on next frpc restart. */
+  updateToken(newToken) {
+    this.serverConfig.hyphaToken = newToken;
+    const admin = this.options.adminStatus && this._adminPort ? { port: this._adminPort, user: this._adminUser, password: this._adminPassword } : void 0;
+    const configContent = generateFrpcConfig(this.serverConfig, this.proxies, admin);
+    writeFileSync(this.configPath, configContent, { mode: 384 });
+    this.log("Config updated with fresh token");
+  }
+  /** Get the public URLs for each port. */
+  getUrls() {
+    const urls = /* @__PURE__ */ new Map();
+    const base = this.serverConfig.subDomainHost || "svc.hypha.amun.ai";
+    for (const proxy of this.proxies) {
+      const subdomain = proxy.subdomain || proxy.name;
+      urls.set(proxy.localPort, `https://${subdomain}.${base}`);
+    }
+    return urls;
+  }
+}
+async function runFrpcTunnel(name, ports, serverConfig, tunnelOptions) {
+  const portList = ports.join(", ");
+  const tunnel = new FrpcTunnel({
+    name,
+    ports,
+    serverConfig,
+    ...tunnelOptions,
+    onConnect: () => {
+      console.log(`Tunnel connected: ${name} \u2192 localhost:[${portList}]`);
+      const urls = tunnel.getUrls();
+      for (const [port, url] of urls) {
+        console.log(`  ${port} \u2192 ${url}`);
+      }
+    },
+    onDisconnect: () => {
+      console.log("Tunnel disconnected, frpc will auto-reconnect...");
+    },
+    onError: (err) => {
+      console.error(`Tunnel error: ${err.message}`);
+    }
+  });
+  const cleanup = () => {
+    console.log("\nTunnel shutting down...");
+    tunnel.destroy();
+    process.exit(0);
+  };
+  process.on("SIGINT", cleanup);
+  process.on("SIGTERM", cleanup);
+  try {
+    await tunnel.connect();
+    console.log(`Tunnel is active. Press Ctrl+C to stop.`);
+    await new Promise(() => {
+    });
+  } catch (err) {
+    console.error(`Failed to establish tunnel: ${err.message}`);
+    process.exit(1);
+  }
+}
+
+var frpc = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    FrpcTunnel: FrpcTunnel,
+    ensureFrpc: ensureFrpc,
+    generateFrpcConfig: generateFrpcConfig,
+    getFreePort: getFreePort,
+    isFrpcSubdomainConflict: isFrpcSubdomainConflict,
+    killOrphanedFrpc: killOrphanedFrpc,
+    parseFrpcStatus: parseFrpcStatus,
+    runFrpcTunnel: runFrpcTunnel,
+    selectOrphanedFrpcPids: selectOrphanedFrpcPids,
+    shouldGiveUpOnConflict: shouldGiveUpOnConflict
+});
+
+const MIME = {
+  ".html": "text/html; charset=utf-8",
+  ".htm": "text/html; charset=utf-8",
+  ".js": "text/javascript; charset=utf-8",
+  ".mjs": "text/javascript; charset=utf-8",
+  ".css": "text/css; charset=utf-8",
+  ".json": "application/json; charset=utf-8",
+  ".map": "application/json; charset=utf-8",
+  ".txt": "text/plain; charset=utf-8",
+  ".md": "text/plain; charset=utf-8",
+  ".xml": "application/xml; charset=utf-8",
+  ".csv": "text/csv; charset=utf-8",
+  ".svg": "image/svg+xml",
+  ".png": "image/png",
+  ".jpg": "image/jpeg",
+  ".jpeg": "image/jpeg",
+  ".gif": "image/gif",
+  ".webp": "image/webp",
+  ".avif": "image/avif",
+  ".ico": "image/x-icon",
+  ".bmp": "image/bmp",
+  ".mp4": "video/mp4",
+  ".webm": "video/webm",
+  ".mov": "video/quicktime",
+  ".m4v": "video/mp4",
+  ".mp3": "audio/mpeg",
+  ".wav": "audio/wav",
+  ".ogg": "audio/ogg",
+  ".m4a": "audio/mp4",
+  ".flac": "audio/flac",
+  ".pdf": "application/pdf",
+  ".wasm": "application/wasm",
+  ".zip": "application/zip",
+  ".gz": "application/gzip",
+  ".tar": "application/x-tar",
+  ".woff": "font/woff",
+  ".woff2": "font/woff2",
+  ".ttf": "font/ttf",
+  ".otf": "font/otf",
+  ".docx": "application/vnd.openxmlformats-officedocument.wordprocessingml.document",
+  ".xlsx": "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
+  ".pptx": "application/vnd.openxmlformats-officedocument.presentationml.presentation"
+};
+function contentTypeFor(filePath) {
+  return MIME[path.extname(filePath).toLowerCase()] || "application/octet-stream";
+}
+function hasBlockedDotSegment(relPath) {
+  const decoded = safeDecode(relPath.replace(/^\/+/, ""));
+  for (const seg of decoded.split("/")) {
+    if (!seg || seg === "." || seg === "..") continue;
+    if (seg.startsWith(".") && seg !== ".well-known") return true;
+  }
+  return false;
+}
+function containedPath(rootDir, relPath) {
+  const base = path.resolve(rootDir);
+  const decoded = safeDecode(relPath);
+  const fp = path.resolve(path.join(base, decoded));
+  if (fp !== base && !fp.startsWith(base + path.sep)) return null;
+  return fp;
+}
+function realContainedPath(rootDir, candidate) {
+  try {
+    const realRoot = fs.realpathSync(path.resolve(rootDir));
+    const real = fs.realpathSync(candidate);
+    if (real === realRoot || real.startsWith(realRoot + path.sep)) return real;
+    return null;
+  } catch {
+    return null;
+  }
+}
+function safeDecode(p) {
+  try {
+    return decodeURIComponent(p);
+  } catch {
+    return p;
+  }
+}
+function parseRange(header, size) {
+  if (!header) return null;
+  const m = /^bytes=(\d*)-(\d*)$/.exec(header.trim());
+  if (!m) return null;
+  const [, s, e] = m;
+  if (s === "" && e === "") return null;
+  let start, end;
+  if (s === "") {
+    const n = parseInt(e, 10);
+    if (n <= 0) return "unsatisfiable";
+    start = Math.max(0, size - n);
+    end = size - 1;
+  } else {
+    start = parseInt(s, 10);
+    end = e === "" ? size - 1 : parseInt(e, 10);
+  }
+  if (Number.isNaN(start) || Number.isNaN(end) || start > end || start >= size) return "unsatisfiable";
+  if (end >= size) end = size - 1;
+  return { start, end };
+}
+function directoryListingHtml(mountRelUrl, entries) {
+  const esc = (s) => s.replace(/[&<>"']/g, (c) => ({ "&": "&amp;", "<": "&lt;", ">": "&gt;", '"': "&quot;", "'": "&#39;" })[c]);
+  const base = mountRelUrl.endsWith("/") ? mountRelUrl : mountRelUrl + "/";
+  const rows = entries.sort((a, b) => a.isDir === b.isDir ? a.name.localeCompare(b.name) : a.isDir ? -1 : 1).map((e) => {
+    const href = base + encodeURIComponent(e.name) + (e.isDir ? "/" : "");
+    return `<li><a href="${esc(href)}">${esc(e.name)}${e.isDir ? "/" : ""}</a></li>`;
+  }).join("\n");
+  return `<!DOCTYPE html><html><head><meta charset="utf-8"><title>${esc(base)}</title>
+<style>body{font-family:system-ui,sans-serif;max-width:760px;margin:40px auto;padding:0 20px;color:#333}
+h1{font-size:1.15rem;word-break:break-all}ul{list-style:none;padding:0}li{padding:6px 0;border-bottom:1px solid #eee}
+a{color:#0969da;text-decoration:none}a:hover{text-decoration:underline}</style></head>
+<body><h1>${esc(base)}</h1><ul>${rows || "<li>(empty)</li>"}</ul></body></html>`;
+}
+const CORS = {
+  "Access-Control-Allow-Origin": "*",
+  "Access-Control-Allow-Methods": "GET, HEAD, OPTIONS",
+  "Access-Control-Allow-Headers": "*"
+};
+function serveStaticMount(req, res, opts) {
+  const { rootDir, relPath, mountUrlPrefix } = opts;
+  const browse = opts.browse !== false;
+  const method = (req.method || "GET").toUpperCase();
+  if (method === "OPTIONS") {
+    res.writeHead(204, CORS);
+    res.end();
+    return;
+  }
+  if (method !== "GET" && method !== "HEAD") {
+    res.writeHead(405, { ...CORS, Allow: "GET, HEAD, OPTIONS" });
+    res.end("Method Not Allowed");
+    return;
+  }
+  let rootStat;
+  try {
+    rootStat = fs.statSync(rootDir);
+  } catch {
+    res.writeHead(404, CORS);
+    res.end("Not Found");
+    return;
+  }
+  if (rootStat.isFile()) {
+    sendFile(req, res, rootDir, rootStat);
+    return;
+  }
+  if (hasBlockedDotSegment(relPath)) {
+    res.writeHead(404, CORS);
+    res.end("Not Found");
+    return;
+  }
+  const lexTarget = containedPath(rootDir, relPath.replace(/^\/+/, ""));
+  if (!lexTarget) {
+    res.writeHead(403, { ...CORS, "Content-Type": "text/plain" });
+    res.end("Forbidden");
+    return;
+  }
+  const target = realContainedPath(rootDir, lexTarget);
+  if (!target) {
+    res.writeHead(404, { ...CORS, "Content-Type": "text/plain" });
+    res.end("Not Found");
+    return;
+  }
+  let st;
+  try {
+    st = fs.statSync(target);
+  } catch {
+    res.writeHead(404, { ...CORS, "Content-Type": "text/plain" });
+    res.end("Not Found");
+    return;
+  }
+  if (st.isDirectory()) {
+    const reqPath = (req.url || "/").split("?")[0];
+    if (!reqPath.endsWith("/")) {
+      res.writeHead(302, { ...CORS, Location: reqPath + "/" });
+      res.end();
+      return;
+    }
+    const indexPath = realContainedPath(rootDir, path.join(target, "index.html"));
+    if (indexPath) {
+      try {
+        const ist = fs.statSync(indexPath);
+        if (ist.isFile()) {
+          sendFile(req, res, indexPath, ist);
+          return;
+        }
+      } catch {
+      }
+    }
+    if (!browse) {
+      res.writeHead(403, { ...CORS, "Content-Type": "text/plain" });
+      res.end("Directory listing disabled");
+      return;
+    }
+    let entries;
+    try {
+      entries = fs.readdirSync(target, { withFileTypes: true }).filter((d) => !d.name.startsWith(".")).map((d) => ({ name: d.name, isDir: d.isDirectory() }));
+    } catch {
+      res.writeHead(500, CORS);
+      res.end("Listing failed");
       return;
     }
     const listUrl = mountUrlPrefix + (relPath === "/" ? "/" : relPath);
@@ -1566,6 +2608,8 @@ class TokenCache {
       this.cache.delete(token);
       return null;
     }
+    this.cache.delete(token);
+    this.cache.set(token, info);
     return info;
   }
   set(token, email) {
@@ -1853,241 +2897,60 @@ btn.addEventListener('click', async () => {
   }
   /**
    * Render an "access denied" page for a request that IS authenticated (valid
-   * Hypha token) but whose email is not authorized for the mount — or for a
-   * misconfigured owner mount with no resolvable owner. This is served as a
-   * 403; it deliberately does NOT redirect to the login page, which would
-   * loop forever and tell the user nothing about why they were rejected.
-   */
-  getAccessDeniedHtml(opts) {
-    const { email, access, ownerEmail, misconfigured } = opts;
-    const loginHref = `/__login__?return=${encodeURIComponent(opts.returnUrl || "/")}`;
-    let requirement;
-    if (misconfigured) {
-      requirement = `This resource is set to <b>owner-only</b> access, but the server never resolved an owner email (the daemon authenticated with a token that has no email claim). No account can satisfy this \u2014 it is a server-side misconfiguration, not a problem with your account. Fix it by re-creating the mount with an explicit email allowlist, e.g. <code>access: ["${escapeHtml(email || "you@example.com")}"]</code>.`;
-    } else if (access === "owner") {
-      requirement = `This resource is restricted to its owner${ownerEmail ? ` (<code>${escapeHtml(ownerEmail)}</code>)` : ""}.`;
-    } else if (Array.isArray(access)) {
-      const list = access.map((e) => `<code>${escapeHtml(e)}</code>`).join(", ");
-      requirement = `This resource is restricted to: ${list}.`;
-    } else {
-      requirement = "This resource is restricted.";
-    }
-    const signedInLine = email ? `You are signed in as <code>${escapeHtml(email)}</code>, which is not on the allow list.` : `You are not signed in.`;
-    return `<!DOCTYPE html>
-<html><head>
-<meta charset="utf-8">
-<meta name="viewport" content="width=device-width,initial-scale=1">
-<title>Access denied \u2014 Svamp File Server</title>
-<style>
-*{box-sizing:border-box;margin:0;padding:0}
-body{font-family:-apple-system,BlinkMacSystemFont,'Segoe UI',Roboto,sans-serif;display:flex;align-items:center;justify-content:center;min-height:100vh;background:#f6f8fa;color:#24292f;padding:16px}
-.card{background:#fff;border:1px solid #d0d7de;border-radius:12px;padding:32px;max-width:480px;width:100%;box-shadow:0 4px 12px rgba(31,35,40,0.06)}
-h1{font-size:1.25rem;margin-bottom:8px}
-.lead{color:#cf222e;font-weight:600;margin-bottom:16px}
-p{color:#3d444d;font-size:0.92rem;line-height:1.5;margin-bottom:14px}
-code{background:#f6f8fa;border:1px solid #d0d7de;border-radius:6px;padding:1px 6px;font-size:0.85em}
-a.btn{display:inline-block;background:#0969da;color:#fff;border-radius:8px;padding:10px 20px;font-weight:500;text-decoration:none;margin-top:4px}
-a.btn:hover{background:#0860c4}
-</style>
-</head><body>
-<div class="card">
-  <h1>${misconfigured ? "\u26D4 Access not possible" : "\u26D4 Access denied"}</h1>
-  <p class="lead">${signedInLine}</p>
-  <p>${requirement}</p>
-  ${misconfigured ? "" : `<a class="btn" href="${loginHref}">Sign in with a different account</a>`}
-</div>
-</body></html>`;
-  }
-  destroy() {
-    this.cache.clear();
-  }
-}
-function escapeHtml(s) {
-  return s.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&#39;");
-}
-
-function svampHome() {
-  return process.env.SVAMP_HOME || join(homedir(), ".svamp");
-}
-function cacheFile() {
-  return join(svampHome(), "instance-config.json");
-}
-const CONFIG_FILENAME = "svamp.json";
-let _config = null;
-let _loaded = false;
-let _cacheChecked = false;
-function stripSlash$1(u) {
-  return u.replace(/\/+$/, "");
-}
-function getInstanceUrl() {
-  const raw = (process.env.SVAMP_INSTANCE_URL || "").trim();
-  return raw ? stripSlash$1(raw) : void 0;
-}
-function configUrlsFor(anchor) {
-  const base = stripSlash$1(anchor);
-  return [`${base}/${CONFIG_FILENAME}`, `${base}/.well-known/${CONFIG_FILENAME}`];
-}
-async function fetchConfig(anchor) {
-  for (const url of configUrlsFor(anchor)) {
-    try {
-      const resp = await fetch(url, { signal: AbortSignal.timeout(8e3) });
-      if (!resp.ok) continue;
-      const data = await resp.json();
-      if (data && typeof data === "object" && !Array.isArray(data)) {
-        return data;
-      }
-    } catch {
-    }
-  }
-  return null;
-}
-function readCache() {
-  try {
-    if (existsSync$1(cacheFile())) {
-      const data = JSON.parse(readFileSync$1(cacheFile(), "utf-8"));
-      if (data && typeof data === "object" && !Array.isArray(data)) return data;
-    }
-  } catch {
-  }
-  return null;
-}
-function writeCache(cfg) {
-  try {
-    mkdirSync(svampHome(), { recursive: true });
-    writeFileSync(cacheFile(), JSON.stringify(cfg, null, 2) + "\n", "utf-8");
-  } catch {
-  }
-}
-function applyConfig(cfg) {
-  _config = cfg;
-  if (cfg.hyphaServerUrl && typeof cfg.hyphaServerUrl === "string") {
-    process.env.HYPHA_SERVER_URL = stripSlash$1(cfg.hyphaServerUrl.trim());
-  }
-}
-async function loadInstanceConfig(opts = {}) {
-  if (_loaded && !opts.force) return _config;
-  const anchor = opts.anchor ? stripSlash$1(opts.anchor) : getInstanceUrl();
-  if (anchor) {
-    const fetched = await fetchConfig(anchor);
-    if (fetched) {
-      applyConfig(fetched);
-      writeCache(fetched);
-      _loaded = true;
-      _cacheChecked = true;
-      return _config;
-    }
-  }
-  const cached = readCache();
-  if (cached) applyConfig(cached);
-  _loaded = true;
-  _cacheChecked = true;
-  return _config;
-}
-function getLoadedConfig() {
-  if (!_loaded && !_cacheChecked) {
-    const cached = readCache();
-    if (cached) applyConfig(cached);
-    _cacheChecked = true;
-  }
-  return _config;
-}
-function clearInstanceConfigCache() {
-  _config = null;
-  _loaded = false;
-  _cacheChecked = false;
-  try {
-    if (existsSync$1(cacheFile())) rmSync(cacheFile());
-  } catch {
-  }
-}
-function __setConfigForTest(cfg) {
-  _config = cfg;
-  _loaded = true;
-  _cacheChecked = true;
-  if (cfg) applyConfig(cfg);
-}
-function __resetForTest() {
-  _config = null;
-  _loaded = false;
-  _cacheChecked = false;
-}
-
-var instanceConfig = /*#__PURE__*/Object.freeze({
-    __proto__: null,
-    CONFIG_FILENAME: CONFIG_FILENAME,
-    __resetForTest: __resetForTest,
-    __setConfigForTest: __setConfigForTest,
-    clearInstanceConfigCache: clearInstanceConfigCache,
-    configUrlsFor: configUrlsFor,
-    getInstanceUrl: getInstanceUrl,
-    getLoadedConfig: getLoadedConfig,
-    loadInstanceConfig: loadInstanceConfig
-});
-
-function stripSlash(u) {
-  return u.replace(/\/+$/, "");
-}
-function getHyphaServerUrl() {
-  const fromCfg = getLoadedConfig()?.hyphaServerUrl;
-  if (typeof fromCfg === "string" && fromCfg.trim()) return stripSlash(fromCfg.trim());
-  const env = (process.env.HYPHA_SERVER_URL || "").trim();
-  return env ? stripSlash(env) : void 0;
-}
-function getFrpsSubdomainHost() {
-  const fromCfg = getLoadedConfig()?.frps?.subdomainHost;
-  if (typeof fromCfg === "string" && fromCfg.trim()) return fromCfg.trim();
-  const env = (process.env.FRPS_SUBDOMAIN_HOST || "").trim();
-  if (env) return env;
-  throw new Error(
-    'frps subdomain host is not configured. Serve a svamp.json with "frps.subdomainHost" at your frontend URL (svamp login <frontend-url>), or set FRPS_SUBDOMAIN_HOST (legacy). It is deployment-specific and never guessed.'
-  );
-}
-function getFrpsServerAddr() {
-  const fromCfg = getLoadedConfig()?.frps?.serverAddr;
-  if (typeof fromCfg === "string" && fromCfg.trim()) return fromCfg.trim();
-  const env = (process.env.FRPS_SERVER_ADDR || "").trim();
-  if (env) return env;
-  return `frps-ctrl.${getFrpsSubdomainHost()}`;
-}
-function getFrpsServerPort() {
-  const fromCfg = getLoadedConfig()?.frps?.serverPort;
-  if (typeof fromCfg === "number" && Number.isFinite(fromCfg)) return fromCfg;
-  const env = parseInt(process.env.FRPS_SERVER_PORT || "", 10);
-  return Number.isFinite(env) ? env : void 0;
-}
-function getSvampWebBaseUrl() {
-  const fromCfg = getLoadedConfig()?.web?.baseUrl;
-  if (typeof fromCfg === "string" && fromCfg.trim()) return stripSlash(fromCfg.trim());
-  const env = (process.env.SVAMP_WEB_URL || "").trim();
-  if (env) return stripSlash(env);
-  const instance = getInstanceUrl();
-  if (instance) return instance;
-  throw new Error(
-    'Svamp web base URL is not configured. Serve a svamp.json with "web.baseUrl", log in with your frontend URL (svamp login <frontend-url>), or set SVAMP_WEB_URL (legacy).'
-  );
-}
-function getSkillsServerUrl() {
-  const fromCfg = getLoadedConfig()?.skills?.server;
-  if (typeof fromCfg === "string" && fromCfg.trim()) return stripSlash(fromCfg.trim());
-  const env = (process.env.HYPHA_SKILLS_SERVER || "").trim();
-  if (env) return stripSlash(env);
-  const server = getHyphaServerUrl();
-  if (server) return server;
-  throw new Error(
-    "Cannot determine skills marketplace server. Serve a svamp.json or set HYPHA_SERVER_URL."
-  );
-}
-function getSkillsWorkspace() {
-  const fromCfg = getLoadedConfig()?.skills?.workspace;
-  if (typeof fromCfg === "string" && fromCfg.trim()) return fromCfg.trim();
-  return (process.env.HYPHA_SKILLS_WORKSPACE || "").trim() || "hypha-cloud";
+   * Hypha token) but whose email is not authorized for the mount — or for a
+   * misconfigured owner mount with no resolvable owner. This is served as a
+   * 403; it deliberately does NOT redirect to the login page, which would
+   * loop forever and tell the user nothing about why they were rejected.
+   */
+  getAccessDeniedHtml(opts) {
+    const { email, access, ownerEmail, misconfigured } = opts;
+    const loginHref = `/__login__?return=${encodeURIComponent(opts.returnUrl || "/")}`;
+    let requirement;
+    if (misconfigured) {
+      requirement = `This resource is set to <b>owner-only</b> access, but the server never resolved an owner email (the daemon authenticated with a token that has no email claim). No account can satisfy this \u2014 it is a server-side misconfiguration, not a problem with your account. Fix it by re-creating the mount with an explicit email allowlist, e.g. <code>access: ["${escapeHtml(email || "you@example.com")}"]</code>.`;
+    } else if (access === "owner") {
+      requirement = `This resource is restricted to its owner${ownerEmail ? ` (<code>${escapeHtml(ownerEmail)}</code>)` : ""}.`;
+    } else if (Array.isArray(access)) {
+      const list = access.map((e) => `<code>${escapeHtml(e)}</code>`).join(", ");
+      requirement = `This resource is restricted to: ${list}.`;
+    } else {
+      requirement = "This resource is restricted.";
+    }
+    const signedInLine = email ? `You are signed in as <code>${escapeHtml(email)}</code>, which is not on the allow list.` : `You are not signed in.`;
+    return `<!DOCTYPE html>
+<html><head>
+<meta charset="utf-8">
+<meta name="viewport" content="width=device-width,initial-scale=1">
+<title>Access denied \u2014 Svamp File Server</title>
+<style>
+*{box-sizing:border-box;margin:0;padding:0}
+body{font-family:-apple-system,BlinkMacSystemFont,'Segoe UI',Roboto,sans-serif;display:flex;align-items:center;justify-content:center;min-height:100vh;background:#f6f8fa;color:#24292f;padding:16px}
+.card{background:#fff;border:1px solid #d0d7de;border-radius:12px;padding:32px;max-width:480px;width:100%;box-shadow:0 4px 12px rgba(31,35,40,0.06)}
+h1{font-size:1.25rem;margin-bottom:8px}
+.lead{color:#cf222e;font-weight:600;margin-bottom:16px}
+p{color:#3d444d;font-size:0.92rem;line-height:1.5;margin-bottom:14px}
+code{background:#f6f8fa;border:1px solid #d0d7de;border-radius:6px;padding:1px 6px;font-size:0.85em}
+a.btn{display:inline-block;background:#0969da;color:#fff;border-radius:8px;padding:10px 20px;font-weight:500;text-decoration:none;margin-top:4px}
+a.btn:hover{background:#0860c4}
+</style>
+</head><body>
+<div class="card">
+  <h1>${misconfigured ? "\u26D4 Access not possible" : "\u26D4 Access denied"}</h1>
+  <p class="lead">${signedInLine}</p>
+  <p>${requirement}</p>
+  ${misconfigured ? "" : `<a class="btn" href="${loginHref}">Sign in with a different account</a>`}
+</div>
+</body></html>`;
+  }
+  destroy() {
+    this.cache.clear();
+  }
 }
-function getSkillsCollection() {
-  const fromCfg = getLoadedConfig()?.skills?.collection;
-  if (typeof fromCfg === "string" && fromCfg.trim()) return fromCfg.trim();
-  return (process.env.HYPHA_SKILLS_COLLECTION || "").trim() || "marketplace";
+function escapeHtml(s) {
+  return s.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&#39;");
 }
 
+const SESSION_FILES_MOUNT = "svamp-session-files";
 function generateLinkToken() {
   return crypto.randomBytes(11).toString("hex");
 }
@@ -2267,6 +3130,8 @@ class ServeManager {
   managedPidDir;
   log;
   hyphaServerUrl;
+  /** #126: daemon-provided lookup of sessionId → { cwd, sharing, ownerEmail } for the files gateway. */
+  sessionResolver = null;
   constructor(svampHome, logger, hyphaServerUrl) {
     this.persistFile = path.join(svampHome, "serve-mounts.json");
     this.managedPidDir = path.join(svampHome, "serve-managed");
@@ -2279,6 +3144,60 @@ class ServeManager {
     this.auth = new ServeAuth({ hyphaServerUrl: this.hyphaServerUrl });
   }
   // ── Public API ───────────────────────────────────────────────────────
+  /**
+   * #126: register the daemon's sessionId → { cwd, sharing, ownerEmail } lookup used by the
+   * session-files gateway to resolve + authorize each request. Call once at daemon start.
+   */
+  setSessionResolver(fn) {
+    this.sessionResolver = fn;
+  }
+  /**
+   * #126: bring up the always-on, per-machine session-files gateway. Idempotent. `stableToken`
+   * must be a stable per-machine hex/alnum string (DNS-label-safe) so the gateway's subdomain is
+   * unique across machines AND stable across daemon restarts. The token is NOT a capability —
+   * every request is authorized per-session inside handleSessionFilesRequest. Returns the gateway
+   * base URL (`https://static-svamp-session-files-<token>.svc…/`) or null if the tunnel isn't up.
+   */
+  async ensureSessionFilesGateway(stableToken) {
+    if (!stableToken || !/^[a-z0-9-]{8,}$/i.test(stableToken)) {
+      throw new Error("ensureSessionFilesGateway: stableToken must be a DNS-label-safe string (\u22658 alnum/hyphen chars)");
+    }
+    const token = stableToken.toLowerCase();
+    const existing = this.mounts.get(SESSION_FILES_MOUNT);
+    if (!existing?.sessionFilesGateway || existing.linkToken !== token) {
+      this.mounts.set(SESSION_FILES_MOUNT, {
+        name: SESSION_FILES_MOUNT,
+        access: "link",
+        linkToken: token,
+        sessionFilesGateway: true,
+        addedAt: Date.now()
+      });
+    }
+    await this.ensureRunning();
+    if (!this.mountTunnels.has(SESSION_FILES_MOUNT)) {
+      await this.startMountTunnel(SESSION_FILES_MOUNT);
+    }
+    const base = this.getSessionFilesBaseUrl();
+    this.log(`Session-files gateway ready: ${base || "(tunnel pending)"}`);
+    return base;
+  }
+  /** #126: base URL of the session-files gateway, or null when the gateway/tunnel isn't up. */
+  getSessionFilesBaseUrl() {
+    const mount = this.mounts.get(SESSION_FILES_MOUNT);
+    if (!mount?.sessionFilesGateway) return null;
+    return this.getMountUrl(SESSION_FILES_MOUNT);
+  }
+  /**
+   * #126: the per-session file endpoint URL — `<base>s/<sessionId>/`. The frontend appends a
+   * relative file path and issues GET (download, Range-streamed) / PUT (upload, streamed) /
+   * DELETE / GET?list=1 (JSON dir listing). Null when the gateway tunnel isn't up (→ RPC fallback).
+   */
+  getSessionFilesEndpoint(sessionId) {
+    const base = this.getSessionFilesBaseUrl();
+    if (!base) return null;
+    const b = base.endsWith("/") ? base : `${base}/`;
+    return `${b}s/${encodeURIComponent(sessionId)}/`;
+  }
   /**
    * Add a static mount (backward-compatible thin wrapper around applyMount).
    * Throws if a mount with the same name already exists, preserving the
@@ -2384,7 +3303,7 @@ class ServeManager {
    * List mounts, optionally filtered by sessionId.
    */
   listMounts(sessionId) {
-    const all = Array.from(this.mounts.values());
+    const all = Array.from(this.mounts.values()).filter((m) => !m.sessionFilesGateway);
     const filtered = sessionId ? all.filter((m) => m.sessionId === sessionId) : all;
     return filtered.map((m) => ({ ...m, url: this.getMountUrl(m.name) || void 0 }));
   }
@@ -2402,8 +3321,9 @@ class ServeManager {
       port: running ? this.port : 0,
       authProxyPort: running ? this.port : 0,
       running,
-      mountCount: this.mounts.size,
-      mounts: Array.from(this.mounts.values()).map((m) => ({
+      // #126: exclude the internal session-files gateway from user-facing counts/listings.
+      mountCount: Array.from(this.mounts.values()).filter((m) => !m.sessionFilesGateway).length,
+      mounts: Array.from(this.mounts.values()).filter((m) => !m.sessionFilesGateway).map((m) => ({
         ...m,
         url: this.getMountUrl(m.name) || void 0
       }))
@@ -2717,7 +3637,9 @@ class ServeManager {
   }
   persist() {
     const state = {
-      mounts: Array.from(this.mounts.values()),
+      // #126: the session-files gateway is recreated fresh at daemon start (directory-less,
+      // token owned by the daemon) — never persist it.
+      mounts: Array.from(this.mounts.values()).filter((m) => !m.sessionFilesGateway),
       ...this.port > 0 ? { port: this.port } : {}
     };
     try {
@@ -2737,6 +3659,7 @@ class ServeManager {
     if (this.proxyServer) return;
     killOrphanedCaddy((m) => this.log(m));
     reapOrphanedManagedProcesses(this.managedPidDir, (m) => this.log(m));
+    killOrphanedFrpc((m) => this.log(m));
     this.port = await tryReservePort(this.persistedPort);
     if (this.persistedPort && this.port !== this.persistedPort) {
       this.log(`\u26A0 Previous serve port ${this.persistedPort} unavailable \u2014 using ${this.port}. Downstream configs referencing the old port will need updating.`);
@@ -2754,6 +3677,195 @@ h1{font-size:1.3rem}ul{list-style:none;padding:0}li{padding:8px 0;border-bottom:
 a{color:#0969da;text-decoration:none;font-weight:500}a:hover{text-decoration:underline}</style></head>
 <body><h1>Svamp File Server</h1><ul>${items || "<li>No mounts registered.</li>"}</ul></body></html>`;
   }
+  /**
+   * #126: handle a request to the session-files gateway. Routes `/s/<sessionId>/<relPath>`:
+   *   OPTIONS            → CORS preflight (GET/HEAD/PUT/DELETE)
+   *   GET/HEAD           → download (Range/206 streamed via serveStaticMount)
+   *   GET …?list=1       → JSON directory listing [{name,isDir,size,mtime}]
+   *   PUT                → streamed upload to a temp file + atomic rename (large-file safe)
+   *   DELETE             → unlink
+   *
+   * Auth (live boundary): authenticate the requester's email via ServeAuth (parse_token), then
+   * authorize against THAT session's owner/sharing at role 'admin' — mirroring the RPC file ops.
+   * CRITICAL: unlike the RPC path (which relies on Hypha workspace isolation for null sharing),
+   * this is a PUBLIC HTTP ingress, so it FAILS CLOSED: a null/disabled sharing config admits ONLY
+   * the session owner. No token → 401; valid token but not owner/admin → 403.
+   */
+  async handleSessionFilesRequest(req, res, url, basePath) {
+    const CORS = {
+      "Access-Control-Allow-Origin": "*",
+      "Access-Control-Allow-Methods": "GET, HEAD, PUT, DELETE, OPTIONS",
+      "Access-Control-Allow-Headers": "*",
+      "Access-Control-Expose-Headers": "Content-Length, Content-Range, ETag",
+      "Access-Control-Max-Age": "600"
+    };
+    const method = (req.method || "GET").toUpperCase();
+    const deny = (code, msg) => {
+      res.writeHead(code, { ...CORS, "Content-Type": "text/plain", "Cache-Control": "no-store" });
+      res.end(msg);
+    };
+    if (method === "OPTIONS") {
+      res.writeHead(204, CORS);
+      res.end();
+      return;
+    }
+    const m = /^\/s\/([^/]+)(?:\/(.*))?$/.exec(basePath);
+    if (!m) {
+      deny(404, "Not found: expected /s/<sessionId>/<path>");
+      return;
+    }
+    const sessionId = decodeURIComponent(m[1]);
+    const relPath = m[2] ? `/${m[2]}` : "/";
+    const target = this.sessionResolver ? this.sessionResolver(sessionId) : void 0;
+    if (!target || !target.cwd) {
+      deny(404, "Unknown session");
+      return;
+    }
+    const userEmail = this.auth ? await this.auth.authenticate(req).catch(() => null) : null;
+    if (!userEmail) {
+      deny(401, "Authentication required");
+      return;
+    }
+    const ownerEmail = (target.ownerEmail || "").toLowerCase();
+    const isOwner = !!ownerEmail && userEmail.toLowerCase() === ownerEmail;
+    if (!isOwner) {
+      const sharing = target.sharing;
+      if (!sharing || !sharing.enabled) {
+        this.log(`Files-gateway DENY '${sessionId}': ${userEmail} not owner and session not shared`);
+        deny(403, "Access denied");
+        return;
+      }
+      try {
+        authorizeRequest({ user: { email: userEmail } }, sharing, "admin");
+      } catch (err) {
+        this.log(`Files-gateway DENY '${sessionId}': ${userEmail} \u2014 ${err?.message || "not admin"}`);
+        deny(403, "Access denied");
+        return;
+      }
+    }
+    const rootDir = target.cwd;
+    if (method === "GET" || method === "HEAD") {
+      if (url.searchParams.get("list") === "1") {
+        const lex = containedPath(rootDir, relPath.replace(/^\/+/, ""));
+        if (!lex) {
+          deny(403, "Forbidden");
+          return;
+        }
+        let entries;
+        try {
+          const dirents = fs.readdirSync(lex, { withFileTypes: true });
+          entries = dirents.map((d) => {
+            let size = 0, mtime = 0, isDir = d.isDirectory();
+            try {
+              const st = fs.statSync(path.join(lex, d.name));
+              size = st.size;
+              mtime = Math.floor(st.mtimeMs);
+              isDir = st.isDirectory();
+            } catch {
+            }
+            return { name: d.name, isDir, size, mtime };
+          });
+        } catch (err) {
+          deny(err?.code === "ENOENT" ? 404 : 500, `Listing failed: ${err?.message || err}`);
+          return;
+        }
+        res.writeHead(200, { ...CORS, "Content-Type": "application/json; charset=utf-8", "Cache-Control": "no-store" });
+        res.end(method === "HEAD" ? void 0 : JSON.stringify({ path: relPath, entries }));
+        return;
+      }
+      serveStaticMount(req, res, { rootDir, relPath, mountUrlPrefix: "", browse: false});
+      return;
+    }
+    if (method === "PUT" || method === "DELETE") {
+      const filePath = this.resolveContainedPath(rootDir, relPath);
+      if (!filePath) {
+        deny(403, "Forbidden: path escapes session root");
+        return;
+      }
+      if (method === "DELETE") {
+        try {
+          fs.unlinkSync(filePath);
+          res.writeHead(204, CORS);
+          res.end();
+        } catch (err) {
+          deny(err?.code === "ENOENT" ? 404 : 500, err?.message || "delete failed");
+        }
+        return;
+      }
+      let dir;
+      try {
+        dir = path.dirname(filePath);
+        fs.mkdirSync(dir, { recursive: true });
+      } catch (err) {
+        deny(500, `mkdir failed: ${err?.message || err}`);
+        return;
+      }
+      const tmp = path.join(dir, `.svamp-upload-${process.pid}-${crypto.randomBytes(6).toString("hex")}.part`);
+      const ws = fs.createWriteStream(tmp);
+      let settled = false;
+      const cleanupPartial = () => {
+        if (settled) return;
+        settled = true;
+        ws.destroy();
+        fs.unlink(tmp, () => {
+        });
+      };
+      req.on("aborted", cleanupPartial);
+      req.on("close", () => {
+        if (!ws.writableFinished && !req.complete) cleanupPartial();
+      });
+      ws.on("error", (err) => {
+        if (settled) return;
+        settled = true;
+        fs.unlink(tmp, () => {
+        });
+        if (!res.headersSent) deny(500, err.message);
+      });
+      ws.on("finish", () => {
+        if (settled) return;
+        settled = true;
+        try {
+          fs.renameSync(tmp, filePath);
+          res.writeHead(201, CORS);
+          res.end();
+        } catch (err) {
+          fs.unlink(tmp, () => {
+          });
+          if (!res.headersSent) deny(500, `rename failed: ${err?.message || err}`);
+        }
+      });
+      req.pipe(ws);
+      return;
+    }
+    deny(405, "Method not allowed");
+  }
+  /**
+   * #126: resolve a session-relative path against `rootDir` with lexical + symlink containment
+   * (mirrors the static PUT handler's resolveContained). Allows a not-yet-existing target (for
+   * PUT) as long as its deepest existing ancestor stays within the real root. Returns the
+   * contained absolute path, or null on any traversal/symlink escape (fail-closed).
+   */
+  resolveContainedPath(rootDir, relPath) {
+    const base = path.resolve(rootDir);
+    const lex = containedPath(base, relPath.replace(/^\/+/, ""));
+    if (!lex) return null;
+    try {
+      const realRoot = fs.realpathSync(base);
+      let ancestor = lex;
+      while (!fs.existsSync(ancestor) && path.dirname(ancestor) !== ancestor) {
+        ancestor = path.dirname(ancestor);
+      }
+      const realAncestor = fs.realpathSync(ancestor);
+      if (realAncestor !== realRoot && !realAncestor.startsWith(realRoot + path.sep)) return null;
+      if (fs.existsSync(lex) && fs.lstatSync(lex).isSymbolicLink()) {
+        const realTarget = fs.realpathSync(lex);
+        if (realTarget !== realRoot && !realTarget.startsWith(realRoot + path.sep)) return null;
+      }
+    } catch {
+      return null;
+    }
+    return lex;
+  }
   /** Start a lightweight Node.js HTTP proxy with auth + upload support. */
   startAuthProxy() {
     return new Promise((resolve, reject) => {
@@ -2798,6 +3910,10 @@ a{color:#0969da;text-decoration:none;font-weight:500}a:hover{text-decoration:und
             res.end(html);
             return;
           }
+          if (mount?.sessionFilesGateway) {
+            await this.handleSessionFilesRequest(req, res, url, basePath);
+            return;
+          }
           if (mount && mount.access !== "public" && mount.access !== "link") {
             const userEmail = this.auth ? await this.auth.authenticate(req).catch(() => null) : null;
             if (mount.access === "owner" && !mount.ownerEmail) {
@@ -3153,7 +4269,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-pwqsONPX.mjs');
+      const { FrpcTunnel } = await Promise.resolve().then(function () { return frpc; });
       let tunnel;
       tunnel = new FrpcTunnel({
         name: tunnelName,
@@ -3249,7 +4365,11 @@ function writeEnvLines(lines) {
   while (lines.length > 0 && lines[lines.length - 1].trim() === "") {
     lines.pop();
   }
-  writeFileSync$1(file, lines.join("\n") + "\n", "utf-8");
+  writeFileSync$1(file, lines.join("\n") + "\n", { encoding: "utf-8", mode: 384 });
+  try {
+    chmodSync$1(file, 384);
+  } catch {
+  }
 }
 function updateEnvFile(updates) {
   const lines = readEnvLines();
@@ -3515,7 +4635,7 @@ function saveAccounts(accounts, svampHome) {
   const payload = { version: 1, accounts };
   writeFileSync$1(file, JSON.stringify(payload, null, 2) + "\n", { encoding: "utf-8", mode: 384 });
   try {
-    chmodSync(file, 384);
+    chmodSync$1(file, 384);
   } catch {
   }
 }
@@ -3570,7 +4690,7 @@ function upsertAccount(input, svampHome) {
   const now = Date.now();
   const existing = input.id ? accounts.find((a) => a.id === input.id) : void 0;
   const account = {
-    id: existing?.id || input.id || randomUUID(),
+    id: existing?.id || input.id || randomUUID$1(),
     label: input.label.trim(),
     vendor,
     method,
@@ -3829,7 +4949,7 @@ const ANTHROPIC_REDIRECT_URI = "https://console.anthropic.com/oauth/code/callbac
 const ANTHROPIC_SCOPES = "user:profile user:inference user:sessions:claude_code user:mcp_servers user:file_upload";
 function generatePkce() {
   const verifier = randomBytes(32).toString("base64url");
-  const challenge = createHash("sha256").update(verifier).digest("base64url");
+  const challenge = createHash$1("sha256").update(verifier).digest("base64url");
   return { verifier, challenge };
 }
 function buildAnthropicAuthUrl(challenge, state) {
@@ -3938,14 +5058,14 @@ function startAnthropicFlow(label) {
   pruneFlows();
   const { verifier, challenge } = generatePkce();
   const state = randomBytes(32).toString("base64url");
-  const flowId = randomUUID();
+  const flowId = randomUUID$1();
   const authorizeUrl = buildAnthropicAuthUrl(challenge, state);
   flows.set(flowId, { id: flowId, vendor: "anthropic", label, createdAt: Date.now(), status: "pending", state, verifier });
   return { flowId, authorizeUrl };
 }
 function startOpenAiDeviceFlow(label, log, svampHome) {
   pruneFlows();
-  const flowId = randomUUID();
+  const flowId = randomUUID$1();
   const codexHome = join$1(oauthFlowDir(flowId, svampHome), "codex");
   mkdirSync$1(codexHome, { recursive: true });
   const flow = { id: flowId, vendor: "openai", label, createdAt: Date.now(), status: "pending", codexHome, outputBuffer: "" };
@@ -4323,10 +5443,17 @@ function validateChannel(c) {
   if (c.action?.kind === "loop" && m === "caller-supplied" && !c.identity?.shared_key)
     errs.push("a caller-supplied channel without a shared_key may not use a loop action (unauthenticated task injection)");
   if (c.action?.kind === "agent" && m === "caller-supplied" && !c.identity?.shared_key) {
-    const MUTATING = ["run_bash", "send_to_session"];
     const ag = c.action.agent || {};
-    const grantsMutating = (ag.tools || []).some((t) => MUTATING.includes(t)) || Object.values(ag.per_caller || {}).some((p) => (p?.tools || []).some((t) => MUTATING.includes(t)));
-    if (grantsMutating) errs.push("a caller-supplied agent channel without a shared_key may not grant run_bash/send_to_session");
+    const offending = /* @__PURE__ */ new Set();
+    for (const t of ag.tools || []) if (MUTATING_TOOLS.includes(t)) offending.add(t);
+    for (const p of Object.values(ag.per_caller || {})) {
+      for (const t of p?.tools || []) if (MUTATING_TOOLS.includes(t)) offending.add(t);
+    }
+    if (offending.size) {
+      errs.push(
+        `a caller-supplied agent channel without a shared_key may not grant mutating tools (${[...offending].sort().join(", ")})`
+      );
+    }
   }
   const unsafe = /[<>"'&\r\n]/;
   if (unsafe.test(c.name || "")) errs.push(`name must be single-line and not contain < > " ' &`);
@@ -4503,11 +5630,15 @@ function generateSkillBody(channel, ctx) {
 const res = await get_service("${svc}").send({ channel: "${channel.id}", message: "\u2026", from: "your-name" });
 if (res.status === "completed") return res.reply;          // answered now \u2014 done
 let cursor = 0;                                            // else poll for the async reply
-while (true) {
+// BOUNDED: ~10 min (24 x wait:25). Do not loop forever \u2014 repliability is now the DEFAULT on
+// every ordinary message channel, so you may well be polling a notification channel nobody
+// is watching, and an unbounded loop would spin (and re-read the server-side outbox) forever.
+for (let i = 0; i < 24; i++) {
   const r = await get_service("${svc}").receive({ channel: "${channel.id}", key: "${key}", correlationId: res.correlationId, cursor, wait: 25 });
   cursor = r.cursor;
   if (r.replies.length) return r.replies[0].body;          // server matched it by correlationId
 }
+return null;                                               // no reply \u2014 this channel may be fire-and-forget
 \`\`\`
 **HTTP:** \`POST ${recvUrl}\` with \`{"kwargs": {"channel": "${channel.id}", "key": "${key}", "correlationId": "<from send>", "cursor": 0, "wait": 25}}\` (long-poll), or stream \`GET <channel-http>/channel/${channel.id}/events?key=${key}\` (SSE).
 > Tip: always pass the \`correlationId\` from \`send\` to \`receive\` \u2014 it is the reply key, so the reply finds you with no identity matching. Omit it and \`receive\` falls back to matching your \`from\`, which you must then supply identically on every call.
@@ -4987,6 +6118,7 @@ const SESSION_METHOD_MIN_ROLE = {
   readFile: "admin",
   writeFile: "admin",
   writeFileChunk: "admin",
+  filesEndpoint: "admin",
   listDirectory: "admin",
   bash: "admin",
   issue: "admin",
@@ -5911,13 +7043,15 @@ async function registerMachineService(server, machineId, metadata, daemonState,
           if (session.outputBuffer.length > 1e3) {
             session.outputBuffer.splice(0, session.outputBuffer.length - 500);
           }
-          try {
-            server.emit({
-              type: "svamp:terminal-output",
-              data: { type: "output", content: batch, sessionId },
-              to: terminalClient ?? "*"
-            });
-          } catch {
+          if (terminalClient) {
+            try {
+              server.emit({
+                type: "svamp:terminal-output",
+                data: { type: "output", content: batch, sessionId },
+                to: terminalClient
+              });
+            } catch {
+            }
           }
         };
         ptyProcess.onData((data) => {
@@ -5930,13 +7064,15 @@ async function registerMachineService(server, machineId, metadata, daemonState,
           session.exited = true;
           session.exitCode = exitCode;
           session.exitSignal = signal;
-          try {
-            server.emit({
-              type: "svamp:terminal-output",
-              data: { type: "exit", content: "", sessionId, exitCode, signal },
-              to: terminalClient ?? "*"
-            });
-          } catch {
+          if (terminalClient) {
+            try {
+              server.emit({
+                type: "svamp:terminal-output",
+                data: { type: "exit", content: "", sessionId, exitCode, signal },
+                to: terminalClient
+              });
+            } catch {
+            }
           }
           setTimeout(() => {
             if (terminalSessions.has(sessionId)) {
@@ -6292,7 +7428,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-pwqsONPX.mjs');
+        const { FrpcTunnel } = await Promise.resolve().then(function () { return frpc; });
         const tunnel = new FrpcTunnel({
           name: params.name,
           ports: params.ports,
@@ -6551,7 +7687,7 @@ async function registerMachineService(server, machineId, metadata, daemonState,
           const sessionRpc = handlers.getSessionRPCHandlers?.(sid);
           if (sessionRpc?.saveChannel) {
             try {
-              const sharedKey = createHash("sha256").update(sid + (process.env.INTERNAL_API_SECRET || "")).digest("hex").slice(0, 32);
+              const sharedKey = createHash$1("sha256").update(sid + (process.env.INTERNAL_API_SECRET || "")).digest("hex").slice(0, 32);
               const meetingChannel = {
                 id: `meeting-${sid}`,
                 name: `Meeting WISE (${sid})`,
@@ -6785,7 +7921,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-DU8QZetT.mjs');
+          const { toolsForRole } = await import('./sideband-C0CGbTIK.mjs');
           const r2 = await runWiseAgent({ message: params.message, sender, config: { tools: toolsForRole(role2) }, deps, transport, model: resolved.model });
           return fmt(r2);
         }
@@ -6884,13 +8020,13 @@ QUESTION: ${params.question || "Summarize this concisely."}` }
       hyphaWorkspace: u?.scope?.current_workspace
     });
     if (r.error || !r.sender) return { error: r.error || "unauthorized" };
-    const callId = "call_" + randomUUID().slice(0, 10);
+    const callId = "call_" + randomUUID$1().slice(0, 10);
     const senderKey = (r.sender.name || "anonymous").toLowerCase();
     if (!statelessLimiter.tryAcquire(senderKey)) {
       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-CjBsJQX-.mjs');
+    const { queryCore } = await import('./commands-DRYk0mQr.mjs');
     const timeout = c.reply?.timeout_sec || 120;
     let result;
     try {
@@ -7030,7 +8166,7 @@ ${d?.error || "not found"}`;
         try {
           const saved = writeUpload(dir, v.target, dec.data);
           try {
-            new ChannelStore(dir).recordCall(c.id, { sender: r.sender.name, verified: r.sender.verified, callId: "up_" + randomUUID().slice(0, 10), outcome: "uploaded" });
+            new ChannelStore(dir).recordCall(c.id, { sender: r.sender.name, verified: r.sender.verified, callId: "up_" + randomUUID$1().slice(0, 10), outcome: "uploaded" });
           } catch {
           }
           return { ok: true, name: saved.name, path: saved.relPath, bytes: saved.bytes };
@@ -7139,7 +8275,7 @@ function writeInboundContext(sessionId, ctx) {
   try {
     const p = ctxPath(sessionId);
     mkdirSync$1(join$1(SVAMP_HOME$2, "inbound"), { recursive: true });
-    const tmp = `${p}.${process.pid}.${randomUUID()}.tmp`;
+    const tmp = `${p}.${process.pid}.${randomUUID$1()}.tmp`;
     writeFileSync$1(tmp, JSON.stringify({ ...ctx, deliveredAt: Date.now() }));
     renameSync(tmp, p);
   } catch {
@@ -7224,7 +8360,7 @@ function writeAwaiting(sessionId, map) {
   try {
     mkdirSync$1(join$1(SVAMP_HOME$2, "awaiting"), { recursive: true });
     const p = awaitPath(sessionId);
-    const tmp = `${p}.${process.pid}.${randomUUID()}.tmp`;
+    const tmp = `${p}.${process.pid}.${randomUUID$1()}.tmp`;
     writeFileSync$1(tmp, JSON.stringify(map));
     renameSync(tmp, p);
   } catch {
@@ -7486,7 +8622,7 @@ function ensureOutpostToken(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);
+    chmodSync$1(file, 384);
   } catch {
   }
   return rec;
@@ -7564,7 +8700,7 @@ function savePairings(pairings, svampHome) {
   const payload = { version: 1, pairings };
   writeFileSync$1(file, JSON.stringify(payload, null, 2) + "\n", { encoding: "utf-8", mode: 384 });
   try {
-    chmodSync(file, 384);
+    chmodSync$1(file, 384);
   } catch {
   }
 }
@@ -8034,14 +9170,35 @@ function loadMessagesFromDiskReverse(messagesDir, beforeSeq, limit) {
     return { messages: [], hasMore: false };
   }
 }
+const messageCountCache = /* @__PURE__ */ new Map();
 function countMessagesOnDisk(messagesDir, fallbackInMemory) {
   const filePath = join$1(messagesDir, "messages.jsonl");
   if (!existsSync(filePath)) return fallbackInMemory;
   try {
-    const data = readFileSync(filePath, "utf-8");
-    let count = 0;
-    for (let i = 0; i < data.length; i++) if (data.charCodeAt(i) === 10) count++;
-    if (data.length > 0 && data[data.length - 1] !== "\n") count++;
+    const st = statSync(filePath);
+    const cached = messageCountCache.get(filePath);
+    if (cached && cached.size === st.size && cached.mtimeMs === st.mtimeMs) return cached.count;
+    let count;
+    if (cached && st.size > cached.size) {
+      const fd = openSync(filePath, "r");
+      try {
+        const len = st.size - cached.size;
+        const buf = Buffer.allocUnsafe(len);
+        const read = readSync(fd, buf, 0, len, cached.size);
+        let added = 0;
+        for (let i = 0; i < read; i++) if (buf[i] === 10) added++;
+        count = cached.count + added;
+        if (read > 0 && buf[read - 1] !== 10) count++;
+      } finally {
+        closeSync(fd);
+      }
+    } else {
+      const data = readFileSync(filePath, "utf-8");
+      count = 0;
+      for (let i = 0; i < data.length; i++) if (data.charCodeAt(i) === 10) count++;
+      if (data.length > 0 && data[data.length - 1] !== "\n") count++;
+    }
+    messageCountCache.set(filePath, { size: st.size, mtimeMs: st.mtimeMs, count });
     return count;
   } catch {
     return fallbackInMemory;
@@ -8255,11 +9412,11 @@ function createSessionStore(server, sessionId, initialMetadata, initialAgentStat
     if (role === "agent") {
       const data = { ...content };
       if ((data.type === "assistant" || data.type === "user") && !data.uuid) {
-        data.uuid = randomUUID();
+        data.uuid = randomUUID$1();
       }
       wrappedContent = { role: "agent", content: { type: "output", data } };
     } else if (role === "event") {
-      wrappedContent = { role: "agent", content: { type: "event", id: randomUUID(), data: content } };
+      wrappedContent = { role: "agent", content: { type: "event", id: randomUUID$1(), data: content } };
     } else if (role === "session") {
       wrappedContent = { role: "session", content: { type: "session", data: content } };
     } else {
@@ -8267,7 +9424,7 @@ function createSessionStore(server, sessionId, initialMetadata, initialAgentStat
       wrappedContent = { role: "user", content: { type: "text", text } };
     }
     const msg = {
-      id: randomUUID(),
+      id: randomUUID$1(),
       seq: nextSeq++,
       content: wrappedContent,
       localId: null,
@@ -8305,7 +9462,7 @@ function createSessionStore(server, sessionId, initialMetadata, initialAgentStat
     const msg = {
       // #0816: CSPRNG — this id routes `svamp session inbox reply`, so a predictable
       // one lets a third party target another agent's reply thread.
-      messageId: "op_" + randomUUID().slice(0, 10),
+      messageId: "op_" + randomUUID$1().slice(0, 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,
@@ -8550,10 +9707,10 @@ function createSessionStore(server, sessionId, initialMetadata, initialAgentStat
     const wrappedContent = parsed && parsed.role === "user" ? { role: "user", content: parsed.content } : { role: "user", content: { type: "text", text: typeof parsed === "string" ? parsed : JSON.stringify(parsed) } };
     if (isBtwEcho) wrappedContent.meta = { btw: true };
     const msg = {
-      id: randomUUID(),
+      id: randomUUID$1(),
       seq: nextSeq++,
       content: wrappedContent,
-      localId: effectiveLocalId || randomUUID(),
+      localId: effectiveLocalId || randomUUID$1(),
       createdAt: Date.now(),
       updatedAt: Date.now()
     };
@@ -8943,7 +10100,7 @@ function createSessionStore(server, sessionId, initialMetadata, initialAgentStat
         hyphaWorkspace: u?.scope?.current_workspace
       });
       if (r.error || !r.sender) return { error: r.error || "unauthorized" };
-      const callId = "call_" + randomUUID().slice(0, 10);
+      const callId = "call_" + randomUUID$1().slice(0, 10);
       const ownerEmail = metadata.sharing?.owner;
       const ownerCtx = ownerEmail ? { user: { email: ownerEmail, id: ownerEmail } } : void 0;
       try {
@@ -9028,7 +10185,7 @@ function createSessionStore(server, sessionId, initialMetadata, initialAgentStat
       if (dec.error || !dec.data) return { error: dec.error || "invalid content" };
       const v = validateUpload({ projectDir: metadata.path, channel: c, filename: params.filename, bytes: dec.data.length, contentType: params.content_type });
       if (v.error || !v.target) return { error: v.error || "upload rejected" };
-      const callId = "call_" + randomUUID().slice(0, 10);
+      const callId = "call_" + randomUUID$1().slice(0, 10);
       try {
         const saved = writeUpload(metadata.path, v.target, dec.data);
         channelStore.recordCall(c.id, { sender: r.sender.name, verified: r.sender.verified, callId, outcome: "uploaded" });
@@ -9065,6 +10222,9 @@ function createSessionStore(server, sessionId, initialMetadata, initialAgentStat
     channelReceive: async (params, context) => {
       const c = channelStore.get(params.channel);
       if (!c || c.enabled === false) return { error: "channel not found" };
+      if (!channelAsyncRepliable(c)) {
+        return { error: "this channel has no async replies (agent/loop/stateless channels reply synchronously)" };
+      }
       const u = context?.user;
       const r = resolveSender(c, {
         key: params.key,
@@ -9194,6 +10354,13 @@ function createSessionStore(server, sessionId, initialMetadata, initialAgentStat
       await callbacks.onWriteFileChunk(path, content, uploadId, chunkIndex, totalChunks, isLast);
       return { success: true };
     },
+    // #126: HTTP files-gateway base URL for this session (large upload/download over the frp
+    // tunnel). Admin-gated like the other file ops. Returns { url: null } when the gateway tunnel
+    // isn't up yet → the frontend falls back to the RPC chunked path.
+    filesEndpoint: async (context) => {
+      authorizeRequest(context, metadata.sharing, "admin");
+      return { url: callbacks.onFilesEndpoint?.() ?? null };
+    },
     listDirectory: async (path, context) => {
       authorizeRequest(context, metadata.sharing, "admin");
       if (!callbacks.onListDirectory) throw new Error("listDirectory not supported");
@@ -10741,10 +11908,10 @@ function computeCollectionConfigUpdate(existingConfig, extra) {
   return { changed, merged: { ...cfg, ...extra } };
 }
 function emailHash(email) {
-  return createHash("sha256").update(email.toLowerCase()).digest("hex").slice(0, 12);
+  return createHash$1("sha256").update(email.toLowerCase()).digest("hex").slice(0, 12);
 }
 function sessionIdHash(sessionId) {
-  return createHash("sha256").update(sessionId).digest("hex").slice(0, 12);
+  return createHash$1("sha256").update(sessionId).digest("hex").slice(0, 12);
 }
 function roleLabel(role) {
   switch (role) {
@@ -10864,7 +12031,7 @@ class SharingNotificationSync {
     const shareType = params.shareType || "session";
     const typeLabel = shareType === "machine" ? "Machine" : "Session";
     await this.publishUserEvent({
-      id: randomUUID(),
+      id: randomUUID$1(),
       recipientEmail: params.recipientEmail.toLowerCase(),
       type: "sharing-invite",
       source: {
@@ -10914,7 +12081,7 @@ class SharingNotificationSync {
     } catch {
     }
     await this.publishUserEvent({
-      id: randomUUID(),
+      id: randomUUID$1(),
       recipientEmail: recipientEmail.toLowerCase(),
       type: "sharing-revoked",
       source: {
@@ -11572,7 +12739,7 @@ class AcpBackend {
   }
   async startSession(initialPrompt) {
     if (this.disposed) throw new Error("Backend has been disposed");
-    const sessionId = randomUUID();
+    const sessionId = randomUUID$1();
     this.emit({ type: "status", status: "starting" });
     let startupStatusErrorEmitted = false;
     try {
@@ -11650,6 +12817,7 @@ class AcpBackend {
         this.emit({ type: "status", status: "error", detail: err.message });
       });
       this.process.on("exit", (code, signal) => {
+        this.process = null;
         if (this.disposed) return;
         if (code !== 0 && code !== null) {
           signalStartupFailure(new Error(`Exit code: ${code}`));
@@ -11721,7 +12889,7 @@ class AcpBackend {
           const extendedParams = params;
           const toolCall = extendedParams.toolCall;
           let toolName = toolCall?.kind || toolCall?.toolName || extendedParams.kind || "Unknown tool";
-          const toolCallId = toolCall?.id || randomUUID();
+          const toolCallId = toolCall?.id || randomUUID$1();
           const permissionId = toolCallId;
           let input = {};
           if (toolCall) {
@@ -12216,6 +13384,25 @@ var acpAgentConfig = /*#__PURE__*/Object.freeze({
     resolveAcpAgentConfig: resolveAcpAgentConfig
 });
 
+function applyPermissionResolution(sessionService, requestId, approved) {
+  const reqs = { ...sessionService._agentState?.requests };
+  if (!(requestId in reqs)) return;
+  const completedReqs = { ...sessionService._agentState?.completedRequests };
+  const existingReq = reqs[requestId];
+  delete reqs[requestId];
+  sessionService.updateAgentState({
+    controlledByUser: false,
+    requests: reqs,
+    completedRequests: {
+      ...completedReqs,
+      [requestId]: {
+        ...existingReq || {},
+        completedAt: Date.now(),
+        status: approved ? "approved" : "denied"
+      }
+    }
+  });
+}
 function bridgeAcpToSession(backend, sessionService, getMetadata, setMetadata, log, onTurnEnd, getModelLabel) {
   let pendingText = "";
   let pendingThinking = "";
@@ -12325,22 +13512,7 @@ function bridgeAcpToSession(backend, sessionService, getMetadata, setMetadata, l
         break;
       }
       case "permission-response": {
-        const reqs = { ...sessionService._agentState?.requests };
-        const completedReqs = { ...sessionService._agentState?.completedRequests };
-        const existingReq = reqs[msg.id];
-        delete reqs[msg.id];
-        sessionService.updateAgentState({
-          controlledByUser: false,
-          requests: reqs,
-          completedRequests: {
-            ...completedReqs,
-            [msg.id]: {
-              ...existingReq || {},
-              completedAt: Date.now(),
-              status: msg.approved ? "approved" : "denied"
-            }
-          }
-        });
+        applyPermissionResolution(sessionService, msg.id, msg.approved);
         break;
       }
       case "event": {
@@ -12372,9 +13544,10 @@ function bridgeAcpToSession(backend, sessionService, getMetadata, setMetadata, l
   };
 }
 class HyphaPermissionHandler {
-  constructor(shouldAutoAllow, log) {
+  constructor(shouldAutoAllow, log, onAutoResolved) {
     this.shouldAutoAllow = shouldAutoAllow;
     this.log = log;
+    this.onAutoResolved = onAutoResolved;
   }
   pendingPermissions = /* @__PURE__ */ new Map();
   // #0445: safety auto-decline so an unanswered ACP/Gemini permission can't wedge the turn
@@ -12396,6 +13569,10 @@ class HyphaPermissionHandler {
           this.pendingPermissions.delete(toolCallId);
           this.log(`[ACP Permission] Auto-declining ${toolName} after ${timeoutMs}ms with no response`);
           p.resolve({ decision: "denied" });
+          try {
+            this.onAutoResolved?.(toolCallId, false);
+          } catch {
+          }
         }
       }, timeoutMs);
       timer.unref?.();
@@ -12422,6 +13599,10 @@ class HyphaPermissionHandler {
     for (const [id, pending] of this.pendingPermissions) {
       if (pending.timer) clearTimeout(pending.timer);
       pending.resolve({ decision: "denied" });
+      try {
+        this.onAutoResolved?.(id, false);
+      } catch {
+      }
     }
     this.pendingPermissions.clear();
   }
@@ -12502,7 +13683,7 @@ function codexCumulativeTokens(payload) {
   return nonCachedInput + output + Math.round(cached * 0.1);
 }
 
-const PINNED_CODEX_VERSION = "0.146.0";
+const PINNED_CODEX_VERSION = "0.147.0";
 const MIN_CODEX_STEER_VERSION = { major: 0, minor: 129, patch: 0 };
 function cmpVer(a, b) {
   return a.major - b.major || a.minor - b.minor || a.patch - b.patch;
@@ -12605,6 +13786,7 @@ class CodexAppServerClient {
     child.stderr?.on("data", (d) => this.log("[codex-app-server:stderr]", d.toString().trim()));
     child.on("exit", (code) => {
       const wasConnected = this.connected;
+      if (this.process === child) this.process = null;
       this.connected = false;
       this.failAllPending(new Error(`codex app-server exited (code ${code})`));
       this.resolvePendingTurn(true);
@@ -12948,7 +14130,7 @@ class CodexAppServerBackend {
   }
   listeners = [];
   client;
-  sessionId = randomUUID();
+  sessionId = randomUUID$1();
   log;
   model;
   // #0438: codex's own approval policy + sandbox, derived from the svamp permission mode. Mutable
@@ -13093,7 +14275,7 @@ class CodexAppServerBackend {
     }
   }
   handleApproval(req) {
-    const id = req.callId || randomUUID();
+    const id = req.callId || randomUUID$1();
     const reason = req.type === "exec" ? `Execute: ${(req.command ?? []).join(" ")}` : req.type === "patch" ? "Apply file changes" : req.toolName ? `Tool: ${req.toolName}` : "Codex requires approval";
     const payload = req.type === "exec" ? { toolName: "CodexBash", input: { command: req.command, cwd: req.cwd } } : req.type === "patch" ? { toolName: "CodexPatch", input: { fileChanges: req.fileChanges } } : { toolName: req.toolName ?? "CodexTool", input: req.input };
     this.emit({ type: "permission-request", id, reason, payload });
@@ -13139,7 +14321,7 @@ class CodexAppServerBackend {
         break;
       }
       case "exec_command_begin": {
-        const callId = String(event.call_id ?? event.callId ?? randomUUID());
+        const callId = String(event.call_id ?? event.callId ?? randomUUID$1());
         const command = Array.isArray(event.command) ? event.command.join(" ") : String(event.command ?? "");
         this.emit({ type: "tool-call", toolName: "CodexBash", callId, args: { command, cwd: event.cwd } });
         break;
@@ -13150,7 +14332,7 @@ class CodexAppServerBackend {
         break;
       }
       case "patch_apply_begin": {
-        const callId = String(event.call_id ?? event.callId ?? randomUUID());
+        const callId = String(event.call_id ?? event.callId ?? randomUUID$1());
         const { filePath, patch, kind } = summarizeCodexChanges(event.changes);
         this.emit({ type: "tool-call", toolName: "CodexPatch", callId, args: {
           filePath: filePath ?? event.file_path ?? event.filePath ?? null,
@@ -13170,7 +14352,7 @@ class CodexAppServerBackend {
         break;
       }
       case "mcp_tool_call_begin": {
-        const callId = String(event.call_id ?? event.callId ?? randomUUID());
+        const callId = String(event.call_id ?? event.callId ?? randomUUID$1());
         this.emit({ type: "tool-call", toolName: String(event.tool ?? "CodexMcpTool"), callId, args: { server: event.server, arguments: event.arguments } });
         break;
       }
@@ -13516,7 +14698,7 @@ function hasKimiProvider(cfg) {
 }
 function buildKimiCatalogAddArgs(cfg) {
   if (!hasKimiProvider(cfg)) return null;
-  const args = ["provider", "catalog", "add", cfg.provider, "--api-key", cfg.apiKey];
+  const args = ["provider", "catalog", "add", cfg.provider];
   if (cfg.apiBase) args.push("--base-url", cfg.apiBase);
   const defaultModel = kimiDefaultModelId(cfg);
   if (defaultModel) args.push("--default-model", defaultModel);
@@ -13532,6 +14714,19 @@ function kimiProviderConfigured(configTomlText, provider) {
   const block = nextTable < 0 ? rest : rest.slice(0, nextTable);
   return /(^|\n)\s*api_key\s*=/.test(block);
 }
+function kimiModelMenu(env = process.env) {
+  return (env.SVAMP_KIMI_MODELS || "").split(",").map((s) => s.trim()).filter(Boolean).filter((m, i, a) => a.indexOf(m) === i);
+}
+function kimiDefaultModel(env = process.env) {
+  const menu = kimiModelMenu(env);
+  return env.SVAMP_KIMI_MODEL || env.LLM_MODEL || menu[0] || void 0;
+}
+function kimiClampModel(requested, env = process.env) {
+  const menu = kimiModelMenu(env);
+  if (!menu.length) return requested;
+  if (requested && menu.includes(requested)) return requested;
+  return kimiDefaultModel(env);
+}
 
 var kimiProvider = /*#__PURE__*/Object.freeze({
     __proto__: null,
@@ -13539,7 +14734,10 @@ var kimiProvider = /*#__PURE__*/Object.freeze({
     DEFAULT_KIMI_PROVIDER: DEFAULT_KIMI_PROVIDER,
     buildKimiCatalogAddArgs: buildKimiCatalogAddArgs,
     hasKimiProvider: hasKimiProvider,
+    kimiClampModel: kimiClampModel,
+    kimiDefaultModel: kimiDefaultModel,
     kimiDefaultModelId: kimiDefaultModelId,
+    kimiModelMenu: kimiModelMenu,
     kimiProviderConfigured: kimiProviderConfigured,
     kimiSpawnEnv: kimiSpawnEnv,
     resolveKimiProvider: resolveKimiProvider
@@ -13553,7 +14751,7 @@ function readKimiConfig() {
     return null;
   }
 }
-function ensureKimiProviderConfigured(env = process.env, command = "kimi", log = () => {
+async function ensureKimiProviderConfigured(env = process.env, command = "kimi", log = () => {
 }) {
   const cfg = resolveKimiProvider(env);
   if (!hasKimiProvider(cfg)) return false;
@@ -13561,10 +14759,18 @@ function ensureKimiProviderConfigured(env = process.env, command = "kimi", log =
   const args = buildKimiCatalogAddArgs(cfg);
   if (!args) return false;
   try {
-    execFileSync(command, args, {
-      stdio: "ignore",
-      timeout: 3e4,
-      env: { ...process.env, KIMI_CLI_NO_AUTO_UPDATE: "1" }
+    await new Promise((resolve, reject) => {
+      execFile$1(
+        command,
+        args,
+        {
+          timeout: 3e4,
+          // #0848: the API key travels in the child ENV, never on argv (argv is world-readable
+          // via ps / /proc/<pid>/cmdline). kimi reads KIMI_REGISTRY_API_KEY when --api-key is omitted.
+          env: { ...process.env, KIMI_CLI_NO_AUTO_UPDATE: "1", KIMI_REGISTRY_API_KEY: cfg.apiKey }
+        },
+        (err) => err ? reject(err) : resolve()
+      );
     });
     log(`[kimi] configured provider '${cfg.provider}' in ${KIMI_CONFIG_PATH}`);
     return kimiProviderConfigured(readKimiConfig(), cfg.provider);
@@ -14094,7 +15300,7 @@ async function stageCredentialsForSharing(sessionId) {
     } catch {
     }
   }
-  if (!credentialsCopied && platform() === "darwin") {
+  if (!credentialsCopied && platform$1() === "darwin") {
     const stagedCredFile = join$1(stagedClaudeDir, ".credentials.json");
     const hasExistingCredentials = existsSync(stagedCredFile);
     if (!hasExistingCredentials) {
@@ -14486,7 +15692,7 @@ class ProcessSupervisor {
     }
     const fullSpec = {
       ...spec,
-      id: randomUUID$1(),
+      id: randomUUID(),
       createdAt: Date.now()
     };
     const entry = this.makeEntry(fullSpec);
@@ -15154,6 +16360,9 @@ function listIssues(projectRoot, opts = {}) {
   if (opts.scope) items = items.filter((i) => i.scope === opts.scope);
   return items.sort((a, b) => Number(a.id) - Number(b.id));
 }
+function isPendingIssue(issue) {
+  return issue.status !== "archived" && issue.status !== "paused";
+}
 function isVisibleTo(issue, session) {
   if (issue.scope === "session") return issue.session === session || issue.owner === session;
   if (issue.owner === session) return true;
@@ -15246,7 +16455,7 @@ function _updateIssueUnlocked(projectRoot, id, patch) {
   if (wasArchived !== nowArchived) {
     const oldPath = issuePath(projectRoot, cur.id, wasArchived);
     try {
-      if (existsSync(oldPath)) unlinkSync(oldPath);
+      if (existsSync(oldPath)) unlinkSync$1(oldPath);
     } catch {
     }
   }
@@ -15323,6 +16532,47 @@ function summarize(issues) {
   return { total: issues.length, ready: by("ready"), in_progress: by("in_progress"), paused: by("paused"), archived: by("archived") };
 }
 
+const DEFAULT_LOG_PRUNE_POLICY = {
+  keepFiles: 10,
+  maxAgeDays: 14,
+  maxBytes: 64 * 1024 * 1024
+  // 64 MiB
+};
+const APPEND_ONLY_LOGS = ["daemon-supervised.log", "daemon-boot.log"];
+function isPerStartLog(name) {
+  if (!name.startsWith("daemon-") || !name.endsWith(".log")) return false;
+  return !APPEND_ONLY_LOGS.includes(name);
+}
+function planLogPrune(files, policy = DEFAULT_LOG_PRUNE_POLICY, nowMs = Date.now(), exclude = []) {
+  const excluded = new Set(exclude);
+  const keepFiles = Math.max(0, policy.keepFiles);
+  const maxAgeMs = Math.max(0, policy.maxAgeDays) * 24 * 60 * 60 * 1e3;
+  const perStart = files.filter((f) => isPerStartLog(f.name) && !excluded.has(f.name)).sort((a, b) => b.mtimeMs - a.mtimeMs);
+  const overCount = keepFiles > 0 ? perStart.slice(keepFiles) : perStart;
+  const tooOld = maxAgeMs > 0 ? perStart.filter((f) => nowMs - f.mtimeMs > maxAgeMs) : [];
+  const deleteFiles = [...new Set([...overCount, ...tooOld].map((f) => f.name))];
+  const truncateFiles = files.filter((f) => APPEND_ONLY_LOGS.includes(f.name) && !excluded.has(f.name)).filter((f) => policy.maxBytes > 0 && f.size > policy.maxBytes).map((f) => ({ name: f.name, size: f.size }));
+  return { deleteFiles, truncateFiles };
+}
+function resolveLogPrunePolicy(env = process.env) {
+  const num = (raw, fallback) => {
+    if (raw === void 0 || raw === "") return fallback;
+    const n = Number(raw);
+    return Number.isFinite(n) && n >= 0 ? n : fallback;
+  };
+  return {
+    keepFiles: num(env.SVAMP_LOG_KEEP_FILES, DEFAULT_LOG_PRUNE_POLICY.keepFiles),
+    maxAgeDays: num(env.SVAMP_LOG_MAX_AGE_DAYS, DEFAULT_LOG_PRUNE_POLICY.maxAgeDays),
+    maxBytes: num(env.SVAMP_LOG_MAX_BYTES, DEFAULT_LOG_PRUNE_POLICY.maxBytes)
+  };
+}
+function tailSlice(buf, tailBytes) {
+  if (buf.length <= tailBytes) return buf;
+  const cut = buf.subarray(buf.length - tailBytes);
+  const nl = cut.indexOf(10);
+  return nl >= 0 && nl + 1 < cut.length ? cut.subarray(nl + 1) : cut;
+}
+
 function isWorkflowEnabled(wf) {
   return wf.enabled !== false;
 }
@@ -15481,7 +16731,7 @@ function removeWorkflow(projectRoot, name) {
   const p = workflowPath(projectRoot, name);
   if (!existsSync(p)) return false;
   try {
-    unlinkSync(p);
+    unlinkSync$1(p);
     return true;
   } catch {
     return false;
@@ -15878,12 +17128,19 @@ function loopCancelledDuringVerify(current) {
 }
 function backlogOraclePending(projectRoot, sessionId) {
   const inScope = (i) => !sessionId || isVisibleTo(i, sessionId);
-  return listIssues(projectRoot).filter(inScope).filter((i) => i.status !== "archived" && i.status !== "paused").map((i) => ({ id: i.id }));
+  return listIssues(projectRoot).filter(inScope).filter(isPendingIssue).map((i) => ({ id: i.id }));
 }
 function isBacklogDrainerOracle(oracle) {
   if (!oracle || typeof oracle !== "string") return false;
   return /(^|\s)svamp\s+issue\s+pending(\s|$)/.test(oracle.trim());
 }
+function oracleScopeSessionId(oracle, selfSessionId) {
+  if (!oracle || typeof oracle !== "string") return void 0;
+  const explicit = /(^|\s)--session[=\s]+(\S+)/.exec(oracle);
+  if (explicit) return explicit[2];
+  if (/(^|\s)--mine(\s|$)/.test(oracle)) return selfSessionId;
+  return void 0;
+}
 function resolveLoopDurable(cfg) {
   if (typeof cfg.durable === "boolean") return cfg.durable;
   return isBacklogDrainerOracle(cfg.oracle);
@@ -16490,7 +17747,7 @@ process.stdin.resume();
   const cleanup = () => {
     for (const p of cleanupPaths) {
       try {
-        if (existsSync(p)) unlinkSync(p);
+        if (existsSync(p)) unlinkSync$1(p);
       } catch {
       }
     }
@@ -16790,16 +18047,24 @@ async function installSkillFromMarketplace(name) {
   const files = await collectFiles();
   if (files.length === 0) throw new Error(`Skill ${name} has no files in marketplace`);
   const targetDir = join(CLAUDE_SKILLS_DIR, name);
-  mkdirSync(targetDir, { recursive: true });
-  for (const filePath of files) {
-    const url = `${BASE}/files/${filePath}`;
-    const resp = await fetch(url, { signal: AbortSignal.timeout(3e4) });
-    if (!resp.ok) throw new Error(`Failed to download ${filePath}: HTTP ${resp.status}`);
-    const content = await resp.text();
-    const localPath = join(targetDir, filePath);
-    if (!localPath.startsWith(targetDir + "/")) continue;
-    mkdirSync(dirname$1(localPath), { recursive: true });
-    writeFileSync(localPath, content, "utf-8");
+  const stagingDir = `${targetDir}.tmp-${process.pid}-${Date.now().toString(36)}`;
+  try {
+    mkdirSync(stagingDir, { recursive: true });
+    for (const filePath of files) {
+      const url = `${BASE}/files/${filePath}`;
+      const resp = await fetch(url, { signal: AbortSignal.timeout(3e4) });
+      if (!resp.ok) throw new Error(`Failed to download ${filePath}: HTTP ${resp.status}`);
+      const content = await resp.text();
+      const localPath = join(stagingDir, filePath);
+      if (!localPath.startsWith(stagingDir + "/")) continue;
+      mkdirSync(dirname$1(localPath), { recursive: true });
+      writeFileSync(localPath, content, "utf-8");
+    }
+    rmSync(targetDir, { recursive: true, force: true });
+    renameSync$1(stagingDir, targetDir);
+  } catch (err) {
+    rmSync(stagingDir, { recursive: true, force: true });
+    throw err;
   }
 }
 function getBundledSkillsDir() {
@@ -17128,7 +18393,7 @@ function readPendingRestart() {
 }
 function clearPendingRestart() {
   try {
-    if (existsSync$1(PENDING_RESTART_FILE)) unlinkSync$1(PENDING_RESTART_FILE);
+    if (existsSync$1(PENDING_RESTART_FILE)) unlinkSync(PENDING_RESTART_FILE);
   } catch {
   }
 }
@@ -17141,7 +18406,7 @@ function writeStopMarker(reason) {
 }
 function clearStopMarker() {
   try {
-    if (existsSync$1(DAEMON_STOP_MARKER_FILE)) unlinkSync$1(DAEMON_STOP_MARKER_FILE);
+    if (existsSync$1(DAEMON_STOP_MARKER_FILE)) unlinkSync(DAEMON_STOP_MARKER_FILE);
   } catch {
   }
 }
@@ -17675,7 +18940,7 @@ function createSvampConfigChecker(directory, sessionId, getMetadata, setMetadata
             }
             if (wasStopped) {
               const eq = getMetadata().messageQueue || [];
-              setMetadata((m) => ({ ...m, messageQueue: [...eq, { id: randomUUID$1(), text: loopResumeMessage(directory, sessionId), displayText: "\u{1F501} Resuming loop (extended)", createdAt: Date.now() }] }));
+              setMetadata((m) => ({ ...m, messageQueue: [...eq, { id: randomUUID(), text: loopResumeMessage(directory, sessionId), displayText: "\u{1F501} Resuming loop (extended)", createdAt: Date.now() }] }));
               onLoopActivated?.();
             }
             sessionService.pushMessage({ type: "message", message: `\u{1F501} Loop extended (+${grant.extension.grantedTurns} turns, ${grant.used}/${grant.max} used)${wasStopped ? " \u2014 resuming" : ""}. Reason: ${grant.extension.reason}`, level: "warning" }, "event");
@@ -17731,7 +18996,7 @@ function createSvampConfigChecker(directory, sessionId, getMetadata, setMetadata
             } catch {
             }
             const eq = getMetadata().messageQueue || [];
-            setMetadata((m) => ({ ...m, messageQueue: [...eq, { id: randomUUID$1(), text: loopResumeMessage(directory, sessionId), displayText: "\u{1F501} Resuming loop", createdAt: Date.now() }] }));
+            setMetadata((m) => ({ ...m, messageQueue: [...eq, { id: randomUUID(), text: loopResumeMessage(directory, sessionId), displayText: "\u{1F501} Resuming loop", createdAt: Date.now() }] }));
             onLoopActivated?.();
           }
           if (!wasStopped && (newMax != null || bumpedBudget)) {
@@ -17764,14 +19029,14 @@ function createSvampConfigChecker(directory, sessionId, getMetadata, setMetadata
         }
         writeGoalLoopState(directory, sessionId, { active: true, phase: "running", durable, iteration: 0, task: condition, goal_task: task, until, oracle, max_iterations: hardMax, budget, started_at: Date.now(), holds: 0, ledger: { turns: 0, tokens: 0, window: [] }, progress_history: [], auto_resumes: 0, verify_errors: 0 });
         const existingQueue = getMetadata().messageQueue || [];
-        setMetadata((m) => ({ ...m, messageQueue: [...existingQueue, { id: randomUUID$1(), text: `/goal ${condition}`, displayText: `\u{1F3AF} Goal: ${(task || until || "").slice(0, 100)}`, createdAt: Date.now() }] }));
+        setMetadata((m) => ({ ...m, messageQueue: [...existingQueue, { id: randomUUID(), text: `/goal ${condition}`, displayText: `\u{1F3AF} Goal: ${(task || until || "").slice(0, 100)}`, createdAt: Date.now() }] }));
         onLoopActivated?.();
         sessionService.pushMessage({ type: "message", message: `\u{1F3AF} Goal set: ${condition.slice(0, 180)}${condition.length > 180 ? "\u2026" : ""}` }, "event");
         logger.log(`[svampConfig] /goal set: "${condition.slice(0, 80)}"`);
       } else {
         writeGoalLoopState(directory, sessionId, { active: false, phase: "cancelled", completed_at: Date.now() });
         const existingQueue = getMetadata().messageQueue || [];
-        setMetadata((m) => ({ ...m, messageQueue: [...existingQueue, { id: randomUUID$1(), text: "/goal clear", displayText: "\u{1F3AF} Goal cleared", createdAt: Date.now() }] }));
+        setMetadata((m) => ({ ...m, messageQueue: [...existingQueue, { id: randomUUID(), text: "/goal clear", displayText: "\u{1F3AF} Goal cleared", createdAt: Date.now() }] }));
         onLoopActivated?.();
         sessionService.pushMessage({ type: "message", message: "Goal cleared." }, "event");
         logger.log(`[svampConfig] /goal cleared`);
@@ -17844,17 +19109,17 @@ function deletePersistedSession(sessionId) {
   if (entry) {
     const sessionFile = getSessionFilePath(entry.directory, sessionId);
     try {
-      if (existsSync$1(sessionFile)) unlinkSync$1(sessionFile);
+      if (existsSync$1(sessionFile)) unlinkSync(sessionFile);
     } catch {
     }
     const messagesFile = getSessionMessagesPath(entry.directory, sessionId);
     try {
-      if (existsSync$1(messagesFile)) unlinkSync$1(messagesFile);
+      if (existsSync$1(messagesFile)) unlinkSync(messagesFile);
     } catch {
     }
     const configFile = getSvampConfigPath(entry.directory, sessionId);
     try {
-      if (existsSync$1(configFile)) unlinkSync$1(configFile);
+      if (existsSync$1(configFile)) unlinkSync(configFile);
     } catch {
     }
     const sessionDir = getSessionDir(entry.directory, sessionId);
@@ -17934,8 +19199,38 @@ function ensureHomeDir() {
     mkdirSync(LOGS_DIR, { recursive: true });
   }
 }
+function pruneDaemonLogs() {
+  try {
+    const policy = resolveLogPrunePolicy(process.env);
+    const entries = readdirSync$1(LOGS_DIR).map((name) => {
+      try {
+        const st = statSync$1(join(LOGS_DIR, name));
+        return { name, size: st.size, mtimeMs: st.mtimeMs };
+      } catch {
+        return null;
+      }
+    }).filter((e) => e !== null);
+    const plan = planLogPrune(entries, policy);
+    for (const name of plan.deleteFiles) {
+      try {
+        unlinkSync(join(LOGS_DIR, name));
+      } catch {
+      }
+    }
+    for (const { name } of plan.truncateFiles) {
+      try {
+        const p = join(LOGS_DIR, name);
+        const kept = tailSlice(readFileSync$1(p), Math.floor(policy.maxBytes / 8));
+        writeFileSync(p, kept);
+      } catch {
+      }
+    }
+  } catch {
+  }
+}
 function createLogger() {
   ensureHomeDir();
+  pruneDaemonLogs();
   const logFile = join(LOGS_DIR, `daemon-${(/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-")}.log`);
   return {
     logFilePath: logFile,
@@ -18167,7 +19462,7 @@ async function startDaemon(options) {
       machineId = readFileSync$1(machineIdFile, "utf-8").trim();
     }
     if (!machineId) {
-      machineId = `machine-${os$1.hostname()}-${randomUUID$1().slice(0, 8)}`;
+      machineId = `machine-${os$1.hostname()}-${randomUUID().slice(0, 8)}`;
       try {
         writeFileSync(machineIdFile, machineId, "utf-8");
       } catch {
@@ -18215,7 +19510,7 @@ async function startDaemon(options) {
     try {
       const dir = loadSessionIndex()[sessionId]?.directory;
       if (!dir) return;
-      const { reconcileServiceLinks } = await import('./agentCommands-RhxyIA_z.mjs');
+      const { reconcileServiceLinks } = await import('./agentCommands-CI_sYhy6.mjs');
       const configPath = getSvampConfigPath(dir, sessionId);
       const config = readSvampConfig(configPath);
       const entries = Array.from(urls.entries());
@@ -18233,7 +19528,7 @@ async function startDaemon(options) {
     }
   }
   async function createExposedTunnel(spec) {
-    const { FrpcTunnel } = await import('./frpc-pwqsONPX.mjs');
+    const { FrpcTunnel } = await Promise.resolve().then(function () { return frpc; });
     const tunnel = new FrpcTunnel({
       name: spec.name,
       ports: spec.ports,
@@ -18261,7 +19556,7 @@ async function startDaemon(options) {
   ensureAutoInstalledCommands(logger);
   (async () => {
     try {
-      const { beginClaudeVersionReconcile } = await import('./pinnedClaudeCode-mM9Q6Q2G.mjs');
+      const { beginClaudeVersionReconcile } = await import('./pinnedClaudeCode-CnCpensV.mjs');
       beginClaudeVersionReconcile((msg) => logger.log(msg));
     } catch (e) {
       logger.log(`[claude-version] check failed: ${e?.message || e}`);
@@ -18310,7 +19605,7 @@ async function startDaemon(options) {
           logger.log(`[supervision] parent ${parentId.slice(0, 8)} not live \u2014 recording verdict on the backlog issue only (no in-memory wake)`);
         }
         if (send) Promise.resolve(send({
-          messageId: randomUUID$1(),
+          messageId: randomUUID(),
           from: `agent:${v.sessionId}`,
           fromSession: v.sessionId,
           to: parentId,
@@ -18348,7 +19643,7 @@ ${v.guidance ? v.guidance + "\n" : ""}Criteria: ${v.criteria || "(none)"}
           return;
         }
         Promise.resolve(send({
-          messageId: randomUUID$1(),
+          messageId: randomUUID(),
           from: "system:issues",
           subject: "issue follow-up",
           body: text,
@@ -18916,7 +20211,7 @@ ${parts.join("\n")}`);
           sessionMetadata = {
             ...sessionMetadata,
             messageQueue: [...existingQueue, {
-              id: randomUUID$1(),
+              id: randomUUID(),
               text,
               displayText: "\u{1F501} Resuming loop",
               createdAt: Date.now()
@@ -18928,7 +20223,7 @@ ${parts.join("\n")}`);
           const existingQueue = sessionMetadata.messageQueue || [];
           sessionMetadata = {
             ...sessionMetadata,
-            messageQueue: [...existingQueue, { id: randomUUID$1(), text, displayText, createdAt: Date.now() }]
+            messageQueue: [...existingQueue, { id: randomUUID(), text, displayText, createdAt: Date.now() }]
           };
           sessionService.updateMetadata(sessionMetadata);
         };
@@ -20044,7 +21339,7 @@ ${capturedError}${buildClaudeErrorHint(capturedError)}`;
                   // NOT re-push a display bubble (that second copy has localId:null and the
                   // frontend can't reconcile it → the message appears TWICE). Only re-send to
                   // the model. Inbox/loop items (no flag) still get their displayText push.
-                  messageQueue: [...existingQueue, { id: randomUUID$1(), text, createdAt: Date.now(), alreadyStored: true }]
+                  messageQueue: [...existingQueue, { id: randomUUID(), text, createdAt: Date.now(), alreadyStored: true }]
                 };
                 sessionService.updateMetadata(sessionMetadata);
                 signalProcessing(false);
@@ -20201,7 +21496,7 @@ ${capturedError}${buildClaudeErrorHint(capturedError)}`;
                 const existingQueue = sessionMetadata.messageQueue || [];
                 sessionMetadata = {
                   ...sessionMetadata,
-                  messageQueue: [...existingQueue, { id: randomUUID$1(), text, createdAt: Date.now(), alreadyStored: true }]
+                  messageQueue: [...existingQueue, { id: randomUUID(), text, createdAt: Date.now(), alreadyStored: true }]
                 };
                 sessionService.updateMetadata(sessionMetadata);
                 signalProcessing(true);
@@ -20578,11 +21873,11 @@ ${capturedError}${buildClaudeErrorHint(capturedError)}`;
               });
             },
             onIssue: async (params) => {
-              const { issueRpc } = await import('./rpc-DAcODVs3.mjs');
+              const { issueRpc } = await import('./rpc-CaKQ3aCj.mjs');
               return issueRpc(params?.cwd || directory, params || {}, { notifySession: notifyIssueOwner, rekickLoopOwner });
             },
             onWorkflow: async (params) => {
-              const { workflowRpc } = await import('./rpc-BFIy8FTe.mjs');
+              const { workflowRpc } = await import('./rpc-DX7_LzZf.mjs');
               return workflowRpc(params?.cwd || directory, params || {});
             },
             onRipgrep: async (args, cwd) => {
@@ -20617,6 +21912,7 @@ ${capturedError}${buildClaudeErrorHint(capturedError)}`;
             onWriteFileChunk: async (path, content, uploadId, chunkIndex, totalChunks, isLast) => {
               await writeSessionFileChunk(directory, sessionMetadata, path, content, uploadId, chunkIndex, isLast);
             },
+            onFilesEndpoint: () => serveManager$1.getSessionFilesEndpoint(sessionId),
             onListDirectory: async (path) => {
               const resolvedDir = resolve$1(directory, path || ".");
               if (sessionMetadata.securityContext && resolvedDir !== resolve$1(directory) && !resolvedDir.startsWith(resolve$1(directory) + "/")) {
@@ -20814,7 +22110,7 @@ ${capturedError}${buildClaudeErrorHint(capturedError)}`;
           enqueueLoopContinue();
           processMessageQueueRef?.();
         };
-        pidToTrackedSession.set(randomUUID$1(), trackedSession);
+        pidToTrackedSession.set(randomUUID(), trackedSession);
         sessionMetadata = { ...sessionMetadata, lifecycleState: "idle" };
         sessionService.updateMetadata(sessionMetadata);
         logger.log(`Session ${sessionId} registered on Hypha, waiting for first message to spawn Claude`);
@@ -20876,7 +22172,9 @@ ${capturedError}${buildClaudeErrorHint(capturedError)}`;
           if (!s || s.phase !== "dormant") return;
           let pending = [];
           try {
-            pending = backlogOraclePending(directory, sessionId);
+            const root = resolveProjectRoot(directory);
+            const scope = oracleScopeSessionId(typeof s.oracle === "string" ? s.oracle : void 0, sessionId);
+            pending = backlogOraclePending(root, scope);
           } catch {
             return;
           }
@@ -21002,7 +22300,7 @@ ${capturedError}${buildClaudeErrorHint(capturedError)}`;
               {
                 const forcedModel = agentName === "codex" ? codexForcedModel() : void 0;
                 const composerModel = typeof msgMeta?.model === "string" && msgMeta.model ? msgMeta.model : void 0;
-                const rawModel = forcedModel || (agentName === "codex" && codexModelMenu().length ? codexClampModel(composerModel) : composerModel);
+                const rawModel = forcedModel || (agentName === "codex" && codexModelMenu().length ? codexClampModel(composerModel) : void 0) || (agentName === "kimi" && kimiModelMenu().length ? kimiClampModel(composerModel) : void 0) || composerModel;
                 const desiredModel = rawModel || agentConfig?.default_model || void 0;
                 if (desiredModel !== appliedAgentModel) {
                   agentBackend?.setModel?.(desiredModel);
@@ -21017,7 +22315,7 @@ ${capturedError}${buildClaudeErrorHint(capturedError)}`;
                   ...sessionMetadata,
                   // #0411: alreadyStored — see Claude path. deliverUserMessageCore already stored
                   // this user message; the drain must not re-push a localId:null duplicate.
-                  messageQueue: [...existingQueue, { id: randomUUID$1(), text, createdAt: Date.now(), alreadyStored: true }]
+                  messageQueue: [...existingQueue, { id: randomUUID(), text, createdAt: Date.now(), alreadyStored: true }]
                 };
                 sessionService.updateMetadata(sessionMetadata);
                 return;
@@ -21029,7 +22327,7 @@ ${capturedError}${buildClaudeErrorHint(capturedError)}`;
                     ...sessionMetadata,
                     // #0411: alreadyStored — deliverUserMessageCore already stored this
                     // user message; the drain must not re-push a localId:null duplicate.
-                    messageQueue: [...existingQueue, { id: randomUUID$1(), text, createdAt: Date.now(), alreadyStored: true }]
+                    messageQueue: [...existingQueue, { id: randomUUID(), text, createdAt: Date.now(), alreadyStored: true }]
                   };
                   sessionService.updateMetadata(sessionMetadata);
                 };
@@ -21286,11 +22584,11 @@ ${capturedError}${buildClaudeErrorHint(capturedError)}`;
               });
             },
             onIssue: async (params) => {
-              const { issueRpc } = await import('./rpc-DAcODVs3.mjs');
+              const { issueRpc } = await import('./rpc-CaKQ3aCj.mjs');
               return issueRpc(params?.cwd || directory, params || {}, { notifySession: notifyIssueOwner, rekickLoopOwner });
             },
             onWorkflow: async (params) => {
-              const { workflowRpc } = await import('./rpc-BFIy8FTe.mjs');
+              const { workflowRpc } = await import('./rpc-DX7_LzZf.mjs');
               return workflowRpc(params?.cwd || directory, params || {});
             },
             onRipgrep: async (args, cwd) => {
@@ -21325,6 +22623,7 @@ ${capturedError}${buildClaudeErrorHint(capturedError)}`;
             onWriteFileChunk: async (path, content, uploadId, chunkIndex, totalChunks, isLast) => {
               await writeSessionFileChunk(directory, sessionMetadata, path, content, uploadId, chunkIndex, isLast);
             },
+            onFilesEndpoint: () => serveManager$1.getSessionFilesEndpoint(sessionId),
             onListDirectory: async (path) => {
               const resolvedDir = resolve$1(directory, path || ".");
               if (sessionMetadata.securityContext && resolvedDir !== resolve$1(directory) && !resolvedDir.startsWith(resolve$1(directory) + "/")) {
@@ -21424,7 +22723,11 @@ ${capturedError}${buildClaudeErrorHint(capturedError)}`;
         );
         const checkSvampConfig = svampConfigChecker.check;
         const writeSvampConfigPatchAcp = svampConfigChecker.writeConfig;
-        const permissionHandler = new HyphaPermissionHandler(shouldAutoAllow2, logger.log);
+        const permissionHandler = new HyphaPermissionHandler(
+          shouldAutoAllow2,
+          logger.log,
+          (requestId, approved) => applyPermissionResolution(sessionService, requestId, approved)
+        );
         let agentIsoConfig;
         const agentShouldIsolate = Boolean(options2.forceIsolation) || Boolean(options2.securityContext);
         if (agentShouldIsolate && isolationCapabilities.preferred) {
@@ -21527,10 +22830,24 @@ ${capturedError}${buildClaudeErrorHint(capturedError)}`;
           let kimiEnv = {};
           if (agentName === "kimi") {
             try {
-              ensureKimiProviderConfigured(process.env, acpConfig.command, logger.log);
+              await ensureKimiProviderConfigured(process.env, acpConfig.command, logger.log);
             } catch {
             }
             kimiEnv = kimiSpawnEnv(process.env);
+            const kimiMenu = kimiModelMenu();
+            if (kimiMenu.length) {
+              const kimiModel = kimiClampModel(options2.model ?? void 0) || kimiDefaultModel();
+              sessionMetadata.models = kimiMenu.map((m) => ({
+                code: m,
+                value: m,
+                description: m === kimiModel ? "Default on this machine" : "Available on this machine"
+              }));
+              try {
+                sessionService.updateMetadata(sessionMetadata);
+              } catch {
+              }
+              logger.log(`[Agent Session ${sessionId}] Kimi model menu advertised (SVAMP_KIMI_MODELS): [${kimiMenu.join(", ")}] default=${kimiModel}`);
+            }
           }
           agentBackend = new AcpBackend({
             agentName,
@@ -21809,7 +23126,7 @@ ${oracle.output.trim().slice(0, 500)}`, "\u{1F501} Continuing loop");
             });
           }
         };
-        pidToTrackedSession.set(randomUUID$1(), trackedSession);
+        pidToTrackedSession.set(randomUUID(), trackedSession);
         let acpInboxReconcileTimer = null;
         const reconcileAcpIdleInbox = () => {
           if (acpStopped) {
@@ -21875,6 +23192,8 @@ ${oracle.output.trim().slice(0, 500)}`, "\u{1F501} Continuing loop");
             "event"
           );
           sessionService.sendSessionEnd();
+          agentBackend.dispose().catch(() => {
+          });
           if (!acpPersisted) {
             deleteSession(sessionId);
           } else {
@@ -22253,6 +23572,27 @@ ${oracle.output.trim().slice(0, 500)}`, "\u{1F501} Continuing loop");
     writeDaemonStateFile(localState);
     logger.log("Daemon state file written \u2014 daemon is up; restoring mounts/sessions in background");
     serveManager$1.restore().catch((err) => logger.error(`[serve] mount restore failed: ${err?.message || err}`));
+    const daemonOwnerEmail = parseJwtEmail(process.env.HYPHA_TOKEN || "") || null;
+    serveManager$1.setSessionResolver((sessionId) => {
+      for (const [, session] of pidToTrackedSession) {
+        if (session.svampSessionId === sessionId && !session.stopped && session.directory) {
+          let sharing = null;
+          try {
+            sharing = session.hyphaService?.getMetadata?.()?.sharing ?? null;
+          } catch {
+            sharing = null;
+          }
+          return {
+            cwd: session.directory,
+            sharing,
+            ownerEmail: sharing?.owner || daemonOwnerEmail
+          };
+        }
+      }
+      return null;
+    });
+    const sessionFilesToken = createHash("sha256").update(`session-files:${machineId}`).digest("hex").slice(0, 20);
+    serveManager$1.ensureSessionFilesGateway(sessionFilesToken).then((base) => logger.log(`[serve] session-files gateway: ${base || "(tunnel pending)"}`)).catch((err) => logger.error(`[serve] session-files gateway failed: ${err?.message || err}`));
     const persistedSessions = loadPersistedSessions();
     try {
       const knownIds = new Set(persistedSessions.map((s) => s.sessionId).concat(Object.keys(loadSessionIndex())));
@@ -22291,7 +23631,7 @@ ${oracle.output.trim().slice(0, 500)}`, "\u{1F501} Continuing loop");
     }
     if (persistedSessions.length > 0) {
       try {
-        const { awaitClaudeVersionReady } = await import('./pinnedClaudeCode-mM9Q6Q2G.mjs');
+        const { awaitClaudeVersionReady } = await import('./pinnedClaudeCode-CnCpensV.mjs');
         await awaitClaudeVersionReady();
       } catch {
       }
@@ -22536,7 +23876,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-DlDYY_wS.mjs');
+    const { WorkflowScheduler } = await import('./scheduler-B11LcOId.mjs');
     const workflowProjectRoots = () => {
       const dirs = /* @__PURE__ */ new Set();
       for (const s of pidToTrackedSession.values()) {
@@ -23170,4 +24510,4 @@ var run = /*#__PURE__*/Object.freeze({
     writeStopMarker: writeStopMarker
 });
 
-export { getSkillInfo as $, removeWorkflow as A, validateWorkflowName as B, saveWorkflow as C, rawWorkflow as D, listWorkflows as E, isWorkflowEnabled as F, workflowSchedules as G, inZone as H, cronMatches as I, summarize as J, workflowSteps as K, parseJwtEmail as L, computeCollectionConfigUpdate as M, SYSTEM_COLLECTION_CONFIG as N, loadMachineContext as O, buildMachineInstructions as P, machineToolsForRole as Q, READ_ONLY_TOOLS as R, SharingNotificationSync as S, buildMachineTools as T, parseFrontmatter as U, getSkillsServer as V, getSkillsWorkspaceName as W, getSkillsCollectionName as X, fetchWithTimeout as Y, searchSkills as Z, SKILLS_DIR as _, createSessionStore as a, downloadSkillFile as a0, listSkillFiles as a1, resolveModel as a2, clearStopMarker as a3, stopMarkerExists as a4, formatHandle as a5, normalizeAllowedUser as a6, loadSecurityContextConfig as a7, resolveSecurityContext as a8, buildSecurityContextFromFlags as a9, kimiProvider as aA, kimiSetup as aB, api as aC, run as aD, mergeSecurityContexts as aa, buildSessionShareUrl as ab, computeOutboundHop as ac, registerAwaitingReply as ad, buildMachineShareUrl as ae, parseHandle as af, handleMatchesMetadata as ag, PINNED_CODEX_VERSION as ah, withFileLock 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, projectInfo as at, DefaultTransport$1 as au, acpBackend as av, acpAgentConfig as aw, codexAppServerBackend as ax, GeminiTransport$1 as ay, KimiTransport$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 $, saveWorkflow as A, rawWorkflow as B, listWorkflows as C, isWorkflowEnabled as D, workflowSchedules as E, inZone 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, kimiSetup as aA, api as aB, run as aC, computeOutboundHop as aa, registerAwaitingReply as ab, buildMachineShareUrl as ac, parseHandle as ad, handleMatchesMetadata as ae, PINNED_CODEX_VERSION as af, withFileLock as ag, describeMisconfiguration as ah, buildMachineDeps as ai, applyClaudeProxyEnv as aj, composeSessionId as ak, generateFriendlyName as al, generateHookSettings as am, instanceConfig as an, frpc as ao, staticFileServer as ap, claudeAuth as aq, codexProvider as ar, projectInfo as as, DefaultTransport$1 as at, acpBackend as au, acpAgentConfig as av, codexAppServerBackend as aw, GeminiTransport$1 as ax, KimiTransport$1 as ay, kimiProvider as az, stopDaemon as b, connectToHypha as c, daemonStatus as d, shortId as e, resolveProjectRoot as f, getHyphaServerUrl$1 as g, getIssue as h, resumeIssue as i, addComment as j, addIssue as k, listIssues as l, isPendingIssue as m, searchIssues as n, isVisibleTo as o, pauseIssue as p, getRun as q, registerMachineService as r, startDaemon as s, listRuns as t, updateIssue as u, getWorkflow as v, runWorkflow as w, setWorkflowEnabled as x, removeWorkflow as y, validateWorkflowName as z };