openmausbot 0.1.75 → 0.1.77

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

@@ -36,12 +36,16 @@
 import readline from "node:readline";
 import { CREDENTIAL_TARGETS, isCredentialTargetId } from "../../shared/credential-request.js";
 import { agentToolAnnotations } from "../agent-tool-policy.js";
+import { peerName } from "../peer-roster.js";
 const HARNESS = process.env.OMB_HARNESS_URL ?? "http://127.0.0.1:8799";
 const BOT_ID = process.env.OMB_BOT_ID ?? "";
 const THREAD_ID = process.env.OMB_THREAD_ID ?? "";
 const TOKEN = process.env.OMB_COMMS_TOKEN ?? "";
 const DEPTH = Number(process.env.OMB_TURN_DEPTH ?? "0") || 0;
 const SKILL_AUTHORING_ENABLED = process.env.OMB_SKILL_AUTHORING_ENABLED === "1";
+// Opt-in computer sharing (server features.sharedComputers). Off unless the
+// harness says "1", the same way skill authoring is gated above.
+const SHARED_COMPUTERS_ENABLED = process.env.OMB_SHARED_COMPUTERS_ENABLED === "1";
 const MAX_CREATED_PER_TURN = 4;
 let createdThisTurn = 0;
 // Same spirit as MAX_CREATED_PER_TURN above and MAX_QUEUED_PER_THREAD in
@@ -342,14 +346,44 @@ const ROUTINE_FIELDS_SCHEMA = {
     },
 };
 const TOOLS = [
+    {
+        name: "list_shared_computers",
+        description: "List online desktop computers explicitly shared with this workspace, and their allowed folders/capabilities. These are the user's computers, not this server. An offline or unshared computer cannot be accessed. Folder paths use opaque folder IDs and relative paths.",
+        inputSchema: { type: "object", properties: {}, additionalProperties: false },
+    },
+    {
+        name: "shared_computer",
+        description: "Use a desktop explicitly shared by the user. Discover computer_id and folder_id with list_shared_computers. list_files/read_file/write_file are confined to chosen folders; paths are relative. read_file returns sha256; overwriting requires expected_sha256. Binary files support base64 encoding. run_command requires a SEPARATE unrestricted terminal grant. computer_tools lists the native computer-control tools; computer_call invokes one with arguments and needs a SEPARATE computer-control grant. Never substitute the server's filesystem when this desktop is offline. Actions are not retried automatically; inspect an uncertain outcome before retrying.",
+        inputSchema: { type: "object", additionalProperties: false, properties: {
+                computer_id: { type: "string" }, action: { type: "string", enum: ["list_files", "read_file", "write_file", "run_command", "computer_tools", "computer_call"] },
+                folder_id: { type: "string" }, path: { type: "string" }, content: { type: "string" }, encoding: { type: "string", enum: ["utf8", "base64"] }, expected_sha256: { type: "string" },
+                command: { type: "string" }, tool_name: { type: "string" }, arguments: { type: "object", additionalProperties: true },
+            }, required: ["computer_id", "action"] },
+    },
+    {
+        name: "list_room_targets",
+        description: "Discover actual OpenMausBot teammates and rooms in your allowed teams. Works in a normal bot conversation too; no room is required. Returns bot and room IDs, roles and working folders, never other conversations' history. Use these bots, not native coding helpers with similar names, when the user asks their team to work together.",
+        inputSchema: { type: "object", properties: {}, additionalProperties: false },
+    },
+    {
+        name: "coordinate_bots",
+        description: "Ask existing OpenMausBot teammates for advice or assign concrete work. From normal chat each assignment gets a separate recipient conversation; from a room it defaults to this room. Use group_id from list_room_targets for a specific room. Name 1-4 bot_ids: they receive only your brief and use their own model, tools and permissions. Busy bots queue. They can consult their specialists; all results return here and resume you automatically. Include exact file paths, constraints and what must be verified. After sending all assignments, END your turn; do not poll or wait. On return, resolve tradeoffs, verify the requested outcome and request concrete corrections if necessary before giving one final answer. Do not send acknowledgements as new work.",
+        inputSchema: { type: "object", additionalProperties: false, properties: {
+                group_id: { type: "string", description: "Optional destination room. Omit for this room, or separate recipient tasks when chatting directly." },
+                bot_ids: { type: "array", items: { type: "string" }, minItems: 1, maxItems: 4, uniqueItems: true },
+                message: { type: "string", minLength: 1, maxLength: 4000, description: "Self-contained question or task for these teammates. Send separate requests when responsibilities differ." },
+                request_key: { type: "string", description: "A short unique assignment key. Reuse for an identical retry." },
+                rework: { type: "boolean", description: "True only for concrete additional work from someone who already completed a request." },
+            }, required: ["bot_ids", "message", "request_key"] },
+    },
     {
         name: "list_bots",
-        description: "List the other bots (agents) in your OpenMausBot section, with their model and whether they're busy. Call this before delegate_bot or ask_bot to discover who's available. Use delegate_bot for assignments; use ask_bot only for a short consultation needed inline.",
+        description: "List the other bots (agents) you may contact in your own team and any additional teams the owner has explicitly allowed you to coordinate, with their team, model and current status. Call this to discover exact teammate IDs before assigning work or requesting advice through your available coordination tools.",
         inputSchema: { type: "object", properties: {} },
     },
     {
         name: "list_rooms",
-        description: "List the shared rooms (team channels) you belong to, with the other members of each. Call this before post_to_room — it is the only place room ids come from. One-to-one bot channels are never listed (reach a single bot with ask_bot or delegate_bot). A room you are in but cannot post into — one containing someone outside your section — is named without an id, together with the reason, so you can tell the user why.",
+        description: "List the shared rooms (team channels) you belong to, with the other members of each. Call this before post_to_room. One-to-one bot channels are never listed; discover individual teammates with list_bots. A room you are in but cannot post into is named without an id, together with the reason, so you can tell the user why.",
         inputSchema: { type: "object", additionalProperties: false, properties: {} },
     },
     {
@@ -402,12 +436,12 @@ const TOOLS = [
     },
     {
         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.",
+        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, idle, or closed), 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.",
+        description: "Mark a thread you opened (or one of your own) as finished once you have read its result: it leaves the person's default sidebar list (still under all threads, with a note saying you closed it) and list_threads reports it as closed. 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,
@@ -456,6 +490,45 @@ const TOOLS = [
             required: ["name", "role", "instructions"],
         },
     },
+    {
+        name: "list_team_setup",
+        description: "Chief of Staff only: list authorized teams, teammate IDs, and exact engine/model choices for team setup. Call before proposing configuration; never invent model IDs. Existing thread models are independent of bot defaults.",
+        inputSchema: { type: "object", additionalProperties: false, properties: {} },
+    },
+    {
+        name: "propose_team_setup",
+        description: "Chief of Staff only: propose all requested specialist creation, profile/model configuration, and authorized team moves in ONE combined review card. Nothing changes until the user applies it. Use exact catalog engine/model IDs from list_team_setup. Combine all fields for each bot; use the same create key or botId to coalesce repeated entries. New teams must be named explicitly in newTeams and have a specialist in this plan; the card also asks to authorize your access to just those new teams. Existing unauthorized teams cannot be included. Models change bot defaults for groups/new threads; existing threads and execution permissions stay unchanged. After proposing, end your turn. The decision and structured result automatically resume you once; do not ask again, poll, or repeat the proposal.",
+        inputSchema: {
+            type: "object", additionalProperties: false,
+            properties: {
+                reason: { type: "string", minLength: 1, maxLength: 500 },
+                newTeams: { type: "array", maxItems: 8, items: { type: "string", minLength: 1, maxLength: 60 } },
+                operations: { type: "array", minItems: 1, maxItems: 24, items: {
+                        type: "object", additionalProperties: false,
+                        properties: {
+                            action: { type: "string", enum: ["create", "update"] },
+                            key: { type: "string", description: "For create: your stable short name for this new bot in this plan." },
+                            botId: { type: "string", description: "For update: exact existing bot ID from list_team_setup." },
+                            fields: { type: "object", additionalProperties: false, properties: {
+                                    name: { type: "string", maxLength: 100 }, title: { type: "string", maxLength: 200 },
+                                    description: { type: "string", maxLength: 4000 }, soul: { type: "string", description: "Standing instructions; required with name/title/modelSelection for every new bot." },
+                                    section: { type: "string", maxLength: 60, description: "Exact authorized existing team, or a team explicitly named in newTeams. Empty string means General." },
+                                    modelSelection: { type: "object", additionalProperties: false, properties: {
+                                            instanceId: { type: "string" }, model: { type: "string" }, effort: { type: "string" },
+                                        }, required: ["instanceId", "model"] },
+                                } },
+                        }, required: ["action", "fields"],
+                    } },
+            }, required: ["reason", "operations"],
+        },
+    },
+    {
+        name: "propose_bot_deletion",
+        description: "Chief of Staff only: when the user explicitly asks to delete a named teammate, create a separate confirmation card for that exact bot. Deletion removes its conversations, memory, instructions and skills; generated project files remain. Running work and owned computers can block deletion. Never delete yourself, substitute an archive, or put deletion into a setup batch. End your turn after proposing; the decision and result resume you once.",
+        inputSchema: { type: "object", additionalProperties: false, properties: {
+                bot_id: { type: "string", minLength: 1 }, reason: { type: "string", minLength: 1, maxLength: 500 },
+            }, required: ["bot_id", "reason"] },
+    },
     {
         name: "create_room",
         description: "Create a room in your own section when the user asks for one (maximum four per turn). Chiefs only. Choose active peers from list_bots; you are included automatically as the default responder. This creates no turns or messages. Section moves stay with the user. If peer approval is enabled, ask the user to make the room change instead.",
@@ -694,9 +767,33 @@ const TOOLS = [
     return annotations ? { ...tool, annotations } : tool;
 });
 const SKILL_TOOL_NAMES = new Set(["skills_list", "skill_manage"]);
-const AVAILABLE_TOOLS = SKILL_AUTHORING_ENABLED
+const AUTHORING_TOOLS = SKILL_AUTHORING_ENABLED
     ? TOOLS
     : TOOLS.filter((tool) => !SKILL_TOOL_NAMES.has(tool.name));
+// A workspace with computer sharing off refuses the routes behind these two,
+// so they must not be advertised at all: a model that sees a tool it cannot
+// use spends turns discovering that.
+const SHARED_COMPUTER_TOOL_NAMES = new Set(["list_shared_computers", "shared_computer"]);
+const SHAREABLE_TOOLS = SHARED_COMPUTERS_ENABLED
+    ? AUTHORING_TOOLS
+    : AUTHORING_TOOLS.filter((tool) => !SHARED_COMPUTER_TOOL_NAMES.has(tool.name));
+// One teamwork path in room turns; keep all unrelated integrations available.
+// Ordinary direct chats use this same bounded coordinator. Goal-owned turns
+// retain their independent loop and cannot start a second coordinator.
+const ROOM_ONLY_TOOLS = new Set(["list_room_targets", "coordinate_bots"]);
+const ROOM_REPLACED_TOOLS = new Set(["ask_bot", "delegate_bot", "check_delegation", "wait_delegation", "start_thread", "send_to_thread", "wait_thread"]);
+const COORDINATING = process.env.OMB_ROOM_TURN === "1";
+const OWN_THREAD_CREATION = process.env.OMB_OWN_THREAD_CREATION === "1";
+const AVAILABLE_TOOLS = COORDINATING
+    ? SHAREABLE_TOOLS.filter(tool => !ROOM_REPLACED_TOOLS.has(tool.name) || (tool.name === "start_thread" && OWN_THREAD_CREATION))
+        .map(tool => tool.name === "start_thread" ? {
+        ...tool,
+        description: "Open a separate job on yourself with its own history and run, without switching the person's selected conversation. Use only when the user requests independent jobs (for example one review per pull request). Give a short specific title and complete instructions; you can open at most five per turn. This is not a teammate handoff: use coordinate_bots for teammates and their automatic replies. Self-opened jobs cannot recursively open more jobs. If refused, do not retry; explain what remains.",
+        inputSchema: { ...tool.inputSchema, properties: { ...tool.inputSchema.properties,
+                bot_id: { type: "string", enum: [BOT_ID], description: "Leave out, or use your own bot ID. For teammates use coordinate_bots." },
+            } },
+    } : tool)
+    : SHAREABLE_TOOLS.filter(tool => !ROOM_ONLY_TOOLS.has(tool.name));
 const send = (msg) => process.stdout.write(JSON.stringify(msg) + "\n");
 const ok = (id, result) => send({ jsonrpc: "2.0", id, result });
 const rpcErr = (id, code, message) => send({ jsonrpc: "2.0", id, error: { code, message } });
@@ -799,18 +896,35 @@ function recallSpeaker(hit) {
     return hit.role === "user" ? "user" : "you";
 }
 async function callTool(name, args) {
+    if (name === "list_room_targets") {
+        const r = await api("/api/internal/room-targets");
+        return { text: JSON.stringify(r), ...(r.error ? { isError: true } : {}) };
+    }
+    if (name === "coordinate_bots") {
+        const r = await api("/api/internal/coordinate-bots", { method: "POST", body: JSON.stringify({
+                groupId: args.group_id, botIds: args.bot_ids, message: args.message,
+                requestKey: args.request_key, rework: args.rework,
+            }) });
+        return { text: JSON.stringify(r), ...(r.error ? { isError: true } : {}) };
+    }
     if (name === "list_bots") {
         const r = await api(`/api/internal/agents?self=${encodeURIComponent(BOT_ID)}`);
         const bots = r.bots ?? [];
         if (!bots.length)
-            return { text: "No other bots in this section yet." };
+            return { text: "No other reachable bots yet." };
         const lines = bots.map((b) => {
             const role = b.title ? ` — ${b.title}` : "";
             const about = b.description ? ` (${String(b.description).slice(0, 120)})` : "";
-            return `- ${b.name}${role}${about} [id: ${b.id}, model: ${b.model}${b.busy ? ", busy" : ""}]`;
+            // statusText is the server's own wording for what the teammate is
+            // doing; an older server only sends busy, so fall back to that.
+            const state = typeof b.statusText === "string"
+                ? (b.status === "available" ? "" : b.statusText)
+                : (b.busy ? "busy" : "");
+            const team = typeof b.section === "string" ? `, team: ${peerName(b.section) || "General"}` : "";
+            return `- ${b.name}${role}${about} [id: ${b.id}, model: ${b.model}${team}${state ? `, ${state}` : ""}]`;
         });
         return {
-            text: `Other bots in your section:\n${lines.join("\n")}\n\nAssign work with delegate_bot. Use ask_bot only for a short answer you need inline.`,
+            text: `Reachable teammates:\n${lines.join("\n")}\n\n${COORDINATING ? "Use coordinate_bots for advice or concrete work, then end your turn. Busy teammates queue and results resume you automatically." : "Assign work with delegate_bot. Use ask_bot only for a short answer you need inline."}`,
         };
     }
     if (name === "list_rooms") {
@@ -943,7 +1057,16 @@ async function callTool(name, args) {
         if (r.status === "done")
             return { text: `${who} finished task ${taskId}:\n${String(r.result || "(no reply text)")}` };
         if (r.status === "queued") {
-            return { text: `Task ${taskId} is still queued — ${who} hasn't picked it up yet${waitMs ? ` after ${timeout}s` : ""}. Keep working and check again later.` };
+            const why = r.targetStatus === "waiting-on-user"
+                ? ` ${who} is waiting on the user, so it goes through after they answer.`
+                : r.targetStatus === "working" ? ` ${who} is busy with other work.` : "";
+            const expiresInMs = Number(r.expiresInMs);
+            const expiry = !Number.isFinite(expiresInMs)
+                ? ""
+                : expiresInMs <= 0
+                    ? " It is past its 24-hour limit and will expire the next time it cannot be delivered."
+                    : ` It expires if not picked up within ${Math.ceil(expiresInMs / 3_600_000)} hour${Math.ceil(expiresInMs / 3_600_000) === 1 ? "" : "s"}.`;
+            return { text: `Task ${taskId} is still queued — ${who} hasn't picked it up yet${waitMs ? ` after ${timeout}s` : ""}.${why}${expiry} Keep working and check again later.` };
         }
         if (r.status === "running") {
             const elapsedMs = Number.isFinite(r.elapsedMs) ? Number(r.elapsedMs) : 0;
@@ -998,6 +1121,9 @@ async function callTool(name, args) {
             };
         }
         const toBotId = typeof args.bot_id === "string" ? args.bot_id.trim() : "";
+        if (COORDINATING && toBotId && toBotId !== BOT_ID) {
+            return { text: "Use coordinate_bots for teammates; start_thread only opens a separate job on yourself.", isError: true };
+        }
         const folder = typeof args.folder === "string" ? args.folder.trim() : "";
         const body = { fromBotId: BOT_ID, fromThreadId: THREAD_ID, title, message, depth: DEPTH };
         if (toBotId)
@@ -1041,6 +1167,18 @@ async function callTool(name, args) {
             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 === "list_team_setup") {
+        return { text: JSON.stringify(await api("/api/internal/team-setup-catalog")) };
+    }
+    if (name === "propose_team_setup" || name === "propose_bot_deletion") {
+        const deleting = name === "propose_bot_deletion";
+        const result = await api(deleting ? "/api/internal/bot-deletion-requests" : "/api/internal/team-setup-requests", {
+            method: "POST", body: JSON.stringify({ fromBotId: BOT_ID, fromThreadId: THREAD_ID,
+                ...(deleting ? { targetBotId: args.bot_id, reason: args.reason } : { plan: args }),
+            }),
+        });
+        return { text: `One review card is visible: ${String(result.title)}. Nothing has been applied. End this turn; the decision and structured result resume you automatically once. Do not ask again, poll, or repeat this proposal.` };
+    }
     if (name === "create_bot") {
         const botName = String(args.name ?? "").trim();
         const role = String(args.role ?? "").trim();
@@ -1063,7 +1201,7 @@ async function callTool(name, args) {
         });
         createdThisTurn += 1;
         return {
-            text: `Created @${r.name ?? botName} in ${r.section ?? "General"} [id: ${r.id}]. Assign work with delegate_bot.`,
+            text: `Created @${r.name ?? botName} in ${r.section ?? "General"} [id: ${r.id}]. Assign work with ${COORDINATING ? "coordinate_bots" : "delegate_bot"}.`,
         };
     }
     if (name === "create_room") {
@@ -1447,6 +1585,27 @@ async function handle(msg) {
             if (!AVAILABLE_TOOLS.some((t) => t.name === name))
                 return rpcErr(id, -32602, `Unknown tool: ${name}`);
             try {
+                // Second lock. With sharing off the tool is not in AVAILABLE_TOOLS, so
+                // a call is already refused above as an unknown tool — the same answer
+                // a build without the feature gives. This keeps the handler itself
+                // refusing if that list is ever assembled differently.
+                if (SHARED_COMPUTER_TOOL_NAMES.has(name) && !SHARED_COMPUTERS_ENABLED) {
+                    textResult(id, "Computer sharing is turned off in this workspace. There are no shared computers to use.", true);
+                    return;
+                }
+                if (name === "list_shared_computers") {
+                    textResult(id, JSON.stringify(await api("/api/internal/shared-computers")));
+                    return;
+                }
+                if (name === "shared_computer") {
+                    const response = await api("/api/internal/shared-computers", { method: "POST", body: JSON.stringify(params.arguments ?? {}) });
+                    const result = response.result;
+                    if (Array.isArray(result?.content))
+                        ok(id, result);
+                    else
+                        textResult(id, JSON.stringify(result));
+                    return;
+                }
                 const { text, isError } = await callTool(name, (params.arguments ?? {}));
                 textResult(id, text, isError);
             }

package/dist-server/server/drivers/boxagent.js

@@ -64,7 +64,7 @@ export const BoxAgentDriver = {
             const model = turn.model || MODELS.default;
             const prompt = [
                 turn.system,
-                "You are working on your own cloud computer — its desktop, Chrome, and shell are yours.",
+                "You are working on the assigned cloud computer — use its desktop, Chrome, and shell within the access described above.",
                 "",
                 turn.text,
             ]

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

@@ -21,7 +21,7 @@ import { ClaudeLoginController } from "./claude-login-auth.js";
 import { computerProxyEnv } from "../container-computer.js";
 import { gateServer, resultBudget } from "../mcp-gate-config.js";
 import { newEventId, newId } from "../contracts.js";
-import { askInputSummary, commandSummary } from "../tool-summary.js";
+import { askInputSummary, commandSummary, toolDetailPreview } from "../tool-summary.js";
 import { classifyError, computeBackoff, interruptibleDelay, RETRY_MAX_ATTEMPTS } from "./retry.js";
 import { applyClaudeInject, decodeInjectId, mergeLocalInject, probeLocalInjects, resolveInjectId, } from "./local-inject.js";
 import { appendNative } from "./native.js";
@@ -408,7 +408,7 @@ function askSummary(ask) {
         return askQuestionSummary(questions).slice(0, 300);
     return askInputSummary(ask.input) ?? ask.tool ?? "tool";
 }
-export function permissionSocketPath(threadId) {
+export function permissionSocketPath(threadId, botId) {
     // A readable prefix alone is not unique: ids that agree on their first
     // characters ("t-perm-dup-1", "t-perm-dup-2") would share a socket. POSIX
     // hides that — a new broker's listen replaces the socket FILE, so the name
@@ -418,8 +418,16 @@ export function permissionSocketPath(threadId) {
     // id so distinct threads get distinct sockets; the tag stays at 8 chars
     // total because the POSIX path already brushes the 104-byte sun_path
     // limit under deep tmp home dirs.
+    //
+    // botId is folded into the digest too (#1017): the driver's session/broker
+    // maps are a single process-wide table keyed on threadId alone, so a
+    // delegated child turn whose threadId ever coincides with its still-open
+    // parent's (or any other bot's) would otherwise collide on the exact same
+    // socket. Namespacing by bot makes that collision structurally impossible
+    // regardless of how two turns end up sharing a threadId.
+    const key = botId ? `${botId}\0${threadId}` : threadId;
     const prefix = threadId.replace(/[^\w-]/g, "").slice(0, 4);
-    const digest = createHash("sha256").update(threadId).digest("hex").slice(0, 4);
+    const digest = createHash("sha256").update(key).digest("hex").slice(0, 4);
     return brokerSocketPath(DATA_DIR, `${prefix}${digest}`);
 }
 /** Paths the broker may bind, tried in order. Windows named pipes are never
@@ -429,11 +437,11 @@ export function permissionSocketPath(threadId) {
  * longer than its small `sun_path` limit; a deep test HOME or long username
  * can otherwise make every approval silently unavailable. The proxy learns
  * the actual bound path from its argv, so either fallback is transparent. */
-export function brokerSocketCandidates(threadId) {
-    const base = permissionSocketPath(threadId);
+export function brokerSocketCandidates(threadId, botId) {
+    const base = permissionSocketPath(threadId, botId);
     if (process.platform !== "win32") {
         const scope = createHash("sha256")
-            .update(`${DATA_DIR}\0${process.pid}\0${threadId}`)
+            .update(`${DATA_DIR}\0${process.pid}\0${botId ?? ""}\0${threadId}`)
             .digest("hex")
             .slice(0, 16);
         return [base, join(tmpdir(), `omb-perm-${scope}.sock`)];
@@ -866,8 +874,8 @@ export const ClaudeDriver = {
         // retry bookkeeping lives PER THREAD, not per sendTurn call: a relaunch
         // is a fresh sendTurn, and the attempt cap must survive across launches
         const retryState = new Map();
-        const sendTurn = async (turn) => {
-            const { threadId } = turn;
+        const sendTurn = async (turn, logicalTurnId) => {
+            const { threadId, botId } = turn;
             if (active.has(threadId))
                 throw new Error("a turn is already running on this thread");
             // A bot-level mode is authoritative for this turn. In particular, an
@@ -887,7 +895,10 @@ export const ClaudeDriver = {
             // Materialize before creating a broker or process. A missing/corrupt
             // attachment must fail this call without leaving a live session behind.
             const promptMsg = claudeUserMessage(turn.text, turn.images);
-            const turnId = newId();
+            // Internal relaunches are still the turn acknowledged to the harness.
+            // A new user message gets a fresh id, but retry/recovery must not orphan
+            // its capability, coordination result or queued continuation ownership.
+            const turnId = logicalTurnId ?? newId();
             const retryAbort = new AbortController();
             const retry = retryState.get(threadId) ?? { attempt: 0, cancelled: false };
             retry.cancelled = false;
@@ -1046,7 +1057,7 @@ export const ClaudeDriver = {
             // Keep ask_user available even in Full access. Native bypass skips
             // permission prompts, not questions requiring a person's answer.
             let broker;
-            const socketPath = permissionSocketPath(threadId);
+            const socketPath = permissionSocketPath(threadId, botId);
             if (permissionMode !== "bypassPermissions") {
                 args.push("--permission-prompt-tool", "mcp__ogb__approve");
             }
@@ -1103,9 +1114,11 @@ export const ClaudeDriver = {
             if (live && !live.turn && !live.closing && live.child.exitCode === null && live.argsKey === argsKey && (!sessionId || sessionId === live.sessionId)) {
                 if (live.idleTimer)
                     clearTimeout(live.idleTimer);
-                live.turn = { turnId, settled: false, sawStreamDelta: false };
+                live.turn = { turnId, input: turn, retryAbort, settled: false, sawStreamDelta: false };
                 active.set(threadId, { stop: () => {
                         closeSession(threadId, "interrupted");
+                        retry.cancelled = true;
+                        retryAbort.abort();
                         stopSession(live);
                     }, turnId, broker: live.broker });
                 emit({ ...base(threadId, turnId), type: "turn.started" });
@@ -1173,7 +1186,7 @@ export const ClaudeDriver = {
                     // event can scope approvals to real desktop-control tools only
                     const askTools = new Map();
                     broker = await createPermissionBroker({
-                        socketPaths: brokerSocketCandidates(threadId),
+                        socketPaths: brokerSocketCandidates(threadId, botId),
                         isActive: () => Boolean(sessions.get(threadId)?.turn),
                         onAsk: (ask) => {
                             const eventTurnId = sessions.get(threadId)?.turn?.turnId ?? turnId;
@@ -1268,7 +1281,7 @@ export const ClaudeDriver = {
                 sessionId: sessionId ?? newSessionId,
                 sawInit: false,
                 nativePermissionMode: null,
-                turn: { turnId, settled: false, sawStreamDelta: false },
+                turn: { turnId, input: turn, retryAbort, settled: false, sawStreamDelta: false },
                 idleTimer: null,
                 closing: false,
                 stderr: "",
@@ -1383,6 +1396,7 @@ export const ClaudeDriver = {
                                     itemId: b.id,
                                     title: b.name,
                                     summary: commandSummary(b.input),
+                                    input: toolDetailPreview(b.input),
                                 });
                             }
                         }
@@ -1402,7 +1416,7 @@ export const ClaudeDriver = {
                     case "user":
                         for (const b of Array.isArray(o.message?.content) ? o.message.content : []) {
                             if (b.type === "tool_result") {
-                                emit({ ...base(threadId, currentTurnId()), type: "item.completed", itemType: "tool", itemId: b.tool_use_id, ok: !b.is_error });
+                                emit({ ...base(threadId, currentTurnId()), type: "item.completed", itemType: "tool", itemId: b.tool_use_id, ok: !b.is_error, output: toolDetailPreview(b.content) });
                             }
                         }
                         break;
@@ -1472,6 +1486,10 @@ export const ClaudeDriver = {
                 // process that exited between turns (idle close, contract change)
                 // is just a session ending
                 if (session.turn && !session.turn.settled) {
+                    // A retained process may be running a later user turn. Its close
+                    // handler must retry that request, not the process's first prompt.
+                    const { turnId, input: turn, retryAbort } = session.turn;
+                    const retry = retryState.get(threadId) ?? { attempt: 0, cancelled: false };
                     const message = `claude exited ${code} before result${session.stderr ? `: ${session.stderr.trim().slice(-300)}` : ""}`;
                     const verdict = classifyError({ exitCode: code, stderr: message });
                     if (!retry.cancelled &&
@@ -1531,7 +1549,7 @@ export const ClaudeDriver = {
                             active.delete(threadId);
                             try {
                                 const cursor = session.sessionId ?? sessionId ?? undefined;
-                                await sendTurn({ ...turn, resumeCursor: cursor });
+                                await sendTurn({ ...turn, resumeCursor: cursor }, turnId);
                             }
                             catch (e) {
                                 retryState.delete(threadId);
@@ -1598,7 +1616,7 @@ export const ClaudeDriver = {
                         void (async () => {
                             try {
                                 // no cursor: a fresh session, carrying the rebuild
-                                await sendTurn({ ...turn, resumeCursor: undefined, recoveryText: undefined, text: recovery.text });
+                                await sendTurn({ ...turn, resumeCursor: undefined, recoveryText: undefined, text: recovery.text }, turnId);
                             }
                             catch (e) {
                                 retryState.delete(threadId);

package/dist-server/server/drivers/codex.js

@@ -22,7 +22,7 @@ import { codexLocalProviderArgs } from "./local-inject.js";
 import { augmentedPath, splitCliString } from "../env-path.js";
 import { classifyError, computeBackoff, RETRY_MAX_ATTEMPTS } from "./retry.js";
 import { appendNative } from "./native.js";
-import { commandSummary } from "../tool-summary.js";
+import { commandSummary, toolDetailPreview } from "../tool-summary.js";
 import { codexDeveloperInstructions, syncCodexInstructions } from "./codex-instructions.js";
 import { CodexDeviceAuthController } from "./codex-device-auth.js";
 import { codexAccountEmail } from "./codex-identity.js";
@@ -799,6 +799,7 @@ export const CodexDriver = {
                                     itemId: item.id,
                                     title,
                                     summary: item.type === "commandExecution" ? commandSummary({ command: item.command }) : undefined,
+                                    input: toolDetailPreview(item.type === "commandExecution" ? { command: item.command, cwd: item.cwd } : item.type === "mcpToolCall" ? item.arguments : item.type === "fileChange" ? item.changes : item.query),
                                 });
                             }
                             break;
@@ -839,6 +840,7 @@ export const CodexDriver = {
                                     itemType: "tool",
                                     itemId: item.id,
                                     ok: item.status !== "failed" && item.status !== "declined",
+                                    output: toolDetailPreview(item.type === "commandExecution" ? { output: item.aggregatedOutput, exitCode: item.exitCode } : item.type === "mcpToolCall" ? item.error ?? item.result : item.type === "fileChange" ? item.changes : item.action),
                                 });
                             }
                             else if (item.type === "reasoning") {