svamp-cli 0.2.335 → 0.2.337

package/dist/{run-DUzNQjSO.mjs → run-bo0i02Dy.mjs}

@@ -5521,27 +5521,63 @@ function sleepSync$1(ms) {
   } catch {
   }
 }
+function isProcessDead(pid) {
+  try {
+    process.kill(pid, 0);
+    return false;
+  } catch (e) {
+    return e?.code === "ESRCH";
+  }
+}
 function withFileLock(lockPath, fn, opts) {
   const deadlineMs = opts?.deadlineMs ?? 50;
   const staleMs = opts?.staleMs ?? 5e3;
+  const trackOwner = opts?.breakOnDeadOwner ?? false;
+  const pidPath = join$1(lockPath, "owner.pid");
   const deadline = Date.now() + deadlineMs;
   let held = false;
   while (Date.now() < deadline) {
     try {
       mkdirSync$1(lockPath);
       held = true;
+      if (trackOwner) {
+        try {
+          writeFileSync$1(pidPath, String(process.pid));
+        } catch {
+        }
+      }
       break;
     } catch {
-      try {
-        if (Date.now() - statSync(lockPath).mtimeMs > staleMs) {
-          rmSync$1(lockPath, { recursive: true, force: true });
-          continue;
+      let broke = false;
+      if (trackOwner) {
+        try {
+          const owner = Number(readFileSync(pidPath, "utf8"));
+          if (Number.isInteger(owner) && owner > 0 && owner !== process.pid && isProcessDead(owner)) {
+            rmSync$1(lockPath, { recursive: true, force: true });
+            broke = true;
+          }
+        } catch {
+        }
+      }
+      if (!broke) {
+        try {
+          if (Date.now() - statSync(lockPath).mtimeMs > staleMs) {
+            rmSync$1(lockPath, { recursive: true, force: true });
+            broke = true;
+          }
+        } catch {
         }
-      } catch {
       }
+      if (broke) continue;
       sleepSync$1(5);
     }
   }
+  if (!held) {
+    try {
+      opts?.onFailOpen?.(lockPath);
+    } catch {
+    }
+  }
   try {
     return fn();
   } finally {
@@ -5554,6 +5590,33 @@ function withFileLock(lockPath, fn, opts) {
   }
 }
 
+function revGuardedMutate(lockPath, io, mutate, opts) {
+  const deadlineMs = opts?.deadlineMs ?? 2e3;
+  const maxAttempts = opts?.maxAttempts ?? 50;
+  let last;
+  for (let attempt = 0; attempt < maxAttempts; attempt++) {
+    const settled = withFileLock(lockPath, () => {
+      const base = io.read();
+      const m = mutate(base.state);
+      last = m.result;
+      if (m.next === null) return { committed: true, result: m.result };
+      if (opts?._seam) opts._seam(attempt);
+      const again = io.read();
+      if (again.rev !== base.rev) return { committed: false, result: m.result };
+      io.write(m.next, base.rev + 1);
+      return { committed: true, result: m.result };
+    }, {
+      deadlineMs,
+      breakOnDeadOwner: true,
+      onFailOpen: opts?.onFailOpen
+    });
+    last = settled.result;
+    if (settled.committed) return settled.result;
+    sleepSync$1(3 + attempt % 5);
+  }
+  return last;
+}
+
 const HARD_MAX_BYTES = 25 * 1024 * 1024;
 const DEFAULT_MAX_BYTES = 5 * 1024 * 1024;
 const DEFAULT_MAX_COUNT = 100;
@@ -5805,6 +5868,23 @@ const _CHANNEL_CACHE_TTL_MS = 1e3;
 function invalidateChannelCache(dir) {
   _channelListCache.delete(dir);
 }
+function makeRmwSeam() {
+  const delayMs = Number(process.env.SVAMP_TEST_RMW_DELAY_MS || 0);
+  if (!delayMs || !Number.isFinite(delayMs)) return void 0;
+  const readyFile = process.env.SVAMP_TEST_RMW_READY_FILE;
+  let fired = false;
+  return (attempt) => {
+    if (attempt !== 0 || fired) return;
+    fired = true;
+    if (readyFile) {
+      try {
+        writeFileSync$1(readyFile, "1");
+      } catch {
+      }
+    }
+    sleepSync$1(delayMs);
+  };
+}
 class ChannelStore {
   dir;
   constructor(projectDir) {
@@ -5818,12 +5898,18 @@ class ChannelStore {
   }
   _lock(id) {
     if (!isValidChannelId(id)) throw new Error(`invalid channel id: ${String(id).slice(0, 64)}`);
+    mkdirSync$1(this.dir, { recursive: true });
     return join$1(this.dir, `${id}.json.lock`);
   }
+  /** The default-filled canonical form of a channel (the minimal fields the store guarantees).
+   *  Extracted so `save()` can return the SAME shape it persists without re-running the write. */
+  _applyDefaults(channel) {
+    return { enabled: true, bind: "dynamic", template: DEFAULT_TEMPLATE, last_calls: [], ...channel };
+  }
   // #0679: the actual validate + atomic write, WITHOUT the lock, so a locked RMW mutator can
   // reuse it inside its own lock section (no re-entrant re-lock / deadlock).
   _writeChannel(channel) {
-    const c = { enabled: true, bind: "dynamic", template: DEFAULT_TEMPLATE, last_calls: [], ...channel };
+    const c = this._applyDefaults(channel);
     if (!c.id) c.id = genId();
     const errs = validateChannel(c);
     if (errs.length) throw new Error("invalid channel: " + errs.join("; "));
@@ -5875,8 +5961,11 @@ class ChannelStore {
     }
   }
   save(channel) {
-    if (channel.id) return withFileLock(this._lock(channel.id), () => this._writeChannel(channel));
-    return this._writeChannel(channel);
+    if (!channel.id) return this._writeChannel(channel);
+    return this._rmw(channel.id, "save", () => {
+      const merged = this._applyDefaults(channel);
+      return { next: merged, result: merged };
+    });
   }
   remove(id) {
     return withFileLock(this._lock(id), () => {
@@ -5887,41 +5976,85 @@ class ChannelStore {
         return true;
       }
       return false;
+    }, {
+      deadlineMs: 2e3,
+      breakOnDeadOwner: true,
+      onFailOpen: () => console.warn(`[channels] remove(${id}): lock contended for 2000ms \u2014 proceeding WITHOUT it`)
     });
   }
-  // #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
-  // serialization two concurrent RMWs both read the same base and the second save() clobbers the
-  // first (addCaller silently DROPS a freshly-generated caller key). Hold the bounded fail-open
-  // per-channel lock across the whole read→mutate→write so the read sees the other's committed
-  // change (mirrors inboxGuard's #0625 withAwaitLock). _writeChannel is the un-locked write.
+  // #0679: setEnabled/recordCall/addCaller/removeCaller are read-modify-write mutators — multiple
+  // ChannelStore instances (one per session, plus the CLI) point at the same
+  // .svamp/channels/<id>.json, so without serialization two concurrent RMWs both read the same base
+  // and the second write clobbers the first (addCaller silently DROPS a freshly-generated caller
+  // key; removeCaller silently RESURRECTS a revoked one — a SECURITY outcome).
+  /**
+   * #1226: the STRUCTURAL fix for those lost updates — a rev-guarded read-modify-write.
+   *
+   * withFileLock is bounded and FAIL-OPEN by design: on timeout it runs the mutation WITHOUT the
+   * lock rather than hanging the daemon's single thread. That fail-open is a genuine lost-update
+   * window, and merely widening the deadline (the earlier 50→2000 change) only shrinks the
+   * PROBABILITY proportional to N×holdTime — the child's barrier harness reproduced 36-of-48
+   * mutations lost at deadline=2000/hold=50/N=48. `revGuardedMutate` instead embeds a monotonic
+   * `_rev`: it reads the base at rev R, applies the mutation, RE-READS immediately before writing,
+   * and if the rev has advanced (a concurrent commit landed in its window) it retries against the
+   * fresh base rather than clobbering. When the lock genuinely holds this is airtight; when it
+   * fails open it collapses the loss window to the sub-millisecond re-read→rename gap (see
+   * util/revLock.ts for the honest residual). `breakOnDeadOwner` (enabled inside revLock) also
+   * closes the #1228 gap where a crashed holder's lock was never broken because deadlineMs(2000)
+   * < staleMs(5000) — safe precisely because the rev guard tolerates the transient double-writer.
+   *
+   * recordCall uses a SHORT deadline + few attempts: it runs on every channel send (a hot path)
+   * and all it can lose is one entry of a 20-deep rolling log, so it must not block the loop — but
+   * it is still rev-guarded, so it no longer silently drops a log entry to a concurrent mutator
+   * when it does acquire.
+   */
+  _rmw(id, op, mutate, opts) {
+    return revGuardedMutate(
+      this._lock(id),
+      {
+        read: () => {
+          const c = this.get(id);
+          return { state: c, rev: c?._rev ?? 0 };
+        },
+        write: (state, rev) => {
+          state._rev = rev;
+          this._writeChannel(state);
+        }
+      },
+      mutate,
+      {
+        deadlineMs: opts?.deadlineMs ?? 2e3,
+        maxAttempts: opts?.maxAttempts,
+        onFailOpen: () => {
+          console.warn(`[channels] ${op}(${id}): lock contended \u2014 proceeding WITHOUT it (rev-guarded); a concurrent update is still highly unlikely to be lost`);
+        },
+        _seam: makeRmwSeam()
+      }
+    );
+  }
   setEnabled(id, enabled) {
-    return withFileLock(this._lock(id), () => {
-      const c = this.get(id);
-      if (!c) return null;
+    return this._rmw(id, "setEnabled", (c) => {
+      if (!c) return { next: null, result: null };
       c.enabled = enabled;
-      return this._writeChannel(c);
+      return { next: c, result: c };
     });
   }
   recordCall(id, entry) {
-    withFileLock(this._lock(id), () => {
-      const c = this.get(id);
-      if (!c) return;
+    this._rmw(id, "recordCall", (c) => {
+      if (!c) return { next: null, result: void 0 };
       c.last_calls = c.last_calls || [];
       c.last_calls.unshift({ at: (/* @__PURE__ */ new Date()).toISOString(), ...entry });
       c.last_calls = c.last_calls.slice(0, 20);
-      this._writeChannel(c);
-    });
+      return { next: c, result: void 0 };
+    }, { deadlineMs: 200, maxAttempts: 3 });
   }
   addCaller(id, name, kind = "agent") {
-    return withFileLock(this._lock(id), () => {
-      const c = this.get(id);
-      if (!c) return null;
+    return this._rmw(id, "addCaller", (c) => {
+      if (!c) return { next: null, result: null };
       c.identity.callers = c.identity.callers || [];
       const caller = { name, kind, key: genKey() };
       c.identity.callers.push(caller);
-      this._writeChannel(c);
-      return caller;
+      return { next: c, result: caller };
     });
   }
   /**
@@ -5936,14 +6069,12 @@ class ChannelStore {
    * resurrect the revoked entry by writing a stale base. Returns true when a caller was removed.
    */
   removeCaller(id, name) {
-    return withFileLock(this._lock(id), () => {
-      const c = this.get(id);
-      if (!c?.identity?.callers) return false;
+    return this._rmw(id, "removeCaller", (c) => {
+      if (!c?.identity?.callers) return { next: null, result: false };
       const before = c.identity.callers.length;
       c.identity.callers = c.identity.callers.filter((x) => x.name !== name);
-      if (c.identity.callers.length === before) return false;
-      this._writeChannel(c);
-      return true;
+      if (c.identity.callers.length === before) return { next: null, result: false };
+      return { next: c, result: true };
     });
   }
 }
@@ -8378,7 +8509,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-_vhbrouu.mjs');
+          const { toolsForRole } = await import('./sideband-D5Kan4J1.mjs');
           const r2 = await runWiseAgent({ message: params.message, sender, config: { tools: toolsForRole(role2) }, deps, transport, model: resolved.model });
           return fmt(r2);
         }
@@ -8510,7 +8641,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-hGgwLjkk.mjs');
+    const { queryCore } = await import('./commands-Dw_oiiqX.mjs');
     const timeout = c.reply?.timeout_sec || 120;
     let result;
     let thrownSessionId;
@@ -18428,6 +18559,22 @@ You share this machine and project folder with other agent sessions (same user,
 }
 
 const STANDARD_WINDOWS = [2e5, 1e6];
+const DEFAULT_MAX_CONTEXT_WINDOW = 2e5;
+function resolveMaxContextWindow(env = process.env) {
+  const raw = (env.SVAMP_MAX_CONTEXT_WINDOW ?? "").trim().toLowerCase();
+  if (!raw) return DEFAULT_MAX_CONTEXT_WINDOW;
+  if (["0", "off", "none", "unlimited", "inf", "infinite", "-1", "false", "no"].includes(raw)) {
+    return 0;
+  }
+  const n = Number(raw);
+  if (Number.isFinite(n) && n > 0) return Math.floor(n);
+  return DEFAULT_MAX_CONTEXT_WINDOW;
+}
+function applyMaxContextWindow(window, cap) {
+  if (!cap || cap <= 0) return window;
+  if (!window || window <= 0) return window;
+  return Math.min(window, cap);
+}
 function readWindow(entry) {
   if (!entry) return 0;
   const cw = entry.contextWindow ?? entry.context_window;
@@ -18520,6 +18667,16 @@ function decideProactiveCompaction(opts) {
   if (pct >= ratio) return { shouldCompact: true, window, pct, reason: "threshold" };
   return { shouldCompact: false, window, pct, reason: "below-threshold" };
 }
+function shouldPreTurnCompact(input) {
+  if (!input.enabled || input.disabled) return false;
+  if (input.incomingIsCompact) return false;
+  return decideProactiveCompaction({
+    observed: input.observed,
+    window: input.window,
+    ratio: input.ratio,
+    enabled: input.enabled
+  }).shouldCompact;
+}
 function fmtK(n) {
   return `${Math.round((n || 0) / 1e3)}K`;
 }
@@ -18584,6 +18741,26 @@ function decideCompactUnsupported(input) {
 function describeNoBoundary(strikes, limit) {
   return `Automatic compaction ran but reported no compaction boundary (attempt ${strikes} of ${limit}) \u2014 usually because there was nothing left to compact. Keeping automatic compaction enabled.`;
 }
+function shouldAccountLoopTurn(state) {
+  if (state.justCompacted) return false;
+  if (state.compactPending) return false;
+  return true;
+}
+function shouldPersistObservedContext(state) {
+  if (state.justCompacted) return false;
+  if (state.compactPending) return false;
+  if (state.turnErrored) return false;
+  return true;
+}
+function postCompactionObservedContext(compactMetadata) {
+  const md = compactMetadata;
+  if (!md || typeof md !== "object") return 0;
+  for (const key of ["post_tokens", "postTokens", "post_token_count", "tokens_after", "after_tokens"]) {
+    const v = md[key];
+    if (typeof v === "number" && Number.isFinite(v) && v > 0) return Math.floor(v);
+  }
+  return 0;
+}
 
 function fmtTokens(n) {
   return Math.max(0, Math.round(n)).toLocaleString("en-US");
@@ -20715,7 +20892,7 @@ async function startDaemon(options) {
     try {
       const dir = loadSessionIndex()[sessionId]?.directory;
       if (!dir) return;
-      const { reconcileServiceLinks } = await import('./agentCommands-Ckfp_hB-.mjs');
+      const { reconcileServiceLinks } = await import('./agentCommands-DmRCmbeU.mjs');
       const configPath = getSvampConfigPath(dir, sessionId);
       const config = readSvampConfig(configPath);
       const entries = Array.from(urls.entries());
@@ -20737,7 +20914,7 @@ async function startDaemon(options) {
     try {
       const dir = loadSessionIndex()[sessionId]?.directory;
       if (!dir) return;
-      const { reconcileServiceLinks } = await import('./agentCommands-Ckfp_hB-.mjs');
+      const { reconcileServiceLinks } = await import('./agentCommands-DmRCmbeU.mjs');
       const configPath = getSvampConfigPath(dir, sessionId);
       const config = readSvampConfig(configPath);
       const incoming = [{
@@ -20758,7 +20935,7 @@ async function startDaemon(options) {
     try {
       const dir = loadSessionIndex()[sessionId]?.directory;
       if (!dir) return;
-      const { dropServiceLinks } = await import('./agentCommands-Ckfp_hB-.mjs');
+      const { dropServiceLinks } = await import('./agentCommands-DmRCmbeU.mjs');
       const configPath = getSvampConfigPath(dir, sessionId);
       const config = readSvampConfig(configPath);
       if (dropServiceLinks(config, "serve", mountName)) {
@@ -20774,7 +20951,7 @@ async function startDaemon(options) {
     try {
       const dir = loadSessionIndex()[sessionId]?.directory;
       if (!dir) return;
-      const { dropServiceLinks } = await import('./agentCommands-Ckfp_hB-.mjs');
+      const { dropServiceLinks } = await import('./agentCommands-DmRCmbeU.mjs');
       const configPath = getSvampConfigPath(dir, sessionId);
       const config = readSvampConfig(configPath);
       if (dropServiceLinks(config, "tunnel", tunnelName)) {
@@ -20786,9 +20963,12 @@ async function startDaemon(options) {
     }
   }
   let liveSessionDirs;
+  let serviceRegistriesRestored = false;
+  const managedLinkSessions = /* @__PURE__ */ new Set();
+  let managedLinkSessionsSeeded = false;
   async function reconcileAllServiceLinks() {
     try {
-      const { reconcileServiceLinksExact } = await import('./agentCommands-Ckfp_hB-.mjs');
+      const { reconcileServiceLinksExact, hasManagedServiceLink } = await import('./agentCommands-DmRCmbeU.mjs');
       const desiredBySession = /* @__PURE__ */ new Map();
       const push = (sessionId, entry) => {
         if (!sessionId || !entry.url) return;
@@ -20816,7 +20996,19 @@ async function startDaemon(options) {
       for (const s of liveSessionDirs?.() ?? []) {
         if (s.sessionId && s.directory) dirBySession.set(s.sessionId, s.directory);
       }
-      const sessionIds = /* @__PURE__ */ new Set([...dirBySession.keys(), ...desiredBySession.keys()]);
+      if (!managedLinkSessionsSeeded) {
+        for (const [sessionId, dir] of dirBySession) {
+          try {
+            if (hasManagedServiceLink(readSvampConfig(getSvampConfigPath(dir, sessionId)), ["serve", "tunnel"])) {
+              managedLinkSessions.add(sessionId);
+            }
+          } catch {
+          }
+        }
+        managedLinkSessionsSeeded = true;
+        logger.log(`[launchpad] Seeded managed-link set: ${managedLinkSessions.size} of ${dirBySession.size} known sessions carry a serve/tunnel link`);
+      }
+      const sessionIds = /* @__PURE__ */ new Set([...managedLinkSessions, ...desiredBySession.keys()]);
       for (const sessionId of sessionIds) {
         try {
           const dir = dirBySession.get(sessionId);
@@ -20824,9 +21016,14 @@ async function startDaemon(options) {
           const configPath = getSvampConfigPath(dir, sessionId);
           const config = readSvampConfig(configPath);
           const desired = desiredBySession.get(sessionId) ?? [];
-          if (reconcileServiceLinksExact(config, ["serve", "tunnel"], desired)) {
+          if (reconcileServiceLinksExact(config, ["serve", "tunnel"], desired, { dropStale: serviceRegistriesRestored })) {
             writeSvampConfig(configPath, config);
-            logger.log(`[launchpad] Reconciled service links for session ${sessionId} (${desired.length} live)`);
+            logger.log(`[launchpad] Reconciled service links for session ${sessionId} (${desired.length} live${serviceRegistriesRestored ? "" : ", upsert-only \u2014 restore in flight"})`);
+          }
+          if (desired.length > 0 || hasManagedServiceLink(config, ["serve", "tunnel"])) {
+            managedLinkSessions.add(sessionId);
+          } else {
+            managedLinkSessions.delete(sessionId);
           }
         } catch (err) {
           logger.log(`[launchpad] Reconcile failed for session ${sessionId}: ${err?.message || err}`);
@@ -21817,10 +22014,12 @@ ${parts.join("\n")}`);
         let pendingCompactTurn = false;
         const autoCompactEnabled = resolveAutoCompactEnabled();
         const autoCompactRatio = resolveAutoCompactRatio();
+        const maxContextWindow = resolveMaxContextWindow();
         let autoCompactWasAutoInjected = false;
         let autoCompactDisabled = false;
         let autoCompactRecoveryTried = false;
         let justCompactedTurn = false;
+        let compactTurnLatch = false;
         let compactNoBoundaryStrikes = 0;
         let compactSupported = void 0;
         let noIsolationWarned = false;
@@ -22306,14 +22505,25 @@ ${parts.join("\n")}`);
                     }
                     signalProcessing(false);
                     sessionWasProcessing = false;
-                    const resolvedWindow = resolveContextWindow({
+                    const resolvedWindow = applyMaxContextWindow(resolveContextWindow({
                       modelUsage: msg.modelUsage,
                       usage: msg.usage,
                       mainModel: lastMainModel,
                       currentWindow: sessionMetadata.contextWindow
+                    }), maxContextWindow);
+                    const observedThisTurn = computeObservedContext(msg.usage);
+                    const mayPersistObserved = shouldPersistObservedContext({
+                      justCompacted: justCompactedTurn,
+                      compactPending: compactTurnLatch,
+                      turnErrored: !!msg.is_error
                     });
-                    if (resolvedWindow > 0 && resolvedWindow !== sessionMetadata.contextWindow) {
-                      sessionMetadata = { ...sessionMetadata, contextWindow: resolvedWindow };
+                    const persistObserved = mayPersistObserved && observedThisTurn > 0 && observedThisTurn !== sessionMetadata.observedContext;
+                    if (resolvedWindow > 0 && resolvedWindow !== sessionMetadata.contextWindow || persistObserved) {
+                      sessionMetadata = {
+                        ...sessionMetadata,
+                        ...resolvedWindow > 0 ? { contextWindow: resolvedWindow } : {},
+                        ...persistObserved ? { observedContext: observedThisTurn } : {}
+                      };
                       sessionService.updateMetadata(sessionMetadata);
                     }
                     if (claudeResumeId && !trackedSession.stopped) {
@@ -22333,7 +22543,11 @@ ${parts.join("\n")}`);
                     clearInboundContext(sessionId);
                     try {
                       const ls = readLoopState(directory, sessionId);
-                      if (ls && ls.engine === "goal" && ls.active !== false && ls.phase !== "dormant" && ls.phase !== "done" && ls.phase !== "gave_up" && ls.phase !== "cancelled") {
+                      const accountLoopTurn = shouldAccountLoopTurn({
+                        justCompacted: justCompactedTurn,
+                        compactPending: compactTurnLatch
+                      });
+                      if (accountLoopTurn && ls && ls.engine === "goal" && ls.active !== false && ls.phase !== "dormant" && ls.phase !== "done" && ls.phase !== "gave_up" && ls.phase !== "cancelled") {
                         const now = Date.now();
                         const ledger = accumulateLedger(ls.ledger, {
                           turns: Number(msg.num_turns) || 0,
@@ -22390,6 +22604,7 @@ ${parts.join("\n")}`);
                       enabled: autoCompactEnabled
                     });
                     justCompactedTurn = false;
+                    compactTurnLatch = false;
                     if (mayEvaluateLayer1) {
                       try {
                         const observed = computeObservedContext(msg.usage);
@@ -22509,7 +22724,16 @@ ${parts.join("\n")}`);
                   autoCompactWasAutoInjected = false;
                   autoCompactRecoveryTried = false;
                   justCompactedTurn = true;
+                  compactTurnLatch = true;
                   compactNoBoundaryStrikes = 0;
+                  try {
+                    const postObserved = postCompactionObservedContext(msg.compact_metadata);
+                    if (sessionMetadata.observedContext !== postObserved) {
+                      sessionMetadata = { ...sessionMetadata, observedContext: postObserved };
+                      sessionService.updateMetadata(sessionMetadata);
+                    }
+                  } catch {
+                  }
                   const compactLine = describeCompaction(msg.compact_metadata);
                   logger.log(`[Session ${sessionId}] ${compactLine}`);
                   sessionService.pushMessage(
@@ -22938,10 +23162,41 @@ ${capturedError}${buildClaudeErrorHint(capturedError)}`;
                 rateLimitRetryTimer = null;
               }
               pendingCompactTurn = isCompactCommand(text);
+              if (pendingCompactTurn) compactTurnLatch = true;
               if (!claudeProcess || claudeProcess.exitCode !== null) {
-                spawnClaude(text, msgMeta);
-                signalProcessing(true);
-                sessionWasProcessing = true;
+                const preTurnWindow = applyMaxContextWindow(sessionMetadata.contextWindow || 0, maxContextWindow);
+                const preTurnObserved = sessionMetadata.observedContext || 0;
+                if (shouldPreTurnCompact({
+                  observed: preTurnObserved,
+                  window: preTurnWindow,
+                  ratio: autoCompactRatio,
+                  enabled: autoCompactEnabled,
+                  disabled: autoCompactDisabled,
+                  incomingIsCompact: isCompactCommand(text)
+                })) {
+                  const pct = preTurnWindow > 0 ? preTurnObserved / preTurnWindow : 0;
+                  logger.log(`[Session ${sessionId}] Pre-turn auto-compaction: persisted observed ${preTurnObserved} tokens at ${Math.round(pct * 100)}% of ${preTurnWindow} window \u2014 compacting before delivering message`);
+                  sessionService.pushMessage(
+                    { type: "message", message: describeAutoCompact(preTurnObserved, preTurnWindow, pct), level: "warning" },
+                    "event"
+                  );
+                  const existingQueue = sessionMetadata.messageQueue || [];
+                  sessionMetadata = {
+                    ...sessionMetadata,
+                    messageQueue: [...existingQueue, { id: randomUUID(), text, createdAt: Date.now(), alreadyStored: true }]
+                  };
+                  sessionService.updateMetadata(sessionMetadata);
+                  pendingCompactTurn = true;
+                  compactTurnLatch = true;
+                  autoCompactWasAutoInjected = true;
+                  spawnClaude("/compact", msgMeta);
+                  signalProcessing(true);
+                  sessionWasProcessing = true;
+                } else {
+                  spawnClaude(text, msgMeta);
+                  signalProcessing(true);
+                  sessionWasProcessing = true;
+                }
               } else if (writeUserFrameToClaude(text)) {
                 signalProcessing(true);
                 sessionWasProcessing = true;
@@ -23326,11 +23581,11 @@ ${capturedError}${buildClaudeErrorHint(capturedError)}`;
               });
             },
             onIssue: async (params) => {
-              const { issueRpc } = await import('./rpc-D-NLQR0s.mjs');
+              const { issueRpc } = await import('./rpc-Cj31v2sm.mjs');
               return issueRpc(params?.cwd || directory, params || {}, { notifySession: notifyIssueOwner, rekickLoopOwner });
             },
             onWorkflow: async (params) => {
-              const { workflowRpc } = await import('./rpc-P1bWcW8c.mjs');
+              const { workflowRpc } = await import('./rpc-BSWkkPHd.mjs');
               return workflowRpc(params?.cwd || directory, params || {});
             },
             onRipgrep: async (args, cwd) => {
@@ -23470,6 +23725,7 @@ ${capturedError}${buildClaudeErrorHint(capturedError)}`;
             turnInitiatedByUser = true;
             currentTurnMessage = next.text;
             pendingCompactTurn = isCompactCommand(next.text);
+            if (pendingCompactTurn) compactTurnLatch = true;
             autoCompactWasAutoInjected = pendingCompactTurn && !!next.autoCompact;
             resetRateLimitStreak();
             if (rateLimitRetryTimer) {
@@ -24053,11 +24309,11 @@ ${capturedError}${buildClaudeErrorHint(capturedError)}`;
               });
             },
             onIssue: async (params) => {
-              const { issueRpc } = await import('./rpc-D-NLQR0s.mjs');
+              const { issueRpc } = await import('./rpc-Cj31v2sm.mjs');
               return issueRpc(params?.cwd || directory, params || {}, { notifySession: notifyIssueOwner, rekickLoopOwner });
             },
             onWorkflow: async (params) => {
-              const { workflowRpc } = await import('./rpc-P1bWcW8c.mjs');
+              const { workflowRpc } = await import('./rpc-BSWkkPHd.mjs');
               return workflowRpc(params?.cwd || directory, params || {});
             },
             onRipgrep: async (args, cwd) => {
@@ -25058,8 +25314,12 @@ ${oracle.output.trim().slice(0, 500)}`, "\u{1F501} Continuing loop");
       } catch (err) {
         logger.log(`[serve] mount link reconcile failed: ${err?.message || err}`);
       }
+      serviceRegistriesRestored = true;
       scheduleServiceLinkReconcile(3e3);
-    }).catch((err) => logger.error(`[serve] mount restore failed: ${err?.message || err}`));
+    }).catch((err) => {
+      serviceRegistriesRestored = true;
+      logger.error(`[serve] mount restore failed: ${err?.message || err}`);
+    });
     const daemonOwnerEmail = parseJwtEmail(process.env.HYPHA_TOKEN || "") || null;
     serveManager$1.setSessionResolver((sessionId) => {
       for (const [, session] of pidToTrackedSession) {
@@ -25408,7 +25668,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-DSloKtUY.mjs');
+    const { WorkflowScheduler } = await import('./scheduler-DkfqQjih.mjs');
     const workflowProjectRoots = () => {
       const dirs = /* @__PURE__ */ new Set();
       for (const s of pidToTrackedSession.values()) {

package/dist/{scheduler-DSloKtUY.mjs → scheduler-DkfqQjih.mjs}

@@ -1,4 +1,4 @@
-import { f as resolveProjectRoot, E as listWorkflows, F as isWorkflowEnabled, G as workflowSchedules, H as inZone, x as runWorkflow, I as cronMatches } from './run-DUzNQjSO.mjs';
+import { f as resolveProjectRoot, E as listWorkflows, F as isWorkflowEnabled, G as workflowSchedules, H as inZone, x as runWorkflow, I as cronMatches } from './run-bo0i02Dy.mjs';
 import 'os';
 import 'fs/promises';
 import 'fs';