svamp-cli 0.2.181 → 0.2.183

package/dist/{commands-qbv-1BoA.mjs → commands-ix9L1jaQ.mjs}

@@ -1,7 +1,7 @@
 import os from 'os';
 import fs__default from 'fs';
 import { resolve, join, relative } from 'path';
-import { C as parseFrontmatter, D as getSkillsServer, E as getSkillsWorkspaceName, F as getSkillsCollectionName, G as fetchWithTimeout, H as searchSkills, I as SKILLS_DIR, J as getSkillInfo, K as downloadSkillFile, L as listSkillFiles } from './run-C9PMX7NQ.mjs';
+import { C as parseFrontmatter, D as getSkillsServer, E as getSkillsWorkspaceName, F as getSkillsCollectionName, G as fetchWithTimeout, H as searchSkills, I as SKILLS_DIR, J as getSkillInfo, K as downloadSkillFile, L as listSkillFiles } from './run-68xel1pO.mjs';
 import 'fs/promises';
 import 'url';
 import 'child_process';

package/dist/{commands-BG-Y0806.mjs → commands-pMwoqGpe.mjs}

@@ -1,7 +1,7 @@
 import { existsSync } from 'node:fs';
-import { connectAndGetMachine, resolveSessionId, createWorktree, connectAndResolveSession } from './commands-CL9hxClH.mjs';
+import { connectAndGetMachine, resolveSessionId, createWorktree, connectAndResolveSession } from './commands-DQ_kpWqH.mjs';
 import { execSync } from 'node:child_process';
-import { u as updateIssue, o as addComment, p as addIssue, x as shortId } from './run-C9PMX7NQ.mjs';
+import { u as updateIssue, o as addComment, p as addIssue, x as shortId } from './run-68xel1pO.mjs';
 import 'node:path';
 import 'node:os';
 import 'os';

package/dist/{fleet-IKkKrYCK.mjs → fleet-B4hfyHp4.mjs}

@@ -1,7 +1,7 @@
 import { existsSync, readFileSync } from 'node:fs';
 import { join } from 'node:path';
 import os from 'node:os';
-import { c as connectToHypha } from './run-C9PMX7NQ.mjs';
+import { c as connectToHypha } from './run-68xel1pO.mjs';
 import { PINNED_CLAUDE_CODE_VERSION } from './pinnedClaudeCode-HydRNEt7.mjs';
 import 'os';
 import 'fs/promises';

package/dist/{frpc-CLJ1PNTL.mjs → frpc-BzkAtKLy.mjs}

@@ -4,7 +4,7 @@ import { mkdirSync, writeFileSync, unlinkSync, existsSync, chmodSync, readFileSy
 import { join } from 'path';
 import { homedir, platform, arch } from 'os';
 import { randomUUID, createHash } from 'crypto';
-import { h as getFrpsSubdomainHost, i as getFrpsServerPort, j as getFrpsServerAddr } from './run-C9PMX7NQ.mjs';
+import { h as getFrpsSubdomainHost, i as getFrpsServerPort, j as getFrpsServerAddr } from './run-68xel1pO.mjs';
 import 'fs/promises';
 import 'url';
 import 'node:crypto';

package/dist/{headlessCli-C8-hCKbi.mjs → headlessCli-ohRvD7CT.mjs}

@@ -1,5 +1,5 @@
-import { M as resolveModel, _ as describeMisconfiguration, $ as buildMachineDeps } from './run-C9PMX7NQ.mjs';
-import { handleRealtimeEvent, initMachineVoiceSession } from './sideband-Dd1I6S5u.mjs';
+import { M as resolveModel, _ as describeMisconfiguration, $ as buildMachineDeps } from './run-68xel1pO.mjs';
+import { handleRealtimeEvent, initMachineVoiceSession } from './sideband-B1jzlbuf.mjs';
 import { WebSocket } from 'ws';
 import { execSync, spawn } from 'child_process';
 import 'os';

package/dist/index.mjs

@@ -1,4 +1,4 @@
-export { c as connectToHypha, a as createSessionStore, d as daemonStatus, g as getHyphaServerUrl, r as registerMachineService, s as startDaemon, b as stopDaemon } from './run-C9PMX7NQ.mjs';
+export { c as connectToHypha, a as createSessionStore, d as daemonStatus, g as getHyphaServerUrl, r as registerMachineService, s as startDaemon, b as stopDaemon } from './run-68xel1pO.mjs';
 import 'os';
 import 'fs/promises';
 import 'fs';

package/dist/{package-D4USifdR.mjs → package-CcFzcCql.mjs}

@@ -1,5 +1,5 @@
 var name = "svamp-cli";
-var version = "0.2.181";
+var version = "0.2.183";
 var description = "Svamp CLI — AI workspace daemon on Hypha Cloud";
 var author = "Amun AI AB";
 var license = "SEE LICENSE IN LICENSE";

package/dist/{rpc-D3J1JM29.mjs → rpc-BwqRLir7.mjs}

@@ -1,4 +1,4 @@
-import { m as resolveProjectRoot, u as updateIssue, n as getIssue, o as addComment, p as addIssue, q as listIssues, t as searchIssues } from './run-C9PMX7NQ.mjs';
+import { m as resolveProjectRoot, u as updateIssue, n as getIssue, o as addComment, p as addIssue, q as listIssues, t as searchIssues } from './run-68xel1pO.mjs';
 import 'os';
 import 'fs/promises';
 import 'fs';

package/dist/{rpc-DLPG3JvW.mjs → rpc-degyMl0V.mjs}

@@ -1,6 +1,6 @@
 import { spawnSync } from 'node:child_process';
-import { m as resolveProjectRoot } from './run-C9PMX7NQ.mjs';
-import { g as getWorkflow, w as workflowSteps, r as removeWorkflow, s as saveWorkflow, a as rawWorkflow, l as listWorkflows } from './store-BPL__e4D.mjs';
+import { m as resolveProjectRoot } from './run-68xel1pO.mjs';
+import { g as getWorkflow, w as workflowSteps, s as setWorkflowEnabled, r as removeWorkflow, a as saveWorkflow, b as rawWorkflow, l as listWorkflows } from './store-D-fJ9ANL.mjs';
 import 'os';
 import 'fs/promises';
 import 'fs';
@@ -53,6 +53,12 @@ function workflowRpc(cwd, params) {
     }
     case "remove":
       return { removed: removeWorkflow(root, String(params.name)) };
+    case "enable":
+    case "disable": {
+      const wf = setWorkflowEnabled(root, String(params.name), op === "enable");
+      if (!wf) throw new Error(`Workflow not found: ${params.name}`);
+      return wf;
+    }
     case "run": {
       const wf = getWorkflow(root, String(params.name));
       if (!wf) throw new Error(`Workflow not found: ${params.name}`);

package/dist/{run-C9PMX7NQ.mjs → run-68xel1pO.mjs}

@@ -84,6 +84,16 @@ function normalizeAllowedUser(input, addedBy) {
 }
 const ISOLATION_PREFERENCE = ["nono", "docker", "podman"];
 
+let ownerWorkspace;
+function setOwnerWorkspace(ws) {
+  ownerWorkspace = ws || void 0;
+}
+function isSameOwnerWorkspace(context) {
+  const ws = context?.ws;
+  if (!ownerWorkspace || ownerWorkspace === "*") return false;
+  if (!ws || ws === "*") return false;
+  return ws === ownerWorkspace;
+}
 function resolveRoleLevel(sharing, userEmail) {
   let level = -1;
   if (userEmail && Array.isArray(sharing.allowedUsers)) {
@@ -107,6 +117,7 @@ function levelToRole(level) {
 }
 function authorizeRequest(context, sharing, requiredRole = "view") {
   if (!context?.user) return;
+  if (isSameOwnerWorkspace(context)) return;
   const userEmail = context.user.email;
   if (!sharing) return;
   if (userEmail && sharing.owner && userEmail.toLowerCase() === sharing.owner.toLowerCase()) return;
@@ -129,6 +140,7 @@ function authorizeRequest(context, sharing, requiredRole = "view") {
 }
 function getEffectiveRole(context, sharing) {
   if (!context?.user) return "admin";
+  if (isSameOwnerWorkspace(context)) return "admin";
   if (!sharing) return "admin";
   const userEmail = context.user.email;
   if (userEmail && sharing.owner && userEmail.toLowerCase() === sharing.owner.toLowerCase()) return "admin";
@@ -1759,6 +1771,10 @@ async function registerMachineService(server, machineId, metadata, daemonState,
   let currentDaemonState = { ...daemonState };
   let metadataVersion = 1;
   let daemonStateVersion = 1;
+  try {
+    setOwnerWorkspace(server.config?.workspace);
+  } catch {
+  }
   let lastInboundRpcAt = Date.now();
   const trackInbound = () => {
     lastInboundRpcAt = Date.now();
@@ -2699,7 +2715,7 @@ async function registerMachineService(server, machineId, metadata, daemonState,
         const tunnels = handlers.tunnels;
         if (!tunnels) throw new Error("Tunnel management not available");
         if (tunnels.has(params.name)) throw new Error(`Tunnel '${params.name}' already running`);
-        const { FrpcTunnel } = await import('./frpc-CLJ1PNTL.mjs');
+        const { FrpcTunnel } = await import('./frpc-BzkAtKLy.mjs');
         const tunnel = new FrpcTunnel({
           name: params.name,
           ports: params.ports,
@@ -3146,7 +3162,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-Dd1I6S5u.mjs');
+          const { toolsForRole } = await import('./sideband-B1jzlbuf.mjs');
           const r2 = await runWiseAgent({ message: params.message, sender, config: { tools: toolsForRole(role2) }, deps, transport, model: resolved.model });
           return fmt(r2);
         }
@@ -3245,7 +3261,7 @@ QUESTION: ${params.question || "Summarize this concisely."}` }
     if (r.error || !r.sender) return { error: r.error || "unauthorized" };
     const callId = "call_" + Math.random().toString(16).slice(2, 12);
     const rendered = renderMessage(c, { sender: r.sender, body: { message: kwargs.message }, callId });
-    const { queryCore } = await import('./commands-CL9hxClH.mjs');
+    const { queryCore } = await import('./commands-DQ_kpWqH.mjs');
     const timeout = c.reply?.timeout_sec || 120;
     let result;
     try {
@@ -3515,6 +3531,35 @@ function applyInboxClear(inbox, opts) {
   return { kept, removed: inbox.length - kept.length };
 }
 
+function envInt(name, fallback) {
+  const raw = process.env[name];
+  if (raw === void 0 || raw === "") return fallback;
+  const n = parseInt(raw, 10);
+  return Number.isFinite(n) && n >= 0 ? n : fallback;
+}
+function getRateLimitRetryConfig() {
+  return {
+    maxRetries: envInt("SVAMP_RATELIMIT_MAX_RETRIES", 10),
+    baseMs: envInt("SVAMP_RATELIMIT_BASE_MS", 5e3),
+    capMs: envInt("SVAMP_RATELIMIT_CAP_MS", 12e4)
+  };
+}
+function computeRetryDelayMs(attempt, cfg = getRateLimitRetryConfig(), rng = Math.random) {
+  const a = Math.max(0, Math.floor(attempt));
+  const expo = Math.min(a, 30);
+  const nominal = Math.min(cfg.capMs, cfg.baseMs * Math.pow(2, expo));
+  const half = nominal / 2;
+  return Math.round(half + rng() * half);
+}
+function isRetryableRateLimit(text, apiErrorStatus) {
+  const t = (text || "").toLowerCase();
+  const hardLimit = t.includes("quota") || t.includes("credit") || t.includes("balance") || t.includes("billing") || t.includes("payment") || t.includes("subscription") || t.includes("1m-context") || t.includes("1m context") || t.includes("insufficient") || t.includes("usage limit") && !t.includes("not your usage limit");
+  if (hardLimit) return false;
+  const authIssue = t.includes("unauthorized") || t.includes("invalid api key") || t.includes("authentication") || t.includes("forbidden");
+  if (authIssue) return false;
+  return apiErrorStatus === 429 || apiErrorStatus === 529 || apiErrorStatus === 503 || /\b(429|529|503)\b/.test(t) || t.includes("temporarily limiting") || t.includes("not your usage limit") || t.includes("overloaded") || t.includes("overload") || t.includes("too many requests") || t.includes("server is busy") || t.includes("rate limit") || t.includes("rate-limit") || t.includes("rate limited");
+}
+
 const PARTICIPANTS_CHANNEL_ID = "sys-participants";
 function channelPublicView(c) {
   return { id: c.id, name: c.name, description: c.description, identity: { mode: c.identity?.mode }, action: c.action?.kind, bind: c.bind };
@@ -3845,7 +3890,7 @@ function createSessionStore(server, sessionId, initialMetadata, initialAgentStat
     }
   };
   ensureParticipantsChannel(initialMetadata.sharing);
-  const forkClaudePrint = async (prompt, claudeSessionId, cwd, maxTurns = 6, timeoutMs = 6e4) => {
+  const forkClaudeOnce = async (prompt, claudeSessionId, cwd, maxTurns, timeoutMs) => {
     const { spawn } = await import('child_process');
     return new Promise((resolve) => {
       const child = spawn("claude", [
@@ -3882,14 +3927,37 @@ function createSessionStore(server, sessionId, initialMetadata, initialAgentStat
         }
         try {
           const result = JSON.parse(stdout);
+          if (result && result.is_error) {
+            resolve({ success: false, error: String(result.result || result.error || stderr || "error") });
+            return;
+          }
           resolve({ success: true, text: result.result || result.text || stdout });
         } catch {
+          if (code !== 0) {
+            resolve({ success: false, error: stderr || stdout.trim() || `claude exited with code ${code}` });
+            return;
+          }
           resolve({ success: true, text: stdout.trim() });
         }
       });
       child.on("error", (err) => resolve({ success: false, error: err.message }));
     });
   };
+  const forkClaudePrint = async (prompt, claudeSessionId, cwd, maxTurns = 6, timeoutMs = 6e4) => {
+    const cfg2 = getRateLimitRetryConfig();
+    let last = { success: false, error: "" };
+    for (let attempt = 0; ; attempt++) {
+      last = await forkClaudeOnce(prompt, claudeSessionId, cwd, maxTurns, timeoutMs);
+      if (last.success) return last;
+      if (!isRetryableRateLimit(last.error || "") || attempt >= cfg2.maxRetries) return last;
+      const delay = computeRetryDelayMs(attempt, cfg2);
+      try {
+        console.error(`[btw] rate-limited \u2014 holding ${Math.round(delay / 1e3)}s then retrying (attempt ${attempt + 1}/${cfg2.maxRetries})`);
+      } catch {
+      }
+      await new Promise((r) => setTimeout(r, delay));
+    }
+  };
   const performEdit = async (target, newText) => {
     if (!callbacks.onEditTranscript) return { success: false, message: "Editing history is not supported for this session." };
     const info = editableInfo(target);
@@ -10201,35 +10269,6 @@ function resolveContextWindow(opts) {
   return candidate;
 }
 
-function envInt(name, fallback) {
-  const raw = process.env[name];
-  if (raw === void 0 || raw === "") return fallback;
-  const n = parseInt(raw, 10);
-  return Number.isFinite(n) && n >= 0 ? n : fallback;
-}
-function getRateLimitRetryConfig() {
-  return {
-    maxRetries: envInt("SVAMP_RATELIMIT_MAX_RETRIES", 10),
-    baseMs: envInt("SVAMP_RATELIMIT_BASE_MS", 5e3),
-    capMs: envInt("SVAMP_RATELIMIT_CAP_MS", 12e4)
-  };
-}
-function computeRetryDelayMs(attempt, cfg = getRateLimitRetryConfig(), rng = Math.random) {
-  const a = Math.max(0, Math.floor(attempt));
-  const expo = Math.min(a, 30);
-  const nominal = Math.min(cfg.capMs, cfg.baseMs * Math.pow(2, expo));
-  const half = nominal / 2;
-  return Math.round(half + rng() * half);
-}
-function isRetryableRateLimit(text, apiErrorStatus) {
-  const t = (text || "").toLowerCase();
-  const hardLimit = t.includes("quota") || t.includes("credit") || t.includes("balance") || t.includes("billing") || t.includes("payment") || t.includes("subscription") || t.includes("1m-context") || t.includes("1m context") || t.includes("insufficient") || t.includes("usage limit") && !t.includes("not your usage limit");
-  if (hardLimit) return false;
-  const authIssue = t.includes("unauthorized") || t.includes("invalid api key") || t.includes("authentication") || t.includes("forbidden");
-  if (authIssue) return false;
-  return apiErrorStatus === 429 || apiErrorStatus === 529 || apiErrorStatus === 503 || /\b(429|529|503)\b/.test(t) || t.includes("temporarily limiting") || t.includes("not your usage limit") || t.includes("overloaded") || t.includes("overload") || t.includes("too many requests") || t.includes("server is busy") || t.includes("rate limit") || t.includes("rate-limit") || t.includes("rate limited");
-}
-
 const SVAMP_HOME$1 = process.env.SVAMP_HOME || join(os.homedir(), ".svamp");
 function generateHookSettings(portOrOptions = {}) {
   const opts = typeof portOrOptions === "number" ? { sessionStartPort: portOrOptions } : portOrOptions;
@@ -11568,7 +11607,7 @@ async function startDaemon(options) {
     saveExposedTunnels(list);
   }
   async function createExposedTunnel(spec) {
-    const { FrpcTunnel } = await import('./frpc-CLJ1PNTL.mjs');
+    const { FrpcTunnel } = await import('./frpc-BzkAtKLy.mjs');
     const tunnel = new FrpcTunnel({
       name: spec.name,
       ports: spec.ports,
@@ -11588,7 +11627,7 @@ async function startDaemon(options) {
     return tunnel;
   }
   const tunnelRecreateState = /* @__PURE__ */ new Map();
-  const { ServeManager } = await import('./serveManager-B6bHAn0B.mjs');
+  const { ServeManager } = await import('./serveManager-BKbhWnMy.mjs');
   const serveManager = new ServeManager(SVAMP_HOME, (msg) => logger.log(`[SERVE] ${msg}`), hyphaServerUrl);
   ensureAutoInstalledSkills(logger).catch(() => {
   });
@@ -12942,73 +12981,119 @@ ${capturedError}${buildClaudeErrorHint(capturedError)}`;
                 return;
               }
               if (msgMeta?.btw && claudeResumeId) {
+                const btwResumeId = claudeResumeId;
                 logger.log(`[Session ${sessionId}] /btw side-channel: "${text.substring(0, 80)}..."`);
                 sessionService.pushMessage(
                   { type: "message", message: `/btw ${text}`, level: "btw-question" },
                   "event"
                 );
                 signalProcessing(true);
-                const btwArgs = [
-                  "--print",
-                  text,
-                  "--resume",
-                  claudeResumeId,
-                  "--fork-session",
-                  "--no-session-persistence",
-                  // /btw is non-interactive; without bypass the
-                  // forked Claude pauses on tool prompts and the
-                  // user just sees a hanging side-channel.
-                  "--permission-mode",
-                  "bypassPermissions",
-                  "--output-format",
-                  "stream-json",
-                  "--verbose"
-                ];
-                const btwProcess = spawn$1("claude", btwArgs, {
-                  cwd: directory,
-                  env: { ...process.env },
-                  stdio: ["pipe", "pipe", "pipe"]
-                });
-                let btwResult = "";
-                let btwBuffer = "";
-                btwProcess.stdout.on("data", (chunk) => {
-                  btwBuffer += chunk.toString();
-                  let newlineIdx;
-                  while ((newlineIdx = btwBuffer.indexOf("\n")) !== -1) {
-                    const line = btwBuffer.substring(0, newlineIdx);
-                    btwBuffer = btwBuffer.substring(newlineIdx + 1);
-                    if (!line.trim()) continue;
-                    try {
-                      const msg = JSON.parse(line);
-                      if (msg.type === "assistant" && msg.message?.content) {
-                        for (const block of msg.message.content) {
-                          if (block.type === "text" && block.text) {
-                            btwResult += block.text;
+                const runBtwOnce = () => new Promise((resolve2, reject) => {
+                  const btwArgs = [
+                    "--print",
+                    text,
+                    "--resume",
+                    btwResumeId,
+                    "--fork-session",
+                    "--no-session-persistence",
+                    // /btw is non-interactive; without bypass the forked Claude
+                    // pauses on tool prompts and the user sees a hanging side-channel.
+                    "--permission-mode",
+                    "bypassPermissions",
+                    "--output-format",
+                    "stream-json",
+                    "--verbose"
+                  ];
+                  const btwProcess = spawn$1("claude", btwArgs, {
+                    cwd: directory,
+                    env: { ...process.env },
+                    stdio: ["pipe", "pipe", "pipe"]
+                  });
+                  let btwResult = "";
+                  let btwBuffer = "";
+                  let btwStderr = "";
+                  let settled = false;
+                  btwProcess.stderr?.on("data", (chunk) => {
+                    btwStderr += chunk.toString();
+                  });
+                  btwProcess.stdout.on("data", (chunk) => {
+                    btwBuffer += chunk.toString();
+                    let newlineIdx;
+                    while ((newlineIdx = btwBuffer.indexOf("\n")) !== -1) {
+                      const line = btwBuffer.substring(0, newlineIdx);
+                      btwBuffer = btwBuffer.substring(newlineIdx + 1);
+                      if (!line.trim()) continue;
+                      try {
+                        const msg = JSON.parse(line);
+                        if (msg.type === "assistant" && msg.message?.content) {
+                          for (const block of msg.message.content) {
+                            if (block.type === "text" && block.text) {
+                              btwResult += block.text;
+                            }
+                          }
+                        } else if (msg.type === "result") {
+                          if (settled) continue;
+                          settled = true;
+                          if (msg.is_error) {
+                            const err = new Error(String(msg.result || "error"));
+                            err.retryable = isRetryableRateLimit(String(msg.result || ""), msg.api_error_status);
+                            reject(err);
+                          } else {
+                            resolve2(btwResult || msg.result || "(no response)");
                           }
                         }
-                      } else if (msg.type === "result") {
-                        const finalText = btwResult || msg.result || "(no response)";
-                        sessionService.pushMessage(
-                          { type: "message", message: finalText, level: "btw-answer" },
-                          "event"
-                        );
-                        signalProcessing(false);
-                        sessionService.sendSessionEnd();
-                        logger.log(`[Session ${sessionId}] /btw complete (${finalText.length} chars)`);
+                      } catch {
                       }
-                    } catch {
                     }
-                  }
+                  });
+                  btwProcess.on("exit", (code) => {
+                    if (settled) return;
+                    settled = true;
+                    if (code === 0) {
+                      resolve2(btwResult || "(no response)");
+                      return;
+                    }
+                    const detail = btwStderr.trim() || btwResult.trim();
+                    const err = new Error(detail || `claude exited with code ${code}`);
+                    err.retryable = isRetryableRateLimit(detail || "");
+                    reject(err);
+                  });
+                  btwProcess.on("error", (e) => {
+                    if (settled) return;
+                    settled = true;
+                    const err = new Error(e.message);
+                    err.retryable = false;
+                    reject(err);
+                  });
                 });
-                btwProcess.on("exit", (code) => {
-                  if (code !== 0) {
-                    sessionService.pushMessage(
-                      { type: "message", message: `/btw failed (exit code ${code})`, level: "error" },
-                      "event"
-                    );
-                    signalProcessing(false);
-                    sessionService.sendSessionEnd();
+                (async () => {
+                  let lastErr = null;
+                  for (let attempt = 0; ; attempt++) {
+                    try {
+                      const finalText = await runBtwOnce();
+                      sessionService.pushMessage(
+                        { type: "message", message: finalText, level: "btw-answer" },
+                        "event"
+                      );
+                      logger.log(`[Session ${sessionId}] /btw complete (${finalText.length} chars)`);
+                      return;
+                    } catch (e) {
+                      lastErr = e;
+                      if (!e?.retryable || attempt >= RATELIMIT_CFG.maxRetries) break;
+                      const delayMs = computeRetryDelayMs(attempt, RATELIMIT_CFG);
+                      logger.log(`[Session ${sessionId}] /btw rate-limited \u2014 holding ${Math.round(delayMs / 1e3)}s then retrying (attempt ${attempt + 1}/${RATELIMIT_CFG.maxRetries})`);
+                      await new Promise((r) => setTimeout(r, delayMs));
+                    }
                   }
+                  const detail = (lastErr?.message || "unknown error").toString().slice(0, 500);
+                  sessionService.pushMessage(
+                    { type: "message", message: `/btw failed: ${detail}`, level: "error" },
+                    "event"
+                  );
+                  logger.log(`[Session ${sessionId}] /btw failed: ${detail}`);
+                })().finally(() => {
+                  signalProcessing(false);
+                  sessionService.sendSessionEnd();
                 });
                 return;
               }
@@ -13379,11 +13464,11 @@ ${capturedError}${buildClaudeErrorHint(capturedError)}`;
               });
             },
             onIssue: async (params) => {
-              const { issueRpc } = await import('./rpc-D3J1JM29.mjs');
+              const { issueRpc } = await import('./rpc-BwqRLir7.mjs');
               return issueRpc(params?.cwd || directory, params || {});
             },
             onWorkflow: async (params) => {
-              const { workflowRpc } = await import('./rpc-DLPG3JvW.mjs');
+              const { workflowRpc } = await import('./rpc-degyMl0V.mjs');
               return workflowRpc(params?.cwd || directory, params || {});
             },
             onRipgrep: async (args, cwd) => {
@@ -13889,11 +13974,11 @@ ${capturedError}${buildClaudeErrorHint(capturedError)}`;
               });
             },
             onIssue: async (params) => {
-              const { issueRpc } = await import('./rpc-D3J1JM29.mjs');
+              const { issueRpc } = await import('./rpc-BwqRLir7.mjs');
               return issueRpc(params?.cwd || directory, params || {});
             },
             onWorkflow: async (params) => {
-              const { workflowRpc } = await import('./rpc-DLPG3JvW.mjs');
+              const { workflowRpc } = await import('./rpc-degyMl0V.mjs');
               return workflowRpc(params?.cwd || directory, params || {});
             },
             onRipgrep: async (args, cwd) => {
@@ -14646,7 +14731,7 @@ ${capturedError}${buildClaudeErrorHint(capturedError)}`;
     const PING_TIMEOUT_MS = 15e3;
     const POST_RECONNECT_GRACE_MS = 2e4;
     const RECONNECT_JITTER_MS = 2500;
-    const { WorkflowScheduler } = await import('./scheduler-Bgs6H33k.mjs');
+    const { WorkflowScheduler } = await import('./scheduler-D0FGGxti.mjs');
     const workflowScheduler = new WorkflowScheduler({
       projectRoots: () => {
         const dirs = /* @__PURE__ */ new Set();

package/dist/{run-D5-ounOl.mjs → run-B2aWNd0R.mjs}

@@ -1,4 +1,4 @@
-import{createRequire as _pkgrollCR}from"node:module";const require=_pkgrollCR(import.meta.url);import { a0 as composeSessionId, a1 as generateFriendlyName, c as connectToHypha, a as createSessionStore, r as registerMachineService, a2 as generateHookSettings } from './run-C9PMX7NQ.mjs';
+import{createRequire as _pkgrollCR}from"node:module";const require=_pkgrollCR(import.meta.url);import { a0 as composeSessionId, a1 as generateFriendlyName, c as connectToHypha, a as createSessionStore, r as registerMachineService, a2 as generateHookSettings } from './run-68xel1pO.mjs';
 import os from 'node:os';
 import { resolve, join } from 'node:path';
 import { existsSync, readFileSync, watch } from 'node:fs';

package/dist/{scheduler-Bgs6H33k.mjs → scheduler-D0FGGxti.mjs}

@@ -1,6 +1,6 @@
 import { spawn } from 'node:child_process';
-import { m as resolveProjectRoot, v as cronMatches } from './run-C9PMX7NQ.mjs';
-import { l as listWorkflows, b as workflowCrons, w as workflowSteps } from './store-BPL__e4D.mjs';
+import { m as resolveProjectRoot, v as cronMatches } from './run-68xel1pO.mjs';
+import { l as listWorkflows, i as isWorkflowEnabled, c as workflowCrons, w as workflowSteps } from './store-D-fJ9ANL.mjs';
 import 'os';
 import 'fs/promises';
 import 'fs';
@@ -73,6 +73,7 @@ class WorkflowScheduler {
         continue;
       }
       for (const wf of workflows) {
+        if (!isWorkflowEnabled(wf)) continue;
         const crons = workflowCrons(wf);
         if (!crons.length) continue;
         if (crons.some((c) => cronMatchesSafe(c, now))) {

package/dist/{serveCommands-Dx5BiAfU.mjs → serveCommands-Bo2xZPIZ.mjs}

@@ -54,7 +54,7 @@ async function handleServeCommand() {
   }
 }
 async function serveAdd(args, machineId) {
-  const { connectAndGetMachine } = await import('./commands-CL9hxClH.mjs');
+  const { connectAndGetMachine } = await import('./commands-DQ_kpWqH.mjs');
   const pos = positionalArgs(args);
   const name = pos[0];
   if (!name) {
@@ -93,7 +93,7 @@ async function serveAdd(args, machineId) {
   }
 }
 async function serveApply(args, machineId) {
-  const { connectAndGetMachine } = await import('./commands-CL9hxClH.mjs');
+  const { connectAndGetMachine } = await import('./commands-DQ_kpWqH.mjs');
   const fs = await import('fs');
   const yaml = await import('yaml');
   const file = positionalArgs(args)[0];
@@ -182,7 +182,7 @@ async function serveApply(args, machineId) {
   }
 }
 async function serveRemove(args, machineId) {
-  const { connectAndGetMachine } = await import('./commands-CL9hxClH.mjs');
+  const { connectAndGetMachine } = await import('./commands-DQ_kpWqH.mjs');
   const pos = positionalArgs(args);
   const name = pos[0];
   if (!name) {
@@ -202,7 +202,7 @@ async function serveRemove(args, machineId) {
   }
 }
 async function serveList(args, machineId) {
-  const { connectAndGetMachine } = await import('./commands-CL9hxClH.mjs');
+  const { connectAndGetMachine } = await import('./commands-DQ_kpWqH.mjs');
   const all = hasFlag(args, "--all", "-a");
   const json = hasFlag(args, "--json");
   const sessionId = getFlag(args, "--session");
@@ -235,7 +235,7 @@ async function serveList(args, machineId) {
   }
 }
 async function serveInfo(machineId) {
-  const { connectAndGetMachine } = await import('./commands-CL9hxClH.mjs');
+  const { connectAndGetMachine } = await import('./commands-DQ_kpWqH.mjs');
   const { machine, server } = await connectAndGetMachine(machineId);
   try {
     const info = await machine.serveInfo();

package/dist/{serveManager-B6bHAn0B.mjs → serveManager-BKbhWnMy.mjs}

@@ -4,7 +4,7 @@ import * as fs from 'fs';
 import * as http from 'http';
 import * as net from 'net';
 import * as path from 'path';
-import { k as getHyphaServerUrl, S as ServeAuth, l as hasCookieToken } from './run-C9PMX7NQ.mjs';
+import { k as getHyphaServerUrl, S as ServeAuth, l as hasCookieToken } from './run-68xel1pO.mjs';
 import 'os';
 import 'fs/promises';
 import 'url';
@@ -733,7 +733,7 @@ class ServeManager {
     const mount = this.mounts.get(mountName);
     const subdomainOverride = mount?.access === "link" && mount.linkToken ? /* @__PURE__ */ new Map([[this.port, buildLinkSubdomain(subdomainSafe, mount.linkToken)]]) : void 0;
     try {
-      const { FrpcTunnel } = await import('./frpc-CLJ1PNTL.mjs');
+      const { FrpcTunnel } = await import('./frpc-BzkAtKLy.mjs');
       let tunnel;
       tunnel = new FrpcTunnel({
         name: tunnelName,

package/dist/{sideband-Dd1I6S5u.mjs → sideband-B1jzlbuf.mjs}

@@ -1,4 +1,4 @@
-import { R as READ_ONLY_TOOLS, y as loadMachineContext, z as buildMachineInstructions, A as machineToolsForRole, B as buildMachineTools } from './run-C9PMX7NQ.mjs';
+import { R as READ_ONLY_TOOLS, y as loadMachineContext, z as buildMachineInstructions, A as machineToolsForRole, B as buildMachineTools } from './run-68xel1pO.mjs';
 import 'node:child_process';
 import 'os';
 import 'fs/promises';