openmausbot 0.1.66 → 0.1.67

package/dist-server/local-computer-proxy.js

@@ -0,0 +1,433 @@
+// server/mcp-bridge.ts
+import { spawn } from "node:child_process";
+import { StringDecoder } from "node:string_decoder";
+
+// server/control-client.ts
+var DISENGAGED = { held: false, helpOpen: false };
+var UNAVAILABLE = { held: true, helpOpen: false };
+function createControlClient(options) {
+  const url2 = options?.url ?? process.env.OMB_CONTROL_URL ?? "";
+  const token2 = options?.token ?? process.env.OMB_CONTROL_TOKEN ?? "";
+  const cacheMs = options?.cacheMs ?? 750;
+  const fetchImpl = options?.fetchImpl ?? fetch;
+  const configured = Boolean(url2 && token2);
+  const headers = { authorization: `Bearer ${token2}`, "content-type": "application/json" };
+  let cachedAt = 0;
+  let cached2 = DISENGAGED;
+  async function read() {
+    try {
+      const res = await fetchImpl(url2, { headers, signal: AbortSignal.timeout(2e3) });
+      if (!res.ok) return UNAVAILABLE;
+      const body = await res.json().catch(() => null);
+      if (typeof body?.held !== "boolean" || typeof body?.helpOpen !== "boolean") return UNAVAILABLE;
+      return {
+        held: body.held,
+        helpOpen: body.helpOpen,
+        ...typeof body.blockedReason === "string" && body.blockedReason.trim() ? { blockedReason: body.blockedReason } : {}
+      };
+    } catch {
+      return UNAVAILABLE;
+    }
+  }
+  return {
+    configured,
+    async state(fresh = false) {
+      if (!configured) return DISENGAGED;
+      const now = Date.now();
+      if (!fresh && now - cachedAt < cacheMs) return cached2;
+      cached2 = await read();
+      cachedAt = Date.now();
+      return cached2;
+    },
+    async requestHelp(reason) {
+      if (!configured) return null;
+      try {
+        const res = await fetchImpl(url2, {
+          method: "POST",
+          headers,
+          body: JSON.stringify({ reason }),
+          signal: AbortSignal.timeout(2e3)
+        });
+        if (!res.ok) return null;
+        const body = await res.json().catch(() => null);
+        return typeof body?.requestId === "string" && body.requestId ? body.requestId : null;
+      } catch {
+        return null;
+      }
+    },
+    async expireHelp(requestId) {
+      if (!configured || !requestId) return;
+      try {
+        await fetchImpl(url2, {
+          method: "DELETE",
+          headers,
+          body: JSON.stringify({ requestId }),
+          signal: AbortSignal.timeout(2e3)
+        });
+      } catch {
+      }
+    }
+  };
+}
+var CONTROL_REFUSAL_PLAIN = "A person has taken control of this computer, so this call was NOT performed. Do not retry it \u2014 the screen is changing under their hands. Pause this task, tell the person you are waiting for them to hand control back, and take a fresh screenshot before your next action once they have.";
+
+// server/env-path.ts
+import { execFile } from "node:child_process";
+import { closeSync, existsSync, openSync, readFileSync, readSync, statSync, readdirSync } from "node:fs";
+import { homedir } from "node:os";
+import { basename, delimiter, dirname, extname, join } from "node:path";
+function nvmBinDirs() {
+  try {
+    const base = join(homedir(), ".nvm", "versions", "node");
+    return readdirSync(base).filter((v) => v.startsWith("v")).sort((a, b) => b.localeCompare(a, void 0, { numeric: true })).map((v) => join(base, v, "bin"));
+  } catch {
+    return [];
+  }
+}
+function knownDirs() {
+  const home = homedir();
+  return [
+    join(home, ".local", "bin"),
+    // claude installer default
+    join(home, ".npm-global", "bin"),
+    // npm prefix ~/.npm-global (claude, opencode)
+    join(home, ".kimi-code", "bin"),
+    // kimi-code installer
+    join(home, ".grok", "bin"),
+    // x.ai installer
+    join(home, ".opencode", "bin"),
+    // opencode installer
+    join(home, ".claude", "local"),
+    // claude "local install"
+    "/opt/homebrew/bin",
+    // brew, Apple silicon
+    "/usr/local/bin",
+    // brew Intel / classic installs
+    join(home, ".volta", "bin"),
+    join(home, ".bun", "bin"),
+    join(home, ".asdf", "shims"),
+    join(home, ".deno", "bin"),
+    join(home, "bin"),
+    ...nvmBinDirs()
+  ];
+}
+function windowsKnownDirs() {
+  const home = homedir();
+  const appData = process.env.APPDATA ?? join(home, "AppData", "Roaming");
+  const localAppData = process.env.LOCALAPPDATA ?? join(home, "AppData", "Local");
+  return [
+    join(appData, "npm"),
+    // npm -g shims: claude, codex
+    join(home, ".grok", "bin"),
+    // x.ai installer
+    join(localAppData, "agy", "bin"),
+    // Antigravity installer
+    join(home, ".local", "bin"),
+    // claude native installer
+    join(home, ".claude", "local"),
+    join(home, "bin"),
+    // Factory droid installer (%USERPROFILE%\bin)
+    join(home, ".bun", "bin"),
+    join(home, ".deno", "bin"),
+    join(home, "go", "bin")
+  ];
+}
+var cached = null;
+var probed = false;
+var loginShellPath = null;
+function augmentedPath() {
+  if (cached === null) {
+    cached = mergePaths([
+      ...process.env.OMB_EXTRA_PATH ? process.env.OMB_EXTRA_PATH.split(delimiter) : [],
+      ...process.env.PATH ? process.env.PATH.split(delimiter) : [],
+      // Keep the last successful login-shell result while a rescan starts a
+      // fresh asynchronous probe. Otherwise resetPathCache() would make
+      // rc-only CLIs disappear again for the response that triggered it.
+      ...loginShellPath ? loginShellPath.split(delimiter) : [],
+      // Both platforms scan their standard install locations; only the
+      // login-shell probe below stays unix-only, since Windows has no
+      // equivalent rc file to source.
+      ...(process.platform === "win32" ? windowsKnownDirs() : knownDirs()).filter((d) => existsSync(d))
+    ]);
+  }
+  if (!probed && !process.env.VITEST && process.platform !== "win32") {
+    probed = true;
+    probeLoginShellPath();
+  }
+  return cached;
+}
+function mergePaths(parts) {
+  return [...new Set(parts.filter(Boolean))].join(delimiter);
+}
+function probeLoginShellPath() {
+  const shell = process.env.SHELL || "/bin/zsh";
+  execFile(
+    shell,
+    ["-l", "-i", "-c", 'printf "__OMB_PATH__%s" "$PATH"'],
+    { timeout: 5e3 },
+    (err, stdout) => {
+      if (err || !stdout) return;
+      const m = /__OMB_PATH__([^\n]*)/.exec(stdout);
+      if (!m || !m[1]) return;
+      loginShellPath = m[1];
+      cached = mergePaths([...(cached ?? "").split(delimiter), ...m[1].split(delimiter)]);
+    }
+  );
+}
+
+// server/mcp-bridge.ts
+var BRIDGE_INACTIVITY_MS = 45e3;
+var PROBE_TIMEOUT_MS = 1e4;
+function runLivenessProbe(probe, timeoutMs = PROBE_TIMEOUT_MS) {
+  return new Promise((resolve) => {
+    const child = spawn(probe.command, probe.args, {
+      shell: false,
+      env: { ...process.env, PATH: augmentedPath() },
+      stdio: ["ignore", "ignore", "ignore"]
+    });
+    const timer = setTimeout(() => {
+      child.kill("SIGKILL");
+      resolve(false);
+    }, timeoutMs);
+    timer.unref?.();
+    child.on("error", () => {
+      clearTimeout(timer);
+      resolve(false);
+    });
+    child.on("close", (code) => {
+      clearTimeout(timer);
+      resolve(code === 0);
+    });
+  });
+}
+function createInactivityWatchdog(options) {
+  let timer = null;
+  let stopped = false;
+  let probing = false;
+  let touchedWhileProbing = false;
+  const arm = () => {
+    if (stopped) return;
+    timer = setTimeout(fire, options.inactivityMs);
+    timer.unref?.();
+  };
+  const settleProbe = (alive) => {
+    probing = false;
+    if (stopped) return;
+    if (alive || touchedWhileProbing) {
+      arm();
+      return;
+    }
+    options.onDead();
+  };
+  const fire = () => {
+    probing = true;
+    touchedWhileProbing = false;
+    void options.probe().then(settleProbe, () => settleProbe(false));
+  };
+  arm();
+  return {
+    touch() {
+      if (stopped) return;
+      if (probing) {
+        touchedWhileProbing = true;
+        return;
+      }
+      if (timer) clearTimeout(timer);
+      arm();
+    },
+    stop() {
+      stopped = true;
+      if (timer) clearTimeout(timer);
+    }
+  };
+}
+function createLineSplitter(onLine) {
+  let pending = "";
+  const decoder = new StringDecoder("utf8");
+  return {
+    push(chunk) {
+      pending += typeof chunk === "string" ? chunk : decoder.write(chunk);
+      let newline;
+      while ((newline = pending.indexOf("\n")) !== -1) {
+        const line = pending.slice(0, newline);
+        pending = pending.slice(newline + 1);
+        onLine(line);
+      }
+    },
+    flush() {
+      pending += decoder.end();
+      if (pending) onLine(pending);
+      pending = "";
+    }
+  };
+}
+function createGateInterceptor(options) {
+  const refusalText = options.refusalText ?? CONTROL_REFUSAL_PLAIN;
+  let queue = Promise.resolve();
+  return (line) => {
+    queue = queue.then(async () => {
+      let frame = null;
+      try {
+        frame = JSON.parse(line);
+      } catch {
+      }
+      if (!frame || frame.method !== "tools/call") {
+        options.forward(line);
+        return;
+      }
+      const held = await options.isHeld().catch(() => true);
+      if (!held) {
+        options.forward(line);
+        return;
+      }
+      options.refuse(
+        JSON.stringify({
+          jsonrpc: "2.0",
+          id: frame.id ?? null,
+          result: { content: [{ type: "text", text: options.getRefusalReason?.() ?? refusalText }], isError: true }
+        })
+      );
+    });
+    return queue;
+  };
+}
+function createMcpBridgeInterceptor(options) {
+  const afterPing = options.gate ? createGateInterceptor({
+    isHeld: options.gate.isHeld,
+    forward: options.forward,
+    refuse: options.answer,
+    refusalText: options.gate.refusalText,
+    getRefusalReason: options.gate.getRefusalReason
+  }) : (line) => {
+    options.forward(line);
+  };
+  return (line) => {
+    let frame = null;
+    try {
+      frame = JSON.parse(line);
+    } catch {
+    }
+    if (frame && frame.method === "ping") {
+      if (frame.id !== void 0) {
+        options.answer(JSON.stringify({ jsonrpc: "2.0", id: frame.id, result: {} }));
+      }
+      return;
+    }
+    return afterPing(line);
+  };
+}
+function runMcpBridge(options) {
+  const child = spawn(options.command, options.args, {
+    shell: false,
+    env: options.env ?? { ...process.env, PATH: augmentedPath() },
+    stdio: ["pipe", "pipe", "pipe"]
+  });
+  child.stdin.on("error", () => {
+  });
+  child.stderr.pipe(process.stderr);
+  const client = options.gate ? createControlClient({ url: options.gate.url, token: options.gate.token }) : null;
+  let refusalReason;
+  const answer = (line) => process.stdout.write(line + "\n");
+  const forward = (line) => child.stdin.write(line + "\n");
+  const intercept = createMcpBridgeInterceptor({
+    answer,
+    forward,
+    ...options.gate ? {
+      gate: {
+        isHeld: async () => {
+          refusalReason = void 0;
+          const state = await client.state(true);
+          refusalReason = state.blockedReason;
+          return state.held;
+        },
+        getRefusalReason: () => refusalReason
+      }
+    } : {}
+  });
+  let pendingInput = Promise.resolve();
+  const inbound = createLineSplitter((line) => {
+    const completion = intercept(line);
+    if (completion) pendingInput = completion;
+  });
+  const onStdin = (chunk) => inbound.push(chunk);
+  process.stdin.on("data", onStdin);
+  process.stdin.on("end", () => {
+    inbound.flush();
+    void pendingInput.finally(() => child.stdin.end());
+  });
+  const outbound = createLineSplitter((line) => process.stdout.write(line + "\n"));
+  child.stdout.on("data", (chunk) => outbound.push(chunk));
+  child.stdout.on("end", () => outbound.flush());
+  const detach = () => {
+    process.stdin.off("data", onStdin);
+    process.stdin.pause();
+  };
+  let watchdog = null;
+  if (options.liveness) {
+    const liveness = options.liveness;
+    watchdog = createInactivityWatchdog({
+      inactivityMs: BRIDGE_INACTIVITY_MS,
+      probe: () => runLivenessProbe(liveness),
+      onDead: () => {
+        process.stderr.write(
+          `${options.label} transport went silent and stopped answering liveness probes; ending the bridge
+`
+        );
+        process.exitCode = 1;
+        detach();
+        child.kill("SIGKILL");
+        const failsafe = setTimeout(() => process.exit(1), 2e3);
+        failsafe.unref?.();
+      }
+    });
+    const touch = () => watchdog?.touch();
+    process.stdin.on("data", touch);
+    child.stdout.on("data", touch);
+    child.stderr.on("data", touch);
+  }
+  child.on("error", (error) => {
+    process.stderr.write(`could not connect to ${options.label}: ${error.message}
+`);
+    process.exitCode = 1;
+    watchdog?.stop();
+    detach();
+  });
+  child.on("close", (code, signal) => {
+    if (signal) process.stderr.write(`${options.label} connection ended with ${signal}
+`);
+    process.exitCode = process.exitCode ?? code ?? 1;
+    watchdog?.stop();
+    detach();
+  });
+  for (const signal of ["SIGTERM", "SIGINT"]) {
+    process.on(signal, () => child.kill(signal));
+  }
+}
+
+// server/local-computer-proxy.ts
+var {
+  OMB_CUA_COMMAND: command,
+  OMB_CUA_ARGS: encodedArgs,
+  OMB_CONTROL_URL: url,
+  OMB_CONTROL_TOKEN: token,
+  ...childEnv
+} = process.env;
+var args;
+try {
+  const parsed = JSON.parse(encodedArgs ?? "");
+  const endpoint = new URL(url ?? "");
+  if (!command?.trim() || command.includes("\0") || !Array.isArray(parsed) || !parsed.every((arg) => typeof arg === "string" && !arg.includes("\0")) || !token || !["http:", "https:"].includes(endpoint.protocol) || !["127.0.0.1", "localhost", "[::1]"].includes(endpoint.hostname) || endpoint.username || endpoint.password) {
+    throw new Error("invalid connection");
+  }
+  args = parsed;
+} catch {
+  process.stderr.write("invalid local computer proxy connection\n");
+  process.exit(2);
+}
+runMcpBridge({
+  command,
+  args,
+  env: { ...childEnv, PATH: augmentedPath() },
+  label: "Local Cua Driver",
+  gate: { url, token }
+});

package/dist-server/local-computer.js

@@ -1,7 +1,35 @@
 // server/local-computer.ts
 import { lstatSync, readFileSync, realpathSync, statSync } from "node:fs";
 import { homedir } from "node:os";
-import { dirname, isAbsolute, join } from "node:path";
+import { dirname as dirname2, isAbsolute, join as join2 } from "node:path";
+
+// server/proxy-paths.ts
+import { existsSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+var SERVER_ROOT = dirname(fileURLToPath(import.meta.url));
+function resolveProxy(relative) {
+  const source = join(SERVER_ROOT, `${relative}.ts`);
+  return existsSync(source) ? source : join(SERVER_ROOT, `${relative}.js`);
+}
+var SPAWNED_PROXIES = {
+  browser: resolveProxy("browser-proxy"),
+  computer: resolveProxy("computer-proxy"),
+  localComputer: resolveProxy("local-computer-proxy"),
+  permission: resolveProxy("permission-proxy"),
+  containerMcp: resolveProxy("container-mcp"),
+  vpsContainerMcp: resolveProxy("vps-container-mcp"),
+  agents: resolveProxy("drivers/agents-proxy"),
+  dweb: resolveProxy("drivers/dweb-proxy"),
+  connectors: resolveProxy("connector-proxy"),
+  phone: resolveProxy("drivers/phone-proxy"),
+  // Loaded by the external `pi` process via `-e`, not by this server — but
+  // resolved through the same single source of truth so the packaged layout
+  // check can assert it ships.
+  piMcpExtension: resolveProxy("drivers/pi-mcp-extension")
+};
+
+// server/local-computer.ts
 var REQUIRED_LINUX_TOOLS = ["click", "get_window_state", "list_apps", "type_text"];
 var DRIVER_FILE_IDENTITY_KEYS = [
   "dev",
@@ -13,6 +41,20 @@ var DRIVER_FILE_IDENTITY_KEYS = [
   "mtimeNs",
   "ctimeNs"
 ];
+function gatedLocalComputer(connection, control) {
+  return {
+    ...connection,
+    command: process.execPath,
+    args: ["--experimental-strip-types", SPAWNED_PROXIES.localComputer],
+    env: {
+      ...connection.env,
+      OMB_CUA_COMMAND: connection.command,
+      OMB_CUA_ARGS: JSON.stringify(connection.args),
+      OMB_CONTROL_URL: control.url,
+      OMB_CONTROL_TOKEN: control.token
+    }
+  };
+}
 function exactKeys(value, keys) {
   const expected = new Set(keys);
   return Object.keys(value).length === expected.size && Object.keys(value).every((key) => expected.has(key));
@@ -142,7 +184,7 @@ function validateLinuxDescriptorRuntime(descriptorFile, raw, {
 } = {}) {
   try {
     const descriptorStat = lstatSync(descriptorFile);
-    const descriptorDirectoryStat = lstatSync(dirname(descriptorFile));
+    const descriptorDirectoryStat = lstatSync(dirname2(descriptorFile));
     if (!descriptorStat.isFile() || descriptorStat.isSymbolicLink() || !ownedPrivate(descriptorStat, uid) || !descriptorDirectoryStat.isDirectory() || descriptorDirectoryStat.isSymbolicLink() || !ownedPrivate(descriptorDirectoryStat, uid)) {
       return false;
     }
@@ -153,7 +195,7 @@ function validateLinuxDescriptorRuntime(descriptorFile, raw, {
     const binaryStat = statSync(binaryPath);
     const currentFileIdentity = currentDriverFileIdentity(binaryPath);
     const socketStat = lstatSync(socketPath);
-    const socketDirectoryStat = lstatSync(dirname(socketPath));
+    const socketDirectoryStat = lstatSync(dirname2(socketPath));
     if (realpathSync(binaryPath) !== binaryPath || !sameDriverFileIdentity(driver.fileIdentity, currentFileIdentity) || !binaryStat.isFile() || binaryStat.uid !== uid && binaryStat.uid !== 0 || (binaryStat.mode & 73) === 0 || (binaryStat.mode & 18) !== 0 || !socketStat.isSocket() || socketStat.isSymbolicLink() || !ownedPrivate(socketStat, uid) || !socketDirectoryStat.isDirectory() || socketDirectoryStat.isSymbolicLink() || !ownedPrivate(socketDirectoryStat, uid) || !isProcessAlive(raw.ownerPid) || !isProcessAlive(daemon.pid)) {
       return false;
     }
@@ -168,10 +210,10 @@ function readCuaConnection({
   home = homedir(),
   validateLinuxRuntime = validateLinuxDescriptorRuntime
 } = {}) {
-  const candidates = userData ? [join(userData, "cua-connection.json")] : [];
+  const candidates = userData ? [join2(userData, "cua-connection.json")] : [];
   if (platform === "darwin") {
     for (const directory of ["OpenMausBot", "openmausbot", "OpenGrokBot", "opengrokbot"]) {
-      candidates.push(join(home, "Library", "Application Support", directory, "cua-connection.json"));
+      candidates.push(join2(home, "Library", "Application Support", directory, "cua-connection.json"));
     }
   }
   for (const file of [...new Set(candidates)]) {
@@ -193,6 +235,7 @@ export {
   DRIVER_FILE_IDENTITY_KEYS,
   REQUIRED_LINUX_TOOLS,
   decodeLinuxDescriptor,
+  gatedLocalComputer,
   readCuaConnection,
   validateLinuxDescriptorRuntime
 };

package/dist-server/mcp-server.js

@@ -145,12 +145,12 @@ var TOOLS = [
   },
   {
     name: "send_bot_message",
-    description: "Send an instruction to a bot's active task. Optionally name the expected task to prevent cross-task races. This may cause the bot to use external tools.",
+    description: "Send an instruction to one bot task without changing the selected task. This may cause the bot to use external tools.",
     inputSchema: {
       type: "object",
       properties: {
         bot_id: { type: "string", description: "The ID of the bot to message." },
-        task_id: { type: "string", description: "Optional expected active task/thread ID." },
+        task_id: { type: "string", description: "Optional owned task/thread ID. Defaults to the bot's selected task." },
         text: { type: "string", description: "The message content/instruction to send." }
       },
       required: ["bot_id", "text"],
@@ -298,7 +298,7 @@ var TOOLS = [
   },
   {
     name: "switch_task",
-    description: "Switch a bot or channel to an existing task. Running or approval-blocked conversations are refused.",
+    description: "Select an existing bot or channel task. Bot tasks keep running independently; busy channels cannot switch.",
     inputSchema: {
       type: "object",
       properties: {
@@ -360,11 +360,12 @@ var TOOLS = [
   },
   {
     name: "set_bot_model",
-    description: "Change an idle bot to an exact configured provider instance and model.",
+    description: "Change an idle bot's default and selected task model, or only one idle task's model when task_id is provided. Other tasks are unchanged.",
     inputSchema: {
       type: "object",
       properties: {
         bot_id: { type: "string", description: "The ID of the bot." },
+        task_id: { type: "string", description: "Optional owned task/thread ID. Omit to change the bot's default and selected task model." },
         instance_id: { type: "string", description: "The configured provider instance ID." },
         model: { type: "string", description: "The exact model ID exposed by that instance." },
         effort: { type: "string", enum: ["none", "low", "medium", "high", "xhigh", "max"] }
@@ -386,12 +387,13 @@ var TOOLS = [
   },
   {
     name: "interrupt_conversation",
-    description: "Interrupt the active turn in a bot or channel conversation.",
+    description: "Interrupt one bot or channel task's turn without stopping other bot tasks.",
     inputSchema: {
       type: "object",
       properties: {
         target_type: { type: "string", enum: ["bot", "channel"] },
-        target_id: { type: "string" }
+        target_id: { type: "string" },
+        task_id: { type: "string", description: "Optional task/thread ID. Defaults to the selected task." }
       },
       required: ["target_type", "target_id"],
       additionalProperties: false
@@ -500,10 +502,18 @@ function projectTask(task, activeThreadId) {
     taskId: task.threadId,
     title: task.title,
     createdAt: task.createdAt,
+    ...typeof task.busy === "boolean" ? { busy: task.busy } : {},
+    ...task.activity ? { activity: task.activity } : {},
+    ...task.modelSelection ? { modelSelection: task.modelSelection } : {},
     ...typeof activeThreadId === "string" ? { active: task.threadId === activeThreadId } : {},
     ...task.usage ? { usage: task.usage } : {}
   };
 }
+function botTaskState(bot, taskId) {
+  const task = records(bot.tasks).find((candidate) => candidate.threadId === taskId);
+  if (task && (typeof task.busy === "boolean" || typeof task.activity === "string")) return task;
+  return bot.threadId === taskId ? bot : { busy: false, activity: "idle" };
+}
 function projectBot(bot) {
   return {
     id: bot.id,
@@ -701,9 +711,6 @@ async function handleToolCall(name, args, baseFetcher = request, signal) {
       if (!bot) throw new Error(`Bot not found: ${botId}`);
       const taskId = args.task_id === void 0 ? String(bot.threadId) : idArg(args, "task_id");
       if (!taskBelongsTo(bot, taskId)) throw new Error(`Task '${taskId}' does not belong to bot '${botId}'`);
-      if (bot.threadId !== taskId) {
-        throw new Error(`Task '${taskId}' is not active for bot '${botId}'; switch to it before sending`);
-      }
       const busyChannel = records(state.groups).find((channel) => channel.busyBotId === botId);
       if (busyChannel) {
         throw new Error(`Bot '${botId}' is working in channel '${busyChannel.id}'; send to or interrupt that channel instead`);
@@ -939,18 +946,19 @@ async function handleToolCall(name, args, baseFetcher = request, signal) {
             hasMore: tail.hasMore
           };
         };
-        if (target.threadId !== taskId) return terminal("settled");
         if (targetType === "bot") {
-          const busyChannel = records(state.groups).find((channel) => channel.busyBotId === targetId);
+          const task = botTaskState(target, taskId);
+          const busyChannel = task === target && records(state.groups).find((channel) => channel.busyBotId === targetId);
           if (busyChannel) {
             throw new Error(`Bot '${targetId}' is working in channel '${busyChannel.id}'; wait on that channel instead`);
           }
-          if (target.activity === "waiting-on-you") return terminal("needs-user");
-          if (target.activity === "dead") return terminal("failed");
-          if (target.activity === "no-signal") return terminal("stalled");
-          if (!target.busy) return terminal("settled");
+          if (task.activity === "waiting-on-you") return terminal("needs-user");
+          if (task.activity === "dead") return terminal("failed");
+          if (task.activity === "no-signal") return terminal("stalled");
+          if (!task.busy) return terminal("settled");
           sawBusy = true;
         } else {
+          if (target.threadId !== taskId) return terminal("settled");
           const tail = await conversationTail(fetcher, taskId);
           if (tail.raw.some(messageNeedsInput)) {
             return terminal("needs-user", tail);
@@ -986,6 +994,18 @@ async function handleToolCall(name, args, baseFetcher = request, signal) {
       const current = await fleet(fetcher);
       const bot = records(current.bots).find((candidate) => candidate.id === botId);
       if (!bot) throw new Error(`Bot not found: ${botId}`);
+      if (args.task_id !== void 0) {
+        const taskId = idArg(args, "task_id");
+        if (!taskBelongsTo(bot, taskId)) throw new Error(`Task '${taskId}' does not belong to bot '${botId}'`);
+        if (botTaskState(bot, taskId).busy) throw new Error("Interrupt the task or let it finish before changing its model");
+        const selection2 = await checkedModelSelection(args, fetcher);
+        const res2 = await fetcher(`${taskRoute("bot", botId)}/${encodeURIComponent(taskId)}`, {
+          method: "PATCH",
+          body: JSON.stringify({ modelSelection: selection2, requireAvailableModel: true })
+        });
+        if (!isRecord(res2?.task)) throw new Error("OpenMausBot did not return the updated task");
+        return { success: true, botId, task: projectTask(res2.task, bot.threadId) };
+      }
       if (bot.busy) throw new Error("Interrupt the bot or let it finish before changing its model");
       const selection = await checkedModelSelection(args, fetcher);
       const res = await fetcher(`/api/bots/${encodeURIComponent(botId)}`, {
@@ -1017,9 +1037,10 @@ async function handleToolCall(name, args, baseFetcher = request, signal) {
       const current = await fleet(fetcher);
       const target = (targetType === "bot" ? records(current.bots) : records(current.groups)).find((candidate) => candidate.id === targetId);
       if (!target) throw new Error(`${targetType === "bot" ? "Bot" : "Channel"} not found: ${targetId}`);
-      const taskId = String(target.threadId);
+      const taskId = args.task_id === void 0 ? String(target.threadId) : idArg(args, "task_id");
+      if (!taskBelongsTo(target, taskId)) throw new Error(`Task '${taskId}' does not belong to ${targetType} '${targetId}'`);
       if (targetType === "bot") {
-        const busyChannel = records(current.groups).find((channel) => channel.busyBotId === targetId);
+        const busyChannel = botTaskState(target, taskId) === target && records(current.groups).find((channel) => channel.busyBotId === targetId);
         if (busyChannel) {
           throw new Error(`Bot '${targetId}' is working in channel '${busyChannel.id}'; interrupt that channel instead`);
         }