grok-bot-cli 0.10.1 → 0.11.0

package/dist/scripts/gbot-relay.mjs

@@ -22133,17 +22133,20 @@ var __webpack_modules__ = {
         var node_child_process__rspack_import_5 = __webpack_require__("node:child_process");
         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");
-        var _user_machine_guidance_js__rspack_import_9 = __webpack_require__("./src/core/user-machine-guidance.js");
-        const PINNED_CODEX_VERSION = "0.154.0";
+        var _codex_remote_control_js__rspack_import_8 = __webpack_require__("./src/core/codex/remote-control.js");
+        var _codex_thread_id_js__rspack_import_11 = __webpack_require__("./src/core/codex/thread-id.js");
+        var _desktop_shim_js__rspack_import_9 = __webpack_require__("./src/core/desktop-shim.js");
+        var _user_machine_guidance_js__rspack_import_10 = __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"
         ];
         const WS_GUID = "258EAFA5-E914-47DA-95CA-C5AB0DC85B11";
         const WS_MAX_HEADER_BYTES = 16 * 1024;
-        const WS_MAX_MESSAGE_BYTES = 4 * 1024 * 1024;
-        const WS_MAX_BUFFER_BYTES = 8 * 1024 * 1024;
+        const WS_MAX_MESSAGE_BYTES = 16 * 1024 * 1024;
+        const WS_MAX_BUFFER_BYTES = 32 * 1024 * 1024;
+        const CODEX_SEND_MAX_BYTES = 4 * 1024 * 1024;
         const WS_MAX_WRITE_BYTES = 8 * 1024 * 1024;
         const CODEX_MAX_REQUESTS = 128;
         const CODEX_MAX_LISTENERS = 128;
@@ -22171,11 +22174,11 @@ var __webpack_modules__ = {
         function boxUnreachableMessage(path) {
             return [
                 "No Codex app-server control socket at " + path + ".",
-                _user_machine_guidance_js__rspack_import_9.M
+                _user_machine_guidance_js__rspack_import_10.M
             ].join("\n");
         }
         function unreachableMessage(path, desktopAttached = "unknown", env = process.env) {
-            if ((0, _user_machine_guidance_js__rspack_import_9.R)({
+            if ((0, _user_machine_guidance_js__rspack_import_10.R)({
                 path,
                 env,
                 home: env.HOME || (0, node_os__rspack_import_3.homedir)()
@@ -22195,7 +22198,7 @@ var __webpack_modules__ = {
                 "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(", ") + ").",
-                "gbot connects only to this machine's local socket; it has no remote transport.",
+                "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");
         }
@@ -22839,6 +22842,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", [
@@ -22973,6 +23017,13 @@ var __webpack_modules__ = {
             if (value == null) return null;
             return typeof value === "string" ? singleLine(value) : value;
         }
+        function summarizeSection(section) {
+            if (!isObject(section) || typeof section.id !== "string" || !section.id) return null;
+            return {
+                id: singleLine(section.id),
+                name: lineField(section.name)
+            };
+        }
         function summarizeThread(t) {
             if (!isObject(t) || typeof t.id !== "string" || !t.id) throw new CodexProtocolError("thread/list", "entry without a string `id`");
             const type = isObject(t.status) && typeof t.status.type === "string" ? t.status.type : "unknown";
@@ -22984,43 +23035,72 @@ var __webpack_modules__ = {
                 preview: typeof t.preview === "string" ? stripTerminalControls(t.preview) : "",
                 cwd: lineField(t.cwd),
                 source: sourceField(t.source),
-                updatedAt: typeof t.updatedAt === "number" ? t.updatedAt : null
+                createdAt: typeof t.createdAt === "number" ? t.createdAt : null,
+                updatedAt: typeof t.updatedAt === "number" ? t.updatedAt : null,
+                section: summarizeSection(t.section),
+                projectId: lineField(t.projectId),
+                modelProvider: lineField(t.modelProvider),
+                model: lineField(t.model),
+                originator: lineField(t.originator)
             };
         }
         const THREAD_LIST_MAX_LIMIT = 200;
-        async function listCodexThreads({ limit = 20, cursor, env = process.env } = {}) {
+        async function listCodexThreads({ limit = 20, cursor, modelProviders = [], env = process.env } = {}) {
             if (!Number.isInteger(limit) || limit < 1 || limit > THREAD_LIST_MAX_LIMIT) {
                 throw new RangeError("--limit must be an integer 1-" + THREAD_LIST_MAX_LIMIT);
             }
             if (cursor !== undefined && (typeof cursor !== "string" || !cursor)) throw new RangeError("--cursor must be a non-empty string");
+            if (!Array.isArray(modelProviders) || modelProviders.some((p)=>typeof p !== "string")) {
+                throw new RangeError("modelProviders must be an array of strings (empty = all providers)");
+            }
             const { client } = await openSession(env);
             try {
-                const params = {
+                const baseParams = {
                     limit,
-                    useStateDbOnly: true,
+                    modelProviders,
                     ...cursor !== undefined ? {
                         cursor
                     } : {}
                 };
                 let out;
+                let usedStateDbOnly = true;
                 try {
-                    out = await client.request("thread/list", params);
+                    out = await client.request("thread/list", {
+                        ...baseParams,
+                        useStateDbOnly: true
+                    });
                 } catch (err) {
                     throw transportError(err);
                 }
                 if (!isObject(out) || !Array.isArray(out.data)) throw new CodexProtocolError("thread/list", "missing `data` array");
+                if (out.data.length === 0 && cursor === undefined && (out.nextCursor == null || out.nextCursor === "")) {
+                    try {
+                        out = await client.request("thread/list", {
+                            ...baseParams,
+                            useStateDbOnly: false
+                        });
+                        usedStateDbOnly = false;
+                    } catch (err) {
+                        throw transportError(err);
+                    }
+                    if (!isObject(out) || !Array.isArray(out.data)) throw new CodexProtocolError("thread/list", "missing `data` array");
+                }
                 if (out.nextCursor != null && typeof out.nextCursor !== "string") throw new CodexProtocolError("thread/list", "`nextCursor` is not a string");
                 const threads = out.data.map(summarizeThread);
                 return {
                     threads,
                     nextCursor: out.nextCursor ?? null,
-                    limit
+                    limit,
+                    useStateDbOnly: usedStateDbOnly
                 };
             } finally{
                 client.close();
             }
         }
-        function explainSendError(err, threadId) {
+        function explainSendError(err, threadId, env = process.env) {
+            if (err instanceof _codex_remote_control_js__rspack_import_8.Rg) return err;
+            const mapped = (0, _codex_remote_control_js__rspack_import_8.R3)(err, threadId, env);
+            if (mapped instanceof _codex_remote_control_js__rspack_import_8.Rg) return mapped;
             if (!(err instanceof CodexRpcError)) return err;
             const msg = String(err.rpc && err.rpc.message || "");
             if (/no rollout found|thread not found/i.test(msg)) {
@@ -23095,12 +23175,19 @@ var __webpack_modules__ = {
         function assertThreadAllowed(threadId, env = process.env) {
             const raw = env.GROK_BOT_CODEX_THREADS;
             if (raw == null || raw.trim() === "") return;
-            const allowed = raw.split(",").map((s)=>s.trim()).filter(Boolean);
-            if (!allowed.includes(threadId)) {
-                throw new CodexSendError("Codex thread " + threadId + " is not in GROK_BOT_CODEX_THREADS; the operator allows only: " + allowed.join(", "), {
+            const bare = (0, _codex_thread_id_js__rspack_import_11.SX)(threadId);
+            const allowed = raw.split(",").map((s)=>{
+                try {
+                    return (0, _codex_thread_id_js__rspack_import_11.SX)(s.trim());
+                } catch  {
+                    return s.trim();
+                }
+            }).filter(Boolean);
+            if (!allowed.includes(bare)) {
+                throw new CodexSendError("Codex thread " + bare + " is not in GROK_BOT_CODEX_THREADS; the operator allows only: " + allowed.join(", "), {
                     delivery: "rejected",
                     reason: "route-not-allowed",
-                    threadId
+                    threadId: bare
                 });
             }
         }
@@ -23137,7 +23224,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"
             });
@@ -23145,7 +23232,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,
@@ -23170,6 +23257,7 @@ var __webpack_modules__ = {
         }
         async function listCodexQueue(threadId, { env = process.env, limit = 50, cursor } = {}) {
             requireExperimental(env, "gbot codex queue");
+            threadId = normalizeCodexThreadId(threadId);
             const { client } = await openSession(env, {
                 experimental: true
             });
@@ -23200,9 +23288,67 @@ var __webpack_modules__ = {
                 client.close();
             }
         }
+        async function readCodexThread(threadId, { limit = 100, env = process.env } = {}) {
+            if (!Number.isInteger(limit) || limit < 1 || limit > 2000) {
+                throw new RangeError("limit must be an integer 1-2000");
+            }
+            const bare = normalizeCodexThreadId(threadId);
+            const { client } = await openSession(env);
+            try {
+                let meta;
+                try {
+                    meta = await client.request("thread/read", {
+                        threadId: bare
+                    });
+                } catch (err) {
+                    const mapped = explainSendError(err, bare, env);
+                    if (mapped instanceof RemoteThreadNotLoadedError) throw mapped;
+                    throw transportError(err);
+                }
+                const turns = [];
+                let cursor;
+                const seen = new Set();
+                for(let page = 0; page < 40 && turns.length < limit; page++){
+                    let out;
+                    try {
+                        out = await client.request("thread/turns/list", {
+                            threadId: bare,
+                            limit: Math.min(100, limit - turns.length),
+                            itemsView: "full",
+                            sortDirection: "desc",
+                            ...cursor !== undefined ? {
+                                cursor
+                            } : {}
+                        });
+                    } catch (err) {
+                        const mapped = explainSendError(err, bare, env);
+                        if (mapped instanceof RemoteThreadNotLoadedError) throw mapped;
+                        throw transportError(err);
+                    }
+                    if (!isObject(out) || !Array.isArray(out.data)) {
+                        throw new CodexProtocolError("thread/turns/list", "missing `data` array");
+                    }
+                    for (const row of out.data)turns.push(row);
+                    cursor = out.nextCursor ?? null;
+                    if (cursor === null) break;
+                    if (typeof cursor !== "string" || !cursor || seen.has(cursor)) {
+                        throw new CodexProtocolError("thread/turns/list", "invalid or repeated cursor");
+                    }
+                    seen.add(cursor);
+                }
+                return {
+                    threadId: bare,
+                    thread: isObject(meta) && isObject(meta.thread) ? meta.thread : null,
+                    turns: turns.slice(0, limit),
+                    nextCursor: cursor ?? null
+                };
+            } finally{
+                client.close();
+            }
+        }
         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,
@@ -23211,6 +23357,8 @@ var __webpack_modules__ = {
                     session,
                     expectedTurnId,
                     expectedCwd,
+                    model,
+                    effort,
                     signal
                 });
                 return (0, _codex_contract_js__rspack_import_7.Dz)(receipt);
@@ -23222,7 +23370,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",
@@ -23231,8 +23391,8 @@ var __webpack_modules__ = {
                 ] : []
             ].includes(whenBusy)) throw new RangeError("--when-busy must be reject, queue, or persistent steer");
             if (whenBusy === "steer" && (typeof expectedTurnId !== "string" || !ID_PATTERN.test(expectedTurnId))) throw new RangeError("steer requires expectedTurnId");
-            if (typeof threadId !== "string" || !ID_PATTERN.test(threadId)) throw new RangeError("Invalid threadId");
-            if (typeof text !== "string" || !text.trim() || Buffer.byteLength(text) > WS_MAX_MESSAGE_BYTES) throw new RangeError("Message must contain text within 4 MiB");
+            threadId = (0, _codex_thread_id_js__rspack_import_11.SX)(threadId);
+            if (typeof text !== "string" || !text.trim() || Buffer.byteLength(text) > CODEX_SEND_MAX_BYTES) throw new RangeError("Message must contain text within 4 MiB");
             if (!envelope || typeof envelope.messageId !== "string" || !ID_PATTERN.test(envelope.messageId)) throw new RangeError("Invalid envelope messageId");
             const validated = buildEnvelope({
                 correlationId: envelope.correlationId,
@@ -23268,12 +23428,22 @@ 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();
-                    if (err instanceof CodexSendError) throw err;
-                    throw new CodexSendError(explainSendError(err, threadId).message, {
+                    if (err instanceof CodexSendError || err instanceof _codex_remote_control_js__rspack_import_8.Rg) throw err;
+                    const explained = explainSendError(err, threadId, env);
+                    if (explained instanceof _codex_remote_control_js__rspack_import_8.Rg) throw explained;
+                    throw new CodexSendError(explained.message, {
                         delivery: err instanceof CodexRpcError ? "rejected" : err && err.delivery || "unknown",
                         reason: err instanceof CodexRpcError ? /no rollout found|thread not found/i.test(String(err.rpc && err.rpc.message)) ? "unknown-thread" : /active writer/i.test(String(err.rpc && err.rpc.message)) ? "external-owner" : "rejected" : "transport",
                         threadId,
@@ -23401,7 +23571,13 @@ var __webpack_modules__ = {
                             }
                         ],
                         clientUserMessageId: envelope.messageId,
-                        turnTrigger: "gbot"
+                        turnTrigger: "gbot",
+                        ...model ? {
+                            model
+                        } : {},
+                        ...effort ? {
+                            effort
+                        } : {}
                     });
                 } catch (err) {
                     if (err instanceof CodexSendError) throw err;
@@ -23498,7 +23674,11 @@ var __webpack_modules__ = {
                     "messageId",
                     "correlationId",
                     "refused",
-                    "hop"
+                    "hop",
+                    "hostId",
+                    "hostName",
+                    "hint",
+                    "code"
                 ]){
                     if (error[key] !== undefined) out[key] = error[key];
                 }
@@ -23533,9 +23713,12 @@ var __webpack_modules__ = {
         var _contract_js__rspack_import_0 = __webpack_require__("./src/core/codex/contract.js");
         var node_fs__rspack_import_1 = __webpack_require__("node:fs");
         var _codex_bridge_js__rspack_import_2 = __webpack_require__("./src/core/codex-bridge.js");
+        var _remote_control_js__rspack_import_3 = __webpack_require__("./src/core/codex/remote-control.js");
+        var _thread_id_js__rspack_import_4 = __webpack_require__("./src/core/codex/thread-id.js");
         const ID = /^[A-Za-z0-9_.:-]{1,128}$/;
         const BUDGET = 4 * 1024 * 1024;
         function conversationId(value, name = 'threadId') {
+            if (name === 'threadId') return (0, _thread_id_js__rspack_import_4.SX)(value);
             if (typeof value !== 'string' || !ID.test(value)) throw new RangeError(`${name} must be 1-128 identifier characters`);
             return value;
         }
@@ -23660,7 +23843,8 @@ var __webpack_modules__ = {
                 if (expected !== undefined && (typeof cwd !== 'string' || (0, node_fs__rspack_import_1.realpathSync)(cwd) !== expected)) throw new Error('Codex thread cwd does not match expectedCwd');
             } catch (error) {
                 await close();
-                throw error;
+                if (error instanceof _remote_control_js__rspack_import_3.Rg) throw error;
+                throw (0, _remote_control_js__rspack_import_3.R3)(error, threadId, env);
             }
             async function wait({ turnId, messageId, afterMessageId, timeoutMs = 120000, signal: waitSignal, maxOutputBytes = 1048576 }) {
                 conversationId(turnId, 'turnId');
@@ -23670,10 +23854,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');
@@ -23720,6 +23904,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);
@@ -23728,7 +23913,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;
@@ -23761,7 +23946,7 @@ var __webpack_modules__ = {
                         interactions
                     };
                 };
-                let timer, notify;
+                let timer, pollTimer, notify;
                 const abortSignals = [
                     signal,
                     waitSignal
@@ -23777,10 +23962,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
                     });
@@ -23851,19 +24044,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);
@@ -23886,6 +24111,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 [
@@ -23933,7 +24159,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',
@@ -23952,6 +24178,8 @@ var __webpack_modules__ = {
                         expectedTurnId,
                         session,
                         expectedCwd,
+                        model,
+                        effort,
                         signal: submissionSignal
                     });
                     if (receipt.delivery === 'accepted' && receipt.turnId) {
@@ -23967,6 +24195,264 @@ var __webpack_modules__ = {
             j: ()=>openCodexConversation
         });
     },
+    "./src/core/codex/remote-control.js" (__unused_rspack___webpack_module__, __webpack_exports__, __webpack_require__) {
+        var node_fs__rspack_import_0 = __webpack_require__("node:fs");
+        var node_os__rspack_import_1 = __webpack_require__("node:os");
+        var node_path__rspack_import_2 = __webpack_require__("node:path");
+        var _thread_id_js__rspack_import_3 = __webpack_require__("./src/core/codex/thread-id.js");
+        const REMOTE_SUMMARY_KEY = /^remote-thread-summaries-v3:(.+)$/;
+        class RemoteThreadNotLoadedError1 extends Error {
+            constructor(threadId, hostId = null, hostName = null){
+                const hostLabel = hostName ? `${JSON.stringify(hostName)} (${JSON.stringify(hostId)})` : hostId ? JSON.stringify(hostId) : null;
+                const owner = hostLabel ? `owned by remote-control host ${hostLabel}` : 'owned by a remote-control host (hostId unknown; check ~/.codex/.codex-global-state.json)';
+                const hint = hostId ? `Read this thread via host ${JSON.stringify(hostId)}'s app-server` + (hostName ? ` (${hostName})` : '') + '. SSH remoting is not implemented in this adapter.' : "Read this thread via the owning host's app-server. SSH remoting is not implemented in this adapter.";
+                super(`Codex thread ${JSON.stringify(threadId)} is not loaded on the local app-server; ${owner}. ${hint}`);
+                this.name = 'RemoteThreadNotLoadedError';
+                this.code = 'REMOTE_THREAD_NOT_LOADED';
+                this.delivery = 'rejected';
+                this.reason = 'remote-thread-not-loaded';
+                this.threadId = threadId;
+                this.hostId = hostId;
+                this.hostName = hostName;
+                this.hint = hint;
+            }
+        }
+        function codexGlobalStatePath(env = process.env) {
+            const home = env.CODEX_HOME || (0, node_path__rspack_import_2.join)((0, node_os__rspack_import_1.homedir)(), '.codex');
+            return (0, node_path__rspack_import_2.join)(home, '.codex-global-state.json');
+        }
+        function loadCodexGlobalState(env = process.env) {
+            let raw;
+            try {
+                raw = (0, node_fs__rspack_import_0.readFileSync)(codexGlobalStatePath(env), 'utf8');
+            } catch  {
+                return null;
+            }
+            try {
+                const data = JSON.parse(raw);
+                if (!data || typeof data !== 'object' || Array.isArray(data)) return null;
+                return data;
+            } catch  {
+                return null;
+            }
+        }
+        function codexStateEntries(data) {
+            const nested = data?.['electron-persisted-atom-state'];
+            return [
+                nested,
+                data
+            ].filter((value)=>value && typeof value === 'object' && !Array.isArray(value));
+        }
+        function findRemoteThreadHost(threadId, env = process.env) {
+            let bare;
+            try {
+                bare = (0, _thread_id_js__rspack_import_3.SX)(threadId);
+            } catch  {
+                bare = typeof threadId === 'string' && threadId.startsWith("local:") ? threadId.slice("local:".length) : threadId;
+            }
+            if (!bare) return null;
+            const data = loadCodexGlobalState(env);
+            if (!data) return null;
+            const hostNames = collectHostNames(data);
+            for (const [key, value] of codexStateEntries(data).flatMap(Object.entries)){
+                const match = REMOTE_SUMMARY_KEY.exec(key);
+                if (!match?.[1]) continue;
+                const hostId = match[1];
+                const hostName = hostNames.get(hostId) ?? extractHostName(value) ?? null;
+                for (const entry of extractThreadEntries(value)){
+                    const id = threadIdFromEntry(entry);
+                    if (!id) continue;
+                    const entryBare = id.startsWith("local:") ? id.slice("local:".length) : id;
+                    if (entryBare === bare) return {
+                        hostId,
+                        hostName
+                    };
+                }
+            }
+            return null;
+        }
+        function mapRemoteThreadError(error, threadId, env = process.env) {
+            const message = errorMessage(error);
+            if (!/thread not loaded|not loaded|no rollout found|thread not found|invalid thread id/i.test(message)) {
+                return error instanceof Error ? error : new Error(message || String(error));
+            }
+            const remote = findRemoteThreadHost(threadId, env);
+            if (remote) {
+                return new RemoteThreadNotLoadedError1(threadId, remote.hostId, remote.hostName);
+            }
+            if (/thread not loaded|not loaded/i.test(message)) {
+                return new RemoteThreadNotLoadedError1(threadId, null, null);
+            }
+            return error instanceof Error ? error : new Error(message || String(error));
+        }
+        function collectHostNames(data) {
+            const names = new Map();
+            for (const [key, value] of codexStateEntries(data).flatMap(Object.entries)){
+                if (!/remote-host|hosts|host-meta|host_directory|environments/i.test(key)) continue;
+                if (!value || typeof value !== 'object') continue;
+                if (Array.isArray(value)) {
+                    for (const entry of value){
+                        const pair = hostNameFromEntry(entry);
+                        if (pair && !names.has(pair.hostId)) names.set(pair.hostId, pair.hostName);
+                    }
+                    continue;
+                }
+                for (const [hostId, entry] of Object.entries(value)){
+                    const fromEntry = hostNameFromEntry(entry);
+                    if (fromEntry) {
+                        if (!names.has(fromEntry.hostId)) names.set(fromEntry.hostId, fromEntry.hostName);
+                        continue;
+                    }
+                    const label = stringField(entry, [
+                        'name',
+                        'hostName',
+                        'displayName',
+                        'envName',
+                        'label',
+                        'title'
+                    ]);
+                    if (label && !names.has(hostId)) names.set(hostId, label);
+                }
+            }
+            return names;
+        }
+        function hostNameFromEntry(entry) {
+            if (!entry || typeof entry !== 'object' || Array.isArray(entry)) return null;
+            const hostId = stringField(entry, [
+                'hostId',
+                'id',
+                'host_id',
+                'uuid'
+            ]);
+            const hostName = stringField(entry, [
+                'name',
+                'hostName',
+                'displayName',
+                'envName',
+                'label',
+                'title'
+            ]);
+            if (!hostId || !hostName) return null;
+            return {
+                hostId,
+                hostName
+            };
+        }
+        function extractHostName(value) {
+            if (!value || typeof value !== 'object' || Array.isArray(value)) return null;
+            return stringField(value, [
+                'hostName',
+                'displayName',
+                'name',
+                'envName',
+                'label',
+                'title',
+                'friendlyName'
+            ]);
+        }
+        function extractThreadEntries(value) {
+            if (Array.isArray(value)) return value;
+            if (!value || typeof value !== 'object') return [];
+            const record = value;
+            for (const key of [
+                'threads',
+                'summaries',
+                'items',
+                'data',
+                'conversations'
+            ]){
+                if (Array.isArray(record[key])) return record[key];
+            }
+            const entries = [];
+            for (const [key, entry] of Object.entries(record)){
+                if ([
+                    'pinnedIds',
+                    'pinned',
+                    'pinnedThreadIds',
+                    'hostName',
+                    'displayName',
+                    'name',
+                    'envName',
+                    'label',
+                    'title',
+                    'friendlyName',
+                    'hostId',
+                    'version'
+                ].includes(key)) continue;
+                if (typeof entry === 'string') continue;
+                if (entry && typeof entry === 'object' && !Array.isArray(entry)) {
+                    const id = stringField(entry, [
+                        'id',
+                        'threadId',
+                        'thread_id',
+                        'conversationId'
+                    ]);
+                    entries.push(id ? entry : {
+                        ...entry,
+                        id: key
+                    });
+                }
+            }
+            return entries;
+        }
+        function threadIdFromEntry(entry) {
+            if (typeof entry === 'string' && entry) return entry;
+            if (!entry || typeof entry !== 'object' || Array.isArray(entry)) return null;
+            return stringField(entry, [
+                'id',
+                'threadId',
+                'thread_id',
+                'conversationId'
+            ]);
+        }
+        function stringField(row, keys) {
+            if (!row || typeof row !== 'object' || Array.isArray(row)) return null;
+            for (const key of keys){
+                const value = row[key];
+                if (typeof value === 'string' && value.trim()) return value.trim();
+            }
+            return null;
+        }
+        function errorMessage(error) {
+            if (!error) return '';
+            if (typeof error === 'string') return error;
+            if (error instanceof Error) return error.message;
+            if (typeof error === 'object' && error && 'message' in error) return String(error.message);
+            if (typeof error === 'object' && error && 'rpc' in error) {
+                const rpc = error.rpc;
+                if (rpc && typeof rpc.message === 'string') return rpc.message;
+            }
+            return String(error);
+        }
+        __webpack_require__.d(__webpack_exports__, {
+            R3: ()=>mapRemoteThreadError,
+            Rg: ()=>RemoteThreadNotLoadedError1
+        });
+    },
+    "./src/core/codex/thread-id.js" (__unused_rspack___webpack_module__, __webpack_exports__, __webpack_require__) {
+        const LOCAL_THREAD_ID_PREFIX = 'local:';
+        const TEMP_THREAD_ID_PREFIX = 'local:client-new-thread:';
+        const ID_PATTERN = /^[A-Za-z0-9_.:-]{1,128}$/;
+        function isTemporaryDesktopThreadId(threadId) {
+            return typeof threadId === 'string' && (threadId.startsWith(TEMP_THREAD_ID_PREFIX) || threadId.startsWith('client-new-thread:'));
+        }
+        function normalizeCodexThreadId1(threadId) {
+            if (typeof threadId !== 'string' || !threadId) {
+                throw new RangeError('Invalid threadId');
+            }
+            if (isTemporaryDesktopThreadId(threadId)) {
+                throw new RangeError('Temporary Desktop thread id ' + JSON.stringify(threadId) + ' has no app-server mapping; wait for the real conversation id');
+            }
+            const bare = threadId.startsWith(LOCAL_THREAD_ID_PREFIX) ? threadId.slice(LOCAL_THREAD_ID_PREFIX.length) : threadId;
+            if (!bare || !ID_PATTERN.test(bare)) {
+                throw new RangeError('Invalid threadId');
+            }
+            return bare;
+        }
+        __webpack_require__.d(__webpack_exports__, {
+            SX: ()=>normalizeCodexThreadId1
+        });
+    },
     "./src/core/desktop-shim.js" (__unused_rspack___webpack_module__, __unused_rspack___webpack_exports__, __webpack_require__) {
         var node_child_process__rspack_import_0 = __webpack_require__("node:child_process");
         var node_fs__rspack_import_1 = __webpack_require__("node:fs");
@@ -25242,6 +25728,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;
@@ -26384,6 +26876,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 ?? [],
@@ -26476,6 +26974,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),
@@ -27383,7 +27890,7 @@ ts() { date -u +%Y-%m-%dT%H:%M:%SZ; }
     "./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).",
-            "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 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");
@@ -27403,7 +27910,7 @@ ts() { date -u +%Y-%m-%dT%H:%M:%SZ; }
     },
     "./package.json" (module) {
         module.exports = {
-            "rE": "0.10.1"
+            "rE": "0.11.0"
         };
     }
 };