svamp-cli 0.2.337 → 0.2.339

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

@@ -8509,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-D5Kan4J1.mjs');
+          const { toolsForRole } = await import('./sideband-D-n2JZSB.mjs');
           const r2 = await runWiseAgent({ message: params.message, sender, config: { tools: toolsForRole(role2) }, deps, transport, model: resolved.model });
           return fmt(r2);
         }
@@ -8641,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-Dw_oiiqX.mjs');
+    const { queryCore } = await import('./commands-CoImSc7s.mjs');
     const timeout = c.reply?.timeout_sec || 120;
     let result;
     let thrownSessionId;
@@ -18559,7 +18559,7 @@ You share this machine and project folder with other agent sessions (same user,
 }
 
 const STANDARD_WINDOWS = [2e5, 1e6];
-const DEFAULT_MAX_CONTEXT_WINDOW = 2e5;
+const DEFAULT_MAX_CONTEXT_WINDOW = 0;
 function resolveMaxContextWindow(env = process.env) {
   const raw = (env.SVAMP_MAX_CONTEXT_WINDOW ?? "").trim().toLowerCase();
   if (!raw) return DEFAULT_MAX_CONTEXT_WINDOW;
@@ -18584,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;
@@ -18640,49 +18652,11 @@ function resolveContextWindow(opts) {
   return candidate;
 }
 
-const DEFAULT_AUTO_COMPACT_RATIO = 0.85;
-const MIN_WINDOW_FOR_BACKSTOP = 5e4;
-const MIN_RATIO = 0.5;
-const MAX_RATIO = 0.97;
 function resolveAutoCompactEnabled(env = process.env) {
   const v = (env.SVAMP_AUTO_COMPACT ?? "").trim().toLowerCase();
   if (v === "0" || v === "false" || v === "off" || v === "no") return false;
   return true;
 }
-function resolveAutoCompactRatio(env = process.env) {
-  const raw = (env.SVAMP_AUTO_COMPACT_RATIO ?? "").trim();
-  if (!raw) return DEFAULT_AUTO_COMPACT_RATIO;
-  const n = Number(raw);
-  if (!Number.isFinite(n)) return DEFAULT_AUTO_COMPACT_RATIO;
-  if (n < MIN_RATIO) return MIN_RATIO;
-  if (n > MAX_RATIO) return MAX_RATIO;
-  return n;
-}
-function decideProactiveCompaction(opts) {
-  const { observed, window, ratio, enabled } = opts;
-  const pct = window > 0 ? observed / window : 0;
-  if (!enabled) return { shouldCompact: false, window, pct, reason: "disabled" };
-  if (!(window >= MIN_WINDOW_FOR_BACKSTOP)) return { shouldCompact: false, window, pct, reason: "window-too-small" };
-  if (!(observed > 0)) return { shouldCompact: false, window, pct, reason: "no-observed" };
-  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`;
-}
-function describeAutoCompact(observed, window, pct) {
-  return `Context at ${Math.round(pct * 100)}% of the ${fmtK(window)} window (${fmtK(observed)} tokens) \u2014 compacting automatically to stay under the model's limit.`;
-}
 function isContextTooLongError(text) {
   if (!text) return false;
   const t = text.toLowerCase();
@@ -18700,67 +18674,11 @@ function isAutocompactThrashError(text) {
   if (t.includes("reading in smaller chunks") && t.includes("context")) return true;
   return false;
 }
-function shouldEvaluateProactiveCompaction(state) {
-  if (!state.enabled) return false;
-  if (state.disabled) return false;
-  if (state.turnErrored) return false;
-  if (state.compactPending) return false;
-  if (state.justCompacted) return false;
-  return true;
-}
-function compactSupportedFromSlashCommands(slashCommands) {
-  if (!Array.isArray(slashCommands) || slashCommands.length === 0) return void 0;
-  return slashCommands.some(
-    (c) => typeof c === "string" && c.trim().replace(/^\//, "").toLowerCase() === "compact"
-  );
-}
-const DEFAULT_COMPACT_NO_BOUNDARY_STRIKES = 3;
-function decideCompactUnsupported(input) {
-  const prior = Math.max(0, input.priorStrikes || 0);
-  const limit = Math.max(1, input.maxStrikes);
-  if (input.turnErrored) {
-    return { disable: false, warnUnsupported: false, strikes: prior, reason: "errored-turn" };
-  }
-  if (!input.wasAutoInjected) {
-    return {
-      disable: false,
-      warnUnsupported: input.compactSupported === false,
-      strikes: prior,
-      reason: "user-typed"
-    };
-  }
-  if (input.compactSupported === false) {
-    return { disable: true, warnUnsupported: true, strikes: prior + 1, reason: "unsupported" };
-  }
-  const strikes = prior + 1;
-  if (strikes >= limit) {
-    return { disable: true, warnUnsupported: false, strikes, reason: "strikes-exhausted" };
-  }
-  return { disable: false, warnUnsupported: false, strikes, reason: "strike" };
-}
-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");
@@ -18787,10 +18705,6 @@ function describeCompaction(meta) {
   }
   return `Context compacted (${trigger}).`;
 }
-function compactUnsupportedWarning(version) {
-  const v = "";
-  return `\u26A0\uFE0F /compact did not run${v} \u2014 Claude Code forwarded it as a normal message, so nothing was compacted. In-session /compact needs a newer Claude Code (>= 2.1.205). Ask the machine owner to upgrade (e.g. \`svamp fleet upgrade-claude\`), then try again.`;
-}
 
 function shouldRunZombieProbe(args) {
   return args.hasActiveSessions && !args.inGrace && args.consecutiveHeartbeatFailures === 0 && args.inboundSilenceMs > args.thresholdMs;
@@ -20892,7 +20806,7 @@ async function startDaemon(options) {
     try {
       const dir = loadSessionIndex()[sessionId]?.directory;
       if (!dir) return;
-      const { reconcileServiceLinks } = await import('./agentCommands-DmRCmbeU.mjs');
+      const { reconcileServiceLinks } = await import('./agentCommands-CIQbCUsB.mjs');
       const configPath = getSvampConfigPath(dir, sessionId);
       const config = readSvampConfig(configPath);
       const entries = Array.from(urls.entries());
@@ -20914,7 +20828,7 @@ async function startDaemon(options) {
     try {
       const dir = loadSessionIndex()[sessionId]?.directory;
       if (!dir) return;
-      const { reconcileServiceLinks } = await import('./agentCommands-DmRCmbeU.mjs');
+      const { reconcileServiceLinks } = await import('./agentCommands-CIQbCUsB.mjs');
       const configPath = getSvampConfigPath(dir, sessionId);
       const config = readSvampConfig(configPath);
       const incoming = [{
@@ -20935,7 +20849,7 @@ async function startDaemon(options) {
     try {
       const dir = loadSessionIndex()[sessionId]?.directory;
       if (!dir) return;
-      const { dropServiceLinks } = await import('./agentCommands-DmRCmbeU.mjs');
+      const { dropServiceLinks } = await import('./agentCommands-CIQbCUsB.mjs');
       const configPath = getSvampConfigPath(dir, sessionId);
       const config = readSvampConfig(configPath);
       if (dropServiceLinks(config, "serve", mountName)) {
@@ -20951,7 +20865,7 @@ async function startDaemon(options) {
     try {
       const dir = loadSessionIndex()[sessionId]?.directory;
       if (!dir) return;
-      const { dropServiceLinks } = await import('./agentCommands-DmRCmbeU.mjs');
+      const { dropServiceLinks } = await import('./agentCommands-CIQbCUsB.mjs');
       const configPath = getSvampConfigPath(dir, sessionId);
       const config = readSvampConfig(configPath);
       if (dropServiceLinks(config, "tunnel", tunnelName)) {
@@ -20968,7 +20882,7 @@ async function startDaemon(options) {
   let managedLinkSessionsSeeded = false;
   async function reconcileAllServiceLinks() {
     try {
-      const { reconcileServiceLinksExact, hasManagedServiceLink } = await import('./agentCommands-DmRCmbeU.mjs');
+      const { reconcileServiceLinksExact, hasManagedServiceLink } = await import('./agentCommands-CIQbCUsB.mjs');
       const desiredBySession = /* @__PURE__ */ new Map();
       const push = (sessionId, entry) => {
         if (!sessionId || !entry.url) return;
@@ -22013,15 +21927,11 @@ ${parts.join("\n")}`);
         let overloadBailedThisTurn = false;
         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 turnRequestUsages = [];
         let noIsolationWarned = false;
         const RATELIMIT_CFG = getRateLimitRetryConfig();
         let currentTurnMessage;
@@ -22356,6 +22266,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)) {
@@ -22385,7 +22296,7 @@ ${parts.join("\n")}`);
                       } else if (isRetryableRateLimit(resultText, msg.api_error_status) && scheduleRateLimitRetry2()) {
                         rateLimitRetryScheduled = true;
                         lastErrorMessagePushed = true;
-                      } else if (isContextTooLongError(resultText) && autoCompactEnabled && !autoCompactDisabled && !autoCompactRecoveryTried) {
+                      } else if (isContextTooLongError(resultText) && autoCompactEnabled && !autoCompactRecoveryTried) {
                         autoCompactRecoveryTried = true;
                         logger.log(`[Session ${sessionId}] Context-overflow 400 \u2014 injecting one automatic /compact recovery`);
                         sessionService.pushMessage(
@@ -22465,32 +22376,7 @@ ${parts.join("\n")}`);
                     }
                     if (pendingCompactTurn) {
                       pendingCompactTurn = false;
-                      const wasAuto = autoCompactWasAutoInjected;
-                      autoCompactWasAutoInjected = false;
-                      const d = decideCompactUnsupported({
-                        wasAutoInjected: wasAuto,
-                        turnErrored: !!msg.is_error,
-                        compactSupported,
-                        priorStrikes: compactNoBoundaryStrikes,
-                        maxStrikes: DEFAULT_COMPACT_NO_BOUNDARY_STRIKES
-                      });
-                      compactNoBoundaryStrikes = d.strikes;
-                      if (d.disable) {
-                        autoCompactDisabled = true;
-                        logger.log(`[Session ${sessionId}] Disabling the auto-compaction backstop for this session (${d.reason})`);
-                      }
-                      logger.log(`[Session ${sessionId}] /compact produced no compaction boundary (reason=${d.reason}, strikes=${d.strikes}, supported=${String(compactSupported)}, errored=${!!msg.is_error})`);
-                      if (d.warnUnsupported) {
-                        sessionService.pushMessage(
-                          { type: "message", message: compactUnsupportedWarning(), level: "warning" },
-                          "event"
-                        );
-                      } else if (wasAuto && d.reason !== "errored-turn") {
-                        sessionService.pushMessage(
-                          { type: "message", message: describeNoBoundary(d.strikes, DEFAULT_COMPACT_NO_BOUNDARY_STRIKES), level: "warning" },
-                          "event"
-                        );
-                      }
+                      logger.log(`[Session ${sessionId}] /compact produced no compaction boundary (errored=${!!msg.is_error})`);
                     }
                     if (!msg.is_error) {
                       resetRateLimitStreak();
@@ -22505,24 +22391,17 @@ ${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);
-                    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) {
+                    if (resolvedWindow > 0 && resolvedWindow !== sessionMetadata.contextWindow) {
                       sessionMetadata = {
                         ...sessionMetadata,
-                        ...resolvedWindow > 0 ? { contextWindow: resolvedWindow } : {},
-                        ...persistObserved ? { observedContext: observedThisTurn } : {}
+                        contextWindow: resolvedWindow
                       };
                       sessionService.updateMetadata(sessionMetadata);
                     }
@@ -22596,44 +22475,8 @@ ${parts.join("\n")}`);
                       logger.log(`[Session ${sessionId}] ${taskInfo}`);
                       sessionService.pushMessage({ type: "session_event", message: taskInfo }, "session");
                     }
-                    const mayEvaluateLayer1 = shouldEvaluateProactiveCompaction({
-                      justCompacted: justCompactedTurn,
-                      compactPending: pendingCompactTurn,
-                      turnErrored: !!msg.is_error,
-                      disabled: autoCompactDisabled,
-                      enabled: autoCompactEnabled
-                    });
                     justCompactedTurn = false;
                     compactTurnLatch = false;
-                    if (mayEvaluateLayer1) {
-                      try {
-                        const observed = computeObservedContext(msg.usage);
-                        const decision = decideProactiveCompaction({
-                          observed,
-                          window: resolvedWindow > 0 ? resolvedWindow : sessionMetadata.contextWindow || 0,
-                          ratio: autoCompactRatio,
-                          enabled: autoCompactEnabled
-                        });
-                        if (decision.shouldCompact) {
-                          logger.log(`[Session ${sessionId}] Auto-compaction backstop firing at ${Math.round(decision.pct * 100)}% of ${decision.window} window (${observed} tokens) \u2014 injecting /compact`);
-                          sessionService.pushMessage(
-                            { type: "message", message: describeAutoCompact(observed, decision.window, decision.pct), level: "warning" },
-                            "event"
-                          );
-                          const existingQueue = sessionMetadata.messageQueue || [];
-                          sessionMetadata = {
-                            ...sessionMetadata,
-                            messageQueue: [
-                              { id: randomUUID(), text: "/compact", displayText: "\u{1F5DC}\uFE0F Auto-compacting context", createdAt: Date.now(), alreadyStored: true, autoCompact: true },
-                              ...existingQueue
-                            ]
-                          };
-                          sessionService.updateMetadata(sessionMetadata);
-                        }
-                      } catch (e) {
-                        logger.log(`[Session ${sessionId}] Auto-compaction backstop check failed: ${e?.message}`);
-                      }
-                    }
                     const queueLen = sessionMetadata.messageQueue?.length ?? 0;
                     if (queueLen > 0 && claudeResumeId && !trackedSession.stopped) {
                       setTimeout(() => processMessageQueueRef?.(), 200);
@@ -22662,6 +22505,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)`);
@@ -22669,7 +22513,6 @@ ${parts.join("\n")}`);
                   userMessagePending = false;
                   if (msg.slash_commands && Array.isArray(msg.slash_commands)) {
                     sessionMetadata = { ...sessionMetadata, slashCommands: msg.slash_commands };
-                    compactSupported = compactSupportedFromSlashCommands(msg.slash_commands);
                   }
                   if (typeof msg.model === "string" && msg.model.length > 0) {
                     lastMainModel = msg.model;
@@ -22721,19 +22564,9 @@ ${parts.join("\n")}`);
                   sessionService.pushMessage(msg, "session");
                 } else if (msg.type === "system" && msg.subtype === "compact_boundary") {
                   pendingCompactTurn = false;
-                  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(
@@ -23164,39 +22997,9 @@ ${capturedError}${buildClaudeErrorHint(capturedError)}`;
               pendingCompactTurn = isCompactCommand(text);
               if (pendingCompactTurn) compactTurnLatch = true;
               if (!claudeProcess || claudeProcess.exitCode !== null) {
-                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;
-                }
+                spawnClaude(text, msgMeta);
+                signalProcessing(true);
+                sessionWasProcessing = true;
               } else if (writeUserFrameToClaude(text)) {
                 signalProcessing(true);
                 sessionWasProcessing = true;
@@ -23581,11 +23384,11 @@ ${capturedError}${buildClaudeErrorHint(capturedError)}`;
               });
             },
             onIssue: async (params) => {
-              const { issueRpc } = await import('./rpc-Cj31v2sm.mjs');
+              const { issueRpc } = await import('./rpc-BPHQnoTZ.mjs');
               return issueRpc(params?.cwd || directory, params || {}, { notifySession: notifyIssueOwner, rekickLoopOwner });
             },
             onWorkflow: async (params) => {
-              const { workflowRpc } = await import('./rpc-BSWkkPHd.mjs');
+              const { workflowRpc } = await import('./rpc--XZCm0p-.mjs');
               return workflowRpc(params?.cwd || directory, params || {});
             },
             onRipgrep: async (args, cwd) => {
@@ -23726,7 +23529,6 @@ ${capturedError}${buildClaudeErrorHint(capturedError)}`;
             currentTurnMessage = next.text;
             pendingCompactTurn = isCompactCommand(next.text);
             if (pendingCompactTurn) compactTurnLatch = true;
-            autoCompactWasAutoInjected = pendingCompactTurn && !!next.autoCompact;
             resetRateLimitStreak();
             if (rateLimitRetryTimer) {
               clearTimeout(rateLimitRetryTimer);
@@ -24309,11 +24111,11 @@ ${capturedError}${buildClaudeErrorHint(capturedError)}`;
               });
             },
             onIssue: async (params) => {
-              const { issueRpc } = await import('./rpc-Cj31v2sm.mjs');
+              const { issueRpc } = await import('./rpc-BPHQnoTZ.mjs');
               return issueRpc(params?.cwd || directory, params || {}, { notifySession: notifyIssueOwner, rekickLoopOwner });
             },
             onWorkflow: async (params) => {
-              const { workflowRpc } = await import('./rpc-BSWkkPHd.mjs');
+              const { workflowRpc } = await import('./rpc--XZCm0p-.mjs');
               return workflowRpc(params?.cwd || directory, params || {});
             },
             onRipgrep: async (args, cwd) => {
@@ -25668,7 +25470,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-DkfqQjih.mjs');
+    const { WorkflowScheduler } = await import('./scheduler-CF01et7j.mjs');
     const workflowProjectRoots = () => {
       const dirs = /* @__PURE__ */ new Set();
       for (const s of pidToTrackedSession.values()) {

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

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

@@ -1,6 +1,6 @@
 import * as path from 'path';
-import { w as wantsHelp } from './cli-v0NMiesq.mjs';
-import './run-bo0i02Dy.mjs';
+import { w as wantsHelp } from './cli-0XZc7Ipp.mjs';
+import './run-UbzzPQPz.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-Dw_oiiqX.mjs');
+  const { connectAndGetMachine } = await import('./commands-CoImSc7s.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-DmRCmbeU.mjs');
+        const { autoAddSessionLink } = await import('./agentCommands-CIQbCUsB.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-Dw_oiiqX.mjs');
+  const { connectAndGetMachine } = await import('./commands-CoImSc7s.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-DmRCmbeU.mjs');
+        const { autoAddSessionLink } = await import('./agentCommands-CIQbCUsB.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-Dw_oiiqX.mjs');
+  const { connectAndGetMachine } = await import('./commands-CoImSc7s.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-DmRCmbeU.mjs');
+    const { removeSessionLinkByService } = await import('./agentCommands-CIQbCUsB.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-Dw_oiiqX.mjs');
+  const { connectAndGetMachine } = await import('./commands-CoImSc7s.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-Dw_oiiqX.mjs');
+  const { connectAndGetMachine } = await import('./commands-CoImSc7s.mjs');
   const { machine, server } = await connectAndGetMachine(machineId);
   try {
     const info = await machine.serveInfo();

package/dist/{sideband-D5Kan4J1.mjs → sideband-D-n2JZSB.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-bo0i02Dy.mjs';
+import { R as READ_ONLY_TOOLS, P as loadMachineContext, Q as buildMachineInstructions, T as machineToolsForRole, U as buildMachineTools } from './run-UbzzPQPz.mjs';
 import 'node:child_process';
 import 'os';
 import 'fs/promises';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "svamp-cli",
-  "version": "0.2.337",
+  "version": "0.2.339",
   "description": "Svamp CLI — AI workspace daemon on Hypha Cloud",
   "author": "Amun AI AB",
   "license": "SEE LICENSE IN LICENSE",