grok-bot-cli 0.10.0 → 0.10.2

package/dist/package.json

@@ -1,6 +1,6 @@
 {
   "name": "grok-bot-cli",
-  "version": "0.10.0",
+  "version": "0.10.2",
   "description": "CLI and Agent Bundle plugin for Grok Bot agents and groups: create, update, message, inspect threads, and automate cleanup",
   "type": "module",
   "engines": {
@@ -46,7 +46,7 @@
     "@agent-bundle/runtime": "https://pkg.pr.new/ScriptedAlchemy/agent-bundle/@agent-bundle/runtime@899755dc6d",
     "@changesets/cli": "3.0.3",
     "@modelcontextprotocol/server": "2.1.0",
-    "@rstest/core": "0.11.12",
+    "@rstest/core": "0.12.2",
     "@types/node": "^24.0.0",
     "@types/react": "^19.2.18",
     "agent-bundle": "https://pkg.pr.new/ScriptedAlchemy/agent-bundle/agent-bundle@899755dc6d",

package/dist/plugin.json

@@ -1 +1 @@
-{"$schema":"https://agent-plugins.org/schemas/1.0.0/plugin.schema.json","author":{"name":"Zack Jackson","url":"https://github.com/ScriptedAlchemy"},"description":"Message Grok Bot from Codex, Claude Code, and Cursor, with managed automatic replies and explicit Codex conversation links.","homepage":"https://github.com/ScriptedAlchemy/grok-bot-cli#readme","keywords":["grok","grok-bot","grokbot","gbot","cursor","ai-agents","automation","terminal","cli","agent-bundle"],"license":"MIT","name":"gbot","repository":"https://github.com/ScriptedAlchemy/grok-bot-cli","version":"0.10.0"}
+{"$schema":"https://agent-plugins.org/schemas/1.0.0/plugin.schema.json","author":{"name":"Zack Jackson","url":"https://github.com/ScriptedAlchemy"},"description":"Message Grok Bot from Codex, Claude Code, and Cursor. Codex/Claude tools use local sockets on the user's registered machines only (no remote transport); from the Grok Bot box, run gbot via Grok Bot Shell with a machineId.","homepage":"https://github.com/ScriptedAlchemy/grok-bot-cli#readme","keywords":["grok","grok-bot","grokbot","gbot","cursor","ai-agents","automation","terminal","cli","agent-bundle"],"license":"MIT","name":"gbot","repository":"https://github.com/ScriptedAlchemy/grok-bot-cli","version":"0.10.2"}

package/dist/rules/codex-claude-on-user-machines.mdc

@@ -0,0 +1,18 @@
+---
+description: Codex and Claude tools run on the user's registered machines via local sockets — never on the Grok Bot box
+alwaysApply: true
+---
+# Codex and Claude run on the user's machines
+
+`codex_*` and `claude_send` talk only to a **local** Unix socket on the machine
+where the process runs. gbot has **no remote transport**.
+
+- Codex/Claude sessions live on the user's registered computers (Linux desktop,
+  Mac, …), not on the Grok Bot agent box (`HOME=/home/box`, no Codex install).
+- When you are on the box, **do not** call those MCP tools. Run the `gbot` CLI on
+  the user's machine through **Grok Bot Shell with a machineId** (the host's
+  machine-targeted shell).
+- On that machine, start the daemon with `codex app-server daemon start` (or
+  bootstrap) so `$CODEX_HOME/app-server-control/app-server-control.sock` exists.
+- Auth stays with each machine's native Codex or Claude login. Do not invent
+  token files or export credentials.

package/dist/scripts/gbot-relay.mjs

@@ -22134,7 +22134,8 @@ var __webpack_modules__ = {
         var _package_json__rspack_import_6 = __webpack_require__("./package.json");
         var _codex_contract_js__rspack_import_7 = __webpack_require__("./src/core/codex/contract.js");
         var _desktop_shim_js__rspack_import_8 = __webpack_require__("./src/core/desktop-shim.js");
-        const PINNED_CODEX_VERSION = "0.154.0";
+        var _user_machine_guidance_js__rspack_import_9 = __webpack_require__("./src/core/user-machine-guidance.js");
+        const PINNED_CODEX_VERSION = "0.158.0";
         const UPSTREAM_DESKTOP_ISSUES = [
             "https://github.com/openai/codex/issues/41014",
             "https://github.com/openai/codex/issues/41112"
@@ -22167,20 +22168,34 @@ var __webpack_modules__ = {
         function singleLine(text) {
             return stripTerminalControls(text).replace(/[\t\n\r\u2028\u2029]+/g, " ");
         }
-        function unreachableMessage(path, desktopAttached = "unknown") {
+        function boxUnreachableMessage(path) {
+            return [
+                "No Codex app-server control socket at " + path + ".",
+                _user_machine_guidance_js__rspack_import_9.M
+            ].join("\n");
+        }
+        function unreachableMessage(path, desktopAttached = "unknown", env = process.env) {
+            if ((0, _user_machine_guidance_js__rspack_import_9.R)({
+                path,
+                env,
+                home: env.HOME || (0, node_os__rspack_import_3.homedir)()
+            })) {
+                return boxUnreachableMessage(path);
+            }
             if (desktopAttached === "private-stdio") {
                 return [
                     "ChatGPT Desktop is running its private stdio app-server, which external clients cannot reach",
                     "(" + UPSTREAM_DESKTOP_ISSUES.join(", ") + ").",
-                    "No Codex app-server control socket at " + path + ": start a managed standalone daemon with `codex app-server daemon start`.",
-                    "gbot codex targets daemon-managed threads only."
+                    "No Codex app-server control socket at " + path + ": start a managed standalone daemon with `codex app-server daemon start` (or bootstrap).",
+                    "gbot codex targets daemon-managed threads only; gbot has no remote transport."
                 ].join("\n");
             }
             return [
                 "No Codex app-server control socket at " + path + ".",
-                "Either no daemon is running (start one with `codex app-server daemon start`),",
+                "Either no daemon is running (start one with `codex app-server daemon start` or bootstrap),",
                 "or ChatGPT Desktop is running a private stdio app-server that external clients cannot reach",
                 "(" + UPSTREAM_DESKTOP_ISSUES.join(", ") + ").",
+                "Codex must run on the same machine as gbot. Set CODEX_APP_SERVER_SOCK to an existing local control socket if it is elsewhere; gbot has no remote transport.",
                 "gbot codex targets daemon-managed threads only."
             ].join("\n");
         }
@@ -22824,6 +22839,47 @@ var __webpack_modules__ = {
             };
         }
         const openSession = openCodexSession;
+        async function startCodexThread({ cwd, expectedCwd, model, effort, message, env = process.env, signal } = {}) {
+            validateModelEffort(model, effort);
+            if (typeof cwd !== "string" || !cwd.trim()) throw new RangeError("--cwd is required for a new Codex thread");
+            const resolvedCwd = realpathSync(cwd);
+            if (expectedCwd !== undefined && realpathSync(expectedCwd) !== resolvedCwd) throw new RangeError("New Codex thread cwd does not match expectedCwd");
+            if (message !== undefined && (typeof message !== "string" || !message.trim())) throw new RangeError("Message must contain text");
+            const { client } = await openSession(env, {
+                signal
+            });
+            let threadId, started;
+            try {
+                started = await client.request("thread/start", {
+                    cwd: resolvedCwd,
+                    ...model ? {
+                        model
+                    } : {},
+                    ...effort ? {
+                        config: {
+                            model_reasoning_effort: effort
+                        }
+                    } : {}
+                });
+                threadId = started?.thread?.id;
+                if (typeof threadId !== "string" || !ID_PATTERN.test(threadId)) throw new CodexProtocolError("thread/start", "missing `thread.id`");
+            } finally{
+                client.close();
+            }
+            if (message === undefined) return {
+                threadId,
+                cwd: resolvedCwd,
+                model: started.model ?? model,
+                exitCode: 0
+            };
+            return await sendToCodexThread(threadId, message, {
+                env,
+                expectedCwd: resolvedCwd,
+                model,
+                effort,
+                signal
+            });
+        }
         const CODEX_VERSION_PROBE_TIMEOUT_MS = 3000;
         function probeLocalCodexVersion(timeoutMs = CODEX_VERSION_PROBE_TIMEOUT_MS) {
             const out = spawnSync("codex", [
@@ -22913,7 +22969,7 @@ var __webpack_modules__ = {
                 session = await openSession(env);
             } catch (err) {
                 if (err instanceof CodexRouteError) {
-                    const message = err.mode === "socket-absent" ? unreachableMessage(path, desktopAttached) : err.message;
+                    const message = err.mode === "socket-absent" ? unreachableMessage(path, desktopAttached, env) : err.message;
                     return withStatusExitCode({
                         ...base,
                         reachable: false,
@@ -23122,7 +23178,7 @@ var __webpack_modules__ = {
         }
         function requireExperimental(env, what) {
             if (experimentalEnabled(env)) return;
-            throw new CodexSendError(what + " uses Codex's experimental app-server API (thread/queue/*), which is off by default. " + "Set GROK_BOT_CODEX_EXPERIMENTAL=1 to opt in; method names are pinned to Codex " + PINNED_CODEX_VERSION + ".", {
+            throw new CodexSendError(what + " needs thread/queue/add, which is experimental and absent from Codex " + PINNED_CODEX_VERSION + "'s stable API. " + "Use --when-busy steer with an expected turn ID, wait until the thread is idle, or opt in with GROK_BOT_CODEX_EXPERIMENTAL=1 on a Codex daemon that supports the experimental queue API.", {
                 delivery: "rejected",
                 reason: "experimental-disabled"
             });
@@ -23130,7 +23186,7 @@ var __webpack_modules__ = {
         function unsupportedOrRpc(err, method, threadId, envelope, turnId) {
             const guarded = method === "turn/steer";
             if (err instanceof CodexRpcError && err.rpc && err.rpc.code === -32601) {
-                return new CodexSendError("Codex app-server does not offer " + method + " (daemon predates it, or experimentalApi was not granted). " + (guarded ? "Upgrade Codex before retrying guarded steering." : "Upgrade Codex or send without --when-busy queue."), {
+                return new CodexSendError("Codex app-server does not offer " + method + " (daemon predates it, or experimentalApi was not granted). " + (guarded ? "Upgrade Codex before retrying guarded steering." : "Use --when-busy steer with an expected turn ID, wait for idle, or use a Codex daemon with experimental queue support and GROK_BOT_CODEX_EXPERIMENTAL=1."), {
                     delivery: "rejected",
                     reason: "unsupported",
                     threadId,
@@ -23187,7 +23243,7 @@ var __webpack_modules__ = {
         }
         async function sendToCodexThread(threadId, text, { env = process.env, envelope = buildEnvelope({
             env
-        }), whenBusy = "reject", session, expectedTurnId, expectedCwd, signal } = {}) {
+        }), whenBusy = "reject", session, expectedTurnId, expectedCwd, model, effort, signal } = {}) {
             try {
                 const receipt = await sendToCodexThreadInner(threadId, text, {
                     env,
@@ -23196,6 +23252,8 @@ var __webpack_modules__ = {
                     session,
                     expectedTurnId,
                     expectedCwd,
+                    model,
+                    effort,
                     signal
                 });
                 return (0, _codex_contract_js__rspack_import_7.Dz)(receipt);
@@ -23207,7 +23265,19 @@ var __webpack_modules__ = {
                 return (0, _codex_contract_js__rspack_import_7.DG)(err);
             }
         }
-        async function sendToCodexThreadInner(threadId, text, { env, envelope, whenBusy, session, expectedTurnId, expectedCwd, signal }) {
+        function validateModelEffort(model, effort) {
+            if (model !== undefined && (typeof model !== "string" || !/^[A-Za-z0-9][A-Za-z0-9._:/-]{0,127}$/.test(model))) throw new RangeError("--model must be a nonempty model ID");
+            if (effort !== undefined && ![
+                "none",
+                "minimal",
+                "low",
+                "medium",
+                "high",
+                "xhigh"
+            ].includes(effort)) throw new RangeError("--effort must be none, minimal, low, medium, high, or xhigh");
+        }
+        async function sendToCodexThreadInner(threadId, text, { env, envelope, whenBusy, session, expectedTurnId, expectedCwd, model, effort, signal }) {
+            validateModelEffort(model, effort);
             if (![
                 "reject",
                 "queue",
@@ -23253,7 +23323,15 @@ var __webpack_modules__ = {
                 try {
                     resumed = await client.request("thread/resume", {
                         threadId,
-                        excludeTurns: true
+                        excludeTurns: true,
+                        ...model ? {
+                            model
+                        } : {},
+                        ...effort ? {
+                            config: {
+                                model_reasoning_effort: effort
+                            }
+                        } : {}
                     });
                 } catch (err) {
                     assertNotCancelled();
@@ -23386,7 +23464,13 @@ var __webpack_modules__ = {
                             }
                         ],
                         clientUserMessageId: envelope.messageId,
-                        turnTrigger: "gbot"
+                        turnTrigger: "gbot",
+                        ...model ? {
+                            model
+                        } : {},
+                        ...effort ? {
+                            effort
+                        } : {}
                     });
                 } catch (err) {
                     if (err instanceof CodexSendError) throw err;
@@ -23655,10 +23739,10 @@ var __webpack_modules__ = {
                 ];
                 if (afterMessageId !== undefined) boundedInteger(anchors.length, 200, 'afterMessageId count');
                 for (const anchor of anchors)conversationId(anchor, 'afterMessageId');
-                boundedInteger(timeoutMs, 600000, 'timeoutMs');
+                boundedInteger(timeoutMs, 7200000, 'timeoutMs');
                 boundedInteger(maxOutputBytes, BUDGET, 'maxOutputBytes');
                 if (waitSignal !== undefined && !(waitSignal instanceof AbortSignal)) throw new TypeError('signal must be an AbortSignal');
-                let done = false, status = acceptedTurns.has(turnId) ? 'inProgress' : undefined, error, historyError, itemBytes = 0, truncated = overflow;
+                let done = false, status = acceptedTurns.has(turnId) ? 'inProgress' : undefined, error, historyError, itemBytes = 0, truncated = false;
                 const items = new Map();
                 const add = (item)=>{
                     if (!item || typeof item.id !== 'string' || typeof item.type !== 'string') throw new Error('Invalid history item');
@@ -23705,6 +23789,7 @@ var __webpack_modules__ = {
                 };
                 const result = (state, detail)=>{
                     const interactions = scan();
+                    const overflowUncertain = state === 'unknown' && /Notification coverage overflow/.test(detail ?? '');
                     const candidates = [
                         ...items.values()
                     ].map((x)=>x.item);
@@ -23713,7 +23798,7 @@ var __webpack_modules__ = {
                     const reply = {
                         text: '',
                         items: [],
-                        truncated: truncated || overflow
+                        truncated: truncated || overflowUncertain
                     };
                     for (const item of selected){
                         const text = reply.text ? `${reply.text}\n${item.text}` : item.text;
@@ -23746,7 +23831,7 @@ var __webpack_modules__ = {
                         interactions
                     };
                 };
-                let timer, notify;
+                let timer, pollTimer, notify;
                 const abortSignals = [
                     signal,
                     waitSignal
@@ -23762,10 +23847,18 @@ var __webpack_modules__ = {
                             'Codex connection closed'
                         ]);
                     };
-                    timer = setTimeout(()=>resolve([
+                    timer = setTimeout(()=>resolve(overflow ? [
+                            'unknown',
+                            'Notification coverage overflow; pending interaction status is uncertain'
+                        ] : [
                             'timeout',
                             'Observation deadline reached'
                         ]), timeoutMs);
+                    pollTimer = setInterval(()=>{
+                        for (const listener of [
+                            ...wake
+                        ])listener();
+                    }, 2000);
                     for (const s of abortSignals)s.addEventListener('abort', notify, {
                         once: true
                     });
@@ -23836,19 +23929,51 @@ var __webpack_modules__ = {
                             historyError
                         ];
                     }
+                    let lastPoll = 0;
                     while(!done){
                         const interactions = scan();
                         if (terminal(status)) return [
                             status,
                             error ?? historyError
                         ];
-                        if (historyError || overflow) return [
+                        if (historyError) return [
                             'unknown',
-                            historyError ?? 'Notification coverage overflow'
+                            historyError
                         ];
                         if (interactions.length) return [
                             'waiting-for-input'
                         ];
+                        if (Date.now() - lastPoll >= 2000) {
+                            lastPoll = Date.now();
+                            try {
+                                await visitCodexHistory(session, threadId, 'thread/turns/list', {}, (data)=>{
+                                    const turn = data.find((t)=>t?.id === turnId);
+                                    if (!turn) return false;
+                                    if (terminal(turn.status)) {
+                                        status = turn.status;
+                                        error = turn.error;
+                                    }
+                                    return true;
+                                }, {
+                                    stopped: ()=>done
+                                });
+                                if (terminal(status)) {
+                                    await visitCodexHistory(session, threadId, 'thread/items/list', {
+                                        turnId,
+                                        sortDirection: 'asc'
+                                    }, (data)=>{
+                                        for (const row of data)if (row?.turnId === turnId && row.item) add(row.item);
+                                        return false;
+                                    }, {
+                                        stopped: ()=>done
+                                    });
+                                    continue;
+                                }
+                            } catch (err) {
+                                historyError = err.message;
+                                truncated = true;
+                            }
+                        }
                         await new Promise((resolve)=>{
                             const listener = ()=>{
                                 wake.delete(listener);
@@ -23871,6 +23996,7 @@ var __webpack_modules__ = {
                 } finally{
                     done = true;
                     clearTimeout(timer);
+                    clearInterval(pollTimer);
                     wake.delete(notify);
                     for (const s of abortSignals)s.removeEventListener('abort', notify);
                     for (const listener of [
@@ -23918,7 +24044,7 @@ var __webpack_modules__ = {
                 close,
                 async send (text, { envelope = (0, _codex_bridge_js__rspack_import_2.nq)({
                     env
-                }), whenBusy = 'reject', expectedTurnId, signal: sendSignal } = {}) {
+                }), whenBusy = 'reject', expectedTurnId, model, effort, signal: sendSignal } = {}) {
                     if (closed) return (0, _contract_js__rspack_import_0.DG)(Object.assign(new Error('Conversation closed'), {
                         delivery: 'rejected',
                         reason: 'closed',
@@ -23937,6 +24063,8 @@ var __webpack_modules__ = {
                         expectedTurnId,
                         session,
                         expectedCwd,
+                        model,
+                        effort,
                         signal: submissionSignal
                     });
                     if (receipt.delivery === 'accepted' && receipt.turnId) {
@@ -25227,6 +25355,12 @@ ts() { date -u +%Y-%m-%dT%H:%M:%SZ; }
                             whenBusy: active ? "steer" : "reject",
                             ...active ? {
                                 expectedTurnId: active
+                            } : {},
+                            ...record.model ? {
+                                model: record.model
+                            } : {},
+                            ...record.effort ? {
+                                effort: record.effort
                             } : {}
                         });
                         if (!active || receipt.delivery !== "rejected" || receipt.reason !== "rejected" || !/guard|expected.*turn|turn.*mismatch|stale/i.test(receipt.error ?? "")) return receipt;
@@ -26369,6 +26503,12 @@ ts() { date -u +%Y-%m-%dT%H:%M:%SZ; }
                     threadId: r.threadId,
                     expectedCwd: r.expectedCwd,
                     busyPolicy: r.busyPolicy,
+                    ...input.model ? {
+                        model: input.model
+                    } : {},
+                    ...input.effort ? {
+                        effort: input.effort
+                    } : {},
                     bindingId: r.bindingId ?? (r.id?.startsWith("binding:") ? r.id : null),
                     text,
                     sourceIds: input.sourceIds ?? [],
@@ -26461,6 +26601,15 @@ ts() { date -u +%Y-%m-%dT%H:%M:%SZ; }
                 "steer",
                 "reject"
             ]),
+            model: zod__rspack_import_3.YjP().regex(/^[A-Za-z0-9][A-Za-z0-9._:/-]{0,127}$/).optional(),
+            effort: zod__rspack_import_3.k5n([
+                "none",
+                "minimal",
+                "low",
+                "medium",
+                "high",
+                "xhigh"
+            ]).optional(),
             bindingId: relayId.nullable(),
             text,
             sourceIds: zod__rspack_import_3.YOg(relayId).max(200),
@@ -27365,9 +27514,30 @@ ts() { date -u +%Y-%m-%dT%H:%M:%SZ; }
             fp: ()=>redactSecrets
         });
     },
+    "./src/core/user-machine-guidance.js" (__unused_rspack___webpack_module__, __webpack_exports__, __webpack_require__) {
+        const USER_MACHINE_CODEX_CLAUDE_GUIDANCE = [
+            "Codex and Claude sessions live on the user's registered machines (for example their Linux desktop or Mac), not on the Grok Bot agent box (/home/box).",
+            "Codex must run on the same machine as gbot. Set CODEX_APP_SERVER_SOCK to an existing local control socket, or use $CODEX_HOME/app-server-control/app-server-control.sock. There is no remote transport.",
+            "When running on the box (HOME=/home/box), do not call codex_* or claude_send there. Run the gbot CLI on the user's machine through Grok Bot Shell with a machineId (the host's machine-targeted shell).",
+            "On that machine, provide the socket with `codex app-server daemon start` (or bootstrap). Auth stays with each machine's native Codex or Claude login; gbot does not store or export credentials."
+        ].join("\n");
+        function looksLikeGrokBotBox({ path = "", env = process.env, home = env.HOME || "" } = {}) {
+            const values = [
+                home,
+                env.HOME,
+                path
+            ].filter((value)=>value != null && value !== "").map(String);
+            return values.some((value)=>value === "/home/box" || value.startsWith("/home/box/"));
+        }
+        __webpack_require__.d(__webpack_exports__, {
+            R: ()=>looksLikeGrokBotBox
+        }, {
+            M: USER_MACHINE_CODEX_CLAUDE_GUIDANCE
+        });
+    },
     "./package.json" (module) {
         module.exports = {
-            "rE": "0.10.0"
+            "rE": "0.10.2"
         };
     }
 };

package/dist/skills/talk-to-grok-bot/SKILL.md

@@ -4,8 +4,23 @@ description: Message Grok Bot, Codex threads, or opted-in local Claude Code chan
 ---
 # Talk to Grok Bot
 
-The `grok-bot` MCP server and `gbot` CLI share Grok gateway access and local
-Codex/Claude transports.
+The `grok-bot` MCP server and `gbot` CLI share Grok gateway access. Codex and
+Claude tools use **local sockets only** on the user's registered machines.
+
+## MCP instructions (Codex / Claude)
+
+gbot connects only to a local Unix socket
+(`$CODEX_HOME/app-server-control/app-server-control.sock`, or
+`CODEX_APP_SERVER_SOCK`). There is **no remote transport**.
+
+- Codex app-server threads and opted-in Claude Code channels live on the user's
+  registered computers (Linux desktop, Mac, …) — **never** on the Grok Bot agent
+  box (`HOME=/home/box`, no Codex install).
+- When this MCP server is running on the box, **do not** call `codex_*` or
+  `claude_send`. Run the `gbot` CLI on the user's machine through **Grok Bot Shell
+  with a machineId** (the host's machine-targeted shell).
+- On that machine, provide the socket with `codex app-server daemon start` (or
+  bootstrap). Auth stays with each machine's native Codex or Claude login.
 
 ## When to load this
 
@@ -49,12 +64,12 @@ which source is present.
 
 ## Claude Code channel
 
-`claude_send` sends to a named live Claude Code session on this machine and waits
-for its explicit `claude_reply`. The destination must enable the native
-`claude-channel` with `GROK_BOT_CLAUDE_CHANNEL=NAME` and Claude's development-channel
-opt-in. Supply `name`, `message`, and optional `timeoutMs` (1..120000). `replied`
-means the reply tool ran; `unknown` is not rejection and must not be automatically
-retried. Normal Claude tool approvals remain in its session. This does not attach
-to arbitrary Claude Desktop chats or connect a remote Grok runtime to local tools.
-CLI: `gbot claude send NAME "message" --json`.
-
+`claude_send` sends to a named live Claude Code session on the user's registered
+machine (local socket under `~/.grok-bot-cli/claude/`) and waits for its explicit
+`claude_reply`. From the Grok Bot box, do not call this tool — use Grok Bot Shell
+with a machineId to run `gbot claude send` on that machine instead. The destination
+must enable the native `claude-channel` with `GROK_BOT_CLAUDE_CHANNEL=NAME` and
+Claude's development-channel opt-in. Supply `name`, `message`, and optional
+`timeoutMs` (1..120000). `replied` means the reply tool ran; `unknown` is not
+rejection and must not be automatically retried. Normal Claude tool approvals remain
+in its session. CLI: `gbot claude send NAME "message" --json`.

package/dist/skills/talk-to-grok-bot/references/bridge-administration.md

@@ -30,9 +30,14 @@ cookie/payment approvals and other unsupported requests require the owning Grok
 ## Codex conversation tools
 
 The generated Codex, Cursor, and Claude plugins and portable MCP artifact expose these
-additional tools on the same `grok-bot` MCP server. Codex tools use the local Codex
-app-server control socket; Grok tools use the Grok gateway. Portable MCP artifacts
-must be configured in an MCP-capable host; they are not automatically loaded by the Grok app.
+additional tools on the same `grok-bot` MCP server. Codex tools connect only to a
+**local** Codex app-server control socket on the process's machine
+(`$CODEX_HOME/...` or `CODEX_APP_SERVER_SOCK`). gbot has **no remote transport**.
+When the MCP server runs on the Grok Bot agent box (`HOME=/home/box`), do not call
+these tools — run the `gbot` CLI on the user's registered machine through Grok Bot
+Shell with a machineId, after `codex app-server daemon start` (or bootstrap) there.
+Grok tools use the Grok gateway. Portable MCP artifacts must be configured in an
+MCP-capable host; they are not automatically loaded by the Grok app.
 
 - `codex_threads`: bounded discovery of daemon-managed Codex threads.
 - `codex_send`: submit a message with a correlation envelope. Default delivery is

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "grok-bot-cli",
-  "version": "0.10.0",
+  "version": "0.10.2",
   "description": "CLI and Agent Bundle plugin for Grok Bot agents and groups: create, update, message, inspect threads, and automate cleanup",
   "type": "module",
   "bin": {
@@ -58,7 +58,7 @@
     "@agent-bundle/runtime": "https://pkg.pr.new/ScriptedAlchemy/agent-bundle/@agent-bundle/runtime@899755dc6d",
     "@changesets/cli": "3.0.3",
     "@modelcontextprotocol/server": "2.1.0",
-    "@rstest/core": "0.11.12",
+    "@rstest/core": "0.12.2",
     "@types/node": "^24.0.0",
     "@types/react": "^19.2.18",
     "agent-bundle": "https://pkg.pr.new/ScriptedAlchemy/agent-bundle/agent-bundle@899755dc6d",