svamp-cli 0.2.308 → 0.2.309

package/dist/{run-VQIHMUdo.mjs → run-DLG-_xa7.mjs}

@@ -18,9 +18,9 @@ import os, { homedir as homedir$1, platform } 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';
+import { promisify as promisify$1 } from 'node:util';
 import { createInterface } from 'node:readline';
 import { mkdir, rm, chmod, access, mkdtemp, copyFile, writeFile, readdir, stat, readFile as readFile$1, rename as rename$1 } from 'node:fs/promises';
-import { promisify as promisify$1 } from 'node:util';
 import { parse, stringify } from 'yaml';
 
 let connectToServerFn = null;
@@ -2172,6 +2172,61 @@ function killOrphanedCaddy(log) {
   } catch {
   }
 }
+function reapOrphanedManagedProcesses(pidDir, log) {
+  if (process.platform === "win32") return;
+  let files;
+  try {
+    files = fs.readdirSync(pidDir).filter((f) => f.endsWith(".pid"));
+  } catch {
+    return;
+  }
+  if (!files.length) return;
+  const cmdByPid = /* @__PURE__ */ new Map();
+  try {
+    const out = execSync("ps -axo pid=,command=", { encoding: "utf-8" });
+    for (const line of out.split("\n")) {
+      const m = /^\s*(\d+)\s+(.*)$/.exec(line);
+      if (m) cmdByPid.set(m[1], m[2]);
+    }
+  } catch {
+  }
+  let reaped = 0;
+  for (const f of files) {
+    const full = path.join(pidDir, f);
+    let rec = {};
+    try {
+      rec = JSON.parse(fs.readFileSync(full, "utf-8"));
+    } catch {
+    }
+    const pid = Number(rec.pid);
+    if (pid > 0 && pid !== process.pid) {
+      const liveCmd = cmdByPid.get(String(pid));
+      const base = rec.command ? path.basename(rec.command) : "";
+      const args = Array.isArray(rec.args) ? rec.args : [];
+      const argOk = args.length === 0 || args.some((a) => a && liveCmd?.includes(a));
+      if (liveCmd && base && liveCmd.includes(base) && argOk) {
+        try {
+          process.kill(-pid, "SIGKILL");
+          reaped++;
+        } catch {
+          try {
+            process.kill(pid, "SIGKILL");
+            reaped++;
+          } catch {
+          }
+        }
+        log(`Reaped orphaned managed process pid=${pid} (port ${rec.port ?? "?"}) from a prior daemon crash (#0758).`);
+      } else if (liveCmd) {
+        log(`Managed pidfile ${f}: live pid=${pid} command does not match recorded '${rec.command} ${args.join(" ")}' \u2014 NOT reaping (likely PID reuse); dropping stale pidfile.`);
+      }
+    }
+    try {
+      fs.unlinkSync(full);
+    } catch {
+    }
+  }
+  if (reaped) log(`Reaped ${reaped} orphaned managed process(es) on startup (#0758).`);
+}
 const MOUNT_NAME_RE = /^[a-zA-Z0-9][a-zA-Z0-9._-]*$/;
 function validateMountName(name) {
   if (!name || name.length > 128) {
@@ -2196,13 +2251,19 @@ class ServeManager {
   auth = null;
   /** Live child processes for managed mounts. Keyed by mount name. */
   managedProcs = /* @__PURE__ */ new Map();
+  /** #0783: per-mount 'stopping' barriers — a wake (ensureManagedRunning) awaits any pending stop
+   *  so it never spawns a replacement on a port the terminating process still holds (EADDRINUSE). */
+  stoppingProcs = /* @__PURE__ */ new Map();
   /** Single timer that scans managed mounts every 30s for idle eviction. */
   idleTimer = null;
   persistFile;
+  /** #0758: dir holding per-managed-mount pidfiles so a crash-orphaned process is reapable on restart. */
+  managedPidDir;
   log;
   hyphaServerUrl;
   constructor(svampHome, logger, hyphaServerUrl) {
     this.persistFile = path.join(svampHome, "serve-mounts.json");
+    this.managedPidDir = path.join(svampHome, "serve-managed");
     this.log = logger || ((msg) => console.log(`[SERVE] ${msg}`));
     const resolvedServerUrl = hyphaServerUrl || getHyphaServerUrl();
     if (!resolvedServerUrl) {
@@ -2443,6 +2504,13 @@ class ServeManager {
   async ensureManagedRunning(name) {
     const mount = this.mounts.get(name);
     if (!mount?.process) return;
+    const pendingStop = this.stoppingProcs.get(name);
+    if (pendingStop) {
+      try {
+        await pendingStop;
+      } catch {
+      }
+    }
     const handle = this.managedProcs.get(name);
     if (handle && handle.warmupPromise) {
       return handle.warmupPromise;
@@ -2474,7 +2542,10 @@ class ServeManager {
     child.on("exit", (code, signal) => {
       this.log(`Managed process '${name}' exited (code=${code}, signal=${signal})`);
       const h = this.managedProcs.get(name);
-      if (h && h.child === child) this.managedProcs.delete(name);
+      if (h && h.child === child) {
+        this.managedProcs.delete(name);
+        this.removeManagedPidFile(name);
+      }
     });
     const warmupPath = cfg.warmupPath ?? "/";
     const warmupTimeoutMs = cfg.warmupTimeoutMs ?? 3e4;
@@ -2500,6 +2571,7 @@ class ServeManager {
       warmupPromise
     };
     this.managedProcs.set(name, newHandle);
+    this.writeManagedPidFile(name, child, cfg);
     this.log(`Managed process '${name}' starting: ${cfg.command} ${(cfg.args ?? []).join(" ")} (port ${cfg.port})`);
     return warmupPromise;
   }
@@ -2509,6 +2581,25 @@ class ServeManager {
    * that a direct child.kill() would orphan, leaving the port bound. Falls back to a direct
    * child.kill() if the group signal fails (e.g. pid already gone).
    */
+  // ── #0758: managed-process pidfiles (crash-orphan reaping) ──────────────
+  managedPidFile(name) {
+    const safe = name.replace(/[^A-Za-z0-9._-]/g, "_");
+    return path.join(this.managedPidDir, `${safe}.pid`);
+  }
+  writeManagedPidFile(name, child, cfg) {
+    try {
+      fs.mkdirSync(this.managedPidDir, { recursive: true, mode: 448 });
+      const rec = { pid: child.pid ?? 0, command: cfg.command, args: cfg.args ?? [], port: cfg.port, startedAt: Date.now() };
+      fs.writeFileSync(this.managedPidFile(name), JSON.stringify(rec), { mode: 384 });
+    } catch {
+    }
+  }
+  removeManagedPidFile(name) {
+    try {
+      fs.unlinkSync(this.managedPidFile(name));
+    } catch {
+    }
+  }
   killManagedTree(child, signal) {
     const pid = child.pid;
     if (pid && pid > 0) {
@@ -2558,18 +2649,30 @@ class ServeManager {
     const h = this.managedProcs.get(name);
     if (!h) return;
     this.managedProcs.delete(name);
+    this.removeManagedPidFile(name);
     const child = h.child;
-    this.killManagedTree(child, "SIGTERM");
-    await new Promise((resolve) => {
-      const t = setTimeout(() => {
-        this.killManagedTree(child, "SIGKILL");
-        resolve();
-      }, 5e3);
-      child.once("exit", () => {
-        clearTimeout(t);
-        resolve();
+    const done = (async () => {
+      if (child.exitCode !== null) return;
+      this.killManagedTree(child, "SIGTERM");
+      await new Promise((resolve) => {
+        const onExit = () => {
+          clearTimeout(t);
+          clearTimeout(cap);
+          resolve();
+        };
+        const t = setTimeout(() => {
+          this.killManagedTree(child, "SIGKILL");
+        }, 5e3);
+        const cap = setTimeout(onExit, 8e3);
+        child.once("exit", onExit);
       });
-    });
+    })();
+    this.stoppingProcs.set(name, done);
+    try {
+      await done;
+    } finally {
+      if (this.stoppingProcs.get(name) === done) this.stoppingProcs.delete(name);
+    }
     this.log(`Managed process '${name}' stopped`);
   }
   /** Idle eviction loop — stops processes that have been idle longer than configured. */
@@ -2631,6 +2734,7 @@ class ServeManager {
   async ensureRunning() {
     if (this.proxyServer) return;
     killOrphanedCaddy((m) => this.log(m));
+    reapOrphanedManagedProcesses(this.managedPidDir, (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.`);
@@ -3047,7 +3151,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-DV_IIYpM.mjs');
+      const { FrpcTunnel } = await import('./frpc-Cv6J2Mex.mjs');
       let tunnel;
       tunnel = new FrpcTunnel({
         name: tunnelName,
@@ -3974,6 +4078,26 @@ function cronMatches(expr, date) {
   if (c.domRestricted && c.dowRestricted) return domOk || dowOk;
   return domOk && dowOk;
 }
+function inZone(date, tz) {
+  if (!tz) return date;
+  try {
+    const p = new Intl.DateTimeFormat("en-US", {
+      timeZone: tz,
+      hour12: false,
+      year: "numeric",
+      month: "2-digit",
+      day: "2-digit",
+      hour: "2-digit",
+      minute: "2-digit"
+    }).formatToParts(date).reduce((o, x) => {
+      o[x.type] = x.value;
+      return o;
+    }, {});
+    return new Date(+p.year, +p.month - 1, +p.day, +(p.hour === "24" ? 0 : p.hour), +p.minute);
+  } catch {
+    return date;
+  }
+}
 function resolvePath(ctx, path) {
   return path.split(".").reduce((o, k) => o == null ? void 0 : o[k], ctx);
 }
@@ -3992,8 +4116,8 @@ function sleepSync$1(ms) {
   }
 }
 function withFileLock(lockPath, fn, opts) {
-  const deadlineMs = 50;
-  const staleMs = 5e3;
+  const deadlineMs = opts?.deadlineMs ?? 50;
+  const staleMs = opts?.staleMs ?? 5e3;
   const deadline = Date.now() + deadlineMs;
   let held = false;
   while (Date.now() < deadline) {
@@ -4277,12 +4401,14 @@ class ChannelStore {
     return this._writeChannel(channel);
   }
   remove(id) {
-    const p = this._path(id);
-    if (existsSync(p)) {
-      rmSync$1(p);
-      return true;
-    }
-    return false;
+    return withFileLock(this._lock(id), () => {
+      const p = this._path(id);
+      if (existsSync(p)) {
+        rmSync$1(p);
+        return true;
+      }
+      return false;
+    });
   }
   // #0679: setEnabled/recordCall/addCaller are read-modify-write mutators — multiple ChannelStore
   // instances (one per session) point at the same .svamp/channels/<id>.json, so without
@@ -4711,10 +4837,14 @@ class ChannelOutbox {
   /** Append a reply addressed to `to`. Assigns seq + ts, persists, and wakes waiters. */
   append(channelId, r) {
     this.reload();
-    const seq = Math.max(this.highWater.get(channelId) || 0, this.seqByChannel.get(channelId) || 0) + 1;
-    this.seqByChannel.set(channelId, seq);
-    this.highWater.set(channelId, seq);
-    this._persistHighWater();
+    const seq = withFileLock(`${this.seqFile}.lock`, () => {
+      this._loadHighWater();
+      const s = Math.max(this.highWater.get(channelId) || 0, this.seqByChannel.get(channelId) || 0) + 1;
+      this.seqByChannel.set(channelId, s);
+      this.highWater.set(channelId, s);
+      this._persistHighWater();
+      return s;
+    });
     const reply = { seq, ts: Date.now(), to: r.to, body: r.body, ...r.correlationId ? { correlationId: r.correlationId } : {} };
     const arr = this.byChannel.get(channelId) || [];
     arr.push(reply);
@@ -4841,6 +4971,7 @@ const SESSION_METHOD_MIN_ROLE = {
   archiveSession: "admin",
   readFile: "admin",
   writeFile: "admin",
+  writeFileChunk: "admin",
   listDirectory: "admin",
   bash: "admin",
   issue: "admin",
@@ -6123,7 +6254,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-DV_IIYpM.mjs');
+        const { FrpcTunnel } = await import('./frpc-Cv6J2Mex.mjs');
         const tunnel = new FrpcTunnel({
           name: params.name,
           ports: params.ports,
@@ -6617,7 +6748,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-CGiNKfNE.mjs');
+          const { toolsForRole } = await import('./sideband-C_3PVGh-.mjs');
           const r2 = await runWiseAgent({ message: params.message, sender, config: { tools: toolsForRole(role2) }, deps, transport, model: resolved.model });
           return fmt(r2);
         }
@@ -6722,7 +6853,7 @@ QUESTION: ${params.question || "Summarize this concisely."}` }
       return { ok: false, call_id: callId, status: "busy", error: "channel is busy (too many concurrent requests) \u2014 retry shortly" };
     }
     const rendered = renderMessage(c, { sender: r.sender, body: { message: kwargs.message }, callId });
-    const { queryCore } = await import('./commands-D3Nu5cYE.mjs');
+    const { queryCore } = await import('./commands-BTN9XxVx.mjs');
     const timeout = c.reply?.timeout_sec || 120;
     let result;
     try {
@@ -7232,9 +7363,17 @@ function getRateLimitRetryConfig() {
   return {
     maxRetries: envInt("SVAMP_RATELIMIT_MAX_RETRIES", 200),
     baseMs: envInt("SVAMP_RATELIMIT_BASE_MS", 5e3),
-    capMs: envInt("SVAMP_RATELIMIT_CAP_MS", 12e4)
+    capMs: envInt("SVAMP_RATELIMIT_CAP_MS", 12e4),
+    maxElapsedMs: envInt("SVAMP_RATELIMIT_MAX_ELAPSED_MS", 36e5)
   };
 }
+function retryStreakExhausted(attempts, streakStartedAtMs, nowMs, cfg = getRateLimitRetryConfig()) {
+  if (attempts >= cfg.maxRetries) return { exhausted: true, reason: "count" };
+  if (cfg.maxElapsedMs > 0 && streakStartedAtMs && streakStartedAtMs > 0 && nowMs - streakStartedAtMs >= cfg.maxElapsedMs) {
+    return { exhausted: true, reason: "elapsed" };
+  }
+  return { exhausted: false };
+}
 function computeRetryDelayMs(attempt, cfg = getRateLimitRetryConfig(), rng = Math.random) {
   const a = Math.max(0, Math.floor(attempt));
   const expo = Math.min(a, 30);
@@ -7413,6 +7552,9 @@ async function deletePairingArtifact(am, artifactId, log) {
   }
 }
 async function sweepExpiredPairings(am, svampHome, log) {
+  return withMintLock("*sweep*", () => _sweepExpiredPairingsUnlocked(am, svampHome, log));
+}
+async function _sweepExpiredPairingsUnlocked(am, svampHome, log) {
   const now = Date.now();
   const all = loadPairings(svampHome);
   const expired = all.filter((p) => p.expiresAt <= now);
@@ -7420,18 +7562,40 @@ async function sweepExpiredPairings(am, svampHome, log) {
   for (const p of expired) await deletePairingArtifact(am, p.artifactId, log);
   savePairings(all.filter((p) => p.expiresAt > now), svampHome);
 }
+let _lastSweepAt = 0;
+async function sweepExpiredPairingsThrottled(am, svampHome, log, minIntervalMs = 5 * 6e4) {
+  const now = Date.now();
+  if (now - _lastSweepAt < minIntervalMs) return;
+  _lastSweepAt = now;
+  await sweepExpiredPairings(am, svampHome, log);
+}
+let _pairingChain = Promise.resolve();
+function withMintLock(_session, fn) {
+  const prior = _pairingChain.catch(() => {
+  });
+  const result = prior.then(fn);
+  _pairingChain = result.catch(() => {
+  });
+  return result;
+}
 async function burnSessionPairings(am, session, svampHome, log) {
-  const all = loadPairings(svampHome);
-  const mine = all.filter((p) => p.session === session);
-  if (mine.length === 0) return;
-  for (const p of mine) await deletePairingArtifact(am, p.artifactId, log);
-  savePairings(all.filter((p) => p.session !== session), svampHome);
+  return withMintLock(session, async () => {
+    const all = loadPairings(svampHome);
+    const mine = all.filter((p) => p.session === session);
+    if (mine.length === 0) return;
+    for (const p of mine) await deletePairingArtifact(am, p.artifactId, log);
+    savePairings(all.filter((p) => p.session !== session), svampHome);
+  });
 }
 async function mintPairingCode(opts) {
-  const { am, session, payload, log } = opts;
+  const { session} = opts;
   const resolver = (opts.resolverBase || "https://hypha.aicell.io").replace(/\/$/, "");
   const ttlMs = opts.ttlMs && opts.ttlMs > 0 ? opts.ttlMs : DEFAULT_PAIRING_TTL_MS;
-  await sweepExpiredPairings(am, opts.svampHome, log).catch(() => {
+  return withMintLock(session, () => _mintPairingCodeLocked(opts, resolver, ttlMs));
+}
+async function _mintPairingCodeLocked(opts, resolver, ttlMs) {
+  const { am, session, payload, log } = opts;
+  await _sweepExpiredPairingsUnlocked(am, opts.svampHome, log).catch(() => {
   });
   const now = Date.now();
   const existing = loadPairings(opts.svampHome).find((p) => p.session === session && p.expiresAt > now + 3e4);
@@ -8072,6 +8236,13 @@ function createSessionStore(server, sessionId, initialMetadata, initialAgentStat
   const channelOutbox = new ChannelOutbox(initialMetadata.path);
   const outpostCoordinator = new OutpostCoordinator();
   outpostCoordinator.startSweeper();
+  void (async () => {
+    try {
+      const am = await server.getService("public/artifact-manager");
+      if (am) await sweepExpiredPairingsThrottled(am, void 0, (m) => console.log(m));
+    } catch {
+    }
+  })();
   const outpostProjectDir = () => metadata.path || process.cwd();
   const announceOutpost = (conn) => {
     const who = conn.label || conn.machine;
@@ -8847,7 +9018,9 @@ function createSessionStore(server, sessionId, initialMetadata, initialAgentStat
       });
       if (r.error || !r.sender) return { error: r.error || "unauthorized" };
       const cursor = Math.max(0, Number(params.cursor) || 0);
-      const waitMs = Math.min(Math.max(0, Number(params.wait ?? 25) * 1e3), 6e4);
+      const waitSecRaw = Number(params.wait);
+      const waitSec = Number.isFinite(waitSecRaw) ? waitSecRaw : 25;
+      const waitMs = Math.min(Math.max(0, waitSec * 1e3), 6e4);
       const out = await channelOutbox.wait(c.id, cursor, r.sender.name, waitMs, params.correlationId);
       return { ok: true, replies: out.replies, cursor: out.cursor };
     },
@@ -8958,6 +9131,12 @@ function createSessionStore(server, sessionId, initialMetadata, initialAgentStat
       await callbacks.onWriteFile(path, content);
       return { success: true };
     },
+    writeFileChunk: async (path, content, uploadId, chunkIndex, totalChunks, isLast, context) => {
+      authorizeRequest(context, metadata.sharing, "admin");
+      if (!callbacks.onWriteFileChunk) throw new Error("writeFileChunk not supported");
+      await callbacks.onWriteFileChunk(path, content, uploadId, chunkIndex, totalChunks, isLast);
+      return { success: true };
+    },
     listDirectory: async (path, context) => {
       authorizeRequest(context, metadata.sharing, "admin");
       if (!callbacks.onListDirectory) throw new Error("listDirectory not supported");
@@ -12291,15 +12470,30 @@ function codexAppServerAvailable() {
     return null;
   }
 }
+const _execFileAsync = promisify$1(execFile$1);
 let _steerSupport = null;
-function codexSupportsSteerInstalled() {
-  if (_steerSupport !== null) return _steerSupport;
-  try {
-    _steerSupport = codexSupportsSteer(parseCodexVersion(execSync$1("codex --version", { encoding: "utf8" }).trim()));
-  } catch {
-    _steerSupport = false;
-  }
-  return _steerSupport;
+let _steerProbedAt = 0;
+let _steerProbe = null;
+const _STEER_TTL_MS = 3e4;
+const DEFAULT_REQUEST_TIMEOUT_MS = 12e4;
+function _steerFresh() {
+  return _steerSupport !== null && Date.now() - _steerProbedAt < _STEER_TTL_MS;
+}
+async function codexSupportsSteerInstalledAsync() {
+  if (_steerFresh()) return _steerSupport;
+  if (_steerProbe) return _steerProbe;
+  _steerProbe = (async () => {
+    try {
+      const { stdout } = await _execFileAsync("codex", ["--version"], { encoding: "utf8" });
+      _steerSupport = codexSupportsSteer(parseCodexVersion(stdout.trim()));
+    } catch {
+      _steerSupport = false;
+    }
+    _steerProbedAt = Date.now();
+    _steerProbe = null;
+    return _steerSupport;
+  })();
+  return _steerProbe;
 }
 class CodexAppServerClient {
   constructor(opts) {
@@ -12474,7 +12668,7 @@ class CodexAppServerClient {
    */
   async injectInput(prompt, _o) {
     if (!this._threadId || !this.pendingTurn || !this._turnId) return false;
-    if (!codexSupportsSteerInstalled()) return false;
+    if (!await codexSupportsSteerInstalledAsync()) return false;
     const params = {
       threadId: this._threadId,
       expectedTurnId: this._turnId,
@@ -12529,17 +12723,16 @@ class CodexAppServerClient {
   // ── JSON-RPC plumbing ──────────────────────────────────────────────────────
   request(method, params, timeoutMs) {
     const id = this.nextId++;
+    const effTimeout = timeoutMs ?? this.opts.requestTimeoutMs ?? DEFAULT_REQUEST_TIMEOUT_MS;
     return new Promise((resolve, reject) => {
       this.pending.set(id, { resolve, reject, method });
-      if (timeoutMs) {
-        const t = setTimeout(() => {
-          if (this.pending.has(id)) {
-            this.pending.delete(id);
-            reject(new Error(`codex ${method} timed out after ${timeoutMs}ms`));
-          }
-        }, timeoutMs);
-        t.unref?.();
-      }
+      const t = setTimeout(() => {
+        if (this.pending.has(id)) {
+          this.pending.delete(id);
+          reject(new Error(`codex ${method} timed out after ${effTimeout}ms`));
+        }
+      }, effTimeout);
+      t.unref?.();
       this.write({ jsonrpc: "2.0", id, method, params });
     });
   }
@@ -14839,8 +15032,8 @@ function isWorkflowEnabled(wf) {
 function workflowSteps(wf) {
   return Object.values(wf.jobs || {}).flatMap((j) => j?.steps || []);
 }
-function workflowCrons(wf) {
-  return (wf.on?.schedule || []).map((s) => s?.cron).filter((c) => !!c);
+function workflowSchedules(wf) {
+  return (wf.on?.schedule || []).filter((s) => !!s?.cron);
 }
 function workflowsDir(projectRoot) {
   return join$1(projectRoot, ".svamp", "workflows");
@@ -14860,7 +15053,11 @@ function normalizeOn(on) {
   }
   const out = {};
   if (Array.isArray(on.schedule)) {
-    const sched = on.schedule.map((s) => ({ cron: String(s?.cron ?? s ?? "") })).filter((s) => s.cron);
+    const sched = on.schedule.map((s) => {
+      const entry = { cron: String(s?.cron ?? s ?? "") };
+      if (s && typeof s === "object" && s.tz != null && String(s.tz).trim()) entry.tz = String(s.tz).trim();
+      return entry;
+    }).filter((s) => s.cron);
     if (sched.length) out.schedule = sched;
   } else if (typeof on.schedule === "string" && on.schedule.trim()) {
     out.schedule = [{ cron: on.schedule.trim() }];
@@ -14908,7 +15105,7 @@ function serializeWorkflow(wf) {
   if (wf.session) clean.session = wf.session;
   if (wf.enabled === false) clean.enabled = false;
   const on = {};
-  if (wf.on?.schedule?.length) on.schedule = wf.on.schedule.map((s) => ({ cron: s.cron }));
+  if (wf.on?.schedule?.length) on.schedule = wf.on.schedule.map((s) => s.tz ? { cron: s.cron, tz: s.tz } : { cron: s.cron });
   if (wf.on?.workflow_dispatch) on.workflow_dispatch = {};
   if (wf.on?.channel) on.channel = wf.on.channel;
   if (wf.on?.issue?.length) on.issue = wf.on.issue;
@@ -15174,7 +15371,7 @@ function escalateWorkflowFailure(projectRoot, wf, run) {
     const open = listIssues(projectRoot, { label: failLabel }).filter((i) => i.status !== "archived");
     if (open.length > 0) return void 0;
     const failed = run.steps.find((s) => s.timedOut || s.exitCode !== 0 && s.exitCode !== null) || run.steps[run.steps.length - 1];
-    const failCause = run.error ? `runner error: ${run.error}` : failed?.timedOut ? `step timed out after ${STEP_TIMEOUT_MS / 1e3}s` : `step exited with code ${failed?.exitCode ?? "null (killed/signal)"}`;
+    const failCause = run.error ? `runner error: ${run.error}` : failed?.timedOut ? `step timed out after ${stepTimeoutMs() / 1e3}s` : `step exited with code ${failed?.exitCode ?? "null (killed/signal)"}`;
     const defLines = workflowSteps(wf).map((s, i) => `  ${i}. ${s.run}`).join("\n") || "  (no steps)";
     const stderrTail = failed?.stderr ? capStream(failed.stderr, 3e3) : "(none)";
     const stdoutTail = failed?.stdout ? capStream(failed.stdout, 1500) : "(none)";
@@ -15358,7 +15555,9 @@ function fireIdleWorkflows(root, sessionId, deps = {}) {
   } catch {
     return [];
   }
-  const matches = workflows.filter((wf) => wf.on?.idle === true && isWorkflowEnabled(wf));
+  const matches = workflows.filter(
+    (wf) => wf.on?.idle === true && isWorkflowEnabled(wf) && (!wf.session || wf.session === sessionId)
+  );
   return matches.map((wf) => {
     deps.log?.(`[workflow] idle fired "${wf.name}" in ${root} for session ${sessionId}`);
     return runWorkflow(root, wf, {
@@ -16114,6 +16313,24 @@ async function readSessionFileBase64(resolvedPath) {
   const buffer = await fs$1.readFile(resolvedPath);
   return buffer.toString("base64");
 }
+async function writeSessionFileChunk(directory, sessionMetadata, path, content, uploadId, chunkIndex, isLast) {
+  const resolvedPath = resolve$1(directory, path);
+  if (sessionMetadata?.securityContext && resolvedPath !== resolve$1(directory) && !resolvedPath.startsWith(resolve$1(directory) + "/")) {
+    throw new Error("Path outside working directory");
+  }
+  const safeUploadId = String(uploadId).replace(/[^a-zA-Z0-9_-]/g, "").slice(0, 64) || "upload";
+  const tempPath = `${resolvedPath}.svamp-upload-${safeUploadId}.part`;
+  const buffer = Buffer.from(content || "", "base64");
+  if (chunkIndex === 0) {
+    await fs$1.mkdir(dirname$1(resolvedPath), { recursive: true });
+    await fs$1.writeFile(tempPath, buffer);
+  } else {
+    await fs$1.appendFile(tempPath, buffer);
+  }
+  if (isLast) {
+    await fs$1.rename(tempPath, resolvedPath);
+  }
+}
 
 const __filename$1 = fileURLToPath(import.meta.url);
 const __dirname$1 = dirname$1(__filename$1);
@@ -17612,7 +17829,7 @@ async function startDaemon(options) {
     try {
       const dir = loadSessionIndex()[sessionId]?.directory;
       if (!dir) return;
-      const { reconcileServiceLinks } = await import('./agentCommands-DEJpgdgc.mjs');
+      const { reconcileServiceLinks } = await import('./agentCommands-DdNUACV8.mjs');
       const configPath = getSvampConfigPath(dir, sessionId);
       const config = readSvampConfig(configPath);
       const entries = Array.from(urls.entries());
@@ -17630,7 +17847,7 @@ async function startDaemon(options) {
     }
   }
   async function createExposedTunnel(spec) {
-    const { FrpcTunnel } = await import('./frpc-DV_IIYpM.mjs');
+    const { FrpcTunnel } = await import('./frpc-Cv6J2Mex.mjs');
     const tunnel = new FrpcTunnel({
       name: spec.name,
       ports: spec.ports,
@@ -17658,7 +17875,7 @@ async function startDaemon(options) {
   ensureAutoInstalledCommands(logger);
   (async () => {
     try {
-      const { beginClaudeVersionReconcile } = await import('./pinnedClaudeCode-BaMR97BE.mjs');
+      const { beginClaudeVersionReconcile } = await import('./pinnedClaudeCode-C6MSkqS9.mjs');
       beginClaudeVersionReconcile((msg) => logger.log(msg));
     } catch (e) {
       logger.log(`[claude-version] check failed: ${e?.message || e}`);
@@ -17941,8 +18158,16 @@ ${v.guidance ? v.guidance + "\n" : ""}Criteria: ${v.criteria || "(none)"}
           if (RATELIMIT_CFG.maxRetries <= 0) return false;
           if (trackedSession?.stopped) return false;
           if (currentTurnMessage === void 0) return false;
-          if (rateLimitRetryCount >= RATELIMIT_CFG.maxRetries) {
-            logger.log(`[Session ${sessionId}] Rate-limit retries exhausted (${rateLimitRetryCount}/${RATELIMIT_CFG.maxRetries}) \u2014 surfacing error`);
+          const nowTs = Date.now();
+          if (rateLimitStreakStartedAt === 0) {
+            rateLimitStreakStartedAt = nowTs;
+            sessionMetadata = { ...sessionMetadata, rateLimitStreakStartedAt: nowTs };
+          }
+          const budget = retryStreakExhausted(rateLimitRetryCount, rateLimitStreakStartedAt, nowTs, RATELIMIT_CFG);
+          if (budget.exhausted) {
+            const elapsedMin = Math.round((nowTs - rateLimitStreakStartedAt) / 6e4);
+            logger.log(`[Session ${sessionId}] Rate-limit retries exhausted (${budget.reason}: ${rateLimitRetryCount}/${RATELIMIT_CFG.maxRetries} attempts, ${elapsedMin}m elapsed) \u2014 surfacing error`);
+            resetRateLimitStreak();
             return false;
           }
           const attempt = rateLimitRetryCount++;
@@ -18410,18 +18635,18 @@ ${parts.join("\n")}`);
                 enqueueLoopMessage(push, label);
                 if (!trackedSession.stopped) setTimeout(() => processMessageQueueRef?.(), 200);
               } else {
-                writeGoalLoopState(directory, sessionId, { active: false, phase: "gave_up", completed_at: Date.now(), gave_up_reason: decision.reason, holds, ledger, progress_history, auto_resumes: ls.auto_resumes, extensions });
+                writeGoalLoopState(directory, sessionId, { ...ls, active: false, phase: "gave_up", completed_at: Date.now(), gave_up_reason: decision.reason, holds, ledger, progress_history, auto_resumes: ls.auto_resumes, extensions });
                 logger.log(`[Session ${sessionId}] [loop-persist] stuck-stop: ${decision.reason}`);
                 checkSvampConfig?.();
               }
             } else {
-              writeGoalLoopState(directory, sessionId, { active: false, phase: "done", completed_at: Date.now(), holds, ledger, progress_history, auto_resumes: ls.auto_resumes, extensions });
+              writeGoalLoopState(directory, sessionId, { ...ls, active: false, phase: "done", completed_at: Date.now(), holds, ledger, progress_history, auto_resumes: ls.auto_resumes, extensions });
               checkSvampConfig?.();
             }
           } catch (e) {
             logger.log(`[Session ${sessionId}] verifyGoalCompletion error \u2014 failing open (done): ${e?.message || e}`);
             try {
-              writeGoalLoopState(directory, sessionId, { active: false, phase: "done", completed_at: Date.now() });
+              writeGoalLoopState(directory, sessionId, { ...ls, active: false, phase: "done", completed_at: Date.now() });
               checkSvampConfig?.();
             } catch {
             }
@@ -18479,8 +18704,16 @@ ${parts.join("\n")}`);
         const RATELIMIT_CFG = getRateLimitRetryConfig();
         let currentTurnMessage;
         let rateLimitRetryCount = 0;
+        let rateLimitStreakStartedAt = Number(sessionMetadata?.rateLimitStreakStartedAt) || 0;
         let rateLimitRetryTimer = null;
         let rateLimitRetryScheduled = false;
+        const resetRateLimitStreak = () => {
+          rateLimitRetryCount = 0;
+          rateLimitStreakStartedAt = 0;
+          if (sessionMetadata?.rateLimitStreakStartedAt) {
+            sessionMetadata = { ...sessionMetadata, rateLimitStreakStartedAt: 0 };
+          }
+        };
         let checkSvampConfig;
         let cleanupSvampConfig;
         const VALID_CLAUDE_PERMISSION_MODES = /* @__PURE__ */ new Set(["default", "acceptEdits", "plan", "bypassPermissions"]);
@@ -18895,7 +19128,7 @@ ${parts.join("\n")}`);
                         "event"
                       );
                     }
-                    if (!msg.is_error) rateLimitRetryCount = 0;
+                    if (!msg.is_error) resetRateLimitStreak();
                     if (msg.session_id) {
                       claudeResumeId = msg.session_id;
                       if (sessionMetadata.claudeSessionId !== msg.session_id) {
@@ -19467,7 +19700,7 @@ ${capturedError}${buildClaudeErrorHint(capturedError)}`;
                 return;
               }
               currentTurnMessage = text;
-              rateLimitRetryCount = 0;
+              resetRateLimitStreak();
               if (rateLimitRetryTimer) {
                 clearTimeout(rateLimitRetryTimer);
                 rateLimitRetryTimer = null;
@@ -19491,7 +19724,7 @@ ${capturedError}${buildClaudeErrorHint(capturedError)}`;
                 clearTimeout(rateLimitRetryTimer);
                 rateLimitRetryTimer = null;
               }
-              rateLimitRetryCount = 0;
+              resetRateLimitStreak();
               if (claudeProcess && !claudeProcess.killed) {
                 try {
                   const interruptMsg = JSON.stringify({ type: "control_request", request: { type: "interrupt" } });
@@ -19848,11 +20081,11 @@ ${capturedError}${buildClaudeErrorHint(capturedError)}`;
               });
             },
             onIssue: async (params) => {
-              const { issueRpc } = await import('./rpc-wL-45Raf.mjs');
+              const { issueRpc } = await import('./rpc-CkcBAtcs.mjs');
               return issueRpc(params?.cwd || directory, params || {}, { notifySession: notifyIssueOwner, rekickLoopOwner });
             },
             onWorkflow: async (params) => {
-              const { workflowRpc } = await import('./rpc-BjKmyKdA.mjs');
+              const { workflowRpc } = await import('./rpc-BwxwusfB.mjs');
               return workflowRpc(params?.cwd || directory, params || {});
             },
             onRipgrep: async (args, cwd) => {
@@ -19884,6 +20117,9 @@ ${capturedError}${buildClaudeErrorHint(capturedError)}`;
               await fs$1.mkdir(dirname$1(resolvedPath), { recursive: true });
               await fs$1.writeFile(resolvedPath, Buffer.from(content, "base64"));
             },
+            onWriteFileChunk: async (path, content, uploadId, chunkIndex, totalChunks, isLast) => {
+              await writeSessionFileChunk(directory, sessionMetadata, path, content, uploadId, chunkIndex, isLast);
+            },
             onListDirectory: async (path) => {
               const resolvedDir = resolve$1(directory, path || ".");
               if (sessionMetadata.securityContext && resolvedDir !== resolve$1(directory) && !resolvedDir.startsWith(resolve$1(directory) + "/")) {
@@ -19893,8 +20129,15 @@ ${capturedError}${buildClaudeErrorHint(capturedError)}`;
               return entries.map((e) => ({ name: e.name, isDirectory: e.isDirectory() }));
             },
             onGetDirectoryTree: async (treePath, maxDepth) => {
+              const SKIP_DIRS = /* @__PURE__ */ new Set(["node_modules", ".git", ".svamp", ".expo", "dist", "build", ".next", ".cache", ".venv", "venv", "__pycache__", ".turbo", ".gradle", "target"]);
+              const MAX_TREE_DEPTH = 8;
+              const MAX_TREE_NODES = 2e4;
+              const effectiveMaxDepth = Math.min(Math.max(0, Math.floor(Number(maxDepth)) || 0), MAX_TREE_DEPTH);
+              let treeNodeCount = 0;
               async function buildTree(p, name, depth) {
                 try {
+                  if (treeNodeCount >= MAX_TREE_NODES) return null;
+                  treeNodeCount++;
                   const stats = await fs$1.stat(p);
                   const node = {
                     name,
@@ -19903,11 +20146,13 @@ ${capturedError}${buildClaudeErrorHint(capturedError)}`;
                     size: stats.size,
                     modified: stats.mtime.getTime()
                   };
-                  if (stats.isDirectory() && depth < maxDepth) {
+                  if (stats.isDirectory() && depth < effectiveMaxDepth) {
                     const entries = await fs$1.readdir(p, { withFileTypes: true });
                     const children = [];
                     await Promise.all(entries.map(async (entry) => {
                       if (entry.isSymbolicLink()) return;
+                      if (entry.isDirectory() && SKIP_DIRS.has(entry.name)) return;
+                      if (treeNodeCount >= MAX_TREE_NODES) return;
                       const childPath = join(p, entry.name);
                       const childNode = await buildTree(childPath, entry.name, depth + 1);
                       if (childNode) children.push(childNode);
@@ -19978,7 +20223,7 @@ ${capturedError}${buildClaudeErrorHint(capturedError)}`;
             userMessagePending = true;
             turnInitiatedByUser = true;
             currentTurnMessage = next.text;
-            rateLimitRetryCount = 0;
+            resetRateLimitStreak();
             if (rateLimitRetryTimer) {
               clearTimeout(rateLimitRetryTimer);
               rateLimitRetryTimer = null;
@@ -20257,6 +20502,30 @@ ${capturedError}${buildClaudeErrorHint(capturedError)}`;
                   };
                   sessionService.updateMetadata(sessionMetadata);
                 };
+                const drainQueueHeadIfIdle = () => {
+                  if (acpStopped || !acpBackendReady) return;
+                  if (sessionMetadata.lifecycleState !== "idle") return;
+                  const queue = sessionMetadata.messageQueue;
+                  if (!queue || queue.length === 0) return;
+                  const next = queue[0];
+                  const remaining = queue.slice(1);
+                  sessionMetadata = { ...sessionMetadata, messageQueue: remaining.length > 0 ? remaining : void 0, lifecycleState: "running" };
+                  sessionService.updateMetadata(sessionMetadata);
+                  if (typeof next.inboxHop === "number") {
+                    writeInboundContext(sessionId, { hopCount: next.inboxHop, threadId: next.inboxThreadId });
+                  }
+                  sessionService.markInboxHandled(next.id);
+                  if (!next.alreadyStored) sessionService.pushMessage(next.displayText || next.text, "user");
+                  sessionService.sendKeepAlive(true);
+                  agentBackend.sendPrompt(sessionId, next.text).catch((err) => {
+                    logger.error(`[${agentName} Session ${sessionId}] Error draining queued message after inject miss: ${err?.message ?? err}`);
+                    if (!acpStopped) {
+                      sessionMetadata = { ...sessionMetadata, lifecycleState: "idle" };
+                      sessionService.updateMetadata(sessionMetadata);
+                      sessionService.sendSessionEnd();
+                    }
+                  });
+                };
                 const injectFn = agentBackend.injectInput;
                 if (typeof injectFn === "function") {
                   Promise.resolve(injectFn.call(agentBackend, text)).then((injected) => {
@@ -20265,10 +20534,12 @@ ${capturedError}${buildClaudeErrorHint(capturedError)}`;
                     } else {
                       logger.log(`[${agentName} Session ${sessionId}] No active turn to inject \u2014 queuing message`);
                       enqueueBusy();
+                      drainQueueHeadIfIdle();
                     }
                   }).catch((err) => {
                     logger.error(`[${agentName} Session ${sessionId}] Mid-turn inject failed \u2014 queuing:`, err?.message ?? err);
                     enqueueBusy();
+                    drainQueueHeadIfIdle();
                   });
                   return;
                 }
@@ -20484,11 +20755,11 @@ ${capturedError}${buildClaudeErrorHint(capturedError)}`;
               });
             },
             onIssue: async (params) => {
-              const { issueRpc } = await import('./rpc-wL-45Raf.mjs');
+              const { issueRpc } = await import('./rpc-CkcBAtcs.mjs');
               return issueRpc(params?.cwd || directory, params || {}, { notifySession: notifyIssueOwner, rekickLoopOwner });
             },
             onWorkflow: async (params) => {
-              const { workflowRpc } = await import('./rpc-BjKmyKdA.mjs');
+              const { workflowRpc } = await import('./rpc-BwxwusfB.mjs');
               return workflowRpc(params?.cwd || directory, params || {});
             },
             onRipgrep: async (args, cwd) => {
@@ -20520,6 +20791,9 @@ ${capturedError}${buildClaudeErrorHint(capturedError)}`;
               await fs$1.mkdir(dirname$1(resolvedPath), { recursive: true });
               await fs$1.writeFile(resolvedPath, Buffer.from(content, "base64"));
             },
+            onWriteFileChunk: async (path, content, uploadId, chunkIndex, totalChunks, isLast) => {
+              await writeSessionFileChunk(directory, sessionMetadata, path, content, uploadId, chunkIndex, isLast);
+            },
             onListDirectory: async (path) => {
               const resolvedDir = resolve$1(directory, path || ".");
               if (sessionMetadata.securityContext && resolvedDir !== resolve$1(directory) && !resolvedDir.startsWith(resolve$1(directory) + "/")) {
@@ -20529,8 +20803,15 @@ ${capturedError}${buildClaudeErrorHint(capturedError)}`;
               return entries.map((e) => ({ name: e.name, isDirectory: e.isDirectory() }));
             },
             onGetDirectoryTree: async (treePath, maxDepth) => {
+              const SKIP_DIRS = /* @__PURE__ */ new Set(["node_modules", ".git", ".svamp", ".expo", "dist", "build", ".next", ".cache", ".venv", "venv", "__pycache__", ".turbo", ".gradle", "target"]);
+              const MAX_TREE_DEPTH = 8;
+              const MAX_TREE_NODES = 2e4;
+              const effectiveMaxDepth = Math.min(Math.max(0, Math.floor(Number(maxDepth)) || 0), MAX_TREE_DEPTH);
+              let treeNodeCount = 0;
               async function buildTree(p, name, depth) {
                 try {
+                  if (treeNodeCount >= MAX_TREE_NODES) return null;
+                  treeNodeCount++;
                   const stats = await fs$1.stat(p);
                   const node = {
                     name,
@@ -20539,11 +20820,13 @@ ${capturedError}${buildClaudeErrorHint(capturedError)}`;
                     size: stats.size,
                     modified: stats.mtime.getTime()
                   };
-                  if (stats.isDirectory() && depth < maxDepth) {
+                  if (stats.isDirectory() && depth < effectiveMaxDepth) {
                     const entries = await fs$1.readdir(p, { withFileTypes: true });
                     const children = [];
                     await Promise.all(entries.map(async (entry) => {
                       if (entry.isSymbolicLink()) return;
+                      if (entry.isDirectory() && SKIP_DIRS.has(entry.name)) return;
+                      if (treeNodeCount >= MAX_TREE_NODES) return;
                       const childPath = join(p, entry.name);
                       const childNode = await buildTree(childPath, entry.name, depth + 1);
                       if (childNode) children.push(childNode);
@@ -21434,7 +21717,7 @@ ${oracle.output.trim().slice(0, 500)}`, "\u{1F501} Continuing loop");
     }
     if (persistedSessions.length > 0) {
       try {
-        const { awaitClaudeVersionReady } = await import('./pinnedClaudeCode-BaMR97BE.mjs');
+        const { awaitClaudeVersionReady } = await import('./pinnedClaudeCode-C6MSkqS9.mjs');
         await awaitClaudeVersionReady();
       } catch {
       }
@@ -21639,7 +21922,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-Dia9Akaw.mjs');
+    const { WorkflowScheduler } = await import('./scheduler-CurN4UtP.mjs');
     const workflowProjectRoots = () => {
       const dirs = /* @__PURE__ */ new Set();
       for (const s of pidToTrackedSession.values()) {
@@ -21928,6 +22211,7 @@ ${oracle.output.trim().slice(0, 500)}`, "\u{1F501} Continuing loop");
       logger.log(`Cleaning up (source: ${source})...`);
       clearInterval(heartbeatInterval);
       clearInterval(workflowSchedulerInterval);
+      clearInterval(backendAccountRefreshInterval);
       if (proxyTokenRefreshInterval) clearInterval(proxyTokenRefreshInterval);
       if (oauthRefreshInterval) clearInterval(oauthRefreshInterval);
       if (unhandledRejectionResetTimer) clearTimeout(unhandledRejectionResetTimer);
@@ -22272,4 +22556,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, workflowCrons as G, cronMatches as H, summarize as I, workflowSteps as J, parseJwtEmail as K, computeCollectionConfigUpdate as L, SYSTEM_COLLECTION_CONFIG as M, loadMachineContext as N, buildMachineInstructions as O, machineToolsForRole as P, buildMachineTools as Q, READ_ONLY_TOOLS as R, SharingNotificationSync as S, PINNED_CODEX_VERSION 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, mergeSecurityContexts as aa, buildSessionShareUrl as ab, computeOutboundHop as ac, registerAwaitingReply as ad, buildMachineShareUrl as ae, parseHandle as af, handleMatchesMetadata as ag, describeMisconfiguration as ah, buildMachineDeps as ai, applyClaudeProxyEnv as aj, composeSessionId as ak, generateFriendlyName as al, generateHookSettings as am, staticFileServer as an, instanceConfig as ao, claudeAuth as ap, codexProvider as aq, projectInfo as ar, DefaultTransport$1 as as, acpBackend as at, acpAgentConfig as au, codexAppServerBackend as av, GeminiTransport$1 as aw, api as ax, run as ay, 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 { SKILLS_DIR 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, PINNED_CODEX_VERSION as U, parseFrontmatter as V, getSkillsServer as W, getSkillsWorkspaceName as X, getSkillsCollectionName as Y, fetchWithTimeout as Z, searchSkills as _, createSessionStore as a, getSkillInfo as a0, downloadSkillFile as a1, listSkillFiles as a2, resolveModel as a3, clearStopMarker as a4, stopMarkerExists as a5, formatHandle as a6, normalizeAllowedUser as a7, loadSecurityContextConfig as a8, resolveSecurityContext as a9, run as aA, buildSecurityContextFromFlags as aa, mergeSecurityContexts as ab, buildSessionShareUrl as ac, computeOutboundHop as ad, registerAwaitingReply as ae, buildMachineShareUrl as af, parseHandle as ag, handleMatchesMetadata 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, api 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 };