openmausbot 0.1.68 → 0.1.70

package/dist-server/server/drivers/acp/qwen.js

@@ -2,13 +2,109 @@
 // the official pane has no Qwen Cloud catalog; live local hosts land in
 // Custom and are written into ~/.qwen/settings.json modelProviders.
 import { chmodSync, existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { createHash } from "node:crypto";
 import { homedir } from "node:os";
 import { join } from "node:path";
 import { decodeInjectId, hostApiKey, localHost, mergeLocalInject } from "../local-inject.js";
 import { createAcpDriver } from "./core.js";
 const EMPTY = { default: "", options: [] };
 function qwenHome(env) {
-    return join(env.HOME || env.USERPROFILE || homedir(), ".qwen");
+    const home = process.platform === "win32"
+        ? env.USERPROFILE || env.HOME || homedir()
+        : env.HOME || env.USERPROFILE || homedir();
+    return join(home, ".qwen");
+}
+function isRecord(value) {
+    return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
+function qwenModelLabel(id, name) {
+    if (!name || name.toLocaleLowerCase().endsWith(id.toLocaleLowerCase()))
+        return id;
+    return `${id} — ${name}`;
+}
+const PROTOCOLS = new Set(["openai", "anthropic", "gemini", "vertex-ai"]);
+function readQwenRoutes(env) {
+    let settings;
+    try {
+        settings = JSON.parse(readFileSync(join(qwenHome(env), "settings.json"), "utf8"));
+    }
+    catch {
+        return [];
+    }
+    if (!isRecord(settings) || !isRecord(settings.modelProviders))
+        return [];
+    const routes = [];
+    const seen = new Set();
+    const mappings = isRecord(settings.providerProtocol) ? settings.providerProtocol : {};
+    for (const [provider, rows] of Object.entries(settings.modelProviders)) {
+        const protocol = Object.hasOwn(mappings, provider) ? mappings[provider] : provider;
+        if (typeof protocol !== "string" || !PROTOCOLS.has(protocol) || !Array.isArray(rows))
+            continue;
+        for (const row of rows) {
+            if (!isRecord(row) || typeof row.id !== "string")
+                continue;
+            const model = row.id;
+            if (!model.trim())
+                continue;
+            if (row.baseUrl !== undefined && typeof row.baseUrl !== "string")
+                continue;
+            const baseUrl = typeof row.baseUrl === "string" && row.baseUrl ? row.baseUrl : undefined;
+            if (baseUrl) {
+                try {
+                    new URL(baseUrl);
+                }
+                catch {
+                    throw new Error("A Qwen model has an invalid endpoint. Fix its baseUrl in Qwen settings and refresh models.");
+                }
+            }
+            const identity = JSON.stringify([protocol, model, baseUrl ?? null]);
+            if (seen.has(identity))
+                continue;
+            seen.add(identity);
+            if (row.imageOnly === true || row.voiceOnly === true || row.fastOnly === true)
+                continue;
+            routes.push({ id: `${model}(${protocol})`, model, provider, protocol, baseUrl,
+                label: typeof row.name === "string" && row.name ? row.name : model,
+                envKey: typeof row.envKey === "string" ? row.envKey : undefined });
+        }
+    }
+    // Qwen's ACP route identity, from QwenLM/qwen-code acpModelUtils.ts
+    // (Copyright 2025 Qwen Team, Apache-2.0). Never publish endpoints or env keys.
+    const counts = new Map();
+    for (const route of routes)
+        counts.set(route.id, (counts.get(route.id) ?? 0) + 1);
+    for (const route of routes) {
+        if (counts.get(route.id) === 1)
+            continue;
+        const endpoint = route.baseUrl ?? (route.protocol === "openai" ? "https://api.openai.com/v1" : "");
+        let publicEndpoint = null;
+        if (endpoint) {
+            try {
+                const url = new URL(endpoint);
+                url.username = "";
+                url.password = "";
+                url.search = "";
+                url.hash = "";
+                publicEndpoint = url.href;
+            }
+            catch {
+                throw new Error("A Qwen model has an invalid endpoint. Fix its baseUrl in Qwen settings and refresh models.");
+            }
+        }
+        const identity = [route.id, route.label, route.envKey ?? null, route.baseUrl === undefined, publicEndpoint];
+        route.id = `qwen-route:v1:${createHash("sha256").update(JSON.stringify(identity)).digest("base64url").slice(0, 16)}`;
+    }
+    if (new Set(routes.map((route) => route.id)).size !== routes.length) {
+        throw new Error("Qwen has indistinguishable model routes. Give them distinct names, envKey values, or public endpoints in Qwen settings.");
+    }
+    return routes;
+}
+/** Public metadata only. Use Qwen's provider-qualified ACP selectors, not raw model IDs. */
+export function readQwenModelCatalog(env = process.env) {
+    const options = readQwenRoutes(env).map(({ id, model, label, provider }) => ({
+        id, label: qwenModelLabel(model, label), custom: true, provider,
+    }));
+    return { default: options[0]?.id ?? "", options };
 }
 function envKeyFor(hostId) {
     return `OPENMAUSBOT_QWEN_${hostId.toUpperCase().replace(/[^A-Z0-9]+/g, "_")}_API_KEY`;
@@ -68,8 +164,46 @@ export function ensureQwenInjectModel(modelId, env = process.env) {
     return inject.model;
 }
 async function resolveModels(env) {
-    const catalog = await mergeLocalInject(EMPTY, env);
-    return { default: catalog.options[0]?.id ?? "", options: catalog.options };
+    const catalog = await mergeLocalInject(readQwenModelCatalog(env), env);
+    const routes = readQwenRoutes(env);
+    const replacements = new Map();
+    for (const option of catalog.options) {
+        const injected = decodeInjectId(option.id);
+        if (!injected)
+            continue;
+        const endpoint = localHost(injected.host)?.baseUrl;
+        for (const route of routes) {
+            if (route.protocol === "openai" && route.model === injected.model && route.baseUrl === endpoint) {
+                replacements.set(route.id, option.id);
+            }
+        }
+    }
+    const options = catalog.options.filter((option) => !replacements.has(option.id));
+    const preferred = replacements.get(catalog.default) ?? catalog.default;
+    return { default: options.some((option) => option.id === preferred) ? preferred : options[0]?.id ?? "", options };
+}
+export function resolveQwenTurnModel(model, env) {
+    if (!model)
+        return model;
+    const injected = decodeInjectId(model);
+    if (injected)
+        ensureQwenInjectModel(model, env);
+    const routes = readQwenRoutes(env);
+    if (injected) {
+        const route = routes.find((row) => row.protocol === "openai" && row.model === injected.model
+            && row.baseUrl === localHost(injected.host)?.baseUrl);
+        if (!route)
+            throw new Error("Qwen could not configure this local model. Refresh models and select it again.");
+        return route.id;
+    }
+    if (routes.some((route) => route.id === model))
+        return model;
+    const matches = routes.filter((route) => route.model === model);
+    if (matches.length > 1)
+        throw new Error("This Qwen model has multiple providers. Refresh models and select the intended provider again.");
+    if (!matches.length)
+        throw new Error("This Qwen model is no longer configured. Refresh models and select it again.");
+    return matches[0].id;
 }
 const support = {
     driverKind: "qwenAgent",
@@ -77,7 +211,7 @@ const support = {
     access: "custom",
     models: EMPTY,
     resolveModels,
-    resolveTurnModel: (model, env) => (model ? ensureQwenInjectModel(model, env) : model),
+    resolveTurnModel: resolveQwenTurnModel,
     defaultCli: "qwen",
     nativeSource: "qwen.acp",
     loginNote: "Qwen Code CLI is not installed",
@@ -89,7 +223,10 @@ const support = {
         },
         docsUrl: "https://qwenlm.github.io/qwen-code-docs/en/users/overview/",
     },
-    spawnArgs: (_config, turn) => ["--acp", ...(turn.model ? ["-m", turn.model] : [])],
+    // A raw -m only changes the model within the saved provider. ACP switches
+    // the complete route and confirms it before any prompt leaves OMB.
+    spawnArgs: () => ["--acp"],
+    selectModel: { configId: "model" },
     pickAuthMethod: () => null,
     authFailure: "continue",
     isAuthenticated: () => true,

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",
@@ -64,7 +73,7 @@ const WEEKDAYS = [
 const ROUTINE_SCHEDULE_SCHEMA = {
     type: "object",
     additionalProperties: false,
-    description: 'Either {"type":"once","at":RFC3339} for one future run, {"type":"weekly","time":"HH:MM","weekdays":[...]} for chosen days, {"type":"daily","time":"HH:MM"} for every day, or {"type":"interval","every_minutes":15,"starts_at":RFC3339} to repeat from an optional starting point.',
+    description: 'Either {"type":"once","at":RFC3339} for one future run, {"type":"weekly","time":"HH:MM","weekdays":[...]} for chosen days, {"type":"daily","time":"HH:MM"} for every day, or {"type":"interval","every_minutes":15} to repeat. Intervals can optionally be limited with weekdays, window_start + window_end, and ends_at.',
     properties: {
         type: {
             type: "string",
@@ -82,7 +91,7 @@ const ROUTINE_SCHEDULE_SCHEMA = {
         weekdays: {
             type: "array",
             items: { type: "string", enum: WEEKDAYS },
-            description: "Only for type weekly: which days the routine runs, in the computer's local timezone.",
+            description: "For type weekly: required run days. For type interval: optional allowed days. Values use the computer's local timezone.",
         },
         every_minutes: {
             type: "integer",
@@ -94,6 +103,30 @@ const ROUTINE_SCHEDULE_SCHEMA = {
             type: "string",
             description: "Optional for type interval: RFC3339 date-time with an explicit timezone offset that anchors the cadence. Omit to start one interval after confirmation.",
         },
+        window_start: {
+            type: "string",
+            description: "Optional for type interval, together with window_end: local 24-hour HH:MM when runs may begin, inclusive.",
+        },
+        window_end: {
+            type: "string",
+            description: "Optional for type interval, together with window_start: local 24-hour HH:MM when the allowed window ends, exclusive. It must be later on the same day.",
+        },
+        ends_at: {
+            type: "string",
+            description: "Optional for type interval: inclusive RFC3339 date-time cutoff with an explicit timezone offset.",
+        },
+        every_day: {
+            type: "boolean",
+            description: "Only for an interval update: true removes an existing weekday restriction.",
+        },
+        all_day: {
+            type: "boolean",
+            description: "Only for an interval update: true removes an existing time-window restriction.",
+        },
+        never_ends: {
+            type: "boolean",
+            description: "Only for an interval update: true removes an existing end cutoff.",
+        },
     },
     required: ["type"],
 };
@@ -111,7 +144,7 @@ const SHORT_WEEKDAYS = {
 };
 const SUPPORTED_SCHEDULES = 'Supported schedules: {"type":"once","at":"2026-09-01T09:00:00+05:30"} (future RFC3339 with explicit offset), ' +
     '{"type":"weekly","time":"09:00","weekdays":["monday","friday"]}, {"type":"daily","time":"09:00"}, ' +
-    'or {"type":"interval","every_minutes":15}.';
+    'or {"type":"interval","every_minutes":15,"weekdays":["monday","friday"],"window_start":"09:00","window_end":"17:00"}.';
 /** A schedule as the harness accepts it, or a message telling the model
  * exactly what to send instead. Coercion first, error second: models
  * routinely stringify nested objects, say "daily", or shorten weekday
@@ -135,7 +168,7 @@ function normalizeScheduleInput(args) {
         : type === "weekly" || type === "daily"
             ? ["type", "time", "weekdays"]
             : type === "interval"
-                ? ["type", "every_minutes", "everyMinutes", "starts_at", "anchorAt"]
+                ? ["type", "every_minutes", "everyMinutes", "starts_at", "anchorAt", "weekdays", "every_day", "window_start", "window_end", "window", "all_day", "ends_at", "endsAt", "never_ends"]
                 : null;
     // Provider conversions may send unused optional fields as null. Ignore
     // those, but never silently discard an actual scheduling constraint (for
@@ -181,6 +214,16 @@ function normalizeScheduleInput(args) {
         return { schedule: { type: "weekly", time, weekdays: normalized } };
     }
     if (type === "interval") {
+        for (const flag of ["every_day", "all_day", "never_ends"]) {
+            if (raw[flag] != null && typeof raw[flag] !== "boolean") {
+                return { error: `"${flag}" must be true or false.` };
+            }
+        }
+        if (raw.window != null && (!jsonRecord(raw.window)
+            || Object.keys(raw.window).some((key) => key !== "start" && key !== "end")
+            || typeof raw.window.start !== "string" || typeof raw.window.end !== "string")) {
+            return { error: '"window" must contain "start" and "end" in HH:MM, for example {"start":"09:00","end":"17:00"}.' };
+        }
         const rawMinutes = raw.every_minutes ?? raw.everyMinutes;
         const everyMinutes = Number(rawMinutes);
         if (!Number.isInteger(everyMinutes) || everyMinutes < 5 || everyMinutes > 1_440) {
@@ -190,11 +233,68 @@ function normalizeScheduleInput(args) {
         if (rawStart !== undefined && (typeof rawStart !== "string" || !rawStart.trim())) {
             return { error: '"starts_at" must be an RFC3339 date-time with an explicit timezone offset.' };
         }
+        if (raw.every_day === true && Array.isArray(raw.weekdays) && raw.weekdays.length > 0) {
+            return { error: 'Choose interval "weekdays" or "every_day", not both.' };
+        }
+        let intervalWeekdays;
+        if (raw.every_day === true) {
+            intervalWeekdays = null;
+        }
+        else if (raw.weekdays !== undefined) {
+            if (!Array.isArray(raw.weekdays) || raw.weekdays.length === 0) {
+                return { error: 'Interval "weekdays" must contain at least one full weekday name.' };
+            }
+            intervalWeekdays = [];
+            for (const day of raw.weekdays) {
+                const lower = String(day).trim().toLowerCase();
+                const full = WEEKDAYS.includes(lower)
+                    ? lower
+                    : Object.hasOwn(SHORT_WEEKDAYS, lower)
+                        ? SHORT_WEEKDAYS[lower]
+                        : undefined;
+                if (!full)
+                    return { error: `Unsupported weekday "${String(day)}". Use full names: ${WEEKDAYS.join(", ")}.` };
+                if (!intervalWeekdays.includes(full))
+                    intervalWeekdays.push(full);
+            }
+        }
+        const rawWindow = jsonRecord(raw.window) ? raw.window : undefined;
+        const windowStart = raw.window_start ?? rawWindow?.start;
+        const windowEnd = raw.window_end ?? rawWindow?.end;
+        if (raw.all_day === true && (windowStart !== undefined || windowEnd !== undefined)) {
+            return { error: 'Choose window_start + window_end or "all_day", not both.' };
+        }
+        let window;
+        if (raw.all_day === true) {
+            window = null;
+        }
+        else if (windowStart !== undefined || windowEnd !== undefined) {
+            if (typeof windowStart !== "string" || !windowStart.trim() || typeof windowEnd !== "string" || !windowEnd.trim()) {
+                return { error: 'An interval time window needs both "window_start" and "window_end" in 24-hour HH:MM.' };
+            }
+            window = { start: windowStart.trim(), end: windowEnd.trim() };
+        }
+        const rawEnd = raw.ends_at ?? raw.endsAt;
+        if (raw.never_ends === true && rawEnd !== undefined) {
+            return { error: 'Choose "ends_at" or "never_ends", not both.' };
+        }
+        let endsAt;
+        if (raw.never_ends === true)
+            endsAt = null;
+        else if (rawEnd !== undefined) {
+            if (typeof rawEnd !== "string" || !rawEnd.trim()) {
+                return { error: '"ends_at" must be an RFC3339 date-time with an explicit timezone offset.' };
+            }
+            endsAt = rawEnd.trim();
+        }
         return {
             schedule: {
                 type: "interval",
                 everyMinutes,
                 ...(typeof rawStart === "string" ? { anchorAt: rawStart.trim() } : {}),
+                ...(intervalWeekdays !== undefined ? { weekdays: intervalWeekdays } : {}),
+                ...(window !== undefined ? { window } : {}),
+                ...(endsAt !== undefined ? { endsAt } : {}),
             },
         };
     }
@@ -291,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.",
@@ -504,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);
 }
@@ -738,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) {