svamp-cli 0.2.336 → 0.2.338

package/dist/{run-CBNIHWhE.mjs → run--wM4gBLw.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 {
         }
-      } catch {
       }
+      if (!broke) {
+        try {
+          if (Date.now() - statSync(lockPath).mtimeMs > staleMs) {
+            rmSync$1(lockPath, { recursive: true, force: true });
+            broke = true;
+          }
+        } 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-QYJM3m1p.mjs');
+          const { toolsForRole } = await import('./sideband-BBOHmvTf.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-BAoTIJjJ.mjs');
+    const { queryCore } = await import('./commands-CBwYOKmf.mjs');
     const timeout = c.reply?.timeout_sec || 120;
     let result;
     let thrownSessionId;
@@ -18453,6 +18584,18 @@ function computeObservedContext(usage) {
   if (!usage) return 0;
   return (usage.input_tokens || 0) + (usage.cache_creation_input_tokens || 0) + (usage.cache_read_input_tokens || 0);
 }
+function peakRequestUsage(usages) {
+  let best;
+  let bestTokens = 0;
+  for (const u of usages) {
+    const n = computeObservedContext(u);
+    if (n > bestTokens) {
+      bestTokens = n;
+      best = u ?? void 0;
+    }
+  }
+  return bestTokens > 0 ? best : void 0;
+}
 function inferWindowFromModelName(model) {
   if (!model) return 0;
   if (/\[1m\]/i.test(model)) return 1e6;
@@ -18610,6 +18753,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");
@@ -20741,7 +20904,7 @@ async function startDaemon(options) {
     try {
       const dir = loadSessionIndex()[sessionId]?.directory;
       if (!dir) return;
-      const { reconcileServiceLinks } = await import('./agentCommands-BcdnoUr6.mjs');
+      const { reconcileServiceLinks } = await import('./agentCommands-f5J1vh6G.mjs');
       const configPath = getSvampConfigPath(dir, sessionId);
       const config = readSvampConfig(configPath);
       const entries = Array.from(urls.entries());
@@ -20763,7 +20926,7 @@ async function startDaemon(options) {
     try {
       const dir = loadSessionIndex()[sessionId]?.directory;
       if (!dir) return;
-      const { reconcileServiceLinks } = await import('./agentCommands-BcdnoUr6.mjs');
+      const { reconcileServiceLinks } = await import('./agentCommands-f5J1vh6G.mjs');
       const configPath = getSvampConfigPath(dir, sessionId);
       const config = readSvampConfig(configPath);
       const incoming = [{
@@ -20784,7 +20947,7 @@ async function startDaemon(options) {
     try {
       const dir = loadSessionIndex()[sessionId]?.directory;
       if (!dir) return;
-      const { dropServiceLinks } = await import('./agentCommands-BcdnoUr6.mjs');
+      const { dropServiceLinks } = await import('./agentCommands-f5J1vh6G.mjs');
       const configPath = getSvampConfigPath(dir, sessionId);
       const config = readSvampConfig(configPath);
       if (dropServiceLinks(config, "serve", mountName)) {
@@ -20800,7 +20963,7 @@ async function startDaemon(options) {
     try {
       const dir = loadSessionIndex()[sessionId]?.directory;
       if (!dir) return;
-      const { dropServiceLinks } = await import('./agentCommands-BcdnoUr6.mjs');
+      const { dropServiceLinks } = await import('./agentCommands-f5J1vh6G.mjs');
       const configPath = getSvampConfigPath(dir, sessionId);
       const config = readSvampConfig(configPath);
       if (dropServiceLinks(config, "tunnel", tunnelName)) {
@@ -20812,9 +20975,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-BcdnoUr6.mjs');
+      const { reconcileServiceLinksExact, hasManagedServiceLink } = await import('./agentCommands-f5J1vh6G.mjs');
       const desiredBySession = /* @__PURE__ */ new Map();
       const push = (sessionId, entry) => {
         if (!sessionId || !entry.url) return;
@@ -20842,7 +21008,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);
@@ -20850,9 +21028,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}`);
@@ -21848,8 +22031,10 @@ ${parts.join("\n")}`);
         let autoCompactDisabled = false;
         let autoCompactRecoveryTried = false;
         let justCompactedTurn = false;
+        let compactTurnLatch = false;
         let compactNoBoundaryStrikes = 0;
         let compactSupported = void 0;
+        let turnRequestUsages = [];
         let noIsolationWarned = false;
         const RATELIMIT_CFG = getRateLimitRetryConfig();
         let currentTurnMessage;
@@ -22184,6 +22369,7 @@ ${parts.join("\n")}`);
                     if (typeof assistantModel === "string" && assistantModel.length > 0) {
                       lastMainModel = assistantModel;
                     }
+                    if (msg.message?.usage) turnRequestUsages.push(msg.message.usage);
                   }
                   const assistantContent = msg.type === "assistant" ? msg.message?.content ?? msg.content : void 0;
                   if (Array.isArray(assistantContent)) {
@@ -22333,18 +22519,25 @@ ${parts.join("\n")}`);
                     }
                     signalProcessing(false);
                     sessionWasProcessing = false;
+                    const peakUsage = peakRequestUsage(turnRequestUsages) ?? msg.usage;
                     const resolvedWindow = applyMaxContextWindow(resolveContextWindow({
                       modelUsage: msg.modelUsage,
-                      usage: msg.usage,
+                      usage: peakUsage,
                       mainModel: lastMainModel,
                       currentWindow: sessionMetadata.contextWindow
                     }), maxContextWindow);
-                    const observedThisTurn = computeObservedContext(msg.usage);
-                    if (resolvedWindow > 0 && resolvedWindow !== sessionMetadata.contextWindow || observedThisTurn > 0 && observedThisTurn !== sessionMetadata.observedContext) {
+                    const observedThisTurn = computeObservedContext(peakUsage);
+                    const mayPersistObserved = shouldPersistObservedContext({
+                      justCompacted: justCompactedTurn,
+                      compactPending: compactTurnLatch,
+                      turnErrored: !!msg.is_error
+                    });
+                    const persistObserved = mayPersistObserved && observedThisTurn > 0 && observedThisTurn !== sessionMetadata.observedContext;
+                    if (resolvedWindow > 0 && resolvedWindow !== sessionMetadata.contextWindow || persistObserved) {
                       sessionMetadata = {
                         ...sessionMetadata,
                         ...resolvedWindow > 0 ? { contextWindow: resolvedWindow } : {},
-                        ...observedThisTurn > 0 ? { observedContext: observedThisTurn } : {}
+                        ...persistObserved ? { observedContext: observedThisTurn } : {}
                       };
                       sessionService.updateMetadata(sessionMetadata);
                     }
@@ -22365,7 +22558,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,
@@ -22422,9 +22619,10 @@ ${parts.join("\n")}`);
                       enabled: autoCompactEnabled
                     });
                     justCompactedTurn = false;
+                    compactTurnLatch = false;
                     if (mayEvaluateLayer1) {
                       try {
-                        const observed = computeObservedContext(msg.usage);
+                        const observed = observedThisTurn;
                         const decision = decideProactiveCompaction({
                           observed,
                           window: resolvedWindow > 0 ? resolvedWindow : sessionMetadata.contextWindow || 0,
@@ -22479,6 +22677,7 @@ ${parts.join("\n")}`);
                 } else if (msg.type === "system" && msg.subtype === "init") {
                   consecutiveOverloadRetries = 0;
                   overloadBailedThisTurn = false;
+                  turnRequestUsages = [];
                   if (!userMessagePending) {
                     turnInitiatedByUser = false;
                     logger.log(`[Session ${sessionId}] SDK-initiated turn (likely stale task_notification)`);
@@ -22541,7 +22740,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(
@@ -22970,6 +23178,7 @@ ${capturedError}${buildClaudeErrorHint(capturedError)}`;
                 rateLimitRetryTimer = null;
               }
               pendingCompactTurn = isCompactCommand(text);
+              if (pendingCompactTurn) compactTurnLatch = true;
               if (!claudeProcess || claudeProcess.exitCode !== null) {
                 const preTurnWindow = applyMaxContextWindow(sessionMetadata.contextWindow || 0, maxContextWindow);
                 const preTurnObserved = sessionMetadata.observedContext || 0;
@@ -22994,6 +23203,7 @@ ${capturedError}${buildClaudeErrorHint(capturedError)}`;
                   };
                   sessionService.updateMetadata(sessionMetadata);
                   pendingCompactTurn = true;
+                  compactTurnLatch = true;
                   autoCompactWasAutoInjected = true;
                   spawnClaude("/compact", msgMeta);
                   signalProcessing(true);
@@ -23387,11 +23597,11 @@ ${capturedError}${buildClaudeErrorHint(capturedError)}`;
               });
             },
             onIssue: async (params) => {
-              const { issueRpc } = await import('./rpc-DUP-qb40.mjs');
+              const { issueRpc } = await import('./rpc-BQ75iSkj.mjs');
               return issueRpc(params?.cwd || directory, params || {}, { notifySession: notifyIssueOwner, rekickLoopOwner });
             },
             onWorkflow: async (params) => {
-              const { workflowRpc } = await import('./rpc-COwRfHss.mjs');
+              const { workflowRpc } = await import('./rpc-CG6XWFXY.mjs');
               return workflowRpc(params?.cwd || directory, params || {});
             },
             onRipgrep: async (args, cwd) => {
@@ -23531,6 +23741,7 @@ ${capturedError}${buildClaudeErrorHint(capturedError)}`;
             turnInitiatedByUser = true;
             currentTurnMessage = next.text;
             pendingCompactTurn = isCompactCommand(next.text);
+            if (pendingCompactTurn) compactTurnLatch = true;
             autoCompactWasAutoInjected = pendingCompactTurn && !!next.autoCompact;
             resetRateLimitStreak();
             if (rateLimitRetryTimer) {
@@ -24114,11 +24325,11 @@ ${capturedError}${buildClaudeErrorHint(capturedError)}`;
               });
             },
             onIssue: async (params) => {
-              const { issueRpc } = await import('./rpc-DUP-qb40.mjs');
+              const { issueRpc } = await import('./rpc-BQ75iSkj.mjs');
               return issueRpc(params?.cwd || directory, params || {}, { notifySession: notifyIssueOwner, rekickLoopOwner });
             },
             onWorkflow: async (params) => {
-              const { workflowRpc } = await import('./rpc-COwRfHss.mjs');
+              const { workflowRpc } = await import('./rpc-CG6XWFXY.mjs');
               return workflowRpc(params?.cwd || directory, params || {});
             },
             onRipgrep: async (args, cwd) => {
@@ -25119,8 +25330,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) {
@@ -25469,7 +25684,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-Cx3yWga4.mjs');
+    const { WorkflowScheduler } = await import('./scheduler-QsXyNajm.mjs');
     const workflowProjectRoots = () => {
       const dirs = /* @__PURE__ */ new Set();
       for (const s of pidToTrackedSession.values()) {

package/dist/{run-DiwHqXsO.mjs → run-9rEzf5ez.mjs}

@@ -1,4 +1,4 @@
-import{createRequire as _pkgrollCR}from"node:module";const require=_pkgrollCR(import.meta.url);import { am as applyClaudeProxyEnv, an as composeSessionId, ao as generateFriendlyName, c as connectToHypha, a as createSessionStore, r as registerMachineService, ap as generateHookSettings } from './run-CBNIHWhE.mjs';
+import{createRequire as _pkgrollCR}from"node:module";const require=_pkgrollCR(import.meta.url);import { am as applyClaudeProxyEnv, an as composeSessionId, ao as generateFriendlyName, c as connectToHypha, a as createSessionStore, r as registerMachineService, ap as generateHookSettings } from './run--wM4gBLw.mjs';
 import os from 'node:os';
 import { resolve, join } from 'node:path';
 import { existsSync, readFileSync, watch } from 'node:fs';

package/dist/{scheduler-Cx3yWga4.mjs → scheduler-QsXyNajm.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-CBNIHWhE.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--wM4gBLw.mjs';
 import 'os';
 import 'fs/promises';
 import 'fs';