svamp-cli 0.2.307 → 0.2.309

package/dist/{run-DYVmYsvg.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-NDcBtpwa.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",
@@ -4857,8 +4988,43 @@ const SESSION_METHOD_MIN_ROLE = {
   refineLastReply: "admin",
   undoLastEdit: "admin"
 };
+const SESSION_VIEW_METHODS = /* @__PURE__ */ new Set([
+  // read-only (authorizeRequest at view-role)
+  "getMessages",
+  "getLatestMessages",
+  "getMessageCount",
+  "getMetadata",
+  "getSharing",
+  "getInbox",
+  "getEffectiveRole",
+  "getActivityState",
+  "getAgentState",
+  "getChannelSkill",
+  "getMeetingActivity",
+  "listChannels",
+  "outpostList",
+  "registerListener",
+  // self-authenticating (own capability key / token) or liveness — machine role stays view
+  "channelDescribe",
+  "channelExecTool",
+  "channelGetProfile",
+  "channelList",
+  "channelOwns",
+  "channelReceive",
+  "channelSend",
+  "channelUpload",
+  "outpostHello",
+  "outpostPoll",
+  "outpostResult",
+  "disconnect",
+  "reregister",
+  "recordMeetingActivity"
+]);
 function sessionMethodMinRole(method) {
-  return SESSION_METHOD_MIN_ROLE[method] ?? "view";
+  const mapped = SESSION_METHOD_MIN_ROLE[method];
+  if (mapped) return mapped;
+  if (SESSION_VIEW_METHODS.has(method)) return "view";
+  return "admin";
 }
 function getParamNames(fn) {
   const src = fn.toString();
@@ -6088,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-NDcBtpwa.mjs');
+        const { FrpcTunnel } = await import('./frpc-Cv6J2Mex.mjs');
         const tunnel = new FrpcTunnel({
           name: params.name,
           ports: params.ports,
@@ -6573,7 +6739,7 @@ QUESTION: ${params.question || "Summarize this concisely."}` }
           let owner;
           try {
             role2 = (await rpc.getEffectiveRole(context))?.role ?? null;
-            if (!role2) return { success: false, error: "Not authorized for this session" };
+            if (!roleAtLeast(role2, "interact")) return { success: false, error: "Not authorized: WISE ask requires interact access to this session." };
             const m = await rpc.getMetadata(context);
             cwd = m?.metadata?.path;
             owner = m?.metadata?.sharing?.owner;
@@ -6582,12 +6748,12 @@ 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-CdJ0O6L6.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);
         }
         const role = getEffectiveRole(context, currentMetadata.sharing);
-        if (!role) return { success: false, error: "Not authorized on this machine" };
+        if (!roleAtLeast(role, "interact")) return { success: false, error: "Not authorized: WISE ask requires interact access to this machine." };
         const machineDeps = buildMachineDeps(
           {
             getSessionIds: handlers.getSessionIds,
@@ -6687,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-CJVqMnNf.mjs');
+    const { queryCore } = await import('./commands-BTN9XxVx.mjs');
     const timeout = c.reply?.timeout_sec || 120;
     let result;
     try {
@@ -7197,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);
@@ -7378,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);
@@ -7385,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);
@@ -7457,6 +7656,7 @@ class OutpostCoordinator {
   clearTimer;
   execTimeoutMs;
   staleMs;
+  randToken;
   sweeper = null;
   constructor(opts = {}) {
     this.now = opts.now || (() => Date.now());
@@ -7464,6 +7664,7 @@ class OutpostCoordinator {
     this.clearTimer = opts.clearTimer || ((t) => clearTimeout(t));
     this.execTimeoutMs = opts.execTimeoutMs ?? OUTPOST_EXEC_TIMEOUT_MS;
     this.staleMs = opts.staleMs ?? OUTPOST_STALE_MS;
+    this.randToken = opts.randToken || (() => randomBytes(9).toString("base64url"));
   }
   isStale(c, at) {
     return at - c.lastSeen > this.staleMs;
@@ -7575,7 +7776,7 @@ class OutpostCoordinator {
    * machine is not connected.
    */
   enqueueExec(machine, cmd, cwd) {
-    const id = `x${(++this.seq).toString(36)}_${this.now().toString(36)}`;
+    const id = `x${(++this.seq).toString(36)}_${this.now().toString(36)}_${this.randToken()}`;
     if (!this.isConnected(machine)) {
       return {
         id,
@@ -8035,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;
@@ -8810,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 };
     },
@@ -8921,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");
@@ -10470,8 +10686,23 @@ function computeCollectionConfigUpdate(existingConfig, extra) {
 function emailHash(email) {
   return createHash("sha256").update(email.toLowerCase()).digest("hex").slice(0, 12);
 }
+function sessionIdHash(sessionId) {
+  return createHash("sha256").update(sessionId).digest("hex").slice(0, 12);
+}
+function roleLabel(role) {
+  switch (role) {
+    case "admin":
+      return "full access";
+    case "interact":
+      return "can interact";
+    case "view":
+      return "view only";
+    default:
+      return String(role);
+  }
+}
 function shareAlias(sessionId, recipientEmail) {
-  return `share-${sessionId.slice(0, 8)}-${emailHash(recipientEmail)}`;
+  return `share-${sessionIdHash(sessionId)}-${emailHash(recipientEmail)}`;
 }
 function eventAlias(eventId, recipientEmail) {
   return `evt-${emailHash(recipientEmail)}-${eventId.slice(0, 8)}`;
@@ -10585,8 +10816,10 @@ class SharingNotificationSync {
         userEmail: params.ownerEmail
       },
       title: `${typeLabel} shared with you`,
-      // Per-user tiers were retired; explicit users always have full access.
-      body: `${params.ownerEmail} shared "${params.label || "Untitled"}" with you (full access)`,
+      // #0689: render the recipient's ACTUAL role (view/interact/admin) — authorize.ts genuinely
+      // enforces per-user roles, so the old hardcoded "(full access)" misstated a view/interact
+      // invitee's access.
+      body: `${params.ownerEmail} shared "${params.label || "Untitled"}" with you (${roleLabel(params.role)})`,
       level: "info",
       action: shareType === "session" ? {
         type: "add-session-bookmark",
@@ -10766,13 +10999,15 @@ class SharingNotificationSync {
   // ── Sharing config diff + sync ───────────────────────────────────
   async syncSharing(sessionId, oldSharing, newSharing, context) {
     if (!this.initialized) return;
-    const oldEmails = new Set(
-      (oldSharing?.allowedUsers || []).map((u) => u.email.toLowerCase())
+    const oldRoleByEmail = new Map(
+      (oldSharing?.allowedUsers || []).map((u) => [u.email.toLowerCase(), u.role])
     );
+    const oldEmails = new Set(oldRoleByEmail.keys());
     const newUsers = newSharing.allowedUsers || [];
     const newEmails = new Set(newUsers.map((u) => u.email.toLowerCase()));
     for (const user of newUsers) {
-      if (!oldEmails.has(user.email.toLowerCase())) {
+      const prevRole = oldRoleByEmail.get(user.email.toLowerCase());
+      if (prevRole === void 0 || prevRole !== user.role) {
         this.notifyShare({
           recipientEmail: user.email,
           sessionId,
@@ -12209,6 +12444,16 @@ function codexCumulativeTokens(payload) {
   return nonCachedInput + output + Math.round(cached * 0.1);
 }
 
+const PINNED_CODEX_VERSION = "0.146.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;
+}
+function codexSupportsSteer(v) {
+  if (!v) return false;
+  return cmpVer(v, MIN_CODEX_STEER_VERSION) >= 0;
+}
+
 function parseCodexVersion(v) {
   const m = v.match(/codex-cli\s+(\d+)\.(\d+)\.(\d+)/);
   if (!m) return null;
@@ -12225,6 +12470,31 @@ function codexAppServerAvailable() {
     return null;
   }
 }
+const _execFileAsync = promisify$1(execFile$1);
+let _steerSupport = null;
+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) {
     this.opts = opts;
@@ -12381,19 +12651,36 @@ class CodexAppServerClient {
   /**
    * Inject additional input into the CURRENTLY RUNNING turn (Claude-Code-style mid-turn steering).
    *
-   * codex app-server FOLDS a second `turn/start` sent mid-turn into the active turn: the new input's
-   * items are emitted under the RUNNING turn's id and NO separate `turn/completed` fires for the
-   * injected turn (verified empirically — probe-codex-midturn). So we send it WITHOUT arming a new
-   * `pendingTurn` slot and WITHOUT overwriting `_turnId` (which must keep pointing at the turn to
-   * interrupt). The single in-flight completion still resolves the original `sendTurnAndWait`.
+   * Uses codex app-server's NATIVE `turn/steer` — the correct primitive for "append this message to
+   * the in-flight turn without interrupting it." The steered input is applied at the next model step
+   * (it does NOT abort a running tool call), the assistant finishes the current work and drains the
+   * steered message as user input before its next LLM call, and NO separate `turn/started` /
+   * `turn/completed` fires — the original single in-flight completion still resolves `sendTurnAndWait`.
+   * So we send it WITHOUT arming a new `pendingTurn` slot and WITHOUT overwriting `_turnId`.
+   *
+   * (The earlier #86 implementation fired a second `turn/start` mid-turn; on codex 0.144 that
+   * ABORTS/REPLACES the running turn instead of folding — the "cuts off the previous task" bug.)
    *
-   * Returns false when there is NO active turn to fold into (the caller then falls back to a normal
-   * turn via sendPrompt). `pendingTurn` is the in-flight signal.
+   * Returns false when there is no active turn to steer, or when the server REJECTS the steer
+   * (no active turn / expectedTurnId mismatch / non-steerable turn kind such as review or manual
+   * compact). The caller then falls back to client-side queueing (post-turn drain via sendPrompt),
+   * so a rejected steer degrades gracefully rather than losing the message.
    */
-  async injectInput(prompt, o) {
-    if (!this._threadId || !this.pendingTurn) return false;
-    await this.request("turn/start", this.buildTurnParams(prompt, o));
-    return true;
+  async injectInput(prompt, _o) {
+    if (!this._threadId || !this.pendingTurn || !this._turnId) return false;
+    if (!await codexSupportsSteerInstalledAsync()) return false;
+    const params = {
+      threadId: this._threadId,
+      expectedTurnId: this._turnId,
+      input: [{ type: "text", text: prompt }]
+    };
+    try {
+      await this.request("turn/steer", params);
+      return true;
+    } catch (e) {
+      this.log("[codex-app-server] turn/steer rejected \u2014 falling back to post-turn queue", e);
+      return false;
+    }
   }
   /** Interrupt the in-flight turn (real server-side abort — the old MCP path couldn't do this). */
   async interrupt() {
@@ -12436,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 });
     });
   }
@@ -14746,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");
@@ -14767,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() }];
@@ -14815,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;
@@ -15081,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)";
@@ -15265,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, {
@@ -16021,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);
@@ -17519,7 +17829,7 @@ async function startDaemon(options) {
     try {
       const dir = loadSessionIndex()[sessionId]?.directory;
       if (!dir) return;
-      const { reconcileServiceLinks } = await import('./agentCommands-D68wBf-y.mjs');
+      const { reconcileServiceLinks } = await import('./agentCommands-DdNUACV8.mjs');
       const configPath = getSvampConfigPath(dir, sessionId);
       const config = readSvampConfig(configPath);
       const entries = Array.from(urls.entries());
@@ -17537,7 +17847,7 @@ async function startDaemon(options) {
     }
   }
   async function createExposedTunnel(spec) {
-    const { FrpcTunnel } = await import('./frpc-NDcBtpwa.mjs');
+    const { FrpcTunnel } = await import('./frpc-Cv6J2Mex.mjs');
     const tunnel = new FrpcTunnel({
       name: spec.name,
       ports: spec.ports,
@@ -17565,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}`);
@@ -17848,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++;
@@ -18317,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 {
             }
@@ -18386,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"]);
@@ -18802,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) {
@@ -19374,7 +19700,7 @@ ${capturedError}${buildClaudeErrorHint(capturedError)}`;
                 return;
               }
               currentTurnMessage = text;
-              rateLimitRetryCount = 0;
+              resetRateLimitStreak();
               if (rateLimitRetryTimer) {
                 clearTimeout(rateLimitRetryTimer);
                 rateLimitRetryTimer = null;
@@ -19398,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" } });
@@ -19755,11 +20081,11 @@ ${capturedError}${buildClaudeErrorHint(capturedError)}`;
               });
             },
             onIssue: async (params) => {
-              const { issueRpc } = await import('./rpc-K5xzddMF.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-DSyBSuTF.mjs');
+              const { workflowRpc } = await import('./rpc-BwxwusfB.mjs');
               return workflowRpc(params?.cwd || directory, params || {});
             },
             onRipgrep: async (args, cwd) => {
@@ -19791,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) + "/")) {
@@ -19800,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,
@@ -19810,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);
@@ -19885,7 +20223,7 @@ ${capturedError}${buildClaudeErrorHint(capturedError)}`;
             userMessagePending = true;
             turnInitiatedByUser = true;
             currentTurnMessage = next.text;
-            rateLimitRetryCount = 0;
+            resetRateLimitStreak();
             if (rateLimitRetryTimer) {
               clearTimeout(rateLimitRetryTimer);
               rateLimitRetryTimer = null;
@@ -20164,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) => {
@@ -20172,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;
                 }
@@ -20391,11 +20755,11 @@ ${capturedError}${buildClaudeErrorHint(capturedError)}`;
               });
             },
             onIssue: async (params) => {
-              const { issueRpc } = await import('./rpc-K5xzddMF.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-DSyBSuTF.mjs');
+              const { workflowRpc } = await import('./rpc-BwxwusfB.mjs');
               return workflowRpc(params?.cwd || directory, params || {});
             },
             onRipgrep: async (args, cwd) => {
@@ -20427,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) + "/")) {
@@ -20436,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,
@@ -20446,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);
@@ -21341,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 {
       }
@@ -21546,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-CtKlSyIq.mjs');
+    const { WorkflowScheduler } = await import('./scheduler-CurN4UtP.mjs');
     const workflowProjectRoots = () => {
       const dirs = /* @__PURE__ */ new Set();
       for (const s of pidToTrackedSession.values()) {
@@ -21835,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);
@@ -22179,4 +22556,4 @@ var run = /*#__PURE__*/Object.freeze({
     writeStopMarker: writeStopMarker
 });
 
-export { downloadSkillFile 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, parseFrontmatter as T, getSkillsServer as U, getSkillsWorkspaceName as V, getSkillsCollectionName as W, fetchWithTimeout as X, searchSkills as Y, SKILLS_DIR as Z, getSkillInfo as _, createSessionStore as a, listSkillFiles as a0, resolveModel as a1, clearStopMarker as a2, stopMarkerExists as a3, formatHandle as a4, normalizeAllowedUser as a5, loadSecurityContextConfig as a6, resolveSecurityContext as a7, buildSecurityContextFromFlags as a8, mergeSecurityContexts as a9, buildSessionShareUrl as aa, computeOutboundHop as ab, registerAwaitingReply as ac, buildMachineShareUrl as ad, parseHandle as ae, handleMatchesMetadata as af, describeMisconfiguration as ag, buildMachineDeps as ah, applyClaudeProxyEnv as ai, composeSessionId as aj, generateFriendlyName as ak, generateHookSettings as al, staticFileServer as am, instanceConfig as an, claudeAuth as ao, codexProvider as ap, projectInfo as aq, DefaultTransport$1 as ar, acpBackend as as, acpAgentConfig as at, codexAppServerBackend as au, GeminiTransport$1 as av, api as aw, run as ax, 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 };