svamp-cli 0.2.336 → 0.2.337

package/dist/{run-CBNIHWhE.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 {
         }
-      } 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-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-BAoTIJjJ.mjs');
+    const { queryCore } = await import('./commands-Dw_oiiqX.mjs');
     const timeout = c.reply?.timeout_sec || 120;
     let result;
     let thrownSessionId;
@@ -18610,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");
@@ -20741,7 +20892,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-DmRCmbeU.mjs');
       const configPath = getSvampConfigPath(dir, sessionId);
       const config = readSvampConfig(configPath);
       const entries = Array.from(urls.entries());
@@ -20763,7 +20914,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-DmRCmbeU.mjs');
       const configPath = getSvampConfigPath(dir, sessionId);
       const config = readSvampConfig(configPath);
       const incoming = [{
@@ -20784,7 +20935,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-DmRCmbeU.mjs');
       const configPath = getSvampConfigPath(dir, sessionId);
       const config = readSvampConfig(configPath);
       if (dropServiceLinks(config, "serve", mountName)) {
@@ -20800,7 +20951,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-DmRCmbeU.mjs');
       const configPath = getSvampConfigPath(dir, sessionId);
       const config = readSvampConfig(configPath);
       if (dropServiceLinks(config, "tunnel", tunnelName)) {
@@ -20812,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-BcdnoUr6.mjs');
+      const { reconcileServiceLinksExact, hasManagedServiceLink } = await import('./agentCommands-DmRCmbeU.mjs');
       const desiredBySession = /* @__PURE__ */ new Map();
       const push = (sessionId, entry) => {
         if (!sessionId || !entry.url) return;
@@ -20842,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);
@@ -20850,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}`);
@@ -21848,6 +22019,7 @@ ${parts.join("\n")}`);
         let autoCompactDisabled = false;
         let autoCompactRecoveryTried = false;
         let justCompactedTurn = false;
+        let compactTurnLatch = false;
         let compactNoBoundaryStrikes = 0;
         let compactSupported = void 0;
         let noIsolationWarned = false;
@@ -22340,11 +22512,17 @@ ${parts.join("\n")}`);
                       currentWindow: sessionMetadata.contextWindow
                     }), maxContextWindow);
                     const observedThisTurn = computeObservedContext(msg.usage);
-                    if (resolvedWindow > 0 && resolvedWindow !== sessionMetadata.contextWindow || observedThisTurn > 0 && observedThisTurn !== sessionMetadata.observedContext) {
+                    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 +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,
@@ -22422,6 +22604,7 @@ ${parts.join("\n")}`);
                       enabled: autoCompactEnabled
                     });
                     justCompactedTurn = false;
+                    compactTurnLatch = false;
                     if (mayEvaluateLayer1) {
                       try {
                         const observed = computeObservedContext(msg.usage);
@@ -22541,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(
@@ -22970,6 +23162,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 +23187,7 @@ ${capturedError}${buildClaudeErrorHint(capturedError)}`;
                   };
                   sessionService.updateMetadata(sessionMetadata);
                   pendingCompactTurn = true;
+                  compactTurnLatch = true;
                   autoCompactWasAutoInjected = true;
                   spawnClaude("/compact", msgMeta);
                   signalProcessing(true);
@@ -23387,11 +23581,11 @@ ${capturedError}${buildClaudeErrorHint(capturedError)}`;
               });
             },
             onIssue: async (params) => {
-              const { issueRpc } = await import('./rpc-DUP-qb40.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-COwRfHss.mjs');
+              const { workflowRpc } = await import('./rpc-BSWkkPHd.mjs');
               return workflowRpc(params?.cwd || directory, params || {});
             },
             onRipgrep: async (args, cwd) => {
@@ -23531,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) {
@@ -24114,11 +24309,11 @@ ${capturedError}${buildClaudeErrorHint(capturedError)}`;
               });
             },
             onIssue: async (params) => {
-              const { issueRpc } = await import('./rpc-DUP-qb40.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-COwRfHss.mjs');
+              const { workflowRpc } = await import('./rpc-BSWkkPHd.mjs');
               return workflowRpc(params?.cwd || directory, params || {});
             },
             onRipgrep: async (args, cwd) => {
@@ -25119,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) {
@@ -25469,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-Cx3yWga4.mjs');
+    const { WorkflowScheduler } = await import('./scheduler-DkfqQjih.mjs');
     const workflowProjectRoots = () => {
       const dirs = /* @__PURE__ */ new Set();
       for (const s of pidToTrackedSession.values()) {

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

package/dist/{serveCommands-nhyPDFIK.mjs → serveCommands-D2sKo0xC.mjs}

@@ -1,6 +1,6 @@
 import * as path from 'path';
-import { w as wantsHelp } from './cli-lUpt1gfZ.mjs';
-import './run-CBNIHWhE.mjs';
+import { w as wantsHelp } from './cli-v0NMiesq.mjs';
+import './run-bo0i02Dy.mjs';
 import 'os';
 import 'fs/promises';
 import 'fs';
@@ -77,7 +77,7 @@ async function handleServeCommand() {
   }
 }
 async function serveAdd(args, machineId) {
-  const { connectAndGetMachine } = await import('./commands-BAoTIJjJ.mjs');
+  const { connectAndGetMachine } = await import('./commands-Dw_oiiqX.mjs');
   const pos = positionalArgs(args);
   const name = pos[0];
   if (!name) {
@@ -110,7 +110,7 @@ async function serveAdd(args, machineId) {
     }
     if (sessionId && result?.url) {
       try {
-        const { autoAddSessionLink } = await import('./agentCommands-BcdnoUr6.mjs');
+        const { autoAddSessionLink } = await import('./agentCommands-DmRCmbeU.mjs');
         autoAddSessionLink(String(result.url), name, void 0, { kind: "serve", name });
       } catch {
       }
@@ -124,7 +124,7 @@ async function serveAdd(args, machineId) {
   }
 }
 async function serveApply(args, machineId) {
-  const { connectAndGetMachine } = await import('./commands-BAoTIJjJ.mjs');
+  const { connectAndGetMachine } = await import('./commands-Dw_oiiqX.mjs');
   const fs = await import('fs');
   const yaml = await import('yaml');
   const file = positionalArgs(args)[0];
@@ -209,7 +209,7 @@ async function serveApply(args, machineId) {
     console.log(`URL: ${result.url}`);
     if (params.sessionId && result?.url) {
       try {
-        const { autoAddSessionLink } = await import('./agentCommands-BcdnoUr6.mjs');
+        const { autoAddSessionLink } = await import('./agentCommands-DmRCmbeU.mjs');
         const prevSession = process.env.SVAMP_SESSION_ID;
         process.env.SVAMP_SESSION_ID = String(params.sessionId);
         try {
@@ -230,7 +230,7 @@ async function serveApply(args, machineId) {
   }
 }
 async function serveRemove(args, machineId) {
-  const { connectAndGetMachine } = await import('./commands-BAoTIJjJ.mjs');
+  const { connectAndGetMachine } = await import('./commands-Dw_oiiqX.mjs');
   const pos = positionalArgs(args);
   const name = pos[0];
   if (!name) {
@@ -240,7 +240,7 @@ async function serveRemove(args, machineId) {
   const { machine, server } = await connectAndGetMachine(machineId);
   try {
     await machine.serveRemove({ name });
-    const { removeSessionLinkByService } = await import('./agentCommands-BcdnoUr6.mjs');
+    const { removeSessionLinkByService } = await import('./agentCommands-DmRCmbeU.mjs');
     removeSessionLinkByService("serve", name);
     console.log(`Mount '${name}' removed.`);
   } catch (err) {
@@ -252,7 +252,7 @@ async function serveRemove(args, machineId) {
   }
 }
 async function serveList(args, machineId) {
-  const { connectAndGetMachine } = await import('./commands-BAoTIJjJ.mjs');
+  const { connectAndGetMachine } = await import('./commands-Dw_oiiqX.mjs');
   const all = hasFlag(args, "--all", "-a");
   const json = hasFlag(args, "--json");
   const sessionId = getFlag(args, "--session");
@@ -286,7 +286,7 @@ async function serveList(args, machineId) {
   }
 }
 async function serveInfo(machineId) {
-  const { connectAndGetMachine } = await import('./commands-BAoTIJjJ.mjs');
+  const { connectAndGetMachine } = await import('./commands-Dw_oiiqX.mjs');
   const { machine, server } = await connectAndGetMachine(machineId);
   try {
     const info = await machine.serveInfo();

package/dist/{sideband-QYJM3m1p.mjs → sideband-D5Kan4J1.mjs}

@@ -1,4 +1,4 @@
-import { R as READ_ONLY_TOOLS, P as loadMachineContext, Q as buildMachineInstructions, T as machineToolsForRole, U as buildMachineTools } from './run-CBNIHWhE.mjs';
+import { R as READ_ONLY_TOOLS, P as loadMachineContext, Q as buildMachineInstructions, T as machineToolsForRole, U as buildMachineTools } from './run-bo0i02Dy.mjs';
 import 'node:child_process';
 import 'os';
 import 'fs/promises';