openmausbot 0.1.69 → 0.1.70

package/dist-server/prepare-cloudflared.js

@@ -173,9 +173,25 @@ async function releaseBytes(asset) {
   const cached = cacheDirectory ? join(cacheDirectory, asset.name) : "";
   if (cached && existsSync(cached)) return readFileSync(cached);
   const url = `https://github.com/cloudflare/cloudflared/releases/download/${CLOUDFLARED_VERSION}/${asset.name}`;
-  const response = await fetch(url, { redirect: "follow", signal: AbortSignal.timeout(12e4) });
-  if (!response.ok) throw new Error(`could not download ${asset.name}: HTTP ${response.status}`);
-  return Buffer.from(await response.arrayBuffer());
+  const retryableStatuses = /* @__PURE__ */ new Set([408, 429, 500, 502, 503, 504]);
+  for (let attempt = 1; attempt <= 3; attempt++) {
+    let failure;
+    try {
+      const response = await fetch(url, { redirect: "follow", signal: AbortSignal.timeout(12e4) });
+      if (response.ok) return Buffer.from(await response.arrayBuffer());
+      await response.body?.cancel().catch(() => {
+      });
+      failure = new Error(`could not download ${asset.name}: HTTP ${response.status}`);
+      if (!retryableStatuses.has(response.status)) throw failure;
+    } catch (error) {
+      if (!(error instanceof TypeError) && !["TimeoutError", "AbortError"].includes(error?.name)) throw error;
+      failure = error;
+    }
+    if (attempt === 3) throw failure;
+    const delay = 1e3 * 2 ** (attempt - 1);
+    console.warn(`cloudflared download attempt ${attempt}/3 failed: ${failure.message}; retrying in ${delay}ms`);
+    await new Promise((resolve) => setTimeout(resolve, delay));
+  }
 }
 async function stageTarget(root, target) {
   const asset = CLOUDFLARED_ASSETS[target];
@@ -251,6 +267,7 @@ export {
   executableTarget,
   parsePrepareCloudflaredArgs,
   prepareCloudflared,
+  releaseBytes,
   sha256,
   targetForCurrentHost,
   targetsForHost,

package/dist-server/server/delegations.js

@@ -86,19 +86,26 @@ export function threadsWaitingOn(toBotId) {
 }
 /** Mark a target's observed busy period as finished and return the source
  * threads that should be retried. This makes retries count distinct busy
- * periods, not unrelated drain requests on the same source thread. */
-export function releaseDelegationsWaitingOn(toBotId) {
-    const threads = threadsWaitingOn(toBotId);
-    if (!threads.length)
-        return threads;
-    for (const threadId of threads) {
-        for (const item of pendingDelegations.get(threadId) ?? []) {
-            if (item.toBotId === toBotId)
-                delete item.waitingOnBusy;
+ * periods, not unrelated drain requests on the same source thread.
+ * `only` narrows the release: a bot that is still busy in one thread has
+ * nevertheless freed a slot for the fresh-thread handoffs waiting on it,
+ * while its active-thread handoffs go on waiting for it to go idle. */
+export function releaseDelegationsWaitingOn(toBotId, only) {
+    const released = [];
+    for (const [threadId, items] of pendingDelegations) {
+        let any = false;
+        for (const item of items) {
+            if (item.toBotId !== toBotId || item.waitingOnBusy !== true || (only && !only(item)))
+                continue;
+            delete item.waitingOnBusy;
+            any = true;
         }
+        if (any)
+            released.push(threadId);
     }
-    savePending();
-    return threads;
+    if (released.length)
+        savePending();
+    return released;
 }
 function savePending() {
     try {
@@ -140,6 +147,9 @@ export function _loadPending() {
                 if (typeof item.originatingGroupId === "string" && item.originatingGroupId) {
                     loaded.originatingGroupId = item.originatingGroupId;
                 }
+                if (typeof item.targetThreadId === "string" && item.targetThreadId) {
+                    loaded.targetThreadId = item.targetThreadId;
+                }
                 return [loaded];
             });
             if (items.length)
@@ -195,6 +205,7 @@ export function pendingDelegationSnapshot() {
         sourceBotId: item.sourceBotId,
         toBotId: item.toBotId,
         ...(item.reason ? { reason: item.reason } : {}),
+        ...(item.targetThreadId ? { targetThreadId: item.targetThreadId } : {}),
     })));
 }
 /** How many handoffs one turn may queue. Small on purpose: this is the only
@@ -231,18 +242,27 @@ export function queueDelegation(bus, from, item, maxDepth, sourceThreadId = from
     list.push({ ...item, id, sourceBotId: from.id, attempts: 0, ...(groupId ? { originatingGroupId: groupId } : {}) });
     pendingDelegations.set(sourceThreadId, list);
     savePending();
-    const label = `Delegated to @${target.name}${item.reason ? `: ${item.reason}` : ""}`;
     const sourceGroup = sourceThreadId ? bus.store.groupByThread(sourceThreadId) : undefined;
-    bus.store.appendMessage(sourceThreadId, {
+    // A fresh-thread handoff is announced as the thread it opened, with a
+    // link to it; a classic one as the delegation it is.
+    const openedThread = item.targetThreadId ? bus.store.taskByThread(target.id, item.targetThreadId) : undefined;
+    const chip = {
         role: "bot",
         kind: "activity",
         // settled at birth: queueing is the whole act. Left open, the chip
         // would spin until the transcript is closed — the chat never patches it
-        tool: { name: label, ok: true },
-        ...(sourceGroup && !sourceGroup.dm
-            ? { from: { botId: from.id, name: from.name, color: from.color } }
-            : {}),
-    });
+        tool: {
+            name: openedThread
+                ? `Opened thread #${openedThread.title} on ${target.name}`
+                : `Delegated to @${target.name}${item.reason ? `: ${item.reason}` : ""}`,
+            ok: true,
+        },
+    };
+    if (openedThread)
+        chip.threadRef = { botId: target.id, threadId: openedThread.threadId, title: openedThread.title };
+    if (sourceGroup && !sourceGroup.dm)
+        chip.from = { botId: from.id, name: from.name, color: from.color };
+    bus.store.appendMessage(sourceThreadId, chip);
     return { result: "ok", id };
 }
 /** Drain queued delegations for a source thread (called on its
@@ -418,35 +438,12 @@ async function processOne(bus, approvalBus, from, sourceThreadId, item, runTarge
     if (dropIfUnreachable(bus, sender, target, sourceThreadId, item)) {
         return "settled";
     }
-    if (target.busy) {
-        if (item.waitingOnBusy)
-            return "requeued";
-        item.attempts += 1;
-        item.waitingOnBusy = true;
-        if (item.attempts < MAX_BUSY_ATTEMPTS) {
-            savePending();
-            bus.store.appendMessage(sourceThreadId, {
-                role: "bot",
-                kind: "activity",
-                tool: { name: `Delegation to @${target.name} waiting — they're busy (retry ${item.attempts}/${MAX_BUSY_ATTEMPTS} when they finish)` },
-            });
-            return "requeued";
-        }
-        recordDelegationReceipt({
-            id: item.id,
-            sourceThreadId,
-            toBotId: target.id,
-            toBotName: target.name,
-            status: "busy_gave_up",
-            result: `@${target.name} stayed busy through ${MAX_BUSY_ATTEMPTS} retries`,
-        });
-        bus.store.appendMessage(sourceThreadId, {
-            role: "bot",
-            kind: "activity",
-            tool: { name: `Delegation to @${target.name} canceled — still busy after ${MAX_BUSY_ATTEMPTS} retries`, ok: false },
-        });
+    if (dropIfThreadGone(bus, target, sourceThreadId, item)) {
         return "settled";
     }
+    const held = holdWhileTargetBusy(bus, target, sourceThreadId, item);
+    if (held)
+        return held;
     if (item.waitingOnBusy) {
         delete item.waitingOnBusy;
         savePending();
@@ -494,35 +491,12 @@ async function processOne(bus, approvalBus, from, sourceThreadId, item, runTarge
         if (dropIfUnreachable(bus, currentSender, current, sourceThreadId, item)) {
             return "settled";
         }
-        if (current.busy) {
-            if (item.waitingOnBusy)
-                return "requeued";
-            item.attempts += 1;
-            item.waitingOnBusy = true;
-            if (item.attempts < MAX_BUSY_ATTEMPTS) {
-                savePending();
-                bus.store.appendMessage(sourceThreadId, {
-                    role: "bot",
-                    kind: "activity",
-                    tool: { name: `Delegation to @${current.name} waiting — they're busy (retry ${item.attempts}/${MAX_BUSY_ATTEMPTS} when they finish)` },
-                });
-                return "requeued";
-            }
-            recordDelegationReceipt({
-                id: item.id,
-                sourceThreadId,
-                toBotId: current.id,
-                toBotName: current.name,
-                status: "busy_gave_up",
-                result: `@${current.name} stayed busy through ${MAX_BUSY_ATTEMPTS} retries`,
-            });
-            bus.store.appendMessage(sourceThreadId, {
-                role: "bot",
-                kind: "activity",
-                tool: { name: `Delegation to @${current.name} canceled — still busy after ${MAX_BUSY_ATTEMPTS} retries`, ok: false },
-            });
+        if (dropIfThreadGone(bus, current, sourceThreadId, item)) {
             return "settled";
         }
+        const heldAfterApproval = holdWhileTargetBusy(bus, current, sourceThreadId, item);
+        if (heldAfterApproval)
+            return heldAfterApproval;
         sender = currentSender;
         target = current;
     }
@@ -533,10 +507,94 @@ async function processOne(bus, approvalBus, from, sourceThreadId, item, runTarge
     const channel = getOrCreateChannel(bus.store, sender, target, originatingGroup);
     mirrorExchange(bus, sender, target, item.message, channel, sourceThreadId);
     const reasonLine = item.reason ? `\n\n[Reason: ${item.reason}]` : "";
-    const prefixed = `[Delegated by @${sender.name}, another bot in this OpenMausBot workspace. Do the work and reply directly.]\n\n${item.message}${reasonLine}`;
-    await runTarget(item.toBotId, prefixed, item.depth + 1, sourceThreadId, channel, item.id, sender.id);
+    // A fresh thread's first line gets the shared peer-provenance note from
+    // the harness (which knows whether the opener was unattended); the
+    // classic handoff keeps the prefix it has always had.
+    const prefixed = item.targetThreadId
+        ? item.message
+        : `[Delegated by @${sender.name}, another bot in this OpenMausBot workspace. Do the work and reply directly.]\n\n${item.message}${reasonLine}`;
+    await runTarget(item.toBotId, prefixed, item.depth + 1, sourceThreadId, channel, item.id, sender.id, item.targetThreadId);
     return "dispatched";
 }
+/** A busy target holds the handoff. What "busy" means depends on where the
+ * turn will run: a classic delegation lands in the target's active thread,
+ * so it waits for the bot to go idle, with bounded retries so a stuck peer
+ * cannot pin the handoff forever. A fresh-thread handoff needs only a free
+ * slot, and waits in line for one without a bound — it IS the line, the
+ * same one a person's message joins at that limit. Returns null when the
+ * target can take the turn now. */
+function holdWhileTargetBusy(bus, target, sourceThreadId, item) {
+    if (item.targetThreadId) {
+        if (bus.threadSlotFree ? bus.threadSlotFree(target.id) : !target.busy)
+            return null;
+        if (item.waitingOnBusy)
+            return "requeued";
+        item.waitingOnBusy = true;
+        savePending();
+        // one chip per wait, not one per retry: the line moves on every settle
+        if (item.attempts === 0) {
+            item.attempts = 1;
+            const title = bus.store.taskByThread(target.id, item.targetThreadId)?.title ?? "thread";
+            bus.store.appendMessage(sourceThreadId, {
+                role: "bot",
+                kind: "activity",
+                tool: { name: `Thread #${title} on @${target.name} waiting for a free slot` },
+            });
+        }
+        return "requeued";
+    }
+    if (!target.busy)
+        return null;
+    if (item.waitingOnBusy)
+        return "requeued";
+    item.attempts += 1;
+    item.waitingOnBusy = true;
+    if (item.attempts < MAX_BUSY_ATTEMPTS) {
+        savePending();
+        bus.store.appendMessage(sourceThreadId, {
+            role: "bot",
+            kind: "activity",
+            tool: { name: `Delegation to @${target.name} waiting — they're busy (retry ${item.attempts}/${MAX_BUSY_ATTEMPTS} when they finish)` },
+        });
+        return "requeued";
+    }
+    recordDelegationReceipt({
+        id: item.id,
+        sourceThreadId,
+        toBotId: target.id,
+        toBotName: target.name,
+        status: "busy_gave_up",
+        result: `@${target.name} stayed busy through ${MAX_BUSY_ATTEMPTS} retries`,
+    });
+    bus.store.appendMessage(sourceThreadId, {
+        role: "bot",
+        kind: "activity",
+        tool: { name: `Delegation to @${target.name} canceled — still busy after ${MAX_BUSY_ATTEMPTS} retries`, ok: false },
+    });
+    return "settled";
+}
+/** The thread a fresh-thread handoff was opened in may be deleted while the
+ * handoff waits. There is nowhere for the turn to run then, and running it
+ * in the target's active thread would put a bot's job in front of the
+ * person unasked. */
+function dropIfThreadGone(bus, target, sourceThreadId, item) {
+    if (!item.targetThreadId || bus.store.taskByThread(target.id, item.targetThreadId))
+        return false;
+    recordDelegationReceipt({
+        id: item.id,
+        sourceThreadId,
+        toBotId: target.id,
+        toBotName: target.name,
+        status: "dropped",
+        result: `the thread opened on @${target.name} was deleted before it could start`,
+    });
+    bus.store.appendMessage(sourceThreadId, {
+        role: "bot",
+        kind: "activity",
+        tool: { name: `Thread on @${target.name} canceled — it was deleted before it could start`, ok: false },
+    });
+    return true;
+}
 /** The source thread may be a bot's own task or a shared group where the
  * bot is a member. This is the same check the API gate uses for group turns. */
 function sourceThreadBelongsToBot(store, botId, threadId) {

package/dist-server/server/drivers/agents-proxy.js

@@ -13,6 +13,9 @@
 //                                          immediately, the peer runs after your
 //                                          current turn finishes, the result is
 //                                          delivered to the source conversation
+//   start_thread(title, msg, bot_id?)    → open a real thread — on yourself for
+//                                          separate work, or on a teammate as a
+//                                          handoff that runs on its own
 //   create_bot(name, role, instructions) → Chiefs can add a specialist to
 //                                          their own section
 //   request_credential(id, reason?)       → show a secure, allowlisted key card
@@ -45,6 +48,12 @@ let createdThisTurn = 0;
 // so the refusal reaches the model without a round trip.
 const MAX_ROOM_POSTS_PER_TURN = 3;
 let roomPostsThisTurn = 0;
+// A thread is a real turn with its own run. Five in one turn is a plan
+// ("one per pull request"); more than that is a model that has stopped
+// deciding. The harness holds the same ceiling; this copy exists so the
+// refusal reaches the model without a round trip.
+const MAX_THREADS_PER_TURN = 5;
+let threadsOpenedThisTurn = 0;
 const delegationTaskIdsThisTurn = new Set();
 const WEEKDAYS = [
     "monday",
@@ -382,6 +391,36 @@ const TOOLS = [
             required: ["task_id"],
         },
     },
+    {
+        name: "list_threads",
+        description: "See your own threads and the threads you opened on teammates, newest first: each with its bot, title, state (running, waiting on the person, queued, or idle), whether the person has unread there, and the delegation id if it was a handoff. Use it to check how the threads you started are going before reporting to the person; write a thread's title as #Title when you mention it. A teammate's other threads are never listed — only the ones you opened. This is a read: it starts nothing and changes nothing.",
+        inputSchema: { type: "object", additionalProperties: false, properties: {} },
+    },
+    {
+        name: "close_thread",
+        description: "Mark a thread you opened (or one of your own) as finished once you have read its result: it goes idle in the person's sidebar with a note saying you closed it. Nothing is deleted — deleting stays the person's decision — and a thread that is still running cannot be closed; wait for it or leave it. Use the thread id from list_threads or from the start_thread result. If a close is refused, do not retry it.",
+        inputSchema: {
+            type: "object",
+            additionalProperties: false,
+            properties: { thread_id: { type: "string", description: "The thread id from list_threads or start_thread." } },
+            required: ["thread_id"],
+        },
+    },
+    {
+        name: "start_thread",
+        description: "Open a new thread: one conversation with its own history and its own run, shown to the person as a row under the bot it belongs to. Leave bot_id out to open it on yourself, for a separate job that should run on its own (\"review each pull request\" — one thread per pull request) instead of inside this conversation. Give bot_id (from list_bots) to open it on a teammate: that is a handoff into a fresh thread, which starts after your current turn ends and whose result is delivered here, like delegate_bot. The title becomes the row's name, so make it short and specific; write it as #Title when you mention it to the person. Do not use it for a question you need answered right now (ask_bot), for one task where the teammate's usual conversation is fine (delegate_bot), or for a note nobody has to act on. If a call is refused, do not retry it: say what you still wanted opened.",
+        inputSchema: {
+            type: "object",
+            additionalProperties: false,
+            properties: {
+                title: { type: "string", description: "The thread's name: one short line, at most 80 characters, specific enough to tell it apart from the others (for example \"QA: PR #412 login fix\")." },
+                message: { type: "string", description: "The complete first message of the thread — everything the run needs, since it will not see this conversation." },
+                bot_id: { type: "string", description: "Optional: the teammate's id from list_bots. Leave out to open the thread on yourself." },
+                folder: { type: "string", description: "Optional: the name of one of that bot's existing folders to file the thread under. Leave out unless the person named one." },
+            },
+            required: ["title", "message"],
+        },
+    },
     {
         name: "post_to_room",
         description: "Put one message into a shared room you belong to, for example when the user asks you to tell the team something. Get group_id from list_rooms. This posts and returns: no room member's turn starts, nobody replies, and nothing comes back except confirmation — so never use it to ask a question or hand out work (use ask_bot or delegate_bot for those). Post once, say it in full, and tell the user what you posted. If a post is refused, do not retry it: say what you wanted to post in your reply instead.",
@@ -595,6 +634,14 @@ async function api(path, init) {
         throw new Error(String(body.error ?? `HTTP ${res.status}`));
     return body;
 }
+/** "1st", "2nd", "3rd", "4th" — the queue position as a person says it. */
+function ordinal(n) {
+    const rem100 = n % 100;
+    if (rem100 >= 11 && rem100 <= 13)
+        return `${n}th`;
+    const rem10 = n % 10;
+    return `${n}${rem10 === 1 ? "st" : rem10 === 2 ? "nd" : rem10 === 3 ? "rd" : "th"}`;
+}
 function jsonRecord(value) {
     return value !== null && typeof value === "object" && !Array.isArray(value);
 }
@@ -829,6 +876,88 @@ async function callTool(name, args) {
         }
         return { text: `Task ${taskId} ended without a reply — ${String(r.status ?? "unknown")}${r.result ? `: ${String(r.result)}` : ""}.`, isError: true };
     }
+    if (name === "list_threads") {
+        const query = new URLSearchParams({ fromBotId: BOT_ID, fromThreadId: THREAD_ID });
+        const r = await api(`/api/internal/threads?${query.toString()}`);
+        if (r.error)
+            return { text: `Couldn't list threads: ${String(r.error)}`, isError: true };
+        const threads = Array.isArray(r.threads) ? r.threads.filter(jsonRecord) : [];
+        if (!threads.length)
+            return { text: "No threads yet: you have none of your own beyond this one, and you have not opened any on a teammate." };
+        const stateWord = { running: "running", "waiting-on-you": "waiting on the person", queued: "queued", idle: "idle" };
+        const lines = threads.map((thread) => {
+            const where = thread.own === true ? "yours" : `on @${String(thread.botName)}`;
+            const state = stateWord[String(thread.state)] ?? String(thread.state);
+            const unread = thread.unread === true ? ", unread for the person" : "";
+            const handoff = typeof thread.delegationId === "string" && thread.delegationId ? ` [delegation id: ${thread.delegationId}]` : "";
+            return `- #${String(thread.title)} (${where}, ${state}${unread}) [thread id: ${String(thread.threadId)}]${handoff}`;
+        });
+        return { text: `Threads, newest first:\n${lines.join("\n")}` };
+    }
+    if (name === "close_thread") {
+        const threadId = String(args.thread_id ?? "").trim();
+        if (!threadId)
+            return { text: "close_thread needs the thread_id from list_threads or start_thread.", isError: true };
+        const r = await api(`/api/internal/threads/${encodeURIComponent(threadId)}/close`, { method: "POST", body: JSON.stringify({ fromBotId: BOT_ID, fromThreadId: THREAD_ID }) });
+        if (r.error)
+            return { text: `Couldn't close that thread: ${String(r.error)}`, isError: true };
+        return { text: `Closed #${String(r.title)}${r.botName ? ` on @${String(r.botName)}` : ""}. It stays in the person's sidebar, idle, with a note that you closed it.` };
+    }
+    if (name === "start_thread") {
+        const title = String(args.title ?? "").trim();
+        const message = String(args.message ?? "").trim();
+        if (!title || !message)
+            return { text: "start_thread needs title (one short line) and message (the complete first message).", isError: true };
+        if (threadsOpenedThisTurn >= MAX_THREADS_PER_TURN) {
+            return {
+                text: `You have already opened ${MAX_THREADS_PER_TURN} threads this turn, which is the limit. Do not retry — finish your turn and tell the person which threads you still wanted to open, so they can open them or ask you again.`,
+                isError: true,
+            };
+        }
+        const toBotId = typeof args.bot_id === "string" ? args.bot_id.trim() : "";
+        const folder = typeof args.folder === "string" ? args.folder.trim() : "";
+        const body = { fromBotId: BOT_ID, fromThreadId: THREAD_ID, title, message, depth: DEPTH };
+        if (toBotId)
+            body.toBotId = toBotId;
+        if (folder)
+            body.folder = folder;
+        const r = await api("/api/internal/threads", { method: "POST", body: JSON.stringify(body) });
+        // A refusal opened nothing. A "failed" state opened the thread and could
+        // not start its turn — that one still counts, and still has an id.
+        if (r.error && r.state !== "failed")
+            return { text: `Couldn't open that thread: ${String(r.error)}`, isError: true };
+        threadsOpenedThisTurn += 1;
+        const threadTitle = String(r.title ?? title);
+        const threadId = String(r.threadId ?? "");
+        const where = r.self === true ? "on yourself" : `on @${String(r.botName ?? "that bot")}`;
+        const opened = `Opened thread #${threadTitle} ${where} [thread id: ${threadId}].`;
+        if (r.self === true) {
+            if (r.state === "running") {
+                return { text: `${opened} It is running now, in parallel with this conversation, and its result stays in that thread — it will not be delivered here. Mention it to the person as #${threadTitle}; use list_threads in a later turn to see how it is going.` };
+            }
+            if (r.state === "queued") {
+                const position = Number(r.position) || 1;
+                const limit = Number(r.limit) || 0;
+                return { text: `${opened} You are at your limit of ${limit} threads running at once, so it is ${ordinal(position)} in line and starts as soon as one of them finishes — nothing more to do. Mention it to the person as #${threadTitle}.` };
+            }
+            return { text: `${opened} It could not start: ${String(r.error ?? "unknown reason")}. The thread exists but nothing is running in it; tell the person.`, isError: true };
+        }
+        // A peer thread is a handoff: like delegate_bot, it starts after this
+        // turn and reports back here, so the id is a claim ticket the model
+        // must not cash in this same turn.
+        const delegationId = typeof r.delegationId === "string" ? r.delegationId.trim() : "";
+        if (delegationId)
+            delegationTaskIdsThisTurn.add(delegationId);
+        const approval = r.approvalRequired === true
+            ? " The person must approve this handoff first; their card appears after your turn ends."
+            : "";
+        const timing = r.state === "queued"
+            ? ` @${String(r.botName ?? "that bot")} can run ${Number(r.limit) || 0} threads at once and they are all spoken for, so it waits ${ordinal(Number(r.position) || 1)} in line for a free slot after this turn ends.`
+            : " It starts when this turn ends, like any handoff.";
+        return {
+            text: `${opened}${timing}${approval} Its result will be delivered to this conversation automatically (delegation id: ${delegationId || "unknown"}). Acknowledge it, mention it to the person as #${threadTitle}, and finish your turn; do not check or wait for it in this turn.`,
+        };
+    }
     if (name === "create_bot") {
         const botName = String(args.name ?? "").trim();
         const role = String(args.role ?? "").trim();

package/dist-server/server/drivers/claude-login-auth.js

@@ -51,6 +51,7 @@ export function claudeLoginCode(value) {
 const NOT_AVAILABLE = "This sign-in is no longer available. Start sign-in again.";
 export class ClaudeLoginController {
     flow = null;
+    logoutChild = null;
     disposed = false;
     options;
     constructor(options) {
@@ -149,20 +150,112 @@ export class ClaudeLoginController {
         await this.flow?.stopping;
         if (this.flow?.terminationFailed)
             throw new Error(this.flow.status.message);
+        if (this.logoutChild && !await this.stopChild(this.logoutChild)) {
+            throw new Error("Claude Code could not be stopped on this server. Ask the server administrator to stop the account command before trying again.");
+        }
     }
     async dispose() {
         this.disposed = true;
         await this.cancel();
         this.flow = null;
     }
+    /** Remove the sign-in Claude Code stores for this server account (its
+     * configuration directory) so a different subscription can sign in. A
+     * sign-in in progress is never pulled away underneath the browser
+     * completing it, and the CLI's own status is the verdict, as for sign-in. */
+    async signOut() {
+        if (this.disposed)
+            throw new Error("This provider was removed. Refresh Settings before signing out.");
+        if (this.flow?.status.phase === "waiting")
+            throw new Error("Finish or cancel the Claude sign-in in progress before signing out.");
+        await this.flow?.stopping;
+        if (this.disposed)
+            throw new Error("This provider was removed. Refresh Settings before signing out.");
+        const env = this.options.environment();
+        const home = env.HOME || env.USERPROFILE || homedir();
+        if (!isAbsolute(home) || (env.CLAUDE_CONFIG_DIR && !isAbsolute(env.CLAUDE_CONFIG_DIR))) {
+            throw new Error("Use an absolute HOME and CLAUDE_CONFIG_DIR path for this server's Claude provider before signing out.");
+        }
+        const homeKey = canonicalPath(resolve(env.CLAUDE_CONFIG_DIR || join(home, ".claude")));
+        if (authenticatingHomes.has(homeKey)) {
+            throw new Error("A Claude sign-in is running for this server account. Finish or cancel it before signing out.");
+        }
+        authenticatingHomes.add(homeKey);
+        try {
+            await this.logout(env);
+            if (this.disposed)
+                throw new Error("This provider was removed. Refresh Settings before signing out.");
+            const status = await this.authStatus(env);
+            if (status === "in")
+                throw new Error("Claude Code still reports a sign-in on this server. Update Claude Code and check its auth status before trying again.");
+            if (status === "unknown")
+                throw new Error("Claude Code could not confirm the sign-out on this server. Update Claude Code and check its auth status before trying again.");
+        }
+        finally {
+            // A command the OS could not stop may still change credentials. Keep
+            // this home reserved until that exact child actually exits.
+            const child = this.logoutChild;
+            if (child && child.exitCode === null && child.signalCode === null) {
+                child.once("close", () => authenticatingHomes.delete(homeKey));
+            }
+            else
+                authenticatingHomes.delete(homeKey);
+        }
+    }
+    /** `claude auth logout`, bounded and non-interactive. Its output stays
+     * here; the status command afterwards decides whether it worked. */
+    logout(env) {
+        return new Promise((resolveDone, rejectDone) => {
+            if (this.disposed) {
+                rejectDone(new Error("This provider was removed. Refresh Settings before signing out."));
+                return;
+            }
+            let child;
+            try {
+                child = spawnCli(this.options.cli, ["auth", "logout"], { env: { ...env, NO_COLOR: "1" }, stdio: ["pipe", "pipe", "pipe"] });
+            }
+            catch {
+                rejectDone(new Error("Claude Code could not start on this server. Install or update the configured Claude CLI, then try again."));
+                return;
+            }
+            this.logoutChild = child;
+            child.stdin.end();
+            child.stdout.on("data", () => { });
+            child.stderr.on("data", () => { });
+            // A hung CLI must not hold the credential-home lock forever.
+            const timer = setTimeout(() => {
+                void this.stopChild(child).catch(() => false).then((stopped) => {
+                    if (!stopped)
+                        rejectDone(new Error("Claude Code could not be stopped on this server. Ask the server administrator to stop the account command before trying again."));
+                });
+            }, this.options.startupTimeoutMs ?? 30_000);
+            timer.unref();
+            child.once("error", (error) => {
+                clearTimeout(timer);
+                rejectDone(new Error(error.code === "ENOENT"
+                    ? "Claude Code is not installed on this server. Install it on the server, then try again."
+                    : "Claude Code could not start on this server. Check the configured CLI path and its executable permissions."));
+            });
+            child.once("close", () => {
+                clearTimeout(timer);
+                if (this.logoutChild === child)
+                    this.logoutChild = null;
+                resolveDone();
+            });
+        });
+    }
     signedIn(env) {
+        return this.authStatus(env).then((status) => status === "in");
+    }
+    /** `claude auth status --json`: signed in, signed out, or not answered. */
+    authStatus(env) {
         return new Promise((resolveStatus) => {
             let child;
             try {
                 child = spawnCli(this.options.cli, ["auth", "status", "--json"], { env: { ...env, NO_COLOR: "1" }, stdio: ["ignore", "pipe", "pipe"] });
             }
             catch {
-                resolveStatus(false);
+                resolveStatus("unknown");
                 return;
             }
             let stdout = "";
@@ -173,21 +266,22 @@ export class ClaudeLoginController {
             child.stderr.on("data", () => { });
             const timer = setTimeout(() => {
                 child.kill("SIGKILL");
-                resolveStatus(false);
+                resolveStatus("unknown");
             }, 8_000);
             timer.unref();
             child.once("error", () => {
                 clearTimeout(timer);
-                resolveStatus(false);
+                resolveStatus("unknown");
             });
-            child.once("close", () => {
+            child.once("close", (code) => {
                 clearTimeout(timer);
                 try {
                     const status = JSON.parse(stdout);
-                    resolveStatus(typeof status === "object" && status !== null && Reflect.get(status, "loggedIn") === true);
+                    const loggedIn = typeof status === "object" && status !== null ? Reflect.get(status, "loggedIn") : undefined;
+                    resolveStatus(code === 0 && loggedIn === true ? "in" : code === 1 && loggedIn === false ? "out" : "unknown");
                 }
                 catch {
-                    resolveStatus(false);
+                    resolveStatus("unknown");
                 }
             });
         });
@@ -286,7 +380,7 @@ export class ClaudeLoginController {
                 flow.completion.reject(new Error(message ?? "Claude sign-in did not finish."));
             flow.completion = undefined;
         }
-        flow.stopping = this.stopChild(flow)
+        flow.stopping = this.stopChild(flow.child)
             .catch(() => false)
             .then((stopped) => {
             const release = () => authenticatingHomes.delete(flow.homeKey);
@@ -305,8 +399,7 @@ export class ClaudeLoginController {
         if (phase === "succeeded")
             void this.options.onAuthenticated?.().catch(() => { });
     }
-    async stopChild(flow) {
-        const child = flow.child;
+    async stopChild(child) {
         if (!child || (await killCliTree(child, this.options.terminateTimeoutMs ?? 1500)))
             return true;
         if (process.platform !== "win32" && child.pid) {