grok-bot-cli 0.10.0 → 0.10.2

package/dist/mcp/mcp-grok-bot-b8c2461e-flight.mjs

@@ -8137,13 +8137,22 @@ var __webpack_modules__ = {
         const observationFields = {
             expectedCwd: zod__rspack_import_3.YjP().min(1).optional(),
             threadId: id,
-            timeoutMs: zod__rspack_import_3.aig().int().min(1).max(600000).optional()
+            timeoutMs: zod__rspack_import_3.aig().int().min(1).max(7200000).optional()
         };
         const sendFields = {
             ...observationFields,
             correlationId: id.optional(),
             envelope: zod__rspack_import_3.zMY().optional(),
             hop: zod__rspack_import_3.aig().int().min(0).optional(),
+            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(),
             replyTo: id.optional(),
             expectedTurnId: id.optional(),
             whenBusy: zod__rspack_import_3.k5n([
@@ -8165,7 +8174,9 @@ var __webpack_modules__ = {
             maxOutputBytes: zod__rspack_import_3.aig().int().min(1).max(4194304).optional()
         }).strict();
         const watchSchema = zod__rspack_import_3.Ikc({
-            ...observationFields,
+            expectedCwd: zod__rspack_import_3.YjP().min(1).optional(),
+            threadId: id,
+            timeoutMs: zod__rspack_import_3.aig().int().min(1).max(600000).optional(),
             maxEvents: zod__rspack_import_3.aig().int().min(1).max(500).default(100)
         }).strict();
         const threadsSchema = zod__rspack_import_3.Ikc({
@@ -8222,6 +8233,8 @@ var __webpack_modules__ = {
                         envelope,
                         whenBusy: input.whenBusy,
                         expectedCwd: input.expectedCwd,
+                        model: input.model,
+                        effort: input.effort,
                         signal
                     });
                 }
@@ -8234,7 +8247,9 @@ var __webpack_modules__ = {
                     receipt = await conversation.send(input.message, {
                         envelope,
                         whenBusy: input.whenBusy,
-                        expectedTurnId: input.expectedTurnId
+                        expectedTurnId: input.expectedTurnId,
+                        model: input.model,
+                        effort: input.effort
                     });
                     if (!input.wait || receipt.delivery !== 'accepted' || !receipt.turnId) return receipt;
                     await progress?.(`Accepted message ${receipt.messageId}; observing turn ${receipt.turnId}`);
@@ -8525,7 +8540,9 @@ var __webpack_modules__ = {
                     requestId: input.requestId,
                     busyPolicy: input.whenBusy,
                     hop: input.hop,
-                    correlationId: input.correlationId
+                    correlationId: input.correlationId,
+                    model: input.model,
+                    effort: input.effort
                 }, options(context)));
         }
         __webpack_require__.d(__webpack_exports__, {
@@ -8654,7 +8671,7 @@ var __webpack_modules__ = {
         var _core_claude_routes_js__rspack_import_2 = __webpack_require__("./src/core/claude-routes.ts");
         const __rspack_default_export = (0, agent_bundle_routes__rspack_import_1.uO)({
             title: 'Message Claude Code',
-            description: 'Send to a named, opted-in live Claude Code channel and wait for its reply. Unknown delivery must not be retried automatically.',
+            description: 'Send to a named, opted-in live Claude Code channel and wait for its reply. Unknown delivery must not be retried automatically. Runs on the user\'s registered machine via its local socket, not the Grok Bot box. From the box, use Grok Bot Shell with a machineId to run gbot there after codex app-server daemon start or bootstrap; gbot has no remote transport.',
             annotations: {
                 readOnlyHint: false
             },
@@ -8697,6 +8714,91 @@ var __webpack_modules__ = {
             "default": __rspack_default_export
         });
     },
+    "./src/mcp/grok-bot/tools/codex_new.tsx" (__unused_rspack_module, __webpack_exports__, __webpack_require__) {
+        __webpack_require__.r(__webpack_exports__);
+        var react_jsx_runtime__rspack_import_0 = __webpack_require__("./node_modules/react/jsx-runtime.react-server.js");
+        var _agent_bundle_runtime__rspack_import_6 = __webpack_require__("./node_modules/@agent-bundle/runtime/dist/506.js");
+        var agent_bundle_routes__rspack_import_1 = __webpack_require__("./node_modules/agent-bundle/dist/routes.js");
+        var zod__rspack_import_5 = __webpack_require__("./node_modules/zod/v4/classic/schemas.js");
+        var _core_codex_bridge_js__rspack_import_2 = __webpack_require__("./src/core/codex-bridge.js");
+        var _core_codex_contract_js__rspack_import_3 = __webpack_require__("./src/core/codex/contract.js");
+        var _core_codex_routes_js__rspack_import_4 = __webpack_require__("./src/core/codex/routes.ts");
+        const inputSchema = zod__rspack_import_5.Ikc({
+            cwd: zod__rspack_import_5.YjP().min(1),
+            expectedCwd: zod__rspack_import_5.YjP().min(1).optional(),
+            model: zod__rspack_import_5.YjP().regex(/^[A-Za-z0-9][A-Za-z0-9._:/-]{0,127}$/).optional(),
+            effort: zod__rspack_import_5.k5n([
+                'none',
+                'minimal',
+                'low',
+                'medium',
+                'high',
+                'xhigh'
+            ]).optional(),
+            message: zod__rspack_import_5.YjP().min(1).optional()
+        }).strict();
+        const __rspack_default_export = (0, agent_bundle_routes__rspack_import_1.uO)({
+            excludeClients: [
+                'codex'
+            ],
+            title: 'Codex new thread',
+            description: 'Start a new Codex thread on this machine in cwd, optionally sending its first message. Codex must run locally on the same machine as gbot.',
+            annotations: {
+                readOnlyHint: false
+            },
+            inputSchema,
+            resultSchema: _core_codex_routes_js__rspack_import_4.FD,
+            inputJsonSchema: {
+                type: 'object',
+                additionalProperties: false,
+                properties: {
+                    cwd: {
+                        type: 'string'
+                    },
+                    expectedCwd: {
+                        type: 'string'
+                    },
+                    model: {
+                        type: 'string'
+                    },
+                    effort: {
+                        type: 'string',
+                        enum: [
+                            'none',
+                            'minimal',
+                            'low',
+                            'medium',
+                            'high',
+                            'xhigh'
+                        ]
+                    },
+                    message: {
+                        type: 'string'
+                    }
+                },
+                required: [
+                    'cwd'
+                ]
+            }
+        }, async (input)=>{
+            let out;
+            try {
+                out = await (0, _core_codex_bridge_js__rspack_import_2.QC)(input);
+            } catch (error) {
+                out = (0, _core_codex_contract_js__rspack_import_3.DG)(error);
+            }
+            return (0, react_jsx_runtime__rspack_import_0.jsx)(_agent_bundle_runtime__rspack_import_6.g.Result, {
+                value: out,
+                children: (0, react_jsx_runtime__rspack_import_0.jsx)(_agent_bundle_runtime__rspack_import_6.g.Text, {
+                    children: out.threadId && !('delivery' in out) ? `Started Codex thread ${out.threadId}` : (0, _core_codex_routes_js__rspack_import_4.D6)(out)
+                })
+            });
+        });
+        __webpack_require__.d(__webpack_exports__, {}, {
+            "default": __rspack_default_export,
+            inputSchema: inputSchema
+        });
+    },
     "./src/mcp/grok-bot/tools/codex_send.tsx" (__unused_rspack_module, __webpack_exports__, __webpack_require__) {
         __webpack_require__.r(__webpack_exports__);
         var react_jsx_runtime__rspack_import_0 = __webpack_require__("./node_modules/react/jsx-runtime.react-server.js");
@@ -8724,13 +8826,13 @@ var __webpack_modules__ = {
             excludeClients: [
                 'codex'
             ],
-            description: 'Send to Codex. With replyToGrok or bindingId, managed delivery returns the terminal answer to Grok automatically. Otherwise optional wait observes completion and explicit steer requires expectedTurnId. Acceptance is not completion.',
+            description: 'Send to a Codex thread. Runs on the user\'s registered machine via its local socket, not the Grok Bot box. From the box, use Grok Bot Shell with a machineId to run gbot there after codex app-server daemon start or bootstrap; gbot has no remote transport. With replyToGrok or bindingId, managed delivery returns the terminal answer to Grok automatically. Otherwise optional wait observes completion and explicit steer requires expectedTurnId. Acceptance is not completion.',
             title: 'Codex send',
             annotations: {
                 readOnlyHint: false
             },
             render: {
-                maxElapsedMs: 660000
+                maxElapsedMs: 7260000
             },
             inputSchema,
             resultSchema,
@@ -8740,6 +8842,20 @@ var __webpack_modules__ = {
                     expectedCwd: {
                         type: 'string'
                     },
+                    model: {
+                        type: 'string'
+                    },
+                    effort: {
+                        type: 'string',
+                        enum: [
+                            'none',
+                            'minimal',
+                            'low',
+                            'medium',
+                            'high',
+                            'xhigh'
+                        ]
+                    },
                     threadId: {
                         type: 'string'
                     },
@@ -8835,7 +8951,7 @@ var __webpack_modules__ = {
             excludeClients: [
                 'codex'
             ],
-            description: 'Discover a bounded page of Codex daemon threads.',
+            description: 'Discover a bounded page of Codex daemon threads. Runs on the user\'s registered machine via its local socket, not the Grok Bot box. From the box, use Grok Bot Shell with a machineId to run gbot there after codex app-server daemon start or bootstrap; gbot has no remote transport.',
             title: 'Codex threads',
             annotations: {
                 readOnlyHint: true
@@ -8886,13 +9002,13 @@ var __webpack_modules__ = {
             excludeClients: [
                 'codex'
             ],
-            description: 'Explicit diagnostic observation of one Codex turn; returns execution and final reply without interrupting it.',
+            description: 'Explicit diagnostic observation of one Codex turn; returns execution and final reply without interrupting it. Runs on the user\'s registered machine via its local socket, not the Grok Bot box. From the box, use Grok Bot Shell with a machineId to run gbot there after codex app-server daemon start or bootstrap; gbot has no remote transport.',
             title: 'Codex wait',
             annotations: {
                 readOnlyHint: true
             },
             render: {
-                maxElapsedMs: 660000
+                maxElapsedMs: 7260000
             },
             inputSchema: _core_codex_routes_js__rspack_import_2.jS,
             resultSchema: _core_codex_routes_js__rspack_import_2.FD,
@@ -8908,7 +9024,7 @@ var __webpack_modules__ = {
                     },
                     "timeoutMs": {
                         "type": "number",
-                        "description": "Observation timeout: 1-600000 milliseconds."
+                        "description": "Observation timeout: 1-7200000 milliseconds."
                     },
                     "turnId": {
                         "type": "string"
@@ -8955,7 +9071,7 @@ var __webpack_modules__ = {
             excludeClients: [
                 'codex'
             ],
-            description: 'Watch bounded Codex thread events for diagnostics without answering approvals.',
+            description: 'Watch bounded Codex thread events for diagnostics without answering approvals. Runs on the user\'s registered machine via its local socket, not the Grok Bot box. From the box, use Grok Bot Shell with a machineId to run gbot there after codex app-server daemon start or bootstrap; gbot has no remote transport.',
             title: 'Codex watch',
             annotations: {
                 readOnlyHint: true
@@ -20235,6 +20351,7 @@ var __webpack_modules__ = {
         var node_net__rspack_import_2 = __webpack_require__("node:net");
         var node_os__rspack_import_3 = __webpack_require__("node:os");
         var node_path__rspack_import_4 = __webpack_require__("node:path");
+        var _user_machine_guidance_js__rspack_import_5 = __webpack_require__("./src/core/user-machine-guidance.js");
         const MAX_BYTES = 65536;
         const FRAME_BYTES = MAX_BYTES * 6 + 1024;
         const defaultDirectory = ()=>(0, node_path__rspack_import_4.join)((0, node_os__rspack_import_3.homedir)(), '.grok-bot-cli', 'claude');
@@ -20245,6 +20362,18 @@ var __webpack_modules__ = {
             if (Buffer.byteLength(path) >= 104) throw Error('Claude channel socket path is too long');
             return path;
         }
+        function absentClaudeChannelMessage(path, directory) {
+            if ((0, _user_machine_guidance_js__rspack_import_5.R)({
+                path,
+                home: directory
+            })) {
+                return [
+                    'No Claude channel socket at ' + path + '.',
+                    _user_machine_guidance_js__rspack_import_5.M
+                ].join('\n');
+            }
+            return 'No Claude channel socket at ' + path + '. Start an opted-in Claude Code session with GROK_BOT_CLAUDE_CHANNEL on this machine (gbot has no remote transport).';
+        }
         function messageText(message) {
             if (typeof message !== 'string' || !message.trim() || Buffer.byteLength(message) > MAX_BYTES) throw Error('Message must contain text within 64 KiB');
             return message;
@@ -20378,8 +20507,21 @@ var __webpack_modules__ = {
             const path = socketPath(name, directory);
             messageText(message);
             timeout(timeoutMs);
-            await privateDirectory(directory);
-            const info = await (0, node_fs_promises__rspack_import_1.lstat)(path);
+            try {
+                await privateDirectory(directory);
+            } catch (error) {
+                if (error && (error.code === 'ENOENT' || /no such file|ENOENT/i.test(String(error.message)))) {
+                    throw Error(absentClaudeChannelMessage(path, directory));
+                }
+                throw error;
+            }
+            let info;
+            try {
+                info = await (0, node_fs_promises__rspack_import_1.lstat)(path);
+            } catch (error) {
+                if (error && error.code === 'ENOENT') throw Error(absentClaudeChannelMessage(path, directory));
+                throw error;
+            }
             if (!info.isSocket() || info.uid !== process.getuid() || info.mode & 63) throw Error('Claude channel socket is not private to this user');
             return new Promise((resolve, reject)=>{
                 const socket = (0, node_net__rspack_import_2.connect)(path);
@@ -20429,7 +20571,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"
@@ -20462,20 +20605,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");
         }
@@ -21119,6 +21276,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 = (0, node_fs__rspack_import_1.realpathSync)(cwd);
+            if (expectedCwd !== undefined && (0, node_fs__rspack_import_1.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", [
@@ -21208,7 +21406,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,
@@ -21417,7 +21615,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"
             });
@@ -21425,7 +21623,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,
@@ -21482,7 +21680,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,
@@ -21491,6 +21689,8 @@ var __webpack_modules__ = {
                     session,
                     expectedTurnId,
                     expectedCwd,
+                    model,
+                    effort,
                     signal
                 });
                 return (0, _codex_contract_js__rspack_import_7.Dz)(receipt);
@@ -21502,7 +21702,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",
@@ -21548,7 +21760,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();
@@ -21681,7 +21901,13 @@ var __webpack_modules__ = {
                             }
                         ],
                         clientUserMessageId: envelope.messageId,
-                        turnTrigger: "gbot"
+                        turnTrigger: "gbot",
+                        ...model ? {
+                            model
+                        } : {},
+                        ...effort ? {
+                            effort
+                        } : {}
                     });
                 } catch (err) {
                     if (err instanceof CodexSendError) throw err;
@@ -21738,6 +21964,7 @@ var __webpack_modules__ = {
         __webpack_require__.d(__webpack_exports__, {
             $3: ()=>assertThreadAllowed,
             Mr: ()=>withEnvelopeHeader,
+            QC: ()=>startCodexThread,
             X$: ()=>listCodexThreads,
             ZS: ()=>sendToCodexThread,
             e0: ()=>experimentalEnabled,
@@ -21952,10 +22179,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');
@@ -22002,6 +22229,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);
@@ -22010,7 +22238,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;
@@ -22043,7 +22271,7 @@ var __webpack_modules__ = {
                         interactions
                     };
                 };
-                let timer, notify;
+                let timer, pollTimer, notify;
                 const abortSignals = [
                     signal,
                     waitSignal
@@ -22059,10 +22287,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
                     });
@@ -22133,19 +22369,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);
@@ -22168,6 +22436,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 [
@@ -22215,7 +22484,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',
@@ -22234,6 +22503,8 @@ var __webpack_modules__ = {
                         expectedTurnId,
                         session,
                         expectedCwd,
+                        model,
+                        effort,
                         signal: submissionSignal
                     });
                     if (receipt.delivery === 'accepted' && receipt.turnId) {
@@ -24135,9 +24406,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"
         };
     }
 };
@@ -24190,49 +24482,51 @@ function __webpack_require__(moduleId) {
 var __webpack_exports__ = {};
 var node_worker_threads__rspack_import_0 = __webpack_require__("node:worker_threads");
 var react__rspack_import_1 = __webpack_require__("./node_modules/react/react.react-server.js");
-var _agent_bundle_runtime_flight_server__rspack_import_19 = __webpack_require__("./node_modules/@agent-bundle/runtime/dist/flight/server.js");
-var _agent_bundle_runtime__rspack_import_16 = __webpack_require__("./node_modules/@agent-bundle/runtime/dist/49.js");
-var _agent_bundle_runtime__rspack_import_17 = __webpack_require__("./node_modules/@agent-bundle/runtime/dist/736.js");
-var _agent_bundle_runtime__rspack_import_18 = __webpack_require__("./node_modules/@agent-bundle/runtime/dist/506.js");
+var _agent_bundle_runtime_flight_server__rspack_import_20 = __webpack_require__("./node_modules/@agent-bundle/runtime/dist/flight/server.js");
+var _agent_bundle_runtime__rspack_import_17 = __webpack_require__("./node_modules/@agent-bundle/runtime/dist/49.js");
+var _agent_bundle_runtime__rspack_import_18 = __webpack_require__("./node_modules/@agent-bundle/runtime/dist/736.js");
+var _agent_bundle_runtime__rspack_import_19 = __webpack_require__("./node_modules/@agent-bundle/runtime/dist/506.js");
 var node_url__rspack_import_2 = __webpack_require__("node:url");
 var _src_mcp_grok_bot_tools_claude_send_tsx__rspack_import_3 = __webpack_require__("./src/mcp/grok-bot/tools/claude_send.tsx");
-var _src_mcp_grok_bot_tools_codex_send_tsx__rspack_import_4 = __webpack_require__("./src/mcp/grok-bot/tools/codex_send.tsx");
-var _src_mcp_grok_bot_tools_codex_threads_tsx__rspack_import_5 = __webpack_require__("./src/mcp/grok-bot/tools/codex_threads.tsx");
-var _src_mcp_grok_bot_tools_codex_wait_tsx__rspack_import_6 = __webpack_require__("./src/mcp/grok-bot/tools/codex_wait.tsx");
-var _src_mcp_grok_bot_tools_codex_watch_tsx__rspack_import_7 = __webpack_require__("./src/mcp/grok-bot/tools/codex_watch.tsx");
-var _src_mcp_grok_bot_tools_gbot_bridge_start_tsx__rspack_import_8 = __webpack_require__("./src/mcp/grok-bot/tools/gbot_bridge_start.tsx");
-var _src_mcp_grok_bot_tools_gbot_bridge_status_tsx__rspack_import_9 = __webpack_require__("./src/mcp/grok-bot/tools/gbot_bridge_status.tsx");
-var _src_mcp_grok_bot_tools_gbot_bridge_stop_tsx__rspack_import_10 = __webpack_require__("./src/mcp/grok-bot/tools/gbot_bridge_stop.tsx");
-var _src_mcp_grok_bot_tools_gbot_codex_respond_tsx__rspack_import_11 = __webpack_require__("./src/mcp/grok-bot/tools/gbot_codex_respond.tsx");
-var _src_mcp_grok_bot_tools_gbot_grok_approvals_tsx__rspack_import_12 = __webpack_require__("./src/mcp/grok-bot/tools/gbot_grok_approvals.tsx");
-var _src_mcp_grok_bot_tools_gbot_grok_respond_tsx__rspack_import_13 = __webpack_require__("./src/mcp/grok-bot/tools/gbot_grok_respond.tsx");
-var _src_mcp_grok_bot_tools_gbot_send_tsx__rspack_import_14 = __webpack_require__("./src/mcp/grok-bot/tools/gbot_send.tsx");
-var _src_mcp_grok_bot_tools_gbot_thread_tsx__rspack_import_15 = __webpack_require__("./src/mcp/grok-bot/tools/gbot_thread.tsx");
+var _src_mcp_grok_bot_tools_codex_new_tsx__rspack_import_4 = __webpack_require__("./src/mcp/grok-bot/tools/codex_new.tsx");
+var _src_mcp_grok_bot_tools_codex_send_tsx__rspack_import_5 = __webpack_require__("./src/mcp/grok-bot/tools/codex_send.tsx");
+var _src_mcp_grok_bot_tools_codex_threads_tsx__rspack_import_6 = __webpack_require__("./src/mcp/grok-bot/tools/codex_threads.tsx");
+var _src_mcp_grok_bot_tools_codex_wait_tsx__rspack_import_7 = __webpack_require__("./src/mcp/grok-bot/tools/codex_wait.tsx");
+var _src_mcp_grok_bot_tools_codex_watch_tsx__rspack_import_8 = __webpack_require__("./src/mcp/grok-bot/tools/codex_watch.tsx");
+var _src_mcp_grok_bot_tools_gbot_bridge_start_tsx__rspack_import_9 = __webpack_require__("./src/mcp/grok-bot/tools/gbot_bridge_start.tsx");
+var _src_mcp_grok_bot_tools_gbot_bridge_status_tsx__rspack_import_10 = __webpack_require__("./src/mcp/grok-bot/tools/gbot_bridge_status.tsx");
+var _src_mcp_grok_bot_tools_gbot_bridge_stop_tsx__rspack_import_11 = __webpack_require__("./src/mcp/grok-bot/tools/gbot_bridge_stop.tsx");
+var _src_mcp_grok_bot_tools_gbot_codex_respond_tsx__rspack_import_12 = __webpack_require__("./src/mcp/grok-bot/tools/gbot_codex_respond.tsx");
+var _src_mcp_grok_bot_tools_gbot_grok_approvals_tsx__rspack_import_13 = __webpack_require__("./src/mcp/grok-bot/tools/gbot_grok_approvals.tsx");
+var _src_mcp_grok_bot_tools_gbot_grok_respond_tsx__rspack_import_14 = __webpack_require__("./src/mcp/grok-bot/tools/gbot_grok_respond.tsx");
+var _src_mcp_grok_bot_tools_gbot_send_tsx__rspack_import_15 = __webpack_require__("./src/mcp/grok-bot/tools/gbot_send.tsx");
+var _src_mcp_grok_bot_tools_gbot_thread_tsx__rspack_import_16 = __webpack_require__("./src/mcp/grok-bot/tools/gbot_thread.tsx");
 const route0 = Object.assign({}, Reflect.get(_src_mcp_grok_bot_tools_claude_send_tsx__rspack_import_3, 'default'), _src_mcp_grok_bot_tools_claude_send_tsx__rspack_import_3);
-const route1 = Object.assign({}, Reflect.get(_src_mcp_grok_bot_tools_codex_send_tsx__rspack_import_4, 'default'), _src_mcp_grok_bot_tools_codex_send_tsx__rspack_import_4);
-const route2 = Object.assign({}, Reflect.get(_src_mcp_grok_bot_tools_codex_threads_tsx__rspack_import_5, 'default'), _src_mcp_grok_bot_tools_codex_threads_tsx__rspack_import_5);
-const route3 = Object.assign({}, Reflect.get(_src_mcp_grok_bot_tools_codex_wait_tsx__rspack_import_6, 'default'), _src_mcp_grok_bot_tools_codex_wait_tsx__rspack_import_6);
-const route4 = Object.assign({}, Reflect.get(_src_mcp_grok_bot_tools_codex_watch_tsx__rspack_import_7, 'default'), _src_mcp_grok_bot_tools_codex_watch_tsx__rspack_import_7);
-const route5 = Object.assign({}, Reflect.get(_src_mcp_grok_bot_tools_gbot_bridge_start_tsx__rspack_import_8, 'default'), _src_mcp_grok_bot_tools_gbot_bridge_start_tsx__rspack_import_8);
-const route6 = Object.assign({}, Reflect.get(_src_mcp_grok_bot_tools_gbot_bridge_status_tsx__rspack_import_9, 'default'), _src_mcp_grok_bot_tools_gbot_bridge_status_tsx__rspack_import_9);
-const route7 = Object.assign({}, Reflect.get(_src_mcp_grok_bot_tools_gbot_bridge_stop_tsx__rspack_import_10, 'default'), _src_mcp_grok_bot_tools_gbot_bridge_stop_tsx__rspack_import_10);
-const route8 = Object.assign({}, Reflect.get(_src_mcp_grok_bot_tools_gbot_codex_respond_tsx__rspack_import_11, 'default'), _src_mcp_grok_bot_tools_gbot_codex_respond_tsx__rspack_import_11);
-const route9 = Object.assign({}, Reflect.get(_src_mcp_grok_bot_tools_gbot_grok_approvals_tsx__rspack_import_12, 'default'), _src_mcp_grok_bot_tools_gbot_grok_approvals_tsx__rspack_import_12);
-const route10 = Object.assign({}, Reflect.get(_src_mcp_grok_bot_tools_gbot_grok_respond_tsx__rspack_import_13, 'default'), _src_mcp_grok_bot_tools_gbot_grok_respond_tsx__rspack_import_13);
-const route11 = Object.assign({}, Reflect.get(_src_mcp_grok_bot_tools_gbot_send_tsx__rspack_import_14, 'default'), _src_mcp_grok_bot_tools_gbot_send_tsx__rspack_import_14);
-const route12 = Object.assign({}, Reflect.get(_src_mcp_grok_bot_tools_gbot_thread_tsx__rspack_import_15, 'default'), _src_mcp_grok_bot_tools_gbot_thread_tsx__rspack_import_15);
+const route1 = Object.assign({}, Reflect.get(_src_mcp_grok_bot_tools_codex_new_tsx__rspack_import_4, 'default'), _src_mcp_grok_bot_tools_codex_new_tsx__rspack_import_4);
+const route2 = Object.assign({}, Reflect.get(_src_mcp_grok_bot_tools_codex_send_tsx__rspack_import_5, 'default'), _src_mcp_grok_bot_tools_codex_send_tsx__rspack_import_5);
+const route3 = Object.assign({}, Reflect.get(_src_mcp_grok_bot_tools_codex_threads_tsx__rspack_import_6, 'default'), _src_mcp_grok_bot_tools_codex_threads_tsx__rspack_import_6);
+const route4 = Object.assign({}, Reflect.get(_src_mcp_grok_bot_tools_codex_wait_tsx__rspack_import_7, 'default'), _src_mcp_grok_bot_tools_codex_wait_tsx__rspack_import_7);
+const route5 = Object.assign({}, Reflect.get(_src_mcp_grok_bot_tools_codex_watch_tsx__rspack_import_8, 'default'), _src_mcp_grok_bot_tools_codex_watch_tsx__rspack_import_8);
+const route6 = Object.assign({}, Reflect.get(_src_mcp_grok_bot_tools_gbot_bridge_start_tsx__rspack_import_9, 'default'), _src_mcp_grok_bot_tools_gbot_bridge_start_tsx__rspack_import_9);
+const route7 = Object.assign({}, Reflect.get(_src_mcp_grok_bot_tools_gbot_bridge_status_tsx__rspack_import_10, 'default'), _src_mcp_grok_bot_tools_gbot_bridge_status_tsx__rspack_import_10);
+const route8 = Object.assign({}, Reflect.get(_src_mcp_grok_bot_tools_gbot_bridge_stop_tsx__rspack_import_11, 'default'), _src_mcp_grok_bot_tools_gbot_bridge_stop_tsx__rspack_import_11);
+const route9 = Object.assign({}, Reflect.get(_src_mcp_grok_bot_tools_gbot_codex_respond_tsx__rspack_import_12, 'default'), _src_mcp_grok_bot_tools_gbot_codex_respond_tsx__rspack_import_12);
+const route10 = Object.assign({}, Reflect.get(_src_mcp_grok_bot_tools_gbot_grok_approvals_tsx__rspack_import_13, 'default'), _src_mcp_grok_bot_tools_gbot_grok_approvals_tsx__rspack_import_13);
+const route11 = Object.assign({}, Reflect.get(_src_mcp_grok_bot_tools_gbot_grok_respond_tsx__rspack_import_14, 'default'), _src_mcp_grok_bot_tools_gbot_grok_respond_tsx__rspack_import_14);
+const route12 = Object.assign({}, Reflect.get(_src_mcp_grok_bot_tools_gbot_send_tsx__rspack_import_15, 'default'), _src_mcp_grok_bot_tools_gbot_send_tsx__rspack_import_15);
+const route13 = Object.assign({}, Reflect.get(_src_mcp_grok_bot_tools_gbot_thread_tsx__rspack_import_16, 'default'), _src_mcp_grok_bot_tools_gbot_thread_tsx__rspack_import_16);
 globalThis.__rspack_rsc_manifest__ ??= Object.freeze({
     clientManifest: Object.freeze({})
 });
 if (node_worker_threads__rspack_import_0.parentPort === null) throw new Error('Generated Flight worker requires a parent port.');
 process.stdout.write = process.stderr.write.bind(process.stderr);
-const ARTIFACT_EPOCH = "gbot@0.10.0";
+const ARTIFACT_EPOCH = "gbot@0.10.2";
 const processLifetime = {
     hits: 0,
     instanceId: crypto.randomUUID(),
     pid: process.pid
 };
-const pluginRoot = (0, _agent_bundle_runtime__rspack_import_16.E7)({
+const pluginRoot = (0, _agent_bundle_runtime__rspack_import_17.E7)({
     fallback: (0, node_url__rspack_import_2.fileURLToPath)(new URL('..', import.meta.url)),
     stateAnchor: 'user-data'
 });
@@ -24243,7 +24537,7 @@ const routes = Object.freeze({
             "annotations": {
                 "readOnlyHint": false
             },
-            "description": "Send to a named, opted-in live Claude Code channel and wait for its reply. Unknown delivery must not be retried automatically.",
+            "description": "Send to a named, opted-in live Claude Code channel and wait for its reply. Unknown delivery must not be retried automatically. Runs on the user's registered machine via its local socket, not the Grok Bot box. From the box, use Grok Bot Shell with a machineId to run gbot there after codex app-server daemon start or bootstrap; gbot has no remote transport.",
             "inputJsonSchema": {
                 "additionalProperties": false,
                 "properties": {
@@ -24274,12 +24568,61 @@ const routes = Object.freeze({
         name: "claude_send",
         serverId: "mcp:grok-bot"
     }),
+    "tool:grok-bot/codex_new": Object.freeze({
+        config: {
+            "annotations": {
+                "readOnlyHint": false
+            },
+            "description": "Start a new Codex thread on this machine in cwd, optionally sending its first message. Codex must run locally on the same machine as gbot.",
+            "excludeClients": [
+                "codex"
+            ],
+            "inputJsonSchema": {
+                "additionalProperties": false,
+                "properties": {
+                    "cwd": {
+                        "type": "string"
+                    },
+                    "effort": {
+                        "enum": [
+                            "none",
+                            "minimal",
+                            "low",
+                            "medium",
+                            "high",
+                            "xhigh"
+                        ],
+                        "type": "string"
+                    },
+                    "expectedCwd": {
+                        "type": "string"
+                    },
+                    "message": {
+                        "type": "string"
+                    },
+                    "model": {
+                        "type": "string"
+                    }
+                },
+                "required": [
+                    "cwd"
+                ],
+                "type": "object"
+            },
+            "title": "Codex new thread"
+        },
+        id: "tool:grok-bot/codex_new",
+        kind: "tool",
+        module: route1,
+        name: "codex_new",
+        serverId: "mcp:grok-bot"
+    }),
     "tool:grok-bot/codex_send": Object.freeze({
         config: {
             "annotations": {
                 "readOnlyHint": false
             },
-            "description": "Send to Codex. With replyToGrok or bindingId, managed delivery returns the terminal answer to Grok automatically. Otherwise optional wait observes completion and explicit steer requires expectedTurnId. Acceptance is not completion.",
+            "description": "Send to a Codex thread. Runs on the user's registered machine via its local socket, not the Grok Bot box. From the box, use Grok Bot Shell with a machineId to run gbot there after codex app-server daemon start or bootstrap; gbot has no remote transport. With replyToGrok or bindingId, managed delivery returns the terminal answer to Grok automatically. Otherwise optional wait observes completion and explicit steer requires expectedTurnId. Acceptance is not completion.",
             "excludeClients": [
                 "codex"
             ],
@@ -24292,6 +24635,17 @@ const routes = Object.freeze({
                     "correlationId": {
                         "type": "string"
                     },
+                    "effort": {
+                        "enum": [
+                            "none",
+                            "minimal",
+                            "low",
+                            "medium",
+                            "high",
+                            "xhigh"
+                        ],
+                        "type": "string"
+                    },
                     "envelope": {
                         "type": "boolean"
                     },
@@ -24310,6 +24664,9 @@ const routes = Object.freeze({
                     "message": {
                         "type": "string"
                     },
+                    "model": {
+                        "type": "string"
+                    },
                     "replyTo": {
                         "type": "string"
                     },
@@ -24345,13 +24702,13 @@ const routes = Object.freeze({
                 "type": "object"
             },
             "render": {
-                "maxElapsedMs": 660000
+                "maxElapsedMs": 7260000
             },
             "title": "Codex send"
         },
         id: "tool:grok-bot/codex_send",
         kind: "tool",
-        module: route1,
+        module: route2,
         name: "codex_send",
         serverId: "mcp:grok-bot"
     }),
@@ -24360,7 +24717,7 @@ const routes = Object.freeze({
             "annotations": {
                 "readOnlyHint": true
             },
-            "description": "Discover a bounded page of Codex daemon threads.",
+            "description": "Discover a bounded page of Codex daemon threads. Runs on the user's registered machine via its local socket, not the Grok Bot box. From the box, use Grok Bot Shell with a machineId to run gbot there after codex app-server daemon start or bootstrap; gbot has no remote transport.",
             "excludeClients": [
                 "codex"
             ],
@@ -24385,7 +24742,7 @@ const routes = Object.freeze({
         },
         id: "tool:grok-bot/codex_threads",
         kind: "tool",
-        module: route2,
+        module: route3,
         name: "codex_threads",
         serverId: "mcp:grok-bot"
     }),
@@ -24394,7 +24751,7 @@ const routes = Object.freeze({
             "annotations": {
                 "readOnlyHint": true
             },
-            "description": "Explicit diagnostic observation of one Codex turn; returns execution and final reply without interrupting it.",
+            "description": "Explicit diagnostic observation of one Codex turn; returns execution and final reply without interrupting it. Runs on the user's registered machine via its local socket, not the Grok Bot box. From the box, use Grok Bot Shell with a machineId to run gbot there after codex app-server daemon start or bootstrap; gbot has no remote transport.",
             "excludeClients": [
                 "codex"
             ],
@@ -24415,7 +24772,7 @@ const routes = Object.freeze({
                         "type": "string"
                     },
                     "timeoutMs": {
-                        "description": "Observation timeout: 1-600000 milliseconds.",
+                        "description": "Observation timeout: 1-7200000 milliseconds.",
                         "type": "number"
                     },
                     "turnId": {
@@ -24429,13 +24786,13 @@ const routes = Object.freeze({
                 "type": "object"
             },
             "render": {
-                "maxElapsedMs": 660000
+                "maxElapsedMs": 7260000
             },
             "title": "Codex wait"
         },
         id: "tool:grok-bot/codex_wait",
         kind: "tool",
-        module: route3,
+        module: route4,
         name: "codex_wait",
         serverId: "mcp:grok-bot"
     }),
@@ -24444,7 +24801,7 @@ const routes = Object.freeze({
             "annotations": {
                 "readOnlyHint": true
             },
-            "description": "Watch bounded Codex thread events for diagnostics without answering approvals.",
+            "description": "Watch bounded Codex thread events for diagnostics without answering approvals. Runs on the user's registered machine via its local socket, not the Grok Bot box. From the box, use Grok Bot Shell with a machineId to run gbot there after codex app-server daemon start or bootstrap; gbot has no remote transport.",
             "excludeClients": [
                 "codex"
             ],
@@ -24478,7 +24835,7 @@ const routes = Object.freeze({
         },
         id: "tool:grok-bot/codex_watch",
         kind: "tool",
-        module: route4,
+        module: route5,
         name: "codex_watch",
         serverId: "mcp:grok-bot"
     }),
@@ -24520,7 +24877,7 @@ const routes = Object.freeze({
         },
         id: "tool:grok-bot/gbot_bridge_start",
         kind: "tool",
-        module: route5,
+        module: route6,
         name: "gbot_bridge_start",
         serverId: "mcp:grok-bot"
     }),
@@ -24546,7 +24903,7 @@ const routes = Object.freeze({
         },
         id: "tool:grok-bot/gbot_bridge_status",
         kind: "tool",
-        module: route6,
+        module: route7,
         name: "gbot_bridge_status",
         serverId: "mcp:grok-bot"
     }),
@@ -24575,7 +24932,7 @@ const routes = Object.freeze({
         },
         id: "tool:grok-bot/gbot_bridge_stop",
         kind: "tool",
-        module: route7,
+        module: route8,
         name: "gbot_bridge_stop",
         serverId: "mcp:grok-bot"
     }),
@@ -24634,7 +24991,7 @@ const routes = Object.freeze({
         },
         id: "tool:grok-bot/gbot_codex_respond",
         kind: "tool",
-        module: route8,
+        module: route9,
         name: "gbot_codex_respond",
         serverId: "mcp:grok-bot"
     }),
@@ -24665,7 +25022,7 @@ const routes = Object.freeze({
         },
         id: "tool:grok-bot/gbot_grok_approvals",
         kind: "tool",
-        module: route9,
+        module: route10,
         name: "gbot_grok_approvals",
         serverId: "mcp:grok-bot"
     }),
@@ -24712,7 +25069,7 @@ const routes = Object.freeze({
         },
         id: "tool:grok-bot/gbot_grok_respond",
         kind: "tool",
-        module: route10,
+        module: route11,
         name: "gbot_grok_respond",
         serverId: "mcp:grok-bot"
     }),
@@ -24773,7 +25130,7 @@ const routes = Object.freeze({
         },
         id: "tool:grok-bot/gbot_send",
         kind: "tool",
-        module: route11,
+        module: route12,
         name: "gbot_send",
         serverId: "mcp:grok-bot"
     }),
@@ -24819,7 +25176,7 @@ const routes = Object.freeze({
         },
         id: "tool:grok-bot/gbot_thread",
         kind: "tool",
-        module: route12,
+        module: route13,
         name: "gbot_thread",
         serverId: "mcp:grok-bot"
     })
@@ -24867,7 +25224,7 @@ const render = async (message)=>{
     };
     try {
         const plugin = message.plugin ?? pluginRoot.identity;
-        await (0, _agent_bundle_runtime__rspack_import_17.iC)({
+        await (0, _agent_bundle_runtime__rspack_import_18.iC)({
             ...message.actor === undefined ? {} : {
                 actor: message.actor
             },
@@ -24881,7 +25238,7 @@ const render = async (message)=>{
                 operationId: route.id,
                 surface: route.name
             },
-            lineage: message.lineage ?? (0, _agent_bundle_runtime__rspack_import_17.hU)('not-provided'),
+            lineage: message.lineage ?? (0, _agent_bundle_runtime__rspack_import_18.hU)('not-provided'),
             plugin,
             progress: {
                 report: async (update)=>{
@@ -24897,7 +25254,7 @@ const render = async (message)=>{
                 session: message.session
             },
             signal: controller.signal,
-            terminal: message.terminal ?? (0, _agent_bundle_runtime__rspack_import_17.hU)('not-provided'),
+            terminal: message.terminal ?? (0, _agent_bundle_runtime__rspack_import_18.hU)('not-provided'),
             ...message.workspace === undefined ? {} : {
                 workspace: message.workspace
             }
@@ -24932,10 +25289,10 @@ const render = async (message)=>{
                 type: 'observed-render-start'
             });
             const renderStartedAt = performance.now();
-            const element = validationError === undefined ? composeLayouts(observedRoute, props, controller.signal) : (0, react__rspack_import_1.createElement)(_agent_bundle_runtime__rspack_import_18.g.Result, null, (0, react__rspack_import_1.createElement)(_agent_bundle_runtime__rspack_import_18.g.Error, {
+            const element = validationError === undefined ? composeLayouts(observedRoute, props, controller.signal) : (0, react__rspack_import_1.createElement)(_agent_bundle_runtime__rspack_import_19.g.Result, null, (0, react__rspack_import_1.createElement)(_agent_bundle_runtime__rspack_import_19.g.Error, {
                 code: 'invalid-input'
             }, `Input validation error: ${validationError instanceof Error ? validationError.message : String(validationError)}`));
-            const flight = (0, _agent_bundle_runtime_flight_server__rspack_import_19.y)(element, {
+            const flight = (0, _agent_bundle_runtime_flight_server__rspack_import_20.y)(element, {
                 signal: controller.signal
             });
             const reader = flight.getReader();