bitfab-cli 0.2.84 → 0.2.86

package/dist/index.js

@@ -5152,8 +5152,8 @@ var require_utils = __commonJS({
       }
       return ind;
     }
-    function removeDotSegments(path15) {
-      let input = path15;
+    function removeDotSegments(path18) {
+      let input = path18;
       const output = [];
       let nextSlash = -1;
       let len = 0;
@@ -5352,8 +5352,8 @@ var require_schemes = __commonJS({
         wsComponent.secure = void 0;
       }
       if (wsComponent.resourceName) {
-        const [path15, query] = wsComponent.resourceName.split("?");
-        wsComponent.path = path15 && path15 !== "/" ? path15 : void 0;
+        const [path18, query] = wsComponent.resourceName.split("?");
+        wsComponent.path = path18 && path18 !== "/" ? path18 : void 0;
         wsComponent.query = query;
         wsComponent.resourceName = void 0;
       }
@@ -5505,10 +5505,10 @@ var require_fast_uri = __commonJS({
     function normalize(uri, options) {
       if (typeof uri === "string") {
         uri = /** @type {T} */
-        serialize(parse3(uri, options), options);
+        serialize2(parse3(uri, options), options);
       } else if (typeof uri === "object") {
         uri = /** @type {T} */
-        parse3(serialize(uri, options), options);
+        parse3(serialize2(uri, options), options);
       }
       return uri;
     }
@@ -5516,13 +5516,13 @@ var require_fast_uri = __commonJS({
       const schemelessOptions = options ? Object.assign({ scheme: "null" }, options) : { scheme: "null" };
       const resolved = resolveComponent(parse3(baseURI, schemelessOptions), parse3(relativeURI, schemelessOptions), schemelessOptions, true);
       schemelessOptions.skipEscape = true;
-      return serialize(resolved, schemelessOptions);
+      return serialize2(resolved, schemelessOptions);
     }
     function resolveComponent(base, relative, options, skipNormalization) {
       const target = {};
       if (!skipNormalization) {
-        base = parse3(serialize(base, options), options);
-        relative = parse3(serialize(relative, options), options);
+        base = parse3(serialize2(base, options), options);
+        relative = parse3(serialize2(relative, options), options);
       }
       options = options || {};
       if (!options.tolerant && relative.scheme) {
@@ -5574,19 +5574,19 @@ var require_fast_uri = __commonJS({
     function equal(uriA, uriB, options) {
       if (typeof uriA === "string") {
         uriA = unescape(uriA);
-        uriA = serialize(normalizeComponentEncoding(parse3(uriA, options), true), { ...options, skipEscape: true });
+        uriA = serialize2(normalizeComponentEncoding(parse3(uriA, options), true), { ...options, skipEscape: true });
       } else if (typeof uriA === "object") {
-        uriA = serialize(normalizeComponentEncoding(uriA, true), { ...options, skipEscape: true });
+        uriA = serialize2(normalizeComponentEncoding(uriA, true), { ...options, skipEscape: true });
       }
       if (typeof uriB === "string") {
         uriB = unescape(uriB);
-        uriB = serialize(normalizeComponentEncoding(parse3(uriB, options), true), { ...options, skipEscape: true });
+        uriB = serialize2(normalizeComponentEncoding(parse3(uriB, options), true), { ...options, skipEscape: true });
       } else if (typeof uriB === "object") {
-        uriB = serialize(normalizeComponentEncoding(uriB, true), { ...options, skipEscape: true });
+        uriB = serialize2(normalizeComponentEncoding(uriB, true), { ...options, skipEscape: true });
       }
       return uriA.toLowerCase() === uriB.toLowerCase();
     }
-    function serialize(cmpts, opts) {
+    function serialize2(cmpts, opts) {
       const component = {
         host: cmpts.host,
         scheme: cmpts.scheme,
@@ -5742,7 +5742,7 @@ var require_fast_uri = __commonJS({
       resolve,
       resolveComponent,
       equal,
-      serialize,
+      serialize: serialize2,
       parse: parse3
     };
     module.exports = fastUri;
@@ -8715,12 +8715,12 @@ var require_dist = __commonJS({
         throw new Error(`Unknown format "${name}"`);
       return f;
     };
-    function addFormats(ajv, list, fs18, exportName) {
+    function addFormats(ajv, list, fs20, exportName) {
       var _a2;
       var _b;
       (_a2 = (_b = ajv.opts.code).formats) !== null && _a2 !== void 0 ? _a2 : _b.formats = (0, codegen_1._)`require("ajv-formats/dist/formats").${exportName}`;
       for (const f of list)
-        ajv.addFormat(f, fs18[f]);
+        ajv.addFormat(f, fs20[f]);
     }
     module.exports = exports = formatsPlugin;
     Object.defineProperty(exports, "__esModule", { value: true });
@@ -8731,6 +8731,10 @@ var require_dist = __commonJS({
 // src/index.ts
 import { cancel as cancel2 } from "@clack/prompts";
 
+// src/init.ts
+import { execSync as execSync3 } from "child_process";
+import * as p4 from "@clack/prompts";
+
 // ../bitfab-plugin-lib/dist/errors.js
 var NotAuthenticatedError = class extends Error {
   constructor(message) {
@@ -8738,6 +8742,24 @@ var NotAuthenticatedError = class extends Error {
     this.name = "NotAuthenticatedError";
   }
 };
+var DaemonUnavailableError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "DaemonUnavailableError";
+  }
+};
+var StudioNavigationError = class extends Error {
+  reason;
+  blockedReason;
+  staleSessionId;
+  constructor(reason, blockedReason, staleSessionId) {
+    super(blockedReason ? `Studio navigation failed (${reason}): ${blockedReason}` : `Studio navigation failed: ${reason}`);
+    this.reason = reason;
+    this.blockedReason = blockedReason;
+    this.staleSessionId = staleSessionId;
+    this.name = "StudioNavigationError";
+  }
+};
 
 // ../bitfab-plugin-lib/dist/studioRoutes.js
 var STUDIO_ROUTE_PATTERNS = [
@@ -8805,7 +8827,7 @@ async function pollAgentSessionEvents(opts) {
   const interval = opts.intervalMs ?? DEFAULT_POLL_INTERVAL_MS;
   const client = {
     serviceUrl: opts.serviceUrl,
-    apiKey: opts.apiKey,
+    apiKey: opts.apiKey ?? "",
     sessionId: opts.sessionId
   };
   let since = opts.startCursor ?? null;
@@ -8816,8 +8838,9 @@ async function pollAgentSessionEvents(opts) {
       if (since) {
         url2.searchParams.set("since", since);
       }
+      const authHeaders = opts.apiKey ? { Authorization: `Bearer ${opts.apiKey}` } : { [STUDIO_SESSION_SCOPE_HEADER]: STUDIO_SESSION_SCOPE_VALUE };
       const res = await fetch(url2.toString(), {
-        headers: { Authorization: `Bearer ${opts.apiKey}` },
+        headers: authHeaders,
         signal: opts.abortSignal
       });
       if (res.ok) {
@@ -8857,124 +8880,13 @@ async function pollAgentSessionEvents(opts) {
     });
   }
 }
-async function pollLoginEvents(opts) {
-  const interval = opts.intervalMs ?? DEFAULT_POLL_INTERVAL_MS;
-  let since = null;
-  while (!opts.abortSignal.aborted) {
-    try {
-      const url2 = new URL(`${opts.serviceUrl}/api/studio/sessions/poll`);
-      url2.searchParams.set("session", opts.sessionId);
-      if (since) {
-        url2.searchParams.set("since", since);
-      }
-      const res = await fetch(url2.toString(), {
-        signal: opts.abortSignal
-      });
-      if (res.ok) {
-        const body = await res.json();
-        for (const event of body.events) {
-          since = event.id;
-          if (event.type === "studio:authenticated" && typeof event.data.token === "string") {
-            return event.data.token;
-          }
-        }
-      }
-    } catch {
-      if (opts.abortSignal.aborted) {
-        break;
-      }
-    }
-    await new Promise((resolve) => {
-      const onAbort = () => {
-        clearTimeout(timer);
-        resolve();
-      };
-      const timer = setTimeout(() => {
-        opts.abortSignal.removeEventListener("abort", onAbort);
-        resolve();
-      }, interval);
-      opts.abortSignal.addEventListener("abort", onAbort, { once: true });
-    });
-  }
-  throw new Error("Login polling aborted");
-}
 var STUDIO_SESSION_SCOPE_HEADER = "x-bitfab-auth-scope";
 var STUDIO_SESSION_SCOPE_VALUE = "session";
-async function requestSessionReauth(opts) {
-  try {
-    const res = await fetch(`${opts.serviceUrl}/api/studio/events`, {
-      method: "POST",
-      headers: {
-        "Content-Type": "application/json",
-        [STUDIO_SESSION_SCOPE_HEADER]: STUDIO_SESSION_SCOPE_VALUE
-      },
-      body: JSON.stringify({
-        session: opts.sessionId,
-        type: "agent:request-reauth",
-        data: { redirectPath: opts.redirectPath }
-      })
-    });
-    if (!res.ok) {
-      return { ok: false };
-    }
-    const body = await res.json();
-    return {
-      ok: true,
-      pushedEventId: body.id,
-      signInUrl: `${opts.serviceUrl}${body.signInPath}`
-    };
-  } catch {
-    return { ok: false };
-  }
-}
-async function pollSessionAuthEvents(opts) {
-  const interval = opts.intervalMs ?? DEFAULT_POLL_INTERVAL_MS;
-  let since = opts.startCursor ?? null;
-  while (!opts.abortSignal.aborted) {
-    try {
-      const url2 = new URL(`${opts.serviceUrl}/api/studio/events`);
-      url2.searchParams.set("session", opts.sessionId);
-      if (since) {
-        url2.searchParams.set("since", since);
-      }
-      const res = await fetch(url2.toString(), {
-        headers: {
-          [STUDIO_SESSION_SCOPE_HEADER]: STUDIO_SESSION_SCOPE_VALUE
-        },
-        signal: opts.abortSignal
-      });
-      if (res.ok) {
-        const body = await res.json();
-        for (const event of body.events) {
-          since = event.id;
-          opts.onEvent(event);
-        }
-        if (body.cursor) {
-          since = body.cursor;
-        }
-      }
-    } catch {
-      if (opts.abortSignal.aborted) {
-        return;
-      }
-    }
-    await new Promise((resolve) => {
-      const onAbort = () => {
-        clearTimeout(timer);
-        resolve();
-      };
-      const timer = setTimeout(() => {
-        opts.abortSignal.removeEventListener("abort", onAbort);
-        resolve();
-      }, interval);
-      opts.abortSignal.addEventListener("abort", onAbort, { once: true });
-    });
-  }
-}
 async function fetchStreamTip(client) {
   const PAGE_LIMIT = 500;
   const MAX_PAGES = 10;
   let tip;
+  const authHeaders = client.apiKey ? { Authorization: `Bearer ${client.apiKey}` } : { [STUDIO_SESSION_SCOPE_HEADER]: STUDIO_SESSION_SCOPE_VALUE };
   try {
     for (let page = 0; page < MAX_PAGES; page++) {
       const url2 = new URL(`${client.serviceUrl}/api/studio/events`);
@@ -8984,7 +8896,7 @@ async function fetchStreamTip(client) {
         url2.searchParams.set("since", tip);
       }
       const res = await fetch(url2.toString(), {
-        headers: { Authorization: `Bearer ${client.apiKey}` }
+        headers: authHeaders
       });
       if (!res.ok) {
         return tip;
@@ -9004,18 +8916,24 @@ async function fetchStreamTip(client) {
   }
   return tip;
 }
-async function navigateStudio(client, path15) {
-  if (!isValidStudioRoute(path15)) {
-    throw new Error(`Studio route not allowed: ${path15}`);
+async function closeStudio(client, message) {
+  return pushAgentSessionEvent(client, {
+    type: "agent:close-studio",
+    data: message ? { message } : {}
+  });
+}
+async function navigateStudio(client, path18) {
+  if (!isValidStudioRoute(path18)) {
+    throw new Error(`Studio route not allowed: ${path18}`);
   }
   return pushAgentSessionEvent(client, {
     type: "agent:navigate",
-    data: { path: path15 }
+    data: { path: path18 }
   });
 }
 var STUDIO_NAVIGATE_ACK_TIMEOUT_MS = 12e3;
 var PING_PONG_TIMEOUT_MS = 5e3;
-function awaitNavigateAck(client, path15, ackTimeoutMs, startCursor) {
+function awaitNavigateAck(client, path18, ackTimeoutMs, startCursor) {
   const abortController = new AbortController();
   let timer = null;
   const result = new Promise((resolve) => {
@@ -9023,7 +8941,7 @@ function awaitNavigateAck(client, path15, ackTimeoutMs, startCursor) {
       resolve({ acked: false, reason: "timeout" });
       abortController.abort();
     }, ackTimeoutMs);
-    const pathOnly = path15.split("?")[0];
+    const pathOnly = path18.split("?")[0];
     pollAgentSessionEvents({
       serviceUrl: client.serviceUrl,
       apiKey: client.apiKey,
@@ -9109,18 +9027,18 @@ function awaitPong(client, pingTs) {
     });
   });
 }
-async function navigateStudioAndAwaitAck(client, path15, opts = {}) {
+async function navigateStudioAndAwaitAck(client, path18, opts = {}) {
   const ackTimeoutMs = opts.ackTimeoutMs ?? STUDIO_NAVIGATE_ACK_TIMEOUT_MS;
-  if (!isValidStudioRoute(path15)) {
+  if (!isValidStudioRoute(path18)) {
     return { acked: false, reason: "invalid-route" };
   }
   const startCursor = await fetchStreamTip(client);
   try {
-    await navigateStudio(client, path15);
+    await navigateStudio(client, path18);
   } catch {
     return { acked: false, reason: "push-failed" };
   }
-  const result = await awaitNavigateAck(client, path15, ackTimeoutMs, startCursor);
+  const result = await awaitNavigateAck(client, path18, ackTimeoutMs, startCursor);
   if (result.acked || result.reason !== "timeout") {
     return result;
   }
@@ -9181,9 +9099,9 @@ var GLOBAL_CONFIG_FILE = path3.join(GLOBAL_CONFIG_DIR, "config.json");
 var GLOBAL_CREDENTIALS_FILE = path3.join(GLOBAL_CONFIG_DIR, "credentials.json");
 var PROJECT_CONFIG_RELATIVE = path3.join(".bitfab", "config.local.json");
 var PROJECT_CREDENTIALS_RELATIVE = path3.join(".bitfab", "credentials.local.json");
-function readJsonFile(filePath2) {
+function readJsonFile(filePath) {
   try {
-    const content = fs3.readFileSync(filePath2, "utf-8");
+    const content = fs3.readFileSync(filePath, "utf-8");
     return JSON.parse(content);
   } catch {
     return null;
@@ -9204,18 +9122,18 @@ function findProjectFile(relativePath, startDir = process.cwd()) {
   }
 }
 function getProjectConfigData() {
-  const filePath2 = findProjectFile(PROJECT_CONFIG_RELATIVE);
-  if (!filePath2) {
+  const filePath = findProjectFile(PROJECT_CONFIG_RELATIVE);
+  if (!filePath) {
     return null;
   }
-  return readJsonFile(filePath2);
+  return readJsonFile(filePath);
 }
 function getProjectCredentialsData() {
-  const filePath2 = findProjectFile(PROJECT_CREDENTIALS_RELATIVE);
-  if (!filePath2) {
+  const filePath = findProjectFile(PROJECT_CREDENTIALS_RELATIVE);
+  if (!filePath) {
     return null;
   }
-  return readJsonFile(filePath2) ?? {};
+  return readJsonFile(filePath) ?? {};
 }
 function getConfigData() {
   return readJsonFile(GLOBAL_CONFIG_FILE) ?? {};
@@ -9345,10 +9263,34 @@ function buildBitfabRequestHeaders(apiKey, pluginVersion, platform2) {
 
 // ../bitfab-plugin-lib/dist/activeStudioSession.js
 import { execFileSync as execFileSync2 } from "child_process";
+import crypto4 from "crypto";
+import fs7 from "fs";
+import os7 from "os";
+import path6 from "path";
+
+// ../bitfab-plugin-lib/dist/agentSessionKey.js
 import crypto3 from "crypto";
 import fs6 from "fs";
 import os6 from "os";
 import path5 from "path";
+var FALLBACK_KEY_PATH = path5.join(os6.homedir(), ".config", "bitfab", "agent-session-key");
+function readOrCreateFallbackKey() {
+  try {
+    const existing = fs6.readFileSync(FALLBACK_KEY_PATH, "utf-8").trim();
+    if (existing) {
+      return existing;
+    }
+  } catch {
+  }
+  const key = crypto3.randomUUID();
+  fs6.mkdirSync(path5.dirname(FALLBACK_KEY_PATH), { recursive: true });
+  fs6.writeFileSync(FALLBACK_KEY_PATH, `${key}
+`);
+  return key;
+}
+function resolveAgentSessionKey() {
+  return process.env.CLAUDE_CODE_SESSION_ID ?? process.env.CURSOR_SESSION_ID ?? process.env.CODEX_THREAD_ID ?? readOrCreateFallbackKey();
+}
 
 // ../bitfab-plugin-lib/dist/getAgentSessionId.js
 function getAgentSessionId() {
@@ -9356,186 +9298,104 @@ function getAgentSessionId() {
 }
 
 // ../bitfab-plugin-lib/dist/activeStudioSession.js
+var SESSIONS_DIR = path6.join(os7.homedir(), ".config", "bitfab", "sessions");
 function shortHash(input) {
-  return crypto3.createHash("sha256").update(input).digest("hex").slice(0, 16);
+  return crypto4.createHash("sha256").update(input).digest("hex").slice(0, 16);
 }
-function sessionScope() {
-  return shortHash(getAgentSessionId() ?? process.cwd());
+function sessionFilePathForKey(key) {
+  return path6.join(SESSIONS_DIR, `${shortHash(key)}.json`);
 }
-function filePath() {
-  return path5.join(os6.homedir(), ".config", "bitfab", `active-studio-session.${sessionScope()}.json`);
+function sessionFilePath() {
+  return sessionFilePathForKey(resolveAgentSessionKey());
 }
-function writeRecord(record2) {
-  const target = filePath();
-  fs6.mkdirSync(path5.dirname(target), { recursive: true });
+function writeStateFile(target, state) {
+  fs7.mkdirSync(path6.dirname(target), { recursive: true });
   const tmp = `${target}.${process.pid}.tmp`;
-  fs6.writeFileSync(tmp, `${JSON.stringify(record2, null, 2)}
+  fs7.writeFileSync(tmp, `${JSON.stringify(state, null, 2)}
 `);
-  fs6.renameSync(tmp, target);
-}
-function writeActiveStudioSession(session) {
-  writeRecord({
-    ...session,
-    pid: process.pid,
-    startedAt: (/* @__PURE__ */ new Date()).toISOString()
-  });
-}
-function isProcessAlive(pid) {
-  try {
-    process.kill(pid, 0);
-    return true;
-  } catch (err) {
-    return err.code === "EPERM";
-  }
-}
-function processStartToken(pid) {
-  try {
-    const out = execFileSync2("ps", ["-o", "lstart=", "-p", String(pid)], {
-      encoding: "utf-8",
-      stdio: ["ignore", "pipe", "ignore"],
-      // Bound it: a local `ps -p` is instant, but with no timeout a wedged `ps`
-      // (severe load, a stuck process table) could block the monitor claim. On
-      // timeout this throws, we return null, and the caller degrades to a plain
-      // liveness check — never a hang.
-      timeout: 2e3
-    }).trim();
-    return out || null;
-  } catch {
-    return null;
-  }
+  fs7.renameSync(tmp, target);
 }
-function clearActiveStudioSession(sessionId, opts = {}) {
+function readStateFile(filePath) {
   try {
-    const current = readActiveStudioSessionRaw();
-    if (!current || current.sessionId !== sessionId) {
-      return false;
-    }
-    if (!opts.force && current.pid !== process.pid && isProcessAlive(current.pid)) {
-      return false;
-    }
-    fs6.unlinkSync(filePath());
-    return true;
-  } catch {
-    return false;
-  }
-}
-function readActiveStudioSessionRaw() {
-  try {
-    const raw = fs6.readFileSync(filePath(), "utf-8");
+    const raw = fs7.readFileSync(filePath, "utf-8");
     const parsed = JSON.parse(raw);
-    if (parsed.closedAt != null || parsed.endedAt != null) {
+    if (typeof parsed.sessionId !== "string" || typeof parsed.serviceUrl !== "string") {
       return null;
     }
-    if (typeof parsed.sessionId === "string" && typeof parsed.serviceUrl === "string" && typeof parsed.pid === "number" && typeof parsed.startedAt === "string") {
-      return {
-        sessionId: parsed.sessionId,
-        serviceUrl: parsed.serviceUrl,
-        pid: parsed.pid,
-        startedAt: parsed.startedAt,
-        ...typeof parsed.windowPid === "number" ? { windowPid: parsed.windowPid } : {}
-      };
-    }
-    return null;
+    return parsed;
   } catch {
     return null;
   }
 }
-function readActiveStudioSession() {
-  return readActiveStudioSessionRaw();
-}
-function monitorLockPath() {
-  return path5.join(os6.homedir(), ".config", "bitfab", `active-studio-session.${sessionScope()}.monitor.lock`);
-}
-function tryClaimStudioMonitor() {
-  const lock = monitorLockPath();
-  fs6.mkdirSync(path5.dirname(lock), { recursive: true });
-  for (let attempt = 0; attempt < 10; attempt++) {
-    try {
-      const fd = fs6.openSync(lock, "wx");
-      fs6.writeSync(fd, monitorLockBody(process.pid));
-      fs6.closeSync(fd);
-      stampMonitorPid();
-      return true;
-    } catch (err) {
-      if (err.code !== "EEXIST") {
-        throw err;
-      }
-      const owner = readLockOwner(lock);
-      if (owner?.pid === process.pid) {
-        return true;
-      }
-      if (owner && isMonitorOwnerLive(owner)) {
-        return false;
-      }
-      try {
-        fs6.unlinkSync(lock);
-      } catch {
-      }
-    }
-  }
-  stampMonitorPid();
-  return true;
+function legacySessionScope() {
+  return shortHash(getAgentSessionId() ?? process.cwd());
 }
-function claimStudioMonitor() {
-  try {
-    const lock = monitorLockPath();
-    fs6.mkdirSync(path5.dirname(lock), { recursive: true });
-    fs6.writeFileSync(lock, monitorLockBody(process.pid));
-  } catch {
-  }
-  stampMonitorPid();
+function legacyFilePath() {
+  return path6.join(os7.homedir(), ".config", "bitfab", `active-studio-session.${legacySessionScope()}.json`);
 }
-function releaseStudioMonitor() {
+function readLegacySession() {
   try {
-    const lock = monitorLockPath();
-    if (readLockOwner(lock)?.pid === process.pid) {
-      fs6.unlinkSync(lock);
+    const raw = fs7.readFileSync(legacyFilePath(), "utf-8");
+    const parsed = JSON.parse(raw);
+    if (parsed.closedAt != null || parsed.endedAt != null) {
+      return null;
     }
-  } catch {
-  }
-}
-function monitorLockBody(pid) {
-  return `${pid}
-${processStartToken(pid) ?? ""}`;
-}
-function isMonitorOwnerLive(owner) {
-  if (!isProcessAlive(owner.pid)) {
-    return false;
-  }
-  if (!owner.start) {
-    return true;
-  }
-  const current = processStartToken(owner.pid);
-  if (current === null) {
-    return true;
-  }
-  return current === owner.start;
-}
-function readLockOwner(lock) {
-  try {
-    const [pidLine = "", ...rest] = fs6.readFileSync(lock, "utf-8").split("\n");
-    const pid = Number.parseInt(pidLine.trim(), 10);
-    if (!Number.isInteger(pid)) {
+    if (typeof parsed.sessionId !== "string" || typeof parsed.serviceUrl !== "string" || typeof parsed.pid !== "number" || typeof parsed.startedAt !== "string") {
       return null;
     }
-    return { pid, start: rest.join("\n").trim() };
+    const legacy = parsed;
+    return {
+      sessionId: legacy.sessionId,
+      serviceUrl: legacy.serviceUrl,
+      windowPid: legacy.windowPid ?? null,
+      pollerPid: legacy.pid,
+      source: "direct",
+      openedAt: legacy.startedAt,
+      currentPath: null,
+      authenticated: true,
+      windowState: "open",
+      agentIntent: "open",
+      lastBrowserPingAt: null,
+      browserConnected: false,
+      lastEventAt: null,
+      lastEventCursor: null,
+      agentSessionKey: null
+    };
   } catch {
     return null;
   }
 }
-function stampMonitorPid() {
-  const current = readActiveStudioSessionRaw();
-  if (current) {
-    writeRecord({ ...current, pid: process.pid });
-  }
+function writeActiveStudioSession(init) {
+  const state = {
+    sessionId: init.sessionId,
+    serviceUrl: init.serviceUrl,
+    windowPid: init.windowPid ?? null,
+    pollerPid: process.pid,
+    source: init.source ?? "direct",
+    openedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    currentPath: init.currentPath ?? null,
+    authenticated: init.authenticated ?? true,
+    windowState: "open",
+    agentIntent: "open",
+    lastBrowserPingAt: null,
+    browserConnected: false,
+    lastEventAt: null,
+    lastEventCursor: null,
+    agentSessionKey: null
+  };
+  writeStateFile(sessionFilePath(), state);
 }
-
-// ../bitfab-plugin-lib/dist/output.js
-function blockingNote(until) {
-  return `BLOCKING: this command does not exit until ${until}. Agents: run it in the background and read its stdout incrementally. A foreground call hangs the conversation until the process exits.`;
+function readActiveStudioSession() {
+  return readStateFile(sessionFilePath()) ?? readLegacySession();
 }
-function printBlockingNotice(until) {
-  console.error(blockingNote(until));
+function updateActiveStudioSession(updates) {
+  const current = readStateFile(sessionFilePath());
+  if (!current) {
+    return null;
+  }
+  const updated = { ...current, ...updates };
+  writeStateFile(sessionFilePath(), updated);
+  return updated;
 }
 
 // ../bitfab-plugin-lib/dist/parseArgs.js
@@ -9604,42 +9464,15 @@ function extractCommandName(argv) {
   return argv[1]?.replace(/.*\//, "").replace(/\.[jt]s$/, "") ?? "command";
 }
 
-// ../bitfab-plugin-lib/dist/studioTeardown.js
-var WINDOW_CLOSE_GRACE_PERIOD_MS = 1e4;
-function createWindowCloseArbiter(handlers, graceMs = WINDOW_CLOSE_GRACE_PERIOD_MS) {
-  let graceTimer = null;
-  const cancel3 = () => {
-    if (graceTimer) {
-      clearTimeout(graceTimer);
-      graceTimer = null;
-    }
-  };
-  return {
-    handleEvent(event) {
-      if (event.type === "studio:window-closed") {
-        cancel3();
-        graceTimer = setTimeout(() => {
-          graceTimer = null;
-          handlers.onConfirmed(event);
-        }, graceMs);
-        return;
-      }
-      if (event.type === "studio:session-started" && graceTimer) {
-        cancel3();
-        handlers.onRefuted?.();
-      }
-    },
-    hasPendingCandidate: () => graceTimer != null,
-    cancel: cancel3
-  };
-}
+// ../bitfab-plugin-lib/dist/studioChannel.js
+import crypto6 from "crypto";
 
 // ../bitfab-plugin-lib/dist/browser.js
 import { execSync, spawn } from "child_process";
-import fs7 from "fs";
-import os7 from "os";
+import fs8 from "fs";
+import os8 from "os";
 function getChromiumBrowsers() {
-  const platform2 = os7.platform();
+  const platform2 = os8.platform();
   if (platform2 === "darwin") {
     return [
       {
@@ -9727,7 +9560,7 @@ function getChromiumBrowsers() {
 function findExistingBinary(paths) {
   for (const candidate of paths) {
     if (candidate.includes("/") || candidate.includes("\\")) {
-      if (fs7.existsSync(candidate)) {
+      if (fs8.existsSync(candidate)) {
         return candidate;
       }
     } else {
@@ -9741,10 +9574,10 @@ function findExistingBinary(paths) {
   return null;
 }
 function getDefaultBrowserId() {
-  const platform2 = os7.platform();
+  const platform2 = os8.platform();
   try {
     if (platform2 === "darwin") {
-      const plistPath = `${os7.homedir()}/Library/Preferences/com.apple.LaunchServices/com.apple.launchservices.secure.plist`;
+      const plistPath = `${os8.homedir()}/Library/Preferences/com.apple.LaunchServices/com.apple.launchservices.secure.plist`;
       const json2 = execSync(`plutil -convert json -o - "${plistPath}"`, {
         stdio: ["ignore", "pipe", "ignore"],
         encoding: "utf-8",
@@ -9785,7 +9618,7 @@ function matchChromiumBrowser(defaultId, browsers) {
 var SCREEN_FRACTION = 0.95;
 function getWorkArea() {
   try {
-    const platform2 = os7.platform();
+    const platform2 = os8.platform();
     if (platform2 === "darwin") {
       const out = execSync(`osascript -l JavaScript -e 'ObjC.import("AppKit"); const s = $.NSScreen.mainScreen; const f = s.frame; const v = s.visibleFrame; const topY = f.size.height - (v.origin.y + v.size.height); JSON.stringify([v.origin.x, topY, v.size.width, v.size.height])'`, {
         stdio: ["ignore", "pipe", "ignore"],
@@ -9845,6 +9678,9 @@ function getWindowSizeArgs() {
   return computeWindowArgs(getWorkArea());
 }
 function spawnDetached(command, args) {
+  if (process.env.VITEST || process.env.NODE_ENV === "test") {
+    throw new Error("spawnDetached called in a test environment without being mocked");
+  }
   const child = spawn(command, [...args], { detached: true, stdio: "ignore" });
   child.on("error", () => {
   });
@@ -9855,14 +9691,14 @@ function openChromiumApp(binaryPath, url2, sizeArgs) {
   return spawnDetached(binaryPath, [`--app=${url2}`, ...sizeArgs]);
 }
 function openOsDefault(url2) {
-  const platform2 = os7.platform();
+  const platform2 = os8.platform();
   if (platform2 === "darwin") {
-    spawnDetached("open", [url2]);
-  } else if (platform2 === "win32") {
-    spawnDetached("cmd", ["/c", "start", "", url2]);
-  } else {
-    spawnDetached("xdg-open", [url2]);
+    return spawnDetached("open", [url2]);
+  }
+  if (platform2 === "win32") {
+    return spawnDetached("cmd", ["/c", "start", "", url2]);
   }
+  return spawnDetached("xdg-open", [url2]);
 }
 function isCodexOnMacos() {
   if (process.platform !== "darwin") {
@@ -9876,7 +9712,22 @@ function shouldDisableChromelessWindows() {
   }
   return isCodexOnMacos();
 }
+var WINDOW_OPEN_RATE_WINDOW_MS = 3e4;
+var WINDOW_OPEN_RATE_LIMIT = 3;
+var recentOpens = [];
 function openChromelessWindow(url2) {
+  if (process.env.VITEST || process.env.NODE_ENV === "test") {
+    throw new Error("openChromelessWindow called in a test environment without being mocked");
+  }
+  const now = Date.now();
+  while (recentOpens.length > 0 && now - recentOpens[0] > WINDOW_OPEN_RATE_WINDOW_MS) {
+    recentOpens.shift();
+  }
+  if (recentOpens.length >= WINDOW_OPEN_RATE_LIMIT) {
+    console.error(`[browser] rate limit: ${recentOpens.length} windows opened in the last ${WINDOW_OPEN_RATE_WINDOW_MS / 1e3}s, refusing to open another`);
+    return null;
+  }
+  recentOpens.push(now);
   if (shouldDisableChromelessWindows()) {
     openOsDefault(url2);
     return null;
@@ -9932,11 +9783,555 @@ async function createStudioSession({ serviceUrl, apiKey, sessionId, initialPath
   writeActiveStudioSession({
     sessionId,
     serviceUrl,
-    windowPid: windowPid ?? void 0
+    windowPid,
+    currentPath: initialPath
   });
   return { sessionId, serviceUrl };
 }
 
+// ../bitfab-plugin-lib/dist/daemon/client.js
+import net2 from "net";
+
+// ../bitfab-plugin-lib/dist/daemon/ensure.js
+import { fork } from "child_process";
+import crypto5 from "crypto";
+import fs9 from "fs";
+import net from "net";
+import path8 from "path";
+import { fileURLToPath as fileURLToPath2 } from "url";
+
+// ../bitfab-plugin-lib/dist/daemon/protocol.js
+import os9 from "os";
+import path7 from "path";
+var BITFAB_CONFIG_DIR = path7.join(os9.homedir(), ".config", "bitfab");
+var SOCKET_PATH = path7.join(BITFAB_CONFIG_DIR, "studio-daemon.sock");
+var PID_FILE_PATH = path7.join(BITFAB_CONFIG_DIR, "studio-daemon.pid");
+var BROWSER_HEALTH_INTERVAL_MS = 10 * 1e3;
+var ENSURE_POLL_INTERVAL_MS = 200;
+var ENSURE_TIMEOUT_MS = 5e3;
+var PING_TIMEOUT_MS = 2e3;
+function serialize(msg) {
+  return `${JSON.stringify(msg)}
+`;
+}
+function isResponse(msg) {
+  return typeof msg === "object" && msg !== null && "ok" in msg;
+}
+function isPush(msg) {
+  return typeof msg === "object" && msg !== null && "event" in msg;
+}
+
+// ../bitfab-plugin-lib/dist/daemon/ensure.js
+var LOCK_STALE_MS = 1e4;
+function processIsAlive(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (err) {
+    return err.code !== "ESRCH";
+  }
+}
+function readPid(pidPath) {
+  try {
+    const raw = fs9.readFileSync(pidPath, "utf-8").trim();
+    const pid = Number.parseInt(raw, 10);
+    return Number.isNaN(pid) ? null : pid;
+  } catch {
+    return null;
+  }
+}
+async function pingSocket(socketPath) {
+  return new Promise((resolve) => {
+    const timeout = setTimeout(() => {
+      socket.destroy();
+      resolve({ alive: false, build: null });
+    }, PING_TIMEOUT_MS);
+    const socket = net.createConnection(socketPath, () => {
+      socket.write('{"cmd":"ping"}\n');
+    });
+    let buffer = "";
+    socket.on("data", (chunk) => {
+      buffer += chunk.toString();
+      if (buffer.includes("\n")) {
+        clearTimeout(timeout);
+        socket.destroy();
+        try {
+          const msg = JSON.parse(buffer.split("\n")[0]);
+          resolve({ alive: msg.ok === true, build: msg.build ?? null });
+        } catch {
+          resolve({ alive: false, build: null });
+        }
+      }
+    });
+    socket.on("error", () => {
+      clearTimeout(timeout);
+      resolve({ alive: false, build: null });
+    });
+  });
+}
+async function waitForSocket(socketPath, timeoutMs) {
+  const deadline = Date.now() + timeoutMs;
+  while (Date.now() < deadline) {
+    const { alive } = await pingSocket(socketPath);
+    if (alive) {
+      return;
+    }
+    await new Promise((r) => setTimeout(r, ENSURE_POLL_INTERVAL_MS));
+  }
+  throw new Error(`daemon did not become ready within ${timeoutMs}ms`);
+}
+function localBuildFingerprint() {
+  try {
+    const thisDir = path8.dirname(fileURLToPath2(import.meta.url));
+    const serverPath = path8.join(thisDir, "server.js");
+    const content = fs9.readFileSync(serverPath);
+    return crypto5.createHash("sha256").update(content).digest("hex").slice(0, 16);
+  } catch {
+    return "unknown";
+  }
+}
+async function killDaemon(pidPath, socketPath) {
+  const pid = readPid(pidPath);
+  if (pid !== null) {
+    try {
+      process.kill(pid, "SIGTERM");
+    } catch {
+    }
+    const deadline = Date.now() + 5e3;
+    while (processIsAlive(pid) && Date.now() < deadline) {
+      await new Promise((r) => setTimeout(r, 50));
+    }
+    if (processIsAlive(pid)) {
+      try {
+        process.kill(pid, "SIGKILL");
+      } catch {
+      }
+    }
+  }
+  cleanupStaleFiles(socketPath, pidPath);
+}
+function spawnDaemon(socketPath, pidPath) {
+  const thisDir = path8.dirname(fileURLToPath2(import.meta.url));
+  const mainPath = path8.join(thisDir, "main.js");
+  if (!fs9.existsSync(mainPath)) {
+    throw new DaemonUnavailableError(`daemon entry point not found: ${mainPath}`);
+  }
+  const child = fork(mainPath, [socketPath, pidPath], {
+    detached: true,
+    stdio: "ignore",
+    execArgv: []
+  });
+  child.unref();
+}
+function cleanupStaleFiles(socketPath, pidPath) {
+  try {
+    fs9.unlinkSync(socketPath);
+  } catch {
+  }
+  try {
+    fs9.unlinkSync(pidPath);
+  } catch {
+  }
+}
+function lockPath(socketPath) {
+  return `${socketPath}.lock`;
+}
+function acquireLock(socketPath) {
+  const lock = lockPath(socketPath);
+  try {
+    fs9.mkdirSync(path8.dirname(lock), { recursive: true });
+    fs9.writeFileSync(lock, `${process.pid}
+`, { flag: "wx" });
+    return true;
+  } catch (err) {
+    if (err.code !== "EEXIST") {
+      return true;
+    }
+    try {
+      const stat = fs9.statSync(lock);
+      if (Date.now() - stat.mtimeMs > LOCK_STALE_MS) {
+        fs9.unlinkSync(lock);
+        fs9.writeFileSync(lock, `${process.pid}
+`, { flag: "wx" });
+        return true;
+      }
+    } catch {
+    }
+    return false;
+  }
+}
+function releaseLock(socketPath) {
+  try {
+    fs9.unlinkSync(lockPath(socketPath));
+  } catch {
+  }
+}
+async function ensureDaemon(socketPath = SOCKET_PATH, pidPath = PID_FILE_PATH) {
+  const pid = readPid(pidPath);
+  if (pid !== null && processIsAlive(pid)) {
+    const ping = await pingSocket(socketPath);
+    if (ping.alive) {
+      const localBuild = localBuildFingerprint();
+      if (ping.build && ping.build !== localBuild && localBuild !== "unknown") {
+        console.error(`[daemon] build mismatch (running: ${ping.build}, local: ${localBuild}), restarting`);
+        await killDaemon(pidPath, socketPath);
+      } else {
+        return;
+      }
+    }
+  }
+  if (!acquireLock(socketPath)) {
+    await waitForSocket(socketPath, ENSURE_TIMEOUT_MS);
+    return;
+  }
+  try {
+    cleanupStaleFiles(socketPath, pidPath);
+    spawnDaemon(socketPath, pidPath);
+    await waitForSocket(socketPath, ENSURE_TIMEOUT_MS);
+  } finally {
+    releaseLock(socketPath);
+  }
+}
+
+// ../bitfab-plugin-lib/dist/daemon/client.js
+var DaemonClient = class {
+  socket = null;
+  buffer = "";
+  responseQueue = [];
+  eventHandler = null;
+  socketPath;
+  constructor(socketPath) {
+    this.socketPath = socketPath ?? SOCKET_PATH;
+  }
+  async connect() {
+    await ensureDaemon(this.socketPath);
+    return new Promise((resolve, reject) => {
+      const socket = net2.createConnection(this.socketPath, () => {
+        this.socket = socket;
+        resolve();
+      });
+      socket.on("data", (chunk) => {
+        this.buffer += chunk.toString();
+        this.drain();
+      });
+      socket.on("error", (err) => {
+        if (!this.socket) {
+          reject(err);
+          return;
+        }
+        this.socket = null;
+      });
+      socket.on("close", () => {
+        this.socket = null;
+      });
+    });
+  }
+  drain() {
+    let idx = this.buffer.indexOf("\n");
+    while (idx !== -1) {
+      const line = this.buffer.slice(0, idx).trim();
+      this.buffer = this.buffer.slice(idx + 1);
+      if (line) {
+        try {
+          const msg = JSON.parse(line);
+          if (isResponse(msg) && this.responseQueue.length > 0) {
+            const resolver = this.responseQueue.shift();
+            resolver(msg);
+          } else if (isPush(msg) && this.eventHandler) {
+            this.eventHandler(msg);
+          }
+        } catch {
+        }
+      }
+      idx = this.buffer.indexOf("\n");
+    }
+  }
+  sendCommand(cmd) {
+    if (!this.socket) {
+      return Promise.reject(new Error("not connected"));
+    }
+    return new Promise((resolve, reject) => {
+      this.responseQueue.push(resolve);
+      try {
+        this.socket.write(serialize(cmd));
+      } catch (err) {
+        this.responseQueue.pop();
+        reject(err);
+      }
+    });
+  }
+  async open(opts) {
+    const cmd = { cmd: "open", ...opts };
+    const res = await this.sendCommand(cmd);
+    if (!res.ok) {
+      throw new Error(res.error);
+    }
+    return res;
+  }
+  async navigate(key, navPath) {
+    const res = await this.sendCommand({ cmd: "navigate", key, path: navPath });
+    if (!res.ok) {
+      throw new Error(res.error);
+    }
+    return res;
+  }
+  async close(key) {
+    const res = await this.sendCommand({ cmd: "close", key });
+    if (!res.ok) {
+      throw new Error(res.error);
+    }
+  }
+  async detach(key) {
+    const res = await this.sendCommand({ cmd: "detach", key });
+    if (!res.ok) {
+      throw new Error(res.error);
+    }
+  }
+  async status() {
+    const res = await this.sendCommand({ cmd: "status" });
+    if (!res.ok) {
+      throw new Error(res.error);
+    }
+    return res;
+  }
+  async ping() {
+    const res = await this.sendCommand({ cmd: "ping" });
+    if (!res.ok) {
+      throw new Error(res.error);
+    }
+  }
+  onEvent(handler) {
+    this.eventHandler = handler;
+  }
+  destroy() {
+    this.eventHandler = null;
+    this.responseQueue = [];
+    if (this.socket) {
+      this.socket.destroy();
+      this.socket = null;
+    }
+  }
+};
+
+// ../bitfab-plugin-lib/dist/studioChannel.js
+var DirectChannel = class {
+  apiKey;
+  serviceUrl;
+  constructor(apiKey, serviceUrl) {
+    this.apiKey = apiKey;
+    this.serviceUrl = serviceUrl;
+  }
+  setApiKey(apiKey) {
+    this.apiKey = apiKey;
+  }
+  async openOrNavigate(path18, opts) {
+    if (!this.apiKey) {
+      const sessionId2 = opts?.sessionId ?? crypto6.randomUUID();
+      const initialPath = path18.startsWith("/studio") ? path18 : "/studio";
+      if (!isValidStudioRoute(initialPath)) {
+        throw new Error(`Studio route not allowed: ${initialPath}`);
+      }
+      const url2 = initialPath.includes("session=") ? `${this.serviceUrl}${initialPath}` : `${this.serviceUrl}${initialPath}${initialPath.includes("?") ? "&" : "?"}session=${encodeURIComponent(sessionId2)}`;
+      const windowPid = openChromelessWindow(url2);
+      writeActiveStudioSession({
+        sessionId: sessionId2,
+        serviceUrl: this.serviceUrl,
+        windowPid,
+        currentPath: initialPath
+      });
+      return { sessionId: sessionId2, opened: true };
+    }
+    const existing = readActiveStudioSession();
+    if (existing && existing.windowState !== "closed") {
+      const ack = await navigateStudioAndAwaitAck({
+        serviceUrl: existing.serviceUrl,
+        apiKey: this.apiKey,
+        sessionId: existing.sessionId
+      }, path18);
+      if (!ack.acked) {
+        throw new StudioNavigationError(ack.reason ?? "unknown", ack.blockedReason, existing.sessionId);
+      }
+      return { sessionId: existing.sessionId, opened: false };
+    }
+    const sessionId = opts?.sessionId ?? crypto6.randomUUID();
+    const session = await createStudioSession({
+      serviceUrl: this.serviceUrl,
+      apiKey: this.apiKey,
+      sessionId,
+      initialPath: path18,
+      clientHeaders: opts?.clientHeaders
+    });
+    return { sessionId: session.sessionId, opened: true };
+  }
+  async close(sessionId, message) {
+    await closeStudio({ serviceUrl: this.serviceUrl, apiKey: this.apiKey, sessionId }, message);
+  }
+  subscribe(sessionId, onEvent, onError) {
+    const abortController = new AbortController();
+    const done = (async () => {
+      const startCursor = await fetchStreamTip({
+        serviceUrl: this.serviceUrl,
+        apiKey: this.apiKey,
+        sessionId
+      });
+      if (abortController.signal.aborted) {
+        return;
+      }
+      await pollAgentSessionEvents({
+        serviceUrl: this.serviceUrl,
+        apiKey: this.apiKey,
+        sessionId,
+        startCursor,
+        abortSignal: abortController.signal,
+        onEvent,
+        onError
+      });
+    })().catch((err) => {
+      if (!abortController.signal.aborted) {
+        onError(err instanceof Error ? err : new Error(String(err)));
+      }
+    });
+    return { abort: () => abortController.abort(), done };
+  }
+  destroy() {
+  }
+};
+var DaemonChannel = class _DaemonChannel {
+  client;
+  key;
+  apiKey;
+  serviceUrl;
+  doneResolve = null;
+  constructor(client, key, apiKey, serviceUrl) {
+    this.client = client;
+    this.key = key;
+    this.apiKey = apiKey;
+    this.serviceUrl = serviceUrl;
+  }
+  static async connect(apiKey, serviceUrl) {
+    const client = new DaemonClient();
+    await client.connect();
+    const key = resolveAgentSessionKey();
+    return new _DaemonChannel(client, key, apiKey, serviceUrl);
+  }
+  setApiKey(apiKey) {
+    this.apiKey = apiKey;
+  }
+  async openOrNavigate(path18, opts) {
+    const openRes = await this.client.open({
+      key: this.key,
+      serviceUrl: this.serviceUrl,
+      apiKey: this.apiKey,
+      sessionId: opts?.sessionId,
+      initialPath: path18,
+      clientHeaders: opts?.clientHeaders
+    });
+    if (openRes.reconnected) {
+      const navRes = await this.client.navigate(this.key, path18);
+      if (!navRes.acked) {
+        this.client.destroy();
+        throw new StudioNavigationError(navRes.reason ?? "unknown", void 0, openRes.sessionId);
+      }
+      writeActiveStudioSession({
+        sessionId: openRes.sessionId,
+        serviceUrl: this.serviceUrl,
+        source: "daemon",
+        currentPath: path18
+      });
+      return { sessionId: openRes.sessionId, opened: false };
+    }
+    writeActiveStudioSession({
+      sessionId: openRes.sessionId,
+      serviceUrl: this.serviceUrl,
+      source: "daemon",
+      currentPath: path18
+    });
+    return { sessionId: openRes.sessionId, opened: true };
+  }
+  async close(sessionId, message) {
+    await Promise.all([
+      closeStudio({ serviceUrl: this.serviceUrl, apiKey: this.apiKey, sessionId }, message),
+      this.client.close(this.key).catch(() => {
+      })
+    ]);
+  }
+  subscribe(_sessionId, onEvent, _onError) {
+    const done = new Promise((resolve) => {
+      this.doneResolve = resolve;
+    });
+    this.client.onEvent((push) => {
+      const event = {
+        id: "",
+        type: push.event,
+        data: push.data
+      };
+      onEvent(event);
+    });
+    return {
+      abort: () => this.destroy(),
+      done
+    };
+  }
+  destroy() {
+    this.client.detach(this.key).catch(() => {
+    });
+    this.client.destroy();
+    if (this.doneResolve) {
+      this.doneResolve();
+      this.doneResolve = null;
+    }
+  }
+};
+function isDaemonEnabled() {
+  return process.env.BITFAB_STUDIO_DAEMON !== "0";
+}
+function withDirectFallback(primary, apiKey, serviceUrl) {
+  let active = primary;
+  return {
+    async openOrNavigate(path18, opts) {
+      try {
+        return await active.openOrNavigate(path18, opts);
+      } catch (err) {
+        if (err instanceof StudioNavigationError || active !== primary) {
+          throw err;
+        }
+        console.error(`daemon failed, falling back to direct: ${err instanceof Error ? err.message : String(err)}`);
+        active.destroy();
+        active = new DirectChannel(apiKey, serviceUrl);
+        return active.openOrNavigate(path18, opts);
+      }
+    },
+    async close(sessionId, message) {
+      await active.close(sessionId, message);
+    },
+    subscribe(sessionId, onEvent, onError) {
+      return active.subscribe(sessionId, onEvent, onError);
+    },
+    setApiKey(key) {
+      active.setApiKey(key);
+    },
+    destroy() {
+      active.destroy();
+    }
+  };
+}
+async function resolveChannel(apiKey, serviceUrl) {
+  if (isDaemonEnabled()) {
+    try {
+      const daemon = await DaemonChannel.connect(apiKey, serviceUrl);
+      return withDirectFallback(daemon, apiKey, serviceUrl);
+    } catch (err) {
+      if (err instanceof StudioNavigationError) {
+        throw err;
+      }
+      if (!(err instanceof DaemonUnavailableError)) {
+        console.error(`daemon unavailable, falling back to direct: ${err instanceof Error ? err.message : String(err)}`);
+      }
+    }
+  }
+  return new DirectChannel(apiKey, serviceUrl);
+}
+
 // ../bitfab-plugin-lib/dist/replayCapabilities.js
 var semver = __toESM(require_semver2(), 1);
 
@@ -9945,12 +10340,12 @@ var semver3 = __toESM(require_semver2(), 1);
 
 // ../bitfab-plugin-lib/dist/installedSdk.js
 var semver2 = __toESM(require_semver2(), 1);
-import fs9 from "fs";
-import path7 from "path";
+import fs11 from "fs";
+import path10 from "path";
 
 // ../bitfab-plugin-lib/dist/workspaces.js
-import fs8 from "fs";
-import path6 from "path";
+import fs10 from "fs";
+import path9 from "path";
 
 // ../bitfab-plugin-lib/dist/analytics.js
 async function reportHandoff(apiKey, pluginVersion, platform2, body) {
@@ -9974,11 +10369,11 @@ async function reportHandoff(apiKey, pluginVersion, platform2, body) {
 }
 
 // ../bitfab-plugin-lib/dist/commands/openStudioTo.js
-import crypto4 from "crypto";
+import crypto7 from "crypto";
 
 // ../bitfab-plugin-lib/dist/frontmostApp.js
 import { execFileSync as execFileSync3, spawn as spawn2 } from "child_process";
-import os8 from "os";
+import os10 from "os";
 function findAncestorApp() {
   try {
     let pid = process.ppid;
@@ -10039,7 +10434,7 @@ function focusItermSession(sessionId) {
   spawnQuiet("osascript", ["-e", script]);
 }
 function getFrontmostApp() {
-  const platform2 = os8.platform();
+  const platform2 = os10.platform();
   try {
     if (platform2 === "darwin") {
       return execFileSync3("osascript", [
@@ -10073,7 +10468,7 @@ function focusApp(identifier) {
   if (!identifier) {
     return;
   }
-  const platform2 = os8.platform();
+  const platform2 = os10.platform();
   if (platform2 === "darwin") {
     spawnQuiet("osascript", [
       "-e",
@@ -10102,145 +10497,144 @@ function focusApp(identifier) {
     spawnQuiet("powershell.exe", ["-NoProfile", "-Command", script]);
   }
 }
-function recordFocus() {
-  const platform2 = os8.platform();
-  if (platform2 === "linux") {
-    const windowId = process.env.WINDOWID;
-    if (windowId) {
-      return () => spawnQuiet("xdotool", ["windowactivate", windowId]);
-    }
-  }
-  if (platform2 === "darwin") {
-    const app = findAncestorApp();
-    if (app) {
-      const itermSessionId = process.env.ITERM_SESSION_ID ?? null;
-      return () => focusAncestorApp(app, itermSessionId);
-    }
-  }
-  const frontmost = getFrontmostApp();
-  return () => focusApp(frontmost);
-}
-
-// ../bitfab-plugin-lib/dist/commands/sessionReady.js
-var SESSION_READY_TIMEOUT_MS = 3e4;
-var SESSION_READY_POLL_MS = 500;
-async function waitForSessionReady(opts) {
-  const deadline = Date.now() + SESSION_READY_TIMEOUT_MS;
-  let since = null;
-  while (Date.now() < deadline) {
-    try {
-      const url2 = new URL(`${opts.serviceUrl}/api/studio/events`);
-      url2.searchParams.set("session", opts.sessionId);
-      if (since) {
-        url2.searchParams.set("since", since);
-      }
-      const res = await fetch(url2.toString(), {
-        headers: { Authorization: `Bearer ${opts.apiKey}` }
-      });
-      if (res.ok) {
-        const body = await res.json();
-        for (const event of body.events) {
-          since = event.id;
-          if (event.type === "studio:session-started") {
-            return;
-          }
-        }
-      }
-    } catch {
+function recordFocus() {
+  const platform2 = os10.platform();
+  if (platform2 === "linux") {
+    const windowId = process.env.WINDOWID;
+    if (windowId) {
+      return () => spawnQuiet("xdotool", ["windowactivate", windowId]);
+    }
+  }
+  if (platform2 === "darwin") {
+    const app = findAncestorApp();
+    if (app) {
+      const itermSessionId = process.env.ITERM_SESSION_ID ?? null;
+      return () => focusAncestorApp(app, itermSessionId);
     }
-    await new Promise((resolve) => setTimeout(resolve, SESSION_READY_POLL_MS));
   }
-  console.error("Warning: Studio session did not confirm readiness within 30s. Proceeding anyway.");
+  const frontmost = getFrontmostApp();
+  return () => focusApp(frontmost);
 }
 
 // ../bitfab-plugin-lib/dist/commands/openStudioTo.js
+var WINDOW_CLOSE_GRACE_PERIOD_MS = 1e4;
 var LOGIN_TIMEOUT_MS = 10 * 60 * 1e3;
-var BLOCKING_NOTICE_UNTIL = "the Studio interaction completes or the session ends";
-var REAUTH_ACK_TIMEOUT_MS = 2e4;
-var StudioNavigationError = class extends Error {
-  reason;
-  blockedReason;
-  staleSessionId;
-  constructor(reason, blockedReason, staleSessionId) {
-    super(blockedReason ? `Studio navigation failed (${reason}): ${blockedReason}` : `Studio navigation failed: ${reason}`);
-    this.reason = reason;
-    this.blockedReason = blockedReason;
-    this.staleSessionId = staleSessionId;
-    this.name = "StudioNavigationError";
-  }
-};
-async function openStudioTo(path15, opts = {}) {
+function createEventSubscription(channel, sessionId, onEvent, restoreFocus) {
+  let graceTimer = null;
+  let endedNotified = false;
+  const clearGraceTimer = () => {
+    if (graceTimer) {
+      clearTimeout(graceTimer);
+      graceTimer = null;
+    }
+  };
+  const notifyEnded = (baseEvent) => {
+    if (!endedNotified) {
+      endedNotified = true;
+      restoreFocus();
+      onEvent({ ...baseEvent, type: "studio:session-ended" });
+    }
+    clearGraceTimer();
+    sub.abort();
+  };
+  const sub = channel.subscribe(sessionId, (event) => {
+    if (event.type === "studio:window-closed") {
+      clearGraceTimer();
+      graceTimer = setTimeout(() => {
+        graceTimer = null;
+        updateActiveStudioSession({ windowState: "closed" });
+        notifyEnded(event);
+      }, WINDOW_CLOSE_GRACE_PERIOD_MS);
+      return;
+    }
+    if (event.type === "studio:session-started") {
+      if (graceTimer) {
+        clearGraceTimer();
+        console.error("Studio reconnected after page refresh");
+      }
+      return;
+    }
+    if (event.type === "studio:session-ended") {
+      clearGraceTimer();
+      notifyEnded(event);
+      return;
+    }
+    if (event.type === "studio:session-closed") {
+      return;
+    }
+    if (event.type === "studio:not-member") {
+      restoreFocus();
+      onEvent(event);
+      sub.abort();
+      return;
+    }
+    if (event.type === "studio:return-to-agent" || event.type === "studio:edit-with-agent") {
+      restoreFocus();
+    }
+    onEvent(event);
+  }, (err) => {
+    console.error(`studio event stream: ${err.message}`);
+  });
+  return {
+    abort: () => {
+      clearGraceTimer();
+      sub.abort();
+    },
+    done: sub.done
+  };
+}
+async function openStudioTo(path18, opts = {}) {
   const config2 = getConfig();
   const serviceUrl = config2.serviceUrl;
   const apiKey = !opts.forceLogin && hasCredentials() ? config2.apiKey : null;
   const noop = () => {
   };
   const restoreFocus = recordFocus();
+  const channel = await resolveChannel(apiKey ?? "", serviceUrl);
   if (!apiKey) {
-    const existing2 = readActiveStudioSession();
-    if (existing2) {
-      const reauth = await requestSessionReauth({
-        serviceUrl: existing2.serviceUrl,
-        sessionId: existing2.sessionId,
-        redirectPath: path15
-      });
-      if (!reauth.ok) {
-        throw new StudioNavigationError("push-failed", void 0, existing2.sessionId);
-      }
-      return loginViaExistingWindow({
-        serviceUrl: existing2.serviceUrl,
-        sessionId: existing2.sessionId,
-        startCursor: reauth.pushedEventId,
-        signInUrl: reauth.signInUrl,
-        restoreFocus,
-        opts
-      });
-    }
-    const sessionId2 = crypto4.randomUUID();
-    const freshPath = opts.freshWindowPath ?? path15;
-    const separator = freshPath.includes("?") ? "&" : "?";
-    const redirectPath = `${freshPath}${separator}session=${encodeURIComponent(sessionId2)}&pluginLogin=true`;
-    const signInPath = `/studio/sign-in?redirect_url=${encodeURIComponent(redirectPath)}`;
-    const signInUrl = `${serviceUrl}${signInPath}&session=${encodeURIComponent(sessionId2)}`;
-    const windowPid = openChromelessWindow(signInUrl);
-    writeActiveStudioSession({
-      sessionId: sessionId2,
-      serviceUrl,
-      windowPid: windowPid ?? void 0
+    const sessionId2 = crypto7.randomUUID();
+    const destination = opts.freshWindowPath ?? path18;
+    const destSeparator = destination.includes("?") ? "&" : "?";
+    const redirectPath = `${destination}${destSeparator}session=${encodeURIComponent(sessionId2)}&pluginLogin=true`;
+    const signInInitialPath = `/studio/sign-in?redirect_url=${encodeURIComponent(redirectPath)}&session=${encodeURIComponent(sessionId2)}`;
+    await channel.openOrNavigate(signInInitialPath, {
+      clientHeaders: opts.clientHeaders,
+      sessionId: sessionId2
     });
+    const signInUrl = `${serviceUrl}${signInInitialPath}`;
     opts.onLoginRequired?.(sessionId2, signInUrl);
-    const abortController = new AbortController();
-    const timer = setTimeout(() => abortController.abort(), LOGIN_TIMEOUT_MS);
-    const keepalive = setInterval(() => process.stderr.write(""), 3e4);
-    let loginApiKey;
-    try {
-      loginApiKey = await pollLoginEvents({
-        serviceUrl,
-        sessionId: sessionId2,
-        abortSignal: abortController.signal
+    const loginApiKey = await new Promise((resolve, reject) => {
+      const timer = setTimeout(() => {
+        sub.abort();
+        reject(new Error("Login polling aborted"));
+      }, LOGIN_TIMEOUT_MS);
+      const keepalive = setInterval(() => process.stderr.write(""), 3e4);
+      const cleanup = () => {
+        clearTimeout(timer);
+        clearInterval(keepalive);
+      };
+      const sub = channel.subscribe(sessionId2, (event) => {
+        if (event.type === "studio:authenticated" && typeof event.data?.token === "string") {
+          cleanup();
+          sub.abort();
+          resolve(event.data.token);
+        }
+      }, (err) => {
+        cleanup();
+        reject(err);
       });
-    } catch (err) {
-      clearTimeout(timer);
-      clearInterval(keepalive);
-      throw err;
-    }
-    clearTimeout(timer);
-    clearInterval(keepalive);
+    });
     saveCredentials(loginApiKey);
     opts.onAuthenticated?.(sessionId2);
+    channel.setApiKey(loginApiKey);
     if (opts.onEvent) {
-      await waitForSessionReady({
-        serviceUrl,
-        apiKey: loginApiKey,
-        sessionId: sessionId2
-      });
-      const poller2 = startEventPoller(serviceUrl, loginApiKey, sessionId2, opts.onEvent, restoreFocus, { claim: opts.monitor !== "wait" });
+      const subscription2 = createEventSubscription(channel, sessionId2, opts.onEvent, restoreFocus);
       return {
         sessionId: sessionId2,
         serviceUrl,
         apiKey: loginApiKey,
         opened: true,
-        ...poller2
+        ...subscription2
       };
     }
     restoreFocus();
@@ -10253,299 +10647,20 @@ async function openStudioTo(path15, opts = {}) {
       done: Promise.resolve()
     };
   }
-  const existing = readActiveStudioSession();
-  if (existing) {
-    const client = {
-      serviceUrl: existing.serviceUrl,
-      apiKey,
-      sessionId: existing.sessionId
-    };
-    const ack = await navigateStudioAndAwaitAck(client, path15);
-    if (!ack.acked) {
-      throw new StudioNavigationError(ack.reason ?? "unknown", ack.blockedReason, existing.sessionId);
-    }
-    if (opts.onEvent && opts.monitor === "wait") {
-      const poller2 = startEventPoller(existing.serviceUrl, apiKey, existing.sessionId, opts.onEvent, restoreFocus, { claim: false });
-      return {
-        sessionId: existing.sessionId,
-        serviceUrl: existing.serviceUrl,
-        apiKey,
-        opened: false,
-        ...poller2
-      };
-    }
-    if (opts.onEvent && opts.monitor === "start" && tryClaimStudioMonitor()) {
-      const poller2 = startEventPoller(existing.serviceUrl, apiKey, existing.sessionId, opts.onEvent, restoreFocus, { claim: true });
-      return {
-        sessionId: existing.sessionId,
-        serviceUrl: existing.serviceUrl,
-        apiKey,
-        opened: false,
-        ...poller2
-      };
-    }
-    restoreFocus();
-    return {
-      sessionId: existing.sessionId,
-      serviceUrl: existing.serviceUrl,
-      apiKey,
-      opened: false,
-      abort: noop,
-      done: Promise.resolve()
-    };
-  }
-  const sessionId = crypto4.randomUUID();
-  const session = await createStudioSession({
-    serviceUrl,
-    apiKey,
-    sessionId,
-    initialPath: path15,
+  const { sessionId, opened } = await channel.openOrNavigate(path18, {
     clientHeaders: opts.clientHeaders
   });
-  const poller = opts.onEvent ? startEventPoller(session.serviceUrl, apiKey, session.sessionId, opts.onEvent, restoreFocus, { claim: opts.monitor !== "wait" }) : { abort: noop, done: Promise.resolve() };
-  return {
-    sessionId: session.sessionId,
-    serviceUrl: session.serviceUrl,
-    apiKey,
-    opened: true,
-    ...poller
-  };
-}
-async function loginViaExistingWindow(args) {
-  const { serviceUrl, sessionId } = args;
-  const noop = () => {
-  };
-  const keepalive = setInterval(() => process.stderr.write(""), 3e4);
-  let loginApiKey;
-  try {
-    loginApiKey = await awaitReauthLogin({
-      serviceUrl,
-      sessionId,
-      startCursor: args.startCursor,
-      // Only fired once the sign-in page proved the window alive AND is
-      // waiting on the user; a still-valid browser session re-auths silently
-      // and the caller never surfaces a sign-in prompt.
-      onAck: () => args.opts.onLoginRequired?.(sessionId, args.signInUrl)
-    });
-  } finally {
-    clearInterval(keepalive);
-  }
-  saveCredentials(loginApiKey);
-  args.opts.onAuthenticated?.(sessionId);
-  if (args.opts.onEvent && (args.opts.monitor === "wait" || args.opts.monitor === "start" && tryClaimStudioMonitor())) {
-    await waitForSessionReady({
-      serviceUrl,
-      apiKey: loginApiKey,
-      sessionId
-    });
-    const poller = startEventPoller(serviceUrl, loginApiKey, sessionId, args.opts.onEvent, args.restoreFocus, { claim: args.opts.monitor !== "wait" });
-    return {
-      sessionId,
-      serviceUrl,
-      apiKey: loginApiKey,
-      opened: false,
-      ...poller
-    };
-  }
-  args.restoreFocus();
+  const subscription = opts.onEvent ? createEventSubscription(channel, sessionId, opts.onEvent, restoreFocus) : { abort: () => channel.destroy(), done: Promise.resolve() };
   return {
     sessionId,
     serviceUrl,
-    apiKey: loginApiKey,
-    opened: false,
-    abort: noop,
-    done: Promise.resolve()
-  };
-}
-function awaitReauthLogin(args) {
-  return new Promise((resolve, reject) => {
-    const abortController = new AbortController();
-    let settled = false;
-    let acked = false;
-    const settle = (fn) => {
-      if (settled) {
-        return;
-      }
-      settled = true;
-      clearTimeout(ackTimer);
-      clearTimeout(loginTimer);
-      abortController.abort();
-      fn();
-    };
-    const ackTimer = setTimeout(() => {
-      settle(() => reject(new StudioNavigationError("timeout", void 0, args.sessionId)));
-    }, REAUTH_ACK_TIMEOUT_MS);
-    const loginTimer = setTimeout(() => {
-      settle(() => reject(new Error("Login polling aborted")));
-    }, LOGIN_TIMEOUT_MS);
-    pollSessionAuthEvents({
-      serviceUrl: args.serviceUrl,
-      sessionId: args.sessionId,
-      startCursor: args.startCursor,
-      abortSignal: abortController.signal,
-      onEvent: (event) => {
-        if (event.type === "studio:auth-required" && !acked) {
-          acked = true;
-          clearTimeout(ackTimer);
-          args.onAck();
-          return;
-        }
-        if (event.type === "studio:authenticated") {
-          const token = event.data.token;
-          if (typeof token === "string") {
-            settle(() => resolve(token));
-          }
-        }
-      }
-    }).catch((err) => {
-      settle(() => reject(err instanceof Error ? err : new Error(String(err))));
-    });
-  });
-}
-function startEventPoller(serviceUrl, apiKey, sessionId, onEvent, restoreFocus, { claim = true, fromStreamStart = false, graceMs, forceClear = false } = {}) {
-  printBlockingNotice(BLOCKING_NOTICE_UNTIL);
-  if (claim) {
-    claimStudioMonitor();
-  }
-  const abortController = new AbortController();
-  let endedNotified = false;
-  const releaseLock = () => {
-    if (claim) {
-      releaseStudioMonitor();
-    }
-  };
-  const notifyEnded = (baseEvent) => {
-    if (!endedNotified) {
-      endedNotified = true;
-      restoreFocus();
-      onEvent({ ...baseEvent, type: "studio:session-ended" });
-    }
-    releaseLock();
-    abortController.abort();
-  };
-  const arbiter = createWindowCloseArbiter({
-    onConfirmed: (event) => {
-      if (forceClear) {
-        clearActiveStudioSession(sessionId, { force: true });
-      } else {
-        clearActiveStudioSession(sessionId);
-      }
-      notifyEnded(event);
-    },
-    onRefuted: () => {
-      console.error("Studio reconnected after page refresh");
-    }
-  }, graceMs);
-  const done = (async () => {
-    const startCursor = fromStreamStart ? void 0 : await fetchStreamTip({ serviceUrl, apiKey, sessionId });
-    if (abortController.signal.aborted) {
-      return;
-    }
-    await pollAgentSessionEvents({
-      serviceUrl,
-      apiKey,
-      sessionId,
-      startCursor,
-      abortSignal: abortController.signal,
-      onEvent: (event) => {
-        if (event.type === "studio:window-closed" || event.type === "studio:session-started") {
-          arbiter.handleEvent(event);
-          return;
-        }
-        if (event.type === "studio:session-ended") {
-          arbiter.cancel();
-          notifyEnded(event);
-          return;
-        }
-        if (event.type === "studio:session-closed") {
-          return;
-        }
-        if (event.type === "studio:not-member") {
-          restoreFocus();
-          onEvent(event);
-          releaseLock();
-          abortController.abort();
-          return;
-        }
-        if (event.type === "studio:return-to-agent" || event.type === "studio:edit-with-agent") {
-          restoreFocus();
-        }
-        onEvent(event);
-      },
-      onError: (err) => {
-        console.error(`studio agent-event poll: ${err.message}`);
-      }
-    });
-  })().catch((err) => {
-    if (!abortController.signal.aborted) {
-      console.error(`studio agent-event poll terminated: ${err.message}`);
-    }
-    releaseLock();
-  });
-  return {
-    abort: () => {
-      releaseLock();
-      abortController.abort();
-    },
-    done
-  };
-}
-var LOGIN_MONITOR_DRAIN_MS = 8e3;
-async function runLoginWindowMonitor(sessionId) {
-  const config2 = getConfig();
-  const apiKey = config2.apiKey;
-  if (!apiKey) {
-    return;
-  }
-  const poller = startEventPoller(
-    config2.serviceUrl,
     apiKey,
-    sessionId,
-    () => {
-    },
-    () => {
-    },
-    // claim: false — this is a transient cleanup reader with a no-op event
-    // handler, NOT the session's real monitor. If it claimed the lock, a
-    // subsequent `openStudioTo` reuse with monitor:"start" (e.g. a flow's
-    // backgrounded open right after a PARKED login) would lose the atomic
-    // claim, assume a live monitor is forwarding events, and fire-and-exit —
-    // leaving the session with no real monitor while this one forwards
-    // nothing. Reading without claiming lets it clean up the pointer
-    // (window-closed → clear) without shadowing the real monitor.
-    //
-    // forceClear: the clear runs in a detached child while the login/init
-    // parent that WROTE the pointer may still be alive (init keeps running with
-    // exitOnComplete:false, even spawnSync-ing the editor), so a non-force clear
-    // would be refused by the writer-alive guard and the closed window's
-    // pointer would leak. Safe — the clear still matches on the unique
-    // sessionId.
-    { claim: false, fromStreamStart: true, graceMs: 0, forceClear: true }
-  );
-  let drainTimer;
-  const drain = new Promise((resolve) => {
-    drainTimer = setTimeout(resolve, LOGIN_MONITOR_DRAIN_MS);
-  });
-  await Promise.race([poller.done, drain]);
-  if (drainTimer) {
-    clearTimeout(drainTimer);
-  }
-  poller.abort();
+    opened,
+    ...subscription
+  };
 }
 
 // ../bitfab-plugin-lib/dist/commands/login.js
-function trySpawnDetachedMonitor(sessionId) {
-  try {
-    const pid = spawnDetached(process.execPath, [
-      ...process.argv.slice(1),
-      "--drain",
-      sessionId
-    ]);
-    return pid != null;
-  } catch {
-    return false;
-  }
-}
 async function verifyToken(serviceUrl, token) {
   try {
     const res = await fetch(`${serviceUrl}/api/plugin/whoami`, {
@@ -10561,23 +10676,6 @@ async function verifyToken(serviceUrl, token) {
 }
 async function runLogin(platform2, pluginVersion, options) {
   const exitOnComplete = options?.exitOnComplete ?? true;
-  const drainIdx = process.argv.indexOf("--drain");
-  if (drainIdx !== -1) {
-    const sessionId = process.argv[drainIdx + 1];
-    if (!sessionId) {
-      throw new Error("--drain requires a sessionId argument");
-    }
-    await runLoginWindowMonitor(sessionId);
-    if (exitOnComplete) {
-      process.exit(0);
-    }
-    return;
-  }
-  if (exitOnComplete) {
-    printHelpIfRequested({
-      description: "Sign in to Bitfab. Opens Studio in the browser for authentication and saves the API key locally. Takes no arguments."
-    });
-  }
   const force = options?.force ?? process.argv.includes("--force");
   const config2 = getConfig();
   if (!force && hasCredentials() && config2.apiKey) {
@@ -10617,9 +10715,7 @@ ${signInUrl}`);
 ${greeting}`);
       console.log("Bitfab MCP tools are now active. (via studio)");
     }
-    if (!trySpawnDetachedMonitor(result.sessionId)) {
-      await runLoginWindowMonitor(result.sessionId);
-    }
+    result.abort();
     if (exitOnComplete) {
       process.exit(0);
     }
@@ -11424,10 +11520,10 @@ function mergeDefs(...defs) {
 function cloneDef(schema) {
   return mergeDefs(schema._zod.def);
 }
-function getElementAtPath(obj, path15) {
-  if (!path15)
+function getElementAtPath(obj, path18) {
+  if (!path18)
     return obj;
-  return path15.reduce((acc, key) => acc?.[key], obj);
+  return path18.reduce((acc, key) => acc?.[key], obj);
 }
 function promiseAllObject(promisesObj) {
   const keys = Object.keys(promisesObj);
@@ -11810,11 +11906,11 @@ function aborted(x, startIndex = 0) {
   }
   return false;
 }
-function prefixIssues(path15, issues) {
+function prefixIssues(path18, issues) {
   return issues.map((iss) => {
     var _a2;
     (_a2 = iss).path ?? (_a2.path = []);
-    iss.path.unshift(path15);
+    iss.path.unshift(path18);
     return iss;
   });
 }
@@ -11997,7 +12093,7 @@ function formatError(error48, mapper = (issue2) => issue2.message) {
 }
 function treeifyError(error48, mapper = (issue2) => issue2.message) {
   const result = { errors: [] };
-  const processError = (error49, path15 = []) => {
+  const processError = (error49, path18 = []) => {
     var _a2, _b;
     for (const issue2 of error49.issues) {
       if (issue2.code === "invalid_union" && issue2.errors.length) {
@@ -12007,7 +12103,7 @@ function treeifyError(error48, mapper = (issue2) => issue2.message) {
       } else if (issue2.code === "invalid_element") {
         processError({ issues: issue2.issues }, issue2.path);
       } else {
-        const fullpath = [...path15, ...issue2.path];
+        const fullpath = [...path18, ...issue2.path];
         if (fullpath.length === 0) {
           result.errors.push(mapper(issue2));
           continue;
@@ -12039,8 +12135,8 @@ function treeifyError(error48, mapper = (issue2) => issue2.message) {
 }
 function toDotPath(_path) {
   const segs = [];
-  const path15 = _path.map((seg) => typeof seg === "object" ? seg.key : seg);
-  for (const seg of path15) {
+  const path18 = _path.map((seg) => typeof seg === "object" ? seg.key : seg);
+  for (const seg of path18) {
     if (typeof seg === "number")
       segs.push(`[${seg}]`);
     else if (typeof seg === "symbol")
@@ -24017,13 +24113,13 @@ function resolveRef(ref, ctx) {
   if (!ref.startsWith("#")) {
     throw new Error("External $ref is not supported, only local refs (#/...) are allowed");
   }
-  const path15 = ref.slice(1).split("/").filter(Boolean);
-  if (path15.length === 0) {
+  const path18 = ref.slice(1).split("/").filter(Boolean);
+  if (path18.length === 0) {
     return ctx.rootSchema;
   }
   const defsKey = ctx.version === "draft-2020-12" ? "$defs" : "definitions";
-  if (path15[0] === defsKey) {
-    const key = path15[1];
+  if (path18[0] === defsKey) {
+    const key = path18[1];
     if (!key || !ctx.defs[key]) {
       throw new Error(`Reference not found: ${ref}`);
     }
@@ -24455,18 +24551,18 @@ var inputFileSchema = external_exports.object({
 import { spawn as spawn3 } from "child_process";
 
 // ../bitfab-plugin-lib/dist/activePreviewSession.js
-import fs10 from "fs";
-import os9 from "os";
-import path8 from "path";
-var FILE_PATH = path8.join(os9.homedir(), ".config", "bitfab", "active-preview-session.json");
+import fs12 from "fs";
+import os11 from "os";
+import path11 from "path";
+var FILE_PATH = path11.join(os11.homedir(), ".config", "bitfab", "active-preview-session.json");
 
 // ../bitfab-plugin-lib/dist/commands/status.js
-import path10 from "path";
+import path13 from "path";
 
 // ../bitfab-plugin-lib/dist/updates.js
-import fs11 from "fs";
-import os10 from "os";
-import path9 from "path";
+import fs13 from "fs";
+import os12 from "os";
+import path12 from "path";
 
 // ../bitfab-plugin-lib/dist/commands/update.js
 import { execSync as execSync2 } from "child_process";
@@ -24475,15 +24571,15 @@ import { execSync as execSync2 } from "child_process";
 var DEFAULT_TIMEOUT_MS = 10 * 60 * 1e3;
 
 // ../bitfab-plugin-lib/dist/hooks/captureHook.js
-import fs12 from "fs";
+import fs14 from "fs";
 
 // ../bitfab-plugin-lib/dist/hooks/userPromptSubmit.js
-import fs13 from "fs";
+import fs15 from "fs";
 
 // ../bitfab-plugin-lib/dist/installScope.js
-import fs14 from "fs";
-import os11 from "os";
-import path11 from "path";
+import fs16 from "fs";
+import os13 from "os";
+import path14 from "path";
 
 // ../node_modules/.pnpm/zod@4.3.6/node_modules/zod/v3/helpers/util.js
 var util;
@@ -24844,8 +24940,8 @@ function getErrorMap2() {
 
 // ../node_modules/.pnpm/zod@4.3.6/node_modules/zod/v3/helpers/parseUtil.js
 var makeIssue = (params) => {
-  const { data, path: path15, errorMaps, issueData } = params;
-  const fullPath = [...path15, ...issueData.path || []];
+  const { data, path: path18, errorMaps, issueData } = params;
+  const fullPath = [...path18, ...issueData.path || []];
   const fullIssue = {
     ...issueData,
     path: fullPath
@@ -24960,11 +25056,11 @@ var errorUtil;
 
 // ../node_modules/.pnpm/zod@4.3.6/node_modules/zod/v3/types.js
 var ParseInputLazyPath = class {
-  constructor(parent, value, path15, key) {
+  constructor(parent, value, path18, key) {
     this._cachedPath = [];
     this.parent = parent;
     this.data = value;
-    this._path = path15;
+    this._path = path18;
     this._key = key;
   }
   get path() {
@@ -29858,15 +29954,11 @@ var McpZodTypeKind;
 // ../node_modules/.pnpm/@modelcontextprotocol+sdk@1.29.0_@cfworker+json-schema@4.1.1_zod@4.3.6/node_modules/@modelcontextprotocol/sdk/dist/esm/server/stdio.js
 import process3 from "process";
 
-// src/init.ts
-import { execSync as execSync3 } from "child_process";
-import * as p4 from "@clack/prompts";
-
 // src/claude.ts
 import { spawnSync } from "child_process";
-import fs15 from "fs";
-import os12 from "os";
-import path12 from "path";
+import fs17 from "fs";
+import os14 from "os";
+import path15 from "path";
 import * as p from "@clack/prompts";
 var REPO = "Project-White-Rabbit/bitfab-claude-plugin";
 var MARKETPLACE = "bitfab";
@@ -29886,7 +29978,7 @@ function runClaudeInstall() {
   }
   s.start("Enabling auto-updates");
   const changed = enableAutoUpdate(
-    path12.join(os12.homedir(), ".claude", "settings.json")
+    path15.join(os14.homedir(), ".claude", "settings.json")
   );
   if (changed) {
     s.stop("Auto-updates enabled");
@@ -29977,8 +30069,8 @@ function runClaude(args) {
 }
 function enableAutoUpdate(settingsPath) {
   let settings = {};
-  if (fs15.existsSync(settingsPath)) {
-    const raw = fs15.readFileSync(settingsPath, "utf-8");
+  if (fs17.existsSync(settingsPath)) {
+    const raw = fs17.readFileSync(settingsPath, "utf-8");
     settings = raw.trim() === "" ? {} : JSON.parse(raw);
   }
   const marketplaces = settings.extraKnownMarketplaces ?? {};
@@ -29992,17 +30084,17 @@ function enableAutoUpdate(settingsPath) {
     autoUpdate: true
   };
   settings.extraKnownMarketplaces = marketplaces;
-  fs15.mkdirSync(path12.dirname(settingsPath), { recursive: true });
-  fs15.writeFileSync(settingsPath, `${JSON.stringify(settings, null, 2)}
+  fs17.mkdirSync(path15.dirname(settingsPath), { recursive: true });
+  fs17.writeFileSync(settingsPath, `${JSON.stringify(settings, null, 2)}
 `);
   return true;
 }
 
 // src/codex.ts
 import { spawnSync as spawnSync2 } from "child_process";
-import fs16 from "fs";
-import os13 from "os";
-import path13 from "path";
+import fs18 from "fs";
+import os15 from "os";
+import path16 from "path";
 import * as p2 from "@clack/prompts";
 var REPO2 = "Project-White-Rabbit/bitfab-codex-plugin";
 var PLUGIN_KEY2 = "bitfab@bitfab";
@@ -30030,7 +30122,7 @@ function runCodexInstall() {
   }
   s.start("Enabling bitfab plugin in config");
   const changed = enableCodexPlugin(
-    path13.join(os13.homedir(), ".codex", "config.toml")
+    path16.join(os15.homedir(), ".codex", "config.toml")
   );
   if (changed) {
     s.stop("Plugin enabled");
@@ -30093,8 +30185,8 @@ function runCodexUpdate(args, skipPermissions) {
 }
 function enableCodexPlugin(configPath) {
   let content = "";
-  if (fs16.existsSync(configPath)) {
-    content = fs16.readFileSync(configPath, "utf-8");
+  if (fs18.existsSync(configPath)) {
+    content = fs18.readFileSync(configPath, "utf-8");
   }
   const header = `[plugins."${PLUGIN_KEY2}"]`;
   const desiredSection = `${header}
@@ -30117,8 +30209,8 @@ enabled = true
 
 ${desiredSection}`;
   }
-  fs16.mkdirSync(path13.dirname(configPath), { recursive: true });
-  fs16.writeFileSync(configPath, next);
+  fs18.mkdirSync(path16.dirname(configPath), { recursive: true });
+  fs18.writeFileSync(configPath, next);
   return true;
 }
 function escapeRegex2(s) {
@@ -30127,7 +30219,7 @@ function escapeRegex2(s) {
 
 // src/cursor.ts
 import { spawn as spawn4, spawnSync as spawnSync3 } from "child_process";
-import os14 from "os";
+import os16 from "os";
 import * as p3 from "@clack/prompts";
 var REPO3 = "Project-White-Rabbit/bitfab-cursor-plugin";
 var ADD_PLUGIN_CMD = `/add-plugin ${REPO3}`;
@@ -30199,13 +30291,13 @@ function copyToClipboard(text) {
   return result.status === 0;
 }
 function clipboardCommand() {
-  if (os14.platform() === "darwin") {
+  if (os16.platform() === "darwin") {
     return { bin: "pbcopy", args: [] };
   }
-  if (os14.platform() === "linux") {
+  if (os16.platform() === "linux") {
     return { bin: "xclip", args: ["-selection", "clipboard"] };
   }
-  if (os14.platform() === "win32") {
+  if (os16.platform() === "win32") {
     return { bin: "clip", args: [] };
   }
   return null;
@@ -30229,12 +30321,12 @@ var platform = {
 };
 
 // src/version.ts
-import fs17 from "fs";
-import path14 from "path";
-import { fileURLToPath as fileURLToPath2 } from "url";
+import fs19 from "fs";
+import path17 from "path";
+import { fileURLToPath as fileURLToPath3 } from "url";
 var CLI_VERSION = JSON.parse(
-  fs17.readFileSync(
-    path14.join(path14.dirname(fileURLToPath2(import.meta.url)), "../package.json"),
+  fs19.readFileSync(
+    path17.join(path17.dirname(fileURLToPath3(import.meta.url)), "../package.json"),
     "utf-8"
   )
 ).version;
@@ -30509,22 +30601,7 @@ function parseArgs2(argv) {
   }
   return { command, editor, skipPermissions, rest };
 }
-async function handleDrainArg(argv) {
-  const drainIdx = argv.indexOf("--drain");
-  if (drainIdx === -1) {
-    return false;
-  }
-  const sessionId = argv[drainIdx + 1];
-  if (!sessionId) {
-    throw new Error("--drain requires a sessionId argument");
-  }
-  await runLoginWindowMonitor(sessionId);
-  return true;
-}
 async function main() {
-  if (await handleDrainArg(process.argv)) {
-    return;
-  }
   const { command, editor, skipPermissions, rest } = parseArgs2(
     process.argv.slice(2)
   );
@@ -30581,7 +30658,6 @@ main().catch((err) => {
   process.exit(1);
 });
 export {
-  handleDrainArg,
   parseArgs2 as parseArgs,
   wantsHelp
 };