grok-bot-cli 0.5.0 → 0.6.0

package/dist/bin/gbot.mjs

@@ -5,11 +5,11 @@ import * as __rspack_external_node_child_process_cd435d64 from "node:child_proce
 import * as __rspack_external_node_crypto_2e7c4b46 from "node:crypto";
 import * as __rspack_external_node_fs_1b05aee1 from "node:fs";
 import * as __rspack_external_node_fs_promises_3b710708 from "node:fs/promises";
-import * as __rspack_external_node_module_9de3fa2f from "node:module";
 import * as __rspack_external_node_net_5ed819e1 from "node:net";
 import * as __rspack_external_node_os_4f3c9d58 from "node:os";
 import * as __rspack_external_node_path_806ed179 from "node:path";
 import * as __rspack_external_node_readline_d8f53bef from "node:readline";
+import * as __rspack_external_node_string_decoder_69b9bd04 from "node:string_decoder";
 import * as __rspack_external_node_url_3991086a from "node:url";
 import * as __rspack_external_node_worker_threads_28ca7740 from "node:worker_threads";
 import { createRequire as __rspack_createRequire } from "node:module";
@@ -11456,6 +11456,376 @@ __webpack_require__.d(__webpack_exports__, {
 });
 
 
+},
+"./src/cli/codex/bridge/respond.tsx"(__unused_rspack_module, __webpack_exports__, __webpack_require__) {
+__webpack_require__.r(__webpack_exports__);
+/* import */ var react_jsx_runtime__rspack_import_0 = __webpack_require__("./node_modules/react/jsx-runtime.js");
+/* import */ var _agent_bundle_runtime__rspack_import_3 = __webpack_require__("./node_modules/@agent-bundle/runtime/dist/736.js");
+/* import */ var _agent_bundle_runtime__rspack_import_4 = __webpack_require__("./node_modules/@agent-bundle/runtime/dist/506.js");
+/* import */ var _core_relay_routes_js__rspack_import_1 = __webpack_require__("./src/core/relay/routes.ts");
+/* import */ var _core_codex_contract_js__rspack_import_2 = __webpack_require__("./src/core/codex/contract.js");
+
+
+
+
+
+const config = {
+    description: 'Managed Grok/Codex bridge respond.',
+    exitCode: 'result',
+    inputJsonSchema: {
+        type: 'object',
+        properties: {
+            interactionId: {
+                type: 'string'
+            },
+            generation: {
+                type: 'string'
+            },
+            threadId: {
+                type: 'string'
+            },
+            turnId: {
+                type: 'string'
+            },
+            bindingId: {
+                type: 'string'
+            },
+            exchangeId: {
+                type: 'string'
+            },
+            decision: {
+                type: 'string',
+                enum: [
+                    'accept',
+                    'decline',
+                    'cancel'
+                ]
+            },
+            answersJson: {
+                type: 'string',
+                description: 'JSON object mapping each advertised question ID to {"answers":["answer"]}; exact IDs required.'
+            }
+        },
+        required: [
+            'interactionId',
+            'generation',
+            'threadId',
+            'turnId'
+        ],
+        additionalProperties: false
+    }
+};
+async function route({ input }) {
+    let out;
+    try {
+        out = {
+            ...await (0,_core_relay_routes_js__rspack_import_1/* .bridgeOperation */.n1)('respond', input, await (0,_agent_bundle_runtime__rspack_import_3/* .agent */.MA)()),
+            exitCode: 0
+        };
+    } catch (error) {
+        out = (0,_core_codex_contract_js__rspack_import_2/* .outcomeFromError */.DG)(error);
+    }
+    return /*#__PURE__*/ (0,react_jsx_runtime__rspack_import_0.jsx)(_agent_bundle_runtime__rspack_import_4/* .Agent.Result */.g6.Result, {
+        value: out,
+        children: /*#__PURE__*/ (0,react_jsx_runtime__rspack_import_0.jsx)(_agent_bundle_runtime__rspack_import_4/* .Agent.Text */.g6.Text, {
+            children: JSON.stringify(out)
+        })
+    });
+}
+
+__webpack_require__.d(__webpack_exports__, {
+  "default": () => (route),
+  inputSchema: () => (/* reexport safe */ _core_relay_routes_js__rspack_import_1.v1),
+  resultSchema: () => (/* reexport safe */ _core_relay_routes_js__rspack_import_1.Ax)
+}, {
+  config: config
+});
+
+
+},
+"./src/cli/codex/bridge/run.tsx"(__unused_rspack_module, __webpack_exports__, __webpack_require__) {
+__webpack_require__.r(__webpack_exports__);
+/* import */ var react_jsx_runtime__rspack_import_0 = __webpack_require__("./node_modules/react/jsx-runtime.js");
+/* import */ var _agent_bundle_runtime__rspack_import_4 = __webpack_require__("./node_modules/@agent-bundle/runtime/dist/736.js");
+/* import */ var _agent_bundle_runtime__rspack_import_5 = __webpack_require__("./node_modules/@agent-bundle/runtime/dist/506.js");
+/* import */ var node_child_process__rspack_import_1 = __webpack_require__("node:child_process");
+/* import */ var zod__rspack_import_3 = __webpack_require__("./node_modules/zod/v4/classic/schemas.js");
+/* import */ var _core_relay_managed_js__rspack_import_2 = __webpack_require__("./src/core/relay/managed.js");
+
+
+
+
+
+const inputSchema = zod__rspack_import_3/* .object */.Ikc({
+    lifetimeMs: zod__rspack_import_3/* .number */.aig().int().min(100).max(82800000).default(82800000)
+}).strict();
+const resultSchema = zod__rspack_import_3/* .object */.Ikc({
+    state: zod__rspack_import_3/* .string */.YjP(),
+    exitCode: zod__rspack_import_3/* .number */.aig()
+});
+const config = {
+    description: 'Run a bounded foreground relay (up to 23 hours). Use the packaged gbot-relay.mjs script for unlimited service lifetime.',
+    exitCode: 'result',
+    render: {
+        maxElapsedMs: 86400000
+    },
+    inputJsonSchema: {
+        type: 'object',
+        properties: {
+            lifetimeMs: {
+                type: 'number',
+                description: 'Foreground lifetime in milliseconds (100..82800000; default 23h).'
+            }
+        },
+        additionalProperties: false
+    }
+};
+async function route({ signal, input }) {
+    const context = await (0,_agent_bundle_runtime__rspack_import_4/* .agent */.MA)();
+    const script = await (0,_core_relay_managed_js__rspack_import_2/* .resolveRelayWorker */._v)({
+        pluginRoot: context.plugin.state === 'available' ? context.plugin.value.root : undefined
+    });
+    // The renderer may terminate immediately on abort. The separate worker can finish
+    // asynchronous socket/ledger cleanup after the synchronous termination signal.
+    const child = (0,node_child_process__rspack_import_1.spawn)(process.execPath, [
+        script,
+        '--lifetime-ms',
+        String(input.lifetimeMs),
+        '--parent-pid',
+        String(process.pid)
+    ], {
+        stdio: [
+            'ignore',
+            'ignore',
+            'inherit'
+        ]
+    });
+    const stop = ()=>{
+        child.kill('SIGTERM');
+    };
+    signal.addEventListener('abort', stop, {
+        once: true
+    });
+    if (signal.aborted) stop();
+    let exitCode;
+    try {
+        exitCode = await new Promise((resolve, reject)=>{
+            child.once('error', reject);
+            child.once('exit', (code)=>resolve(code ?? 1));
+        });
+    } finally{
+        signal.removeEventListener('abort', stop);
+    }
+    return /*#__PURE__*/ (0,react_jsx_runtime__rspack_import_0.jsx)(_agent_bundle_runtime__rspack_import_5/* .Agent.Result */.g6.Result, {
+        value: {
+            state: 'stopped',
+            exitCode
+        },
+        children: /*#__PURE__*/ (0,react_jsx_runtime__rspack_import_0.jsx)(_agent_bundle_runtime__rspack_import_5/* .Agent.Text */.g6.Text, {
+            children: "Relay worker stopped."
+        })
+    });
+}
+
+__webpack_require__.d(__webpack_exports__, {
+  "default": () => (route)
+}, {
+  config: config,
+  inputSchema: inputSchema,
+  resultSchema: resultSchema
+});
+
+
+},
+"./src/cli/codex/bridge/start.tsx"(__unused_rspack_module, __webpack_exports__, __webpack_require__) {
+__webpack_require__.r(__webpack_exports__);
+/* import */ var react_jsx_runtime__rspack_import_0 = __webpack_require__("./node_modules/react/jsx-runtime.js");
+/* import */ var _agent_bundle_runtime__rspack_import_3 = __webpack_require__("./node_modules/@agent-bundle/runtime/dist/736.js");
+/* import */ var _agent_bundle_runtime__rspack_import_4 = __webpack_require__("./node_modules/@agent-bundle/runtime/dist/506.js");
+/* import */ var _core_relay_routes_js__rspack_import_1 = __webpack_require__("./src/core/relay/routes.ts");
+/* import */ var _core_codex_contract_js__rspack_import_2 = __webpack_require__("./src/core/codex/contract.js");
+
+
+
+
+
+const config = {
+    description: 'Managed Grok/Codex bridge start.',
+    exitCode: 'result',
+    positionals: [
+        'grokTarget'
+    ],
+    inputJsonSchema: {
+        type: 'object',
+        properties: {
+            grokTarget: {
+                type: 'string'
+            },
+            codexThreadId: {
+                type: 'string'
+            },
+            expectedCwd: {
+                type: 'string'
+            },
+            busyPolicy: {
+                type: 'string',
+                enum: [
+                    'steer',
+                    'reject'
+                ]
+            },
+            requestId: {
+                type: 'string'
+            }
+        },
+        required: [
+            'grokTarget'
+        ],
+        additionalProperties: false
+    }
+};
+async function route({ input }) {
+    let out;
+    try {
+        out = {
+            ...await (0,_core_relay_routes_js__rspack_import_1/* .bridgeOperation */.n1)('startBinding', input, await (0,_agent_bundle_runtime__rspack_import_3/* .agent */.MA)()),
+            exitCode: 0
+        };
+    } catch (error) {
+        out = (0,_core_codex_contract_js__rspack_import_2/* .outcomeFromError */.DG)(error);
+    }
+    return /*#__PURE__*/ (0,react_jsx_runtime__rspack_import_0.jsx)(_agent_bundle_runtime__rspack_import_4/* .Agent.Result */.g6.Result, {
+        value: out,
+        children: /*#__PURE__*/ (0,react_jsx_runtime__rspack_import_0.jsx)(_agent_bundle_runtime__rspack_import_4/* .Agent.Text */.g6.Text, {
+            children: JSON.stringify(out)
+        })
+    });
+}
+
+__webpack_require__.d(__webpack_exports__, {
+  "default": () => (route),
+  inputSchema: () => (/* reexport safe */ _core_relay_routes_js__rspack_import_1.xD),
+  resultSchema: () => (/* reexport safe */ _core_relay_routes_js__rspack_import_1.Ax)
+}, {
+  config: config
+});
+
+
+},
+"./src/cli/codex/bridge/status.tsx"(__unused_rspack_module, __webpack_exports__, __webpack_require__) {
+__webpack_require__.r(__webpack_exports__);
+/* import */ var react_jsx_runtime__rspack_import_0 = __webpack_require__("./node_modules/react/jsx-runtime.js");
+/* import */ var _agent_bundle_runtime__rspack_import_3 = __webpack_require__("./node_modules/@agent-bundle/runtime/dist/736.js");
+/* import */ var _agent_bundle_runtime__rspack_import_4 = __webpack_require__("./node_modules/@agent-bundle/runtime/dist/506.js");
+/* import */ var _core_relay_routes_js__rspack_import_1 = __webpack_require__("./src/core/relay/routes.ts");
+/* import */ var _core_codex_contract_js__rspack_import_2 = __webpack_require__("./src/core/codex/contract.js");
+
+
+
+
+
+const config = {
+    description: 'Managed Grok/Codex bridge status.',
+    exitCode: 'result',
+    inputJsonSchema: {
+        type: 'object',
+        properties: {
+            bindingId: {
+                type: 'string'
+            },
+            limit: {
+                type: 'number'
+            }
+        },
+        additionalProperties: false
+    }
+};
+async function route({ input }) {
+    let out;
+    try {
+        out = {
+            ...await (0,_core_relay_routes_js__rspack_import_1/* .bridgeOperation */.n1)('status', input, await (0,_agent_bundle_runtime__rspack_import_3/* .agent */.MA)()),
+            exitCode: 0
+        };
+    } catch (error) {
+        out = (0,_core_codex_contract_js__rspack_import_2/* .outcomeFromError */.DG)(error);
+    }
+    return /*#__PURE__*/ (0,react_jsx_runtime__rspack_import_0.jsx)(_agent_bundle_runtime__rspack_import_4/* .Agent.Result */.g6.Result, {
+        value: out,
+        children: /*#__PURE__*/ (0,react_jsx_runtime__rspack_import_0.jsx)(_agent_bundle_runtime__rspack_import_4/* .Agent.Text */.g6.Text, {
+            children: JSON.stringify(out)
+        })
+    });
+}
+
+__webpack_require__.d(__webpack_exports__, {
+  "default": () => (route),
+  inputSchema: () => (/* reexport safe */ _core_relay_routes_js__rspack_import_1.np),
+  resultSchema: () => (/* reexport safe */ _core_relay_routes_js__rspack_import_1.Ax)
+}, {
+  config: config
+});
+
+
+},
+"./src/cli/codex/bridge/stop.tsx"(__unused_rspack_module, __webpack_exports__, __webpack_require__) {
+__webpack_require__.r(__webpack_exports__);
+/* import */ var react_jsx_runtime__rspack_import_0 = __webpack_require__("./node_modules/react/jsx-runtime.js");
+/* import */ var _agent_bundle_runtime__rspack_import_3 = __webpack_require__("./node_modules/@agent-bundle/runtime/dist/736.js");
+/* import */ var _agent_bundle_runtime__rspack_import_4 = __webpack_require__("./node_modules/@agent-bundle/runtime/dist/506.js");
+/* import */ var _core_relay_routes_js__rspack_import_1 = __webpack_require__("./src/core/relay/routes.ts");
+/* import */ var _core_codex_contract_js__rspack_import_2 = __webpack_require__("./src/core/codex/contract.js");
+
+
+
+
+
+const config = {
+    description: 'Managed Grok/Codex bridge stop.',
+    exitCode: 'result',
+    inputJsonSchema: {
+        type: 'object',
+        properties: {
+            bindingId: {
+                type: 'string'
+            },
+            all: {
+                type: 'boolean'
+            },
+            worker: {
+                type: 'boolean'
+            }
+        },
+        additionalProperties: false
+    }
+};
+async function route({ input }) {
+    let out;
+    try {
+        out = {
+            ...await (0,_core_relay_routes_js__rspack_import_1/* .bridgeOperation */.n1)('stop', input, await (0,_agent_bundle_runtime__rspack_import_3/* .agent */.MA)()),
+            exitCode: 0
+        };
+    } catch (error) {
+        out = (0,_core_codex_contract_js__rspack_import_2/* .outcomeFromError */.DG)(error);
+    }
+    return /*#__PURE__*/ (0,react_jsx_runtime__rspack_import_0.jsx)(_agent_bundle_runtime__rspack_import_4/* .Agent.Result */.g6.Result, {
+        value: out,
+        children: /*#__PURE__*/ (0,react_jsx_runtime__rspack_import_0.jsx)(_agent_bundle_runtime__rspack_import_4/* .Agent.Text */.g6.Text, {
+            children: JSON.stringify(out)
+        })
+    });
+}
+
+__webpack_require__.d(__webpack_exports__, {
+  "default": () => (route),
+  inputSchema: () => (/* reexport safe */ _core_relay_routes_js__rspack_import_1.d5),
+  resultSchema: () => (/* reexport safe */ _core_relay_routes_js__rspack_import_1.Ax)
+}, {
+  config: config
+});
+
+
 },
 "./src/cli/codex/desktop-shim.tsx"(__unused_rspack_module, __webpack_exports__, __webpack_require__) {
 __webpack_require__.r(__webpack_exports__);
@@ -11766,117 +12136,145 @@ __webpack_require__.d(__webpack_exports__, {
 "./src/cli/codex/send.tsx"(__unused_rspack_module, __webpack_exports__, __webpack_require__) {
 __webpack_require__.r(__webpack_exports__);
 /* import */ var react_jsx_runtime__rspack_import_0 = __webpack_require__("./node_modules/react/jsx-runtime.js");
-/* import */ var _agent_bundle_runtime__rspack_import_4 = __webpack_require__("./node_modules/@agent-bundle/runtime/dist/506.js");
+/* import */ var _agent_bundle_runtime__rspack_import_4 = __webpack_require__("./node_modules/@agent-bundle/runtime/dist/736.js");
+/* import */ var _agent_bundle_runtime__rspack_import_5 = __webpack_require__("./node_modules/@agent-bundle/runtime/dist/506.js");
 /* import */ var zod__rspack_import_3 = __webpack_require__("./node_modules/zod/v4/classic/schemas.js");
-/* import */ var _core_codex_bridge_js__rspack_import_1 = __webpack_require__("./src/core/codex-bridge.js");
-/* import */ var _core_codex_contract_js__rspack_import_2 = __webpack_require__("./src/core/codex/contract.js");
+/* import */ var _core_codex_routes_js__rspack_import_1 = __webpack_require__("./src/core/codex/routes.ts");
+/* import */ var _core_relay_routes_js__rspack_import_2 = __webpack_require__("./src/core/relay/routes.ts");
 
 
 
 
 
+const resultSchema = zod__rspack_import_3/* .union */.KCZ([
+    _core_codex_routes_js__rspack_import_1/* .resultSchema */.FD,
+    _core_relay_routes_js__rspack_import_2/* .relayResultSchema */.Ax
+]);
+const inputSchema = zod__rspack_import_3/* .object */.Ikc({
+    ..._core_codex_routes_js__rspack_import_1/* .sendFields */.at,
+    whenBusy: zod__rspack_import_3/* ["enum"] */.k5n([
+        'reject',
+        'queue',
+        'steer'
+    ]).optional(),
+    replyToGrok: zod__rspack_import_3/* .string */.YjP().min(1).optional(),
+    bindingId: zod__rspack_import_3/* .string */.YjP().min(1).optional(),
+    requestId: zod__rspack_import_3/* .string */.YjP().min(1).max(128).optional(),
+    correlationId: zod__rspack_import_3/* .string */.YjP().min(1).optional(),
+    replyTo: zod__rspack_import_3/* .string */.YjP().min(1).optional(),
+    message: zod__rspack_import_3/* .array */.YOg(zod__rspack_import_3/* .string */.YjP()).min(1)
+}).strict();
 const config = {
-    description: 'Send a message to a Codex thread. Options go before <threadId>; `--` protects flag-like text.',
+    description: 'Send to Codex; acceptance is distinct from completion. Options precede threadId.',
     exitCode: 'result',
+    render: {
+        maxElapsedMs: 660000
+    },
+    positionals: [
+        'threadId',
+        'message'
+    ],
     inputJsonSchema: {
+        type: 'object',
         additionalProperties: false,
         properties: {
+            replyToGrok: {
+                type: 'string'
+            },
+            bindingId: {
+                type: 'string'
+            },
+            requestId: {
+                type: 'string'
+            },
+            threadId: {
+                type: 'string'
+            },
+            expectedCwd: {
+                type: 'string'
+            },
+            timeoutMs: {
+                type: 'number',
+                description: 'Observation timeout: 1-600000 milliseconds.'
+            },
             correlationId: {
-                description: 'Stable correlation id for multi-hop replies',
                 type: 'string'
             },
             envelope: {
-                description: 'Prepend the [gbot …] header to the message body',
                 type: 'boolean'
             },
             hop: {
-                description: 'Hop count; refused at GROK_BOT_MAX_HOPS',
                 type: 'number'
             },
-            message: {
-                items: {
-                    type: 'string'
-                },
-                type: 'array'
-            },
             replyTo: {
-                description: 'Prior message id this send replies to',
                 type: 'string'
             },
-            threadId: {
-                type: 'string'
+            expectedTurnId: {
+                type: 'string',
+                description: 'Required active-turn guard for steer; stale guards reject.'
+            },
+            wait: {
+                type: 'boolean'
+            },
+            maxOutputBytes: {
+                type: 'number',
+                description: 'Reply budget: 1-4194304 bytes.'
             },
             whenBusy: {
-                description: 'reject (default) or queue (needs GROK_BOT_CODEX_EXPERIMENTAL=1)',
+                type: 'string',
                 enum: [
                     'reject',
-                    'queue'
-                ],
-                type: 'string'
+                    'queue',
+                    'steer'
+                ]
+            },
+            message: {
+                type: 'array',
+                items: {
+                    type: 'string'
+                }
             }
         },
         required: [
             'threadId',
             'message'
-        ],
-        type: 'object'
-    },
-    positionals: [
-        'threadId',
-        'message'
-    ]
+        ]
+    }
 };
-const inputSchema = zod__rspack_import_3/* .object */.Ikc({
-    correlationId: zod__rspack_import_3/* .string */.YjP().min(1).optional(),
-    envelope: zod__rspack_import_3/* .boolean */.zMY().optional(),
-    hop: zod__rspack_import_3/* .number */.aig().int().min(0).optional(),
-    message: zod__rspack_import_3/* .array */.YOg(zod__rspack_import_3/* .string */.YjP()).min(1),
-    replyTo: zod__rspack_import_3/* .string */.YjP().min(1).optional(),
-    threadId: zod__rspack_import_3/* .string */.YjP().min(1),
-    whenBusy: zod__rspack_import_3/* ["enum"] */.k5n([
-        'reject',
-        'queue'
-    ]).default('reject')
-}).strict();
-const resultSchema = zod__rspack_import_3/* .object */.Ikc({
-    delivery: zod__rspack_import_3/* ["enum"] */.k5n([
-        'accepted',
-        'queued',
-        'rejected',
-        'unknown'
-    ]),
-    exitCode: zod__rspack_import_3/* .union */.KCZ([
-        zod__rspack_import_3/* .literal */.euz(0),
-        zod__rspack_import_3/* .literal */.euz(1)
-    ])
-}).passthrough();
-async function codexSend({ input }) {
-    let out;
-    try {
-        const envelope = (0,_core_codex_bridge_js__rspack_import_1/* .buildEnvelope */.nq)({
-            correlationId: input.correlationId,
-            envelope: Boolean(input.envelope),
-            hop: input.hop,
-            replyTo: input.replyTo
-        });
-        out = await (0,_core_codex_bridge_js__rspack_import_1/* .sendToCodexThread */.ZS)(input.threadId, input.message.join(' ').trim(), {
-            envelope,
-            whenBusy: input.whenBusy
+async function route({ input, signal }) {
+    const context = await (0,_agent_bundle_runtime__rspack_import_4/* .agent */.MA)();
+    if (input.replyToGrok || input.bindingId) {
+        const out = await (0,_core_relay_routes_js__rspack_import_2/* .codexReturnOperation */.lt)({
+            ...input,
+            message: input.message.join(' ').trim()
+        }, context);
+        return /*#__PURE__*/ (0,react_jsx_runtime__rspack_import_0.jsx)(_agent_bundle_runtime__rspack_import_5/* .Agent.Result */.g6.Result, {
+            value: {
+                ...out,
+                exitCode: out.delivery === 'rejected' ? 1 : 0
+            },
+            children: /*#__PURE__*/ (0,react_jsx_runtime__rspack_import_0.jsx)(_agent_bundle_runtime__rspack_import_5/* .Agent.Text */.g6.Text, {
+                children: `Delivery ${out.delivery}; terminal answer returns to Grok automatically.`
+            })
         });
-    } catch (error) {
-        out = (0,_core_codex_contract_js__rspack_import_2/* .outcomeFromError */.DG)(error);
     }
-    const text = out.delivery === 'queued' && typeof out.queuedSubmissionId === 'string' ? `Queued ${out.queuedSubmissionId} on busy Codex thread ${out.threadId}; message ${out.messageId}` : out.exitCode === 0 ? `Started turn ${out.turnId} (${out.turnStatus}) on Codex thread ${out.threadId}; message ${out.messageId}` : typeof out.error === 'string' ? out.error : `Codex delivery ${out.delivery} on thread ${out.threadId}`;
-    return /*#__PURE__*/ (0,react_jsx_runtime__rspack_import_0.jsx)(_agent_bundle_runtime__rspack_import_4/* .Agent.Result */.g6.Result, {
+    const out = await (0,_core_codex_routes_js__rspack_import_1/* .sendOperation */.UP)({
+        ...input,
+        whenBusy: input.whenBusy ?? 'reject',
+        message: input.message.join(' ').trim()
+    }, signal, (message)=>context.progress.report({
+            message
+        }), true);
+    return /*#__PURE__*/ (0,react_jsx_runtime__rspack_import_0.jsx)(_agent_bundle_runtime__rspack_import_5/* .Agent.Result */.g6.Result, {
         value: out,
-        children: /*#__PURE__*/ (0,react_jsx_runtime__rspack_import_0.jsx)(_agent_bundle_runtime__rspack_import_4/* .Agent.Text */.g6.Text, {
-            children: text
+        children: /*#__PURE__*/ (0,react_jsx_runtime__rspack_import_0.jsx)(_agent_bundle_runtime__rspack_import_5/* .Agent.Text */.g6.Text, {
+            children: (0,_core_codex_routes_js__rspack_import_1/* .resultText */.D6)(out)
         })
     });
 }
 
 __webpack_require__.d(__webpack_exports__, {
-  "default": () => (codexSend)
+  "default": () => (route)
 }, {
   config: config,
   inputSchema: inputSchema,
@@ -11932,6 +12330,146 @@ __webpack_require__.d(__webpack_exports__, {
 });
 
 
+},
+"./src/cli/codex/wait.tsx"(__unused_rspack_module, __webpack_exports__, __webpack_require__) {
+__webpack_require__.r(__webpack_exports__);
+/* import */ var react_jsx_runtime__rspack_import_0 = __webpack_require__("./node_modules/react/jsx-runtime.js");
+/* import */ var _agent_bundle_runtime__rspack_import_2 = __webpack_require__("./node_modules/@agent-bundle/runtime/dist/736.js");
+/* import */ var _agent_bundle_runtime__rspack_import_3 = __webpack_require__("./node_modules/@agent-bundle/runtime/dist/506.js");
+/* import */ var _core_codex_routes_js__rspack_import_1 = __webpack_require__("./src/core/codex/routes.ts");
+
+
+
+
+const config = {
+    description: 'Bounded Codex wait observation; never interrupts execution.',
+    exitCode: 'result',
+    render: {
+        maxElapsedMs: 660000
+    },
+    positionals: [
+        'threadId',
+        'turnId'
+    ],
+    inputJsonSchema: {
+        type: 'object',
+        additionalProperties: false,
+        properties: {
+            "threadId": {
+                "type": "string"
+            },
+            "expectedCwd": {
+                "type": "string"
+            },
+            "timeoutMs": {
+                "type": "number",
+                "description": "Observation timeout: 1-600000 milliseconds."
+            },
+            "turnId": {
+                "type": "string"
+            },
+            "messageId": {
+                "type": "string"
+            },
+            "maxOutputBytes": {
+                "type": "number",
+                "description": "Reply budget: 1-4194304 bytes."
+            }
+        },
+        required: [
+            'threadId',
+            'turnId'
+        ]
+    }
+};
+async function route({ input, signal }) {
+    const context = await (0,_agent_bundle_runtime__rspack_import_2/* .agent */.MA)();
+    const out = await (0,_core_codex_routes_js__rspack_import_1/* .observeOperation */.gT)('wait', input, signal, (message)=>context.progress.report({
+            message
+        }));
+    return /*#__PURE__*/ (0,react_jsx_runtime__rspack_import_0.jsx)(_agent_bundle_runtime__rspack_import_3/* .Agent.Result */.g6.Result, {
+        value: out,
+        children: /*#__PURE__*/ (0,react_jsx_runtime__rspack_import_0.jsx)(_agent_bundle_runtime__rspack_import_3/* .Agent.Text */.g6.Text, {
+            children: (0,_core_codex_routes_js__rspack_import_1/* .resultText */.D6)(out)
+        })
+    });
+}
+
+__webpack_require__.d(__webpack_exports__, {
+  "default": () => (route),
+  inputSchema: () => (/* reexport safe */ _core_codex_routes_js__rspack_import_1.jS),
+  resultSchema: () => (/* reexport safe */ _core_codex_routes_js__rspack_import_1.FD)
+}, {
+  config: config
+});
+
+
+},
+"./src/cli/codex/watch.tsx"(__unused_rspack_module, __webpack_exports__, __webpack_require__) {
+__webpack_require__.r(__webpack_exports__);
+/* import */ var react_jsx_runtime__rspack_import_0 = __webpack_require__("./node_modules/react/jsx-runtime.js");
+/* import */ var _agent_bundle_runtime__rspack_import_2 = __webpack_require__("./node_modules/@agent-bundle/runtime/dist/736.js");
+/* import */ var _agent_bundle_runtime__rspack_import_3 = __webpack_require__("./node_modules/@agent-bundle/runtime/dist/506.js");
+/* import */ var _core_codex_routes_js__rspack_import_1 = __webpack_require__("./src/core/codex/routes.ts");
+
+
+
+
+const config = {
+    description: 'Bounded Codex watch observation; never interrupts execution.',
+    exitCode: 'result',
+    render: {
+        maxElapsedMs: 660000
+    },
+    positionals: [
+        'threadId'
+    ],
+    inputJsonSchema: {
+        type: 'object',
+        additionalProperties: false,
+        properties: {
+            "threadId": {
+                "type": "string"
+            },
+            "expectedCwd": {
+                "type": "string"
+            },
+            "timeoutMs": {
+                "type": "number",
+                "description": "Observation timeout: 1-600000 milliseconds."
+            },
+            "maxEvents": {
+                "type": "number",
+                "description": "Maximum observed events: 1-500."
+            }
+        },
+        required: [
+            'threadId'
+        ]
+    }
+};
+async function route({ input, signal }) {
+    const context = await (0,_agent_bundle_runtime__rspack_import_2/* .agent */.MA)();
+    const out = await (0,_core_codex_routes_js__rspack_import_1/* .observeOperation */.gT)('watch', input, signal, (message)=>context.progress.report({
+            message
+        }));
+    return /*#__PURE__*/ (0,react_jsx_runtime__rspack_import_0.jsx)(_agent_bundle_runtime__rspack_import_3/* .Agent.Result */.g6.Result, {
+        value: out,
+        children: /*#__PURE__*/ (0,react_jsx_runtime__rspack_import_0.jsx)(_agent_bundle_runtime__rspack_import_3/* .Agent.Text */.g6.Text, {
+            children: (0,_core_codex_routes_js__rspack_import_1/* .resultText */.D6)(out)
+        })
+    });
+}
+
+__webpack_require__.d(__webpack_exports__, {
+  "default": () => (route),
+  inputSchema: () => (/* reexport safe */ _core_codex_routes_js__rspack_import_1.R9),
+  resultSchema: () => (/* reexport safe */ _core_codex_routes_js__rspack_import_1.FD)
+}, {
+  config: config
+});
+
+
 },
 "./src/cli/doctor.tsx"(__unused_rspack_module, __webpack_exports__, __webpack_require__) {
 __webpack_require__.r(__webpack_exports__);
@@ -12805,12 +13343,15 @@ __webpack_require__.d(__webpack_exports__, {
 "./src/cli/send.tsx"(__unused_rspack_module, __webpack_exports__, __webpack_require__) {
 __webpack_require__.r(__webpack_exports__);
 /* import */ var react_jsx_runtime__rspack_import_0 = __webpack_require__("./node_modules/react/jsx-runtime.js");
-/* import */ var _agent_bundle_runtime__rspack_import_6 = __webpack_require__("./node_modules/@agent-bundle/runtime/dist/506.js");
-/* import */ var zod__rspack_import_5 = __webpack_require__("./node_modules/zod/v4/classic/schemas.js");
-/* import */ var _core_codex_bridge_js__rspack_import_1 = __webpack_require__("./src/core/codex-bridge.js");
-/* import */ var _core_codex_contract_js__rspack_import_2 = __webpack_require__("./src/core/codex/contract.js");
-/* import */ var _core_history_js__rspack_import_3 = __webpack_require__("./src/core/history.js");
-/* import */ var _shared_js__rspack_import_4 = __webpack_require__("./src/cli/_shared.ts");
+/* import */ var _agent_bundle_runtime__rspack_import_7 = __webpack_require__("./node_modules/@agent-bundle/runtime/dist/736.js");
+/* import */ var _agent_bundle_runtime__rspack_import_8 = __webpack_require__("./node_modules/@agent-bundle/runtime/dist/506.js");
+/* import */ var zod__rspack_import_6 = __webpack_require__("./node_modules/zod/v4/classic/schemas.js");
+/* import */ var _core_relay_routes_js__rspack_import_1 = __webpack_require__("./src/core/relay/routes.ts");
+/* import */ var _core_codex_bridge_js__rspack_import_2 = __webpack_require__("./src/core/codex-bridge.js");
+/* import */ var _core_codex_contract_js__rspack_import_3 = __webpack_require__("./src/core/codex/contract.js");
+/* import */ var _core_history_js__rspack_import_4 = __webpack_require__("./src/core/history.js");
+/* import */ var _shared_js__rspack_import_5 = __webpack_require__("./src/cli/_shared.ts");
+
 
 
 
@@ -12824,6 +13365,25 @@ const config = {
     inputJsonSchema: {
         additionalProperties: false,
         properties: {
+            replyMode: {
+                type: 'string',
+                enum: [
+                    'auto',
+                    'manual'
+                ]
+            },
+            codexThreadId: {
+                type: 'string'
+            },
+            bindingId: {
+                type: 'string'
+            },
+            expectedCwd: {
+                type: 'string'
+            },
+            requestId: {
+                type: 'string'
+            },
             correlationId: {
                 description: 'Stable correlation id for multi-hop replies',
                 type: 'string'
@@ -12881,52 +13441,58 @@ const config = {
         'message'
     ]
 };
-const inputSchema = _shared_js__rspack_import_4/* .backendFlagsSchema.extend */.lK.extend({
-    correlationId: zod__rspack_import_5/* .string */.YjP().min(1).optional(),
-    envelope: zod__rspack_import_5/* .boolean */.zMY().default(false),
-    historyDir: zod__rspack_import_5/* .string */.YjP().min(1).optional(),
-    hop: zod__rspack_import_5/* .number */.aig().int().min(0).optional(),
-    message: zod__rspack_import_5/* .array */.YOg(zod__rspack_import_5/* .string */.YjP()).min(1),
-    noHistory: zod__rspack_import_5/* .boolean */.zMY().default(false),
-    replyTo: zod__rspack_import_5/* .string */.YjP().min(1).optional(),
-    target: zod__rspack_import_5/* .string */.YjP().min(1)
+const inputSchema = _shared_js__rspack_import_5/* .backendFlagsSchema.extend */.lK.extend({
+    ..._core_relay_routes_js__rspack_import_1/* .routeFields */.zK,
+    replyMode: zod__rspack_import_6/* ["enum"] */.k5n([
+        'auto',
+        'manual'
+    ]).optional(),
+    correlationId: zod__rspack_import_6/* .string */.YjP().min(1).optional(),
+    envelope: zod__rspack_import_6/* .boolean */.zMY().default(false),
+    historyDir: zod__rspack_import_6/* .string */.YjP().min(1).optional(),
+    hop: zod__rspack_import_6/* .number */.aig().int().min(0).optional(),
+    message: zod__rspack_import_6/* .array */.YOg(zod__rspack_import_6/* .string */.YjP()).min(1),
+    noHistory: zod__rspack_import_6/* .boolean */.zMY().default(false),
+    replyTo: zod__rspack_import_6/* .string */.YjP().min(1).optional(),
+    target: zod__rspack_import_6/* .string */.YjP().min(1)
 }).strict();
-const receiptSchema = zod__rspack_import_5/* .object */.Ikc({
-    correlationId: zod__rspack_import_5/* .string */.YjP(),
-    delivery: zod__rspack_import_5/* ["enum"] */.k5n([
+const receiptSchema = zod__rspack_import_6/* .object */.Ikc({
+    correlationId: zod__rspack_import_6/* .string */.YjP(),
+    delivery: zod__rspack_import_6/* ["enum"] */.k5n([
         'accepted',
         'unknown'
     ]),
-    envelopeId: zod__rspack_import_5/* .string */.YjP(),
-    exitCode: zod__rspack_import_5/* .literal */.euz(0),
-    hop: zod__rspack_import_5/* .number */.aig().int().min(0),
-    id: zod__rspack_import_5/* .string */.YjP(),
-    kind: zod__rspack_import_5/* ["enum"] */.k5n([
+    envelopeId: zod__rspack_import_6/* .string */.YjP(),
+    exitCode: zod__rspack_import_6/* .literal */.euz(0),
+    hop: zod__rspack_import_6/* .number */.aig().int().min(0),
+    id: zod__rspack_import_6/* .string */.YjP(),
+    kind: zod__rspack_import_6/* ["enum"] */.k5n([
         'bot',
         'group'
     ]),
-    maxHops: zod__rspack_import_5/* .number */.aig().int().min(0),
-    messageId: zod__rspack_import_5/* .string */.YjP().optional(),
-    name: zod__rspack_import_5/* .string */.YjP(),
-    replyTo: zod__rspack_import_5/* .string */.YjP().optional(),
-    result: zod__rspack_import_5/* .record */.g1P(zod__rspack_import_5/* .string */.YjP(), zod__rspack_import_5/* .json */.Pq9())
+    maxHops: zod__rspack_import_6/* .number */.aig().int().min(0),
+    messageId: zod__rspack_import_6/* .string */.YjP().optional(),
+    name: zod__rspack_import_6/* .string */.YjP(),
+    replyTo: zod__rspack_import_6/* .string */.YjP().optional(),
+    result: zod__rspack_import_6/* .record */.g1P(zod__rspack_import_6/* .string */.YjP(), zod__rspack_import_6/* .json */.Pq9())
 }).strict();
 // Refusals and gateway failures are the same flat document `codex send` emits.
-const resultSchema = zod__rspack_import_5/* .union */.KCZ([
+const resultSchema = zod__rspack_import_6/* .union */.KCZ([
     receiptSchema,
-    _shared_js__rspack_import_4/* .failureDocumentSchema */.R9
+    _shared_js__rspack_import_5/* .failureDocumentSchema */.R9,
+    _core_relay_routes_js__rspack_import_1/* .relayResultSchema */.Ax
 ]);
 const deliver = async (input)=>{
-    const envelope = (0,_core_codex_bridge_js__rspack_import_1/* .buildEnvelope */.nq)({
+    const envelope = (0,_core_codex_bridge_js__rspack_import_2/* .buildEnvelope */.nq)({
         correlationId: input.correlationId,
         envelope: input.envelope,
         hop: input.hop,
         replyTo: input.replyTo
     });
     const message = input.message.join(' ').trim();
-    const backend = await (0,_shared_js__rspack_import_4/* .openBackendFromInput */.FS)(input);
-    const out = await backend.send(input.target, (0,_core_codex_bridge_js__rspack_import_1/* .withEnvelopeHeader */.Mr)(message, envelope));
-    (0,_core_history_js__rspack_import_3/* .saveHistory */.QX)(out, {
+    const backend = await (0,_shared_js__rspack_import_5/* .openBackendFromInput */.FS)(input);
+    const out = await backend.send(input.target, (0,_core_codex_bridge_js__rspack_import_2/* .withEnvelopeHeader */.Mr)(message, envelope));
+    (0,_core_history_js__rspack_import_4/* .saveHistory */.QX)(out, {
         dir: input.historyDir,
         disabled: input.noHistory,
         event: 'send',
@@ -12954,14 +13520,38 @@ const deliver = async (input)=>{
 async function send({ input }) {
     let value;
     try {
+        if (input.replyMode === 'auto' || input.codexThreadId || input.bindingId) {
+            (0,_core_relay_routes_js__rspack_import_1/* .assertManagedSendOptions */.MB)(input);
+            if (input.files) throw Error('Automatic routes require the gateway backend');
+            const out = await (0,_core_relay_routes_js__rspack_import_1/* .grokSendOperation */.bv)({
+                target: input.target,
+                message: input.message.join(' ').trim(),
+                replyMode: input.replyMode ?? 'auto',
+                codexThreadId: input.codexThreadId,
+                bindingId: input.bindingId,
+                expectedCwd: input.expectedCwd,
+                requestId: input.requestId,
+                hop: input.hop,
+                correlationId: input.correlationId
+            }, await (0,_agent_bundle_runtime__rspack_import_7/* .agent */.MA)());
+            return /*#__PURE__*/ (0,react_jsx_runtime__rspack_import_0.jsx)(_agent_bundle_runtime__rspack_import_8/* .Agent.Result */.g6.Result, {
+                value: {
+                    ...out,
+                    exitCode: out.delivery === 'rejected' ? 1 : 0
+                },
+                children: /*#__PURE__*/ (0,react_jsx_runtime__rspack_import_0.jsx)(_agent_bundle_runtime__rspack_import_8/* .Agent.Text */.g6.Text, {
+                    children: `Delivery ${out.delivery}; inspect codex bridge status for automatic reply delivery.`
+                })
+            });
+        }
         value = await deliver(input);
     } catch (error) {
-        value = (0,_core_codex_contract_js__rspack_import_2/* .outcomeFromError */.DG)(error);
+        value = (0,_core_codex_contract_js__rspack_import_3/* .outcomeFromError */.DG)(error);
     }
     const text = value.exitCode === 0 ? `Sent to ${value.kind} ${value.name} (${value.id})${value.messageId ? ` message ${value.messageId}` : ''}; envelope ${value.envelopeId}` : value.error;
-    return /*#__PURE__*/ (0,react_jsx_runtime__rspack_import_0.jsx)(_agent_bundle_runtime__rspack_import_6/* .Agent.Result */.g6.Result, {
+    return /*#__PURE__*/ (0,react_jsx_runtime__rspack_import_0.jsx)(_agent_bundle_runtime__rspack_import_8/* .Agent.Result */.g6.Result, {
         value: value,
-        children: /*#__PURE__*/ (0,react_jsx_runtime__rspack_import_0.jsx)(_agent_bundle_runtime__rspack_import_6/* .Agent.Text */.g6.Text, {
+        children: /*#__PURE__*/ (0,react_jsx_runtime__rspack_import_0.jsx)(_agent_bundle_runtime__rspack_import_8/* .Agent.Text */.g6.Text, {
             children: text
         })
     });
@@ -13131,6 +13721,411 @@ __webpack_require__.d(__webpack_exports__, {
 });
 
 
+},
+"./src/core/codex/routes.ts"(__unused_rspack_module, __webpack_exports__, __webpack_require__) {
+/* import */ var zod__rspack_import_3 = __webpack_require__("./node_modules/zod/v4/classic/schemas.js");
+/* import */ var _codex_bridge_js__rspack_import_0 = __webpack_require__("./src/core/codex-bridge.js");
+/* import */ var _contract_js__rspack_import_1 = __webpack_require__("./src/core/codex/contract.js");
+/* import */ var _conversation_js__rspack_import_2 = __webpack_require__("./src/core/codex/conversation.js");
+
+
+
+
+const id = zod__rspack_import_3/* .string */.YjP().regex(/^[A-Za-z0-9_.:-]{1,128}$/);
+const observationFields = {
+    expectedCwd: zod__rspack_import_3/* .string */.YjP().min(1).optional(),
+    threadId: id,
+    timeoutMs: zod__rspack_import_3/* .number */.aig().int().min(1).max(600000).optional()
+};
+const sendFields = {
+    ...observationFields,
+    correlationId: id.optional(),
+    envelope: zod__rspack_import_3/* .boolean */.zMY().optional(),
+    hop: zod__rspack_import_3/* .number */.aig().int().min(0).optional(),
+    replyTo: id.optional(),
+    expectedTurnId: id.optional(),
+    whenBusy: zod__rspack_import_3/* ["enum"] */.k5n([
+        'reject',
+        'queue',
+        'steer'
+    ]).default('reject'),
+    wait: zod__rspack_import_3/* .boolean */.zMY().default(false),
+    maxOutputBytes: zod__rspack_import_3/* .number */.aig().int().min(1).max(4194304).optional()
+};
+const sendSchema = zod__rspack_import_3/* .object */.Ikc({
+    ...sendFields,
+    message: zod__rspack_import_3/* .string */.YjP().min(1).max(4194304)
+}).strict();
+const waitSchema = zod__rspack_import_3/* .object */.Ikc({
+    ...observationFields,
+    turnId: id,
+    messageId: id.optional(),
+    maxOutputBytes: zod__rspack_import_3/* .number */.aig().int().min(1).max(4194304).optional()
+}).strict();
+const watchSchema = zod__rspack_import_3/* .object */.Ikc({
+    ...observationFields,
+    maxEvents: zod__rspack_import_3/* .number */.aig().int().min(1).max(500).default(100)
+}).strict();
+const threadsSchema = zod__rspack_import_3/* .object */.Ikc({
+    limit: zod__rspack_import_3/* .number */.aig().int().min(1).max(200).default(20),
+    cursor: zod__rspack_import_3/* .string */.YjP().min(1).max(4096).optional()
+}).strict();
+const resultSchema = zod__rspack_import_3/* .object */.Ikc({
+    exitCode: zod__rspack_import_3/* .number */.aig().int().min(0).max(1),
+    threadId: zod__rspack_import_3/* .string */.YjP().optional(),
+    turnId: zod__rspack_import_3/* .string */.YjP().optional(),
+    messageId: zod__rspack_import_3/* .string */.YjP().optional(),
+    delivery: zod__rspack_import_3/* ["enum"] */.k5n([
+        'accepted',
+        'queued',
+        'rejected',
+        'unknown'
+    ]).optional(),
+    execution: zod__rspack_import_3/* .object */.Ikc({
+        state: zod__rspack_import_3/* ["enum"] */.k5n([
+            'completed',
+            'failed',
+            'interrupted',
+            'waiting-for-input',
+            'timeout',
+            'disconnected',
+            'unknown'
+        ]),
+        error: zod__rspack_import_3/* .unknown */.L5J().optional()
+    }).optional(),
+    reply: zod__rspack_import_3/* .object */.Ikc({
+        text: zod__rspack_import_3/* .string */.YjP().max(4194304),
+        items: zod__rspack_import_3/* .array */.YOg(zod__rspack_import_3/* .object */.Ikc({
+            id: zod__rspack_import_3/* .string */.YjP(),
+            type: zod__rspack_import_3/* .literal */.euz('agentMessage'),
+            phase: zod__rspack_import_3/* ["enum"] */.k5n([
+                'final_answer'
+            ]).nullable(),
+            text: zod__rspack_import_3/* .string */.YjP().max(4194304)
+        })).max(2000),
+        truncated: zod__rspack_import_3/* .boolean */.zMY()
+    }).optional(),
+    interactions: zod__rspack_import_3/* .array */.YOg(zod__rspack_import_3/* .record */.g1P(zod__rspack_import_3/* .string */.YjP(), zod__rspack_import_3/* .unknown */.L5J())).max(500).optional(),
+    events: zod__rspack_import_3/* .array */.YOg(zod__rspack_import_3/* .record */.g1P(zod__rspack_import_3/* .string */.YjP(), zod__rspack_import_3/* .unknown */.L5J())).max(500).optional(),
+    reason: zod__rspack_import_3/* .string */.YjP().optional(),
+    truncated: zod__rspack_import_3/* .boolean */.zMY().optional()
+}).passthrough();
+async function sendOperation(input, signal, progress, oneShot = false) {
+    let envelope;
+    let receipt;
+    try {
+        envelope = (0,_codex_bridge_js__rspack_import_0/* .buildEnvelope */.nq)(input);
+        if (oneShot && !input.wait && input.whenBusy !== 'steer') {
+            return await (0,_codex_bridge_js__rspack_import_0/* .sendToCodexThread */.ZS)(input.threadId, input.message, {
+                envelope,
+                whenBusy: input.whenBusy,
+                expectedCwd: input.expectedCwd,
+                signal
+            });
+        }
+        await progress?.('Opening Codex conversation');
+        const conversation = await (0,_conversation_js__rspack_import_2/* .openCodexConversation */.j)(input.threadId, {
+            expectedCwd: input.expectedCwd,
+            signal
+        });
+        try {
+            receipt = await conversation.send(input.message, {
+                envelope,
+                whenBusy: input.whenBusy,
+                expectedTurnId: input.expectedTurnId
+            });
+            if (!input.wait || receipt.delivery !== 'accepted' || !receipt.turnId) return receipt;
+            await progress?.(`Accepted message ${receipt.messageId}; observing turn ${receipt.turnId}`);
+            const result = await conversation.wait({
+                turnId: receipt.turnId,
+                messageId: receipt.messageId,
+                timeoutMs: input.timeoutMs,
+                maxOutputBytes: input.maxOutputBytes,
+                signal
+            });
+            return {
+                ...receipt,
+                execution: result.execution,
+                reply: result.reply,
+                interactions: result.interactions,
+                exitCode: result.execution.state === 'completed' ? 0 : 1
+            };
+        } finally{
+            await conversation.close();
+        }
+    } catch (error) {
+        if (receipt?.delivery === 'accepted') return {
+            ...receipt,
+            execution: {
+                state: 'unknown',
+                error: (0,_contract_js__rspack_import_1/* .outcomeFromError */.DG)(error).error
+            },
+            reply: {
+                text: '',
+                items: [],
+                truncated: true
+            },
+            interactions: [],
+            exitCode: 1
+        };
+        return {
+            ...(0,_contract_js__rspack_import_1/* .outcomeFromError */.DG)(error),
+            threadId: input.threadId,
+            ...envelope ? {
+                messageId: envelope.messageId,
+                correlationId: envelope.correlationId,
+                hop: envelope.hop
+            } : {}
+        };
+    }
+}
+async function observeOperation(kind, input, signal, progress) {
+    try {
+        await progress?.(`Observing Codex thread ${input.threadId}`);
+        const conversation = await (0,_conversation_js__rspack_import_2/* .openCodexConversation */.j)(input.threadId, {
+            expectedCwd: input.expectedCwd,
+            signal
+        });
+        try {
+            if (kind === 'wait') {
+                const result = await conversation.wait({
+                    ...input,
+                    signal
+                });
+                return {
+                    ...result,
+                    exitCode: result.execution.state === 'completed' ? 0 : 1
+                };
+            }
+            const result = await conversation.watch({
+                ...input,
+                signal
+            });
+            return {
+                ...result,
+                exitCode: [
+                    'timeout',
+                    'event-limit'
+                ].includes(result.reason) ? 0 : 1
+            };
+        } finally{
+            await conversation.close();
+        }
+    } catch (error) {
+        return {
+            ...(0,_contract_js__rspack_import_1/* .outcomeFromError */.DG)(error),
+            threadId: input.threadId,
+            ...'turnId' in input ? {
+                turnId: input.turnId,
+                messageId: input.messageId
+            } : {}
+        };
+    }
+}
+async function threadsOperation(input) {
+    try {
+        return {
+            ...await listCodexThreads(input),
+            exitCode: 0
+        };
+    } catch (error) {
+        return outcomeFromError(error);
+    }
+}
+function resultText(result) {
+    if (result.execution && typeof result.execution === 'object' && 'state' in result.execution) return `Codex turn ${result.turnId}: ${result.execution.state}`;
+    if (result.delivery === 'queued') return `Queued ${result.queuedSubmissionId} on busy Codex thread ${result.threadId}; message ${result.messageId}`;
+    if (result.error) return String(result.error);
+    if (result.delivery === 'accepted') return `Started turn ${result.turnId} (${result.turnStatus}) on Codex thread ${result.threadId}; message ${result.messageId}`;
+    if (result.delivery) return `Codex delivery ${result.delivery} on thread ${result.threadId}`;
+    if (result.reason) return `Codex observation: ${result.reason}`;
+    if (Array.isArray(result.threads)) return `${result.threads.length} Codex threads`;
+    return String(result.error ?? 'Codex observation complete');
+}
+
+__webpack_require__.d(__webpack_exports__, {
+  D6: () => (resultText),
+  UP: () => (sendOperation),
+  gT: () => (observeOperation)
+}, {
+  FD: resultSchema,
+  R9: watchSchema,
+  at: sendFields,
+  jS: waitSchema
+});
+
+
+},
+"./src/core/relay/routes.ts"(__unused_rspack_module, __webpack_exports__, __webpack_require__) {
+/* import */ var _agent_bundle_runtime__rspack_import_4 = __webpack_require__("./node_modules/@agent-bundle/runtime/dist/40.js");
+/* import */ var zod__rspack_import_3 = __webpack_require__("./node_modules/zod/v4/classic/schemas.js");
+/* import */ var _managed_js__rspack_import_0 = __webpack_require__("./src/core/relay/managed.js");
+/* import */ var _gbot_js__rspack_import_1 = __webpack_require__("./src/gbot.ts");
+/* import */ var _codex_bridge_js__rspack_import_2 = __webpack_require__("./src/core/codex-bridge.js");
+
+
+
+
+
+const id = zod__rspack_import_3/* .string */.YjP().min(1).max(128);
+const routeFields = {
+    codexThreadId: id.optional(),
+    expectedCwd: zod__rspack_import_3/* .string */.YjP().min(1).max(4096).optional(),
+    bindingId: zod__rspack_import_3/* .string */.YjP().min(1).max(512).optional(),
+    requestId: id.optional()
+};
+const grokSendSchema = zod__rspack_import_3/* .object */.Ikc({
+    target: zod__rspack_import_3/* .string */.YjP().min(1),
+    message: zod__rspack_import_3/* .string */.YjP().min(1),
+    replyMode: zod__rspack_import_3/* ["enum"] */.k5n([
+        "auto",
+        "manual"
+    ]).optional(),
+    hop: zod__rspack_import_3/* .number */.aig().int().min(0).optional(),
+    correlationId: id.optional(),
+    ...routeFields
+}).strict();
+const bridgeStartSchema = zod__rspack_import_3/* .object */.Ikc({
+    grokTarget: zod__rspack_import_3/* .string */.YjP().min(1),
+    codexThreadId: id.optional(),
+    expectedCwd: zod__rspack_import_3/* .string */.YjP().min(1).max(4096).optional(),
+    busyPolicy: zod__rspack_import_3/* ["enum"] */.k5n([
+        "steer",
+        "reject"
+    ]).optional(),
+    requestId: id.optional()
+}).strict();
+const bridgeStatusSchema = zod__rspack_import_3/* .object */.Ikc({
+    bindingId: zod__rspack_import_3/* .string */.YjP().min(1).max(512).optional(),
+    limit: zod__rspack_import_3/* .number */.aig().int().min(1).max(100).optional()
+}).strict();
+const bridgeStopSchema = zod__rspack_import_3/* .object */.Ikc({
+    bindingId: zod__rspack_import_3/* .string */.YjP().min(1).max(512).optional(),
+    all: zod__rspack_import_3/* .boolean */.zMY().optional(),
+    worker: zod__rspack_import_3/* .boolean */.zMY().optional()
+}).strict().refine((x)=>!!x.bindingId || x.all === true || x.worker === true, "Specify bindingId, all or worker");
+const respondSchema = zod__rspack_import_3/* .object */.Ikc({
+    interactionId: zod__rspack_import_3/* .string */.YjP().min(1).max(512),
+    generation: id,
+    threadId: id,
+    turnId: id,
+    bindingId: zod__rspack_import_3/* .string */.YjP().min(1).max(512).optional(),
+    exchangeId: zod__rspack_import_3/* .string */.YjP().min(1).max(512).optional(),
+    decision: zod__rspack_import_3/* ["enum"] */.k5n([
+        "accept",
+        "decline",
+        "cancel"
+    ]).optional(),
+    answersJson: zod__rspack_import_3/* .string */.YjP().min(2).max(65536).optional()
+}).strict().refine((x)=>!!x.bindingId || !!x.exchangeId, "Binding or exchange scope required").refine((x)=>!!x.decision !== !!x.answersJson, "Supply decision or answersJson");
+const answersSchema = zod__rspack_import_3/* .record */.g1P(zod__rspack_import_3/* .string */.YjP().min(1).max(128), zod__rspack_import_3/* .object */.Ikc({
+    answers: zod__rspack_import_3/* .array */.YOg(zod__rspack_import_3/* .string */.YjP().max(8192)).max(20)
+}).strict());
+const relayResultSchema = zod__rspack_import_3/* .record */.g1P(zod__rspack_import_3/* .string */.YjP(), zod__rspack_import_3/* .json */.Pq9());
+function nativeCodexThread(context) {
+    return context.host.state === "available" && (0,_agent_bundle_runtime__rspack_import_4/* .lineageHostFromClient */.bg)(context.host.value.name) === "codex" && context.lineage.state === "available" && context.lineage.source === "native" && context.lineage.value.resolution === "native" ? context.lineage.value.conversation : undefined;
+}
+function options(context) {
+    return {
+        pluginRoot: context?.plugin.state === "available" ? context.plugin.value.root : undefined,
+        signal: context?.signal
+    };
+}
+function destination(input, context) {
+    const codexThreadId = input.codexThreadId ?? (context ? nativeCodexThread(context) : undefined);
+    // Native workspace evidence belongs to the invocation, not the plugin installation directory.
+    const workspace = context?.workspace;
+    const expectedCwd = input.expectedCwd ?? (workspace?.state === "available" && workspace.source === "native" ? workspace.value.root : undefined);
+    return {
+        codexThreadId,
+        expectedCwd
+    };
+}
+async function grokSendOperation(input, context) {
+    const route = destination(input, input.bindingId ? undefined : context);
+    if (input.replyMode !== "manual" && (input.bindingId || route.codexThreadId)) return (0,_gbot_js__rspack_import_1/* .withRedactedErrors */.yF)(()=>(0,_managed_js__rspack_import_0/* .managedOperation */.Bb)("sendToGrok", {
+            grokTarget: input.target,
+            message: input.message,
+            hop: input.hop,
+            correlationId: input.correlationId,
+            ...route,
+            ...input.bindingId ? {
+                bindingId: input.bindingId
+            } : {},
+            ...input.requestId ? {
+                requestId: input.requestId
+            } : {}
+        }, options(context)));
+    if (input.replyMode === "auto") throw Error("Automatic reply delivery requires a native Codex source, codexThreadId or bindingId");
+    const message = input.hop !== undefined || input.correlationId !== undefined ? (0,_codex_bridge_js__rspack_import_2/* .withEnvelopeHeader */.Mr)(input.message, (0,_codex_bridge_js__rspack_import_2/* .buildEnvelope */.nq)(input)) : input.message;
+    const sent = await (0,_gbot_js__rspack_import_1/* .withRedactedErrors */.yF)(async ()=>(0,_gbot_js__rspack_import_1/* .sendPrompt */.LV)(await (0,_gbot_js__rspack_import_1/* .connectGateway */.Vq)(), input.target, message));
+    return {
+        result: sent.result,
+        target: (0,_gbot_js__rspack_import_1/* .summarizeTarget */.rW)(sent.target),
+        delivery: sent.delivery === "accepted" ? "accepted" : "unknown",
+        ...sent.delivery === "accepted" && typeof sent.messageId === "string" ? {
+            messageId: sent.messageId
+        } : {},
+        replyRoute: {
+            mode: "manual",
+            reason: input.replyMode === "manual" ? "requested" : "source-unavailable"
+        }
+    };
+}
+async function bridgeOperation(method, input, context) {
+    let routed = method === "startBinding" ? {
+        ...input,
+        ...destination(input, context)
+    } : input;
+    if (method === "respond") {
+        const { decision, answersJson, ...scope } = respondSchema.parse(input);
+        routed = {
+            ...scope,
+            result: decision ? {
+                decision
+            } : {
+                answers: answersSchema.parse(JSON.parse(answersJson))
+            }
+        };
+    }
+    if (method === "startBinding" && !routed.codexThreadId) throw Error("Specify codexThreadId when native Codex source identity is unavailable");
+    return (0,_gbot_js__rspack_import_1/* .withRedactedErrors */.yF)(()=>(0,_managed_js__rspack_import_0/* .managedOperation */.Bb)(method, routed, options(context)));
+}
+function assertManagedSendOptions(input) {
+    if (input.expectedTurnId !== undefined) throw Error("Managed relay does not support expectedTurnId; omit it to use managed guarded steering, or use a plain Codex send for an explicit turn guard");
+    if (input.replyTo !== undefined || input.envelope === true) throw Error("Managed relay does not support legacy replyTo/envelope options; omit them or use a plain send. Use hop/correlationId for explicit managed chains");
+}
+async function codexReturnOperation(input, context) {
+    assertManagedSendOptions(input);
+    if (input.whenBusy === "queue") throw Error("Managed relay supports steer or reject, not experimental queue");
+    return (0,_gbot_js__rspack_import_1/* .withRedactedErrors */.yF)(()=>(0,_managed_js__rspack_import_0/* .managedOperation */.Bb)("sendToCodex", {
+            grokTarget: input.replyToGrok,
+            codexThreadId: input.threadId,
+            expectedCwd: input.expectedCwd,
+            bindingId: input.bindingId,
+            message: input.message,
+            requestId: input.requestId,
+            busyPolicy: input.whenBusy,
+            hop: input.hop,
+            correlationId: input.correlationId
+        }, options(context)));
+}
+
+__webpack_require__.d(__webpack_exports__, {
+  MB: () => (assertManagedSendOptions),
+  bv: () => (grokSendOperation),
+  lt: () => (codexReturnOperation),
+  n1: () => (bridgeOperation)
+}, {
+  Ax: relayResultSchema,
+  d5: bridgeStopSchema,
+  np: bridgeStatusSchema,
+  v1: respondSchema,
+  xD: bridgeStartSchema,
+  zK: routeFields
+});
+
+
 },
 "./src/gbot.ts"(__unused_rspack_module, __webpack_exports__, __webpack_require__) {
 /* import */ var zod__rspack_import_2 = __webpack_require__("./node_modules/zod/v4/classic/schemas.js");
@@ -13235,7 +14230,10 @@ const transcriptEntries = (transcript)=>{
 };
 
 __webpack_require__.d(__webpack_exports__, {
+  LV: () => (/* reexport safe */ _core_gateway_js__rspack_import_0.LV),
+  Vq: () => (/* reexport safe */ _core_gateway_js__rspack_import_0.Vq)
 }, {
+  rW: summarizeTarget,
   yF: withRedactedErrors
 });
 
@@ -13276,12 +14274,6 @@ module.exports = __rspack_external_node_fs_1b05aee1;
 module.exports = __rspack_external_node_fs_promises_3b710708;
 
 
-},
-"node:module"(module) {
-
-module.exports = __rspack_external_node_module_9de3fa2f;
-
-
 },
 "node:net"(module) {
 
@@ -13306,6 +14298,12 @@ module.exports = __rspack_external_node_path_806ed179;
 module.exports = __rspack_external_node_readline_d8f53bef;
 
 
+},
+"node:string_decoder"(module) {
+
+module.exports = __rspack_external_node_string_decoder_69b9bd04;
+
+
 },
 "node:url"(module) {
 
@@ -14019,6 +15017,195 @@ __webpack_require__.d(__webpack_exports__, {
 });
 
 
+},
+"./node_modules/@agent-bundle/runtime/dist/40.js"(__unused_rspack___webpack_module__, __webpack_exports__, __webpack_require__) {
+/* import */ var node_fs_promises__rspack_import_0 = __webpack_require__("node:fs/promises");
+
+
+const CODEX_ROLLOUT_HEAD_BYTES = 1048576;
+const ROLLOUT_BASENAME = /rollout-\d{4}-\d{2}-\d{2}T\d{2}-\d{2}-\d{2}-([0-9a-f]{8}(?:-[0-9a-f]{4}){3}-[0-9a-f]{12})\.jsonl$/iu;
+const codexThreadFromRolloutPath = (path)=>{
+    if (void 0 === path) return;
+    const match = ROLLOUT_BASENAME.exec(path);
+    return match?.[1]?.toLowerCase();
+};
+const record = (value)=>null === value || 'object' != typeof value || Array.isArray(value) ? void 0 : value;
+const codex_rollout_text = (value)=>'string' == typeof value && '' !== value.trim() ? value : void 0;
+const parseCodexRolloutMeta = (head)=>{
+    const newline = head.indexOf('\n');
+    const line = (-1 === newline ? head : head.slice(0, newline)).trim();
+    if ('' === line) return;
+    let parsed;
+    try {
+        parsed = JSON.parse(line);
+    } catch  {
+        return;
+    }
+    const item = record(parsed);
+    if (item?.['type'] !== 'session_meta') return;
+    const payload = record(item['payload']);
+    const thread = codex_rollout_text(payload?.['id']);
+    if (void 0 === payload || void 0 === thread) return;
+    const root = codex_rollout_text(payload['session_id']);
+    const source = record(payload['source']);
+    const subagent = record(source?.['subagent']);
+    if (void 0 === subagent) {
+        const kind = codex_rollout_text(source?.['subagent']);
+        return {
+            ...void 0 === kind ? {} : {
+                subagentKind: kind
+            },
+            ...void 0 === root ? {} : {
+                root
+            },
+            thread
+        };
+    }
+    const [subagentKind] = Object.keys(subagent);
+    const spawn = record(subagent['thread_spawn']);
+    const parent = codex_rollout_text(spawn?.['parent_thread_id']) ?? codex_rollout_text(payload['parent_thread_id']);
+    const rawDepth = spawn?.['depth'];
+    const depth = 'number' == typeof rawDepth && Number.isInteger(rawDepth) && rawDepth > 0 ? rawDepth : void 0;
+    const agentPath = codex_rollout_text(spawn?.['agent_path']) ?? codex_rollout_text(payload['agent_path']);
+    return {
+        ...void 0 === agentPath ? {} : {
+            agentPath
+        },
+        ...void 0 === depth ? {} : {
+            depth
+        },
+        ...void 0 === parent ? {} : {
+            parent
+        },
+        ...void 0 === root ? {} : {
+            root
+        },
+        ...void 0 === subagentKind ? {} : {
+            subagentKind
+        },
+        thread
+    };
+};
+const readCodexRolloutHead = async (path)=>{
+    let handle;
+    try {
+        handle = await promises_open(path, 'r');
+        const buffer = Buffer.allocUnsafe(CODEX_ROLLOUT_HEAD_BYTES);
+        let filled = 0;
+        while(filled < buffer.length){
+            const { bytesRead } = await handle.read(buffer, filled, buffer.length - filled, filled);
+            if (0 === bytesRead) break;
+            const newline = buffer.subarray(filled, filled + bytesRead).indexOf(0x0a);
+            if (-1 !== newline) {
+                filled += newline;
+                break;
+            }
+            filled += bytesRead;
+        }
+        return buffer.subarray(0, filled).toString('utf8');
+    } catch  {
+        return;
+    } finally{
+        await handle?.close().catch(()=>void 0);
+    }
+};
+const readCodexSpawnLineage = async (path, thread, read = readCodexRolloutHead)=>{
+    if (void 0 === path) return;
+    const head = await read(path);
+    if (void 0 === head) return;
+    const meta = parseCodexRolloutMeta(head);
+    if (void 0 === meta || meta.thread !== thread || void 0 === meta.parent || void 0 === meta.depth) return;
+    return {
+        ...meta,
+        depth: meta.depth,
+        parent: meta.parent
+    };
+};
+const nativeString = (native, key)=>{
+    const value = native[key];
+    return 'string' == typeof value && '' !== value.trim() ? value : void 0;
+};
+const lineageHostFromClient = (clientName)=>{
+    if (void 0 === clientName) return;
+    if (clientName.startsWith('claude')) return 'claude';
+    if (clientName.startsWith('codex')) return 'codex';
+    if (clientName.startsWith('cursor')) return 'cursor';
+};
+const lineageCarrier = (host, native)=>{
+    switch(host){
+        case 'claude':
+            return {
+                conversation: nativeString(native, 'agent_id') ?? nativeString(native, 'session_id'),
+                generation: nativeString(native, 'prompt_id'),
+                root: nativeString(native, 'session_id')
+            };
+        case 'codex':
+            return {
+                conversation: nativeString(native, 'agent_id') ?? nativeString(native, 'session_id'),
+                generation: nativeString(native, 'turn_id'),
+                root: nativeString(native, 'session_id')
+            };
+        case 'cursor':
+            return {
+                conversation: nativeString(native, 'conversation_id') ?? nativeString(native, 'session_id'),
+                generation: nativeString(native, 'generation_id'),
+                root: void 0
+            };
+        default:
+            {
+                const unreachable = host;
+                throw new Error(`Unhandled lineage host ${String(unreachable)}`);
+            }
+    }
+};
+const resolveNativeLineage = (host, native)=>{
+    const carrier = lineageCarrier(host, native);
+    if ('cursor' === host || void 0 === carrier.conversation || void 0 === carrier.root) return unavailable('no-shared-runtime');
+    if (carrier.conversation !== carrier.root) return unavailable('no-shared-runtime');
+    return available({
+        conversation: carrier.root,
+        depth: 0,
+        ...void 0 === carrier.generation ? {} : {
+            generation: carrier.generation
+        },
+        resolution: 'native',
+        root: carrier.root
+    }, 'native');
+};
+const resolveStandaloneLineage = async (host, native, read)=>{
+    const fromPayload = resolveNativeLineage(host, native);
+    if ('codex' !== host || 'available' === fromPayload.state) return fromPayload;
+    const carrier = lineageCarrier(host, native);
+    if (void 0 === carrier.conversation || void 0 === carrier.root) return fromPayload;
+    const ownRollout = 'SubagentStop' === nativeString(native, 'hook_event_name') ? nativeString(native, "agent_transcript_path") : nativeString(native, "transcript_path");
+    const spawn = await readCodexSpawnLineage(ownRollout, carrier.conversation, read);
+    if (void 0 === spawn) return fromPayload;
+    const type = nativeString(native, 'agent_type');
+    return available({
+        conversation: carrier.conversation,
+        depth: spawn.depth,
+        ...void 0 === carrier.generation ? {} : {
+            generation: carrier.generation
+        },
+        parent: spawn.parent,
+        resolution: "transcript",
+        root: carrier.root,
+        subagent: {
+            id: carrier.conversation,
+            ...void 0 === type ? {} : {
+                type
+            }
+        }
+    }, 'derived');
+};
+
+
+__webpack_require__.d(__webpack_exports__, {
+}, {
+  bg: lineageHostFromClient
+});
+
+
 },
 "./node_modules/@agent-bundle/runtime/dist/49.js"(__unused_rspack___webpack_module__, __webpack_exports__, __webpack_require__) {
 /* import */ var node_crypto__rspack_import_0 = __webpack_require__("node:crypto");
@@ -14499,6 +15686,7 @@ const providerRequest = ({ notices, state, ...axes })=>Object.freeze({
 __webpack_require__.d(__webpack_exports__, {
   r8: () => (AgentRequestError)
 }, {
+  MA: agent,
   hU: unavailable,
   iC: runAgentRequest,
   qC: available
@@ -74600,6 +75788,7 @@ function preprocess(fn, schema) {
 __webpack_require__.d(__webpack_exports__, {
   Ikc: () => (object),
   KCZ: () => (union),
+  L5J: () => (unknown),
   Pq9: () => (json),
   YOg: () => (array),
   YjP: () => (string),
@@ -82877,9 +84066,9 @@ __webpack_require__.d(__webpack_exports__, {
 __webpack_require__.a(__webpack_module__, async function (__rspack_load_async_deps, __rspack_async_done) { try {
 /* import */ var agent_bundle_launch_env_layer__rspack_import_0 = __webpack_require__("./.agent-bundle-virtual/bin-gbot-0.mjs");
 /* import */ var agent_bundle_cli_entry__rspack_import_1 = __webpack_require__("./node_modules/agent-bundle/dist/cli-entry.js");
-/* import */ var _agent_bundle_runtime__rspack_import_27 = __webpack_require__("./node_modules/@agent-bundle/runtime/dist/49.js");
-/* import */ var _agent_bundle_runtime__rspack_import_28 = __webpack_require__("./node_modules/@agent-bundle/runtime/dist/736.js");
-/* import */ var _agent_bundle_runtime__rspack_import_29 = __webpack_require__("./node_modules/@agent-bundle/runtime/dist/index.js");
+/* import */ var _agent_bundle_runtime__rspack_import_34 = __webpack_require__("./node_modules/@agent-bundle/runtime/dist/49.js");
+/* import */ var _agent_bundle_runtime__rspack_import_35 = __webpack_require__("./node_modules/@agent-bundle/runtime/dist/736.js");
+/* import */ var _agent_bundle_runtime__rspack_import_36 = __webpack_require__("./node_modules/@agent-bundle/runtime/dist/index.js");
 /* import */ var node_url__rspack_import_2 = __webpack_require__("node:url");
 /* import */ var node_worker_threads__rspack_import_3 = __webpack_require__("node:worker_threads");
 /* import */ var _home_runner_work_grok_bot_cli_grok_bot_cli_src_cli_bots_create_tsx__rspack_import_4 = __webpack_require__("./src/cli/bots/create.tsx");
@@ -82887,24 +84076,31 @@ __webpack_require__.a(__webpack_module__, async function (__rspack_load_async_de
 /* import */ var _home_runner_work_grok_bot_cli_grok_bot_cli_src_cli_bots_get_tsx__rspack_import_6 = __webpack_require__("./src/cli/bots/get.tsx");
 /* import */ var _home_runner_work_grok_bot_cli_grok_bot_cli_src_cli_bots_list_tsx__rspack_import_7 = __webpack_require__("./src/cli/bots/list.tsx");
 /* import */ var _home_runner_work_grok_bot_cli_grok_bot_cli_src_cli_bots_update_tsx__rspack_import_8 = __webpack_require__("./src/cli/bots/update.tsx");
-/* import */ var _home_runner_work_grok_bot_cli_grok_bot_cli_src_cli_codex_desktop_shim_tsx__rspack_import_9 = __webpack_require__("./src/cli/codex/desktop-shim.tsx");
-/* import */ var _home_runner_work_grok_bot_cli_grok_bot_cli_src_cli_codex_list_threads_tsx__rspack_import_10 = __webpack_require__("./src/cli/codex/list-threads.tsx");
-/* import */ var _home_runner_work_grok_bot_cli_grok_bot_cli_src_cli_codex_queue_tsx__rspack_import_11 = __webpack_require__("./src/cli/codex/queue.tsx");
-/* import */ var _home_runner_work_grok_bot_cli_grok_bot_cli_src_cli_codex_send_tsx__rspack_import_12 = __webpack_require__("./src/cli/codex/send.tsx");
-/* import */ var _home_runner_work_grok_bot_cli_grok_bot_cli_src_cli_codex_status_tsx__rspack_import_13 = __webpack_require__("./src/cli/codex/status.tsx");
-/* import */ var _home_runner_work_grok_bot_cli_grok_bot_cli_src_cli_doctor_tsx__rspack_import_14 = __webpack_require__("./src/cli/doctor.tsx");
-/* import */ var _home_runner_work_grok_bot_cli_grok_bot_cli_src_cli_groups_add_tsx__rspack_import_15 = __webpack_require__("./src/cli/groups/add.tsx");
-/* import */ var _home_runner_work_grok_bot_cli_grok_bot_cli_src_cli_groups_create_tsx__rspack_import_16 = __webpack_require__("./src/cli/groups/create.tsx");
-/* import */ var _home_runner_work_grok_bot_cli_grok_bot_cli_src_cli_groups_delete_tsx__rspack_import_17 = __webpack_require__("./src/cli/groups/delete.tsx");
-/* import */ var _home_runner_work_grok_bot_cli_grok_bot_cli_src_cli_groups_get_tsx__rspack_import_18 = __webpack_require__("./src/cli/groups/get.tsx");
-/* import */ var _home_runner_work_grok_bot_cli_grok_bot_cli_src_cli_groups_list_tsx__rspack_import_19 = __webpack_require__("./src/cli/groups/list.tsx");
-/* import */ var _home_runner_work_grok_bot_cli_grok_bot_cli_src_cli_groups_members_tsx__rspack_import_20 = __webpack_require__("./src/cli/groups/members.tsx");
-/* import */ var _home_runner_work_grok_bot_cli_grok_bot_cli_src_cli_groups_remove_tsx__rspack_import_21 = __webpack_require__("./src/cli/groups/remove.tsx");
-/* import */ var _home_runner_work_grok_bot_cli_grok_bot_cli_src_cli_groups_set_tsx__rspack_import_22 = __webpack_require__("./src/cli/groups/set.tsx");
-/* import */ var _home_runner_work_grok_bot_cli_grok_bot_cli_src_cli_groups_update_tsx__rspack_import_23 = __webpack_require__("./src/cli/groups/update.tsx");
-/* import */ var _home_runner_work_grok_bot_cli_grok_bot_cli_src_cli_history_tsx__rspack_import_24 = __webpack_require__("./src/cli/history.tsx");
-/* import */ var _home_runner_work_grok_bot_cli_grok_bot_cli_src_cli_send_tsx__rspack_import_25 = __webpack_require__("./src/cli/send.tsx");
-/* import */ var _home_runner_work_grok_bot_cli_grok_bot_cli_src_cli_thread_tsx__rspack_import_26 = __webpack_require__("./src/cli/thread.tsx");
+/* import */ var _home_runner_work_grok_bot_cli_grok_bot_cli_src_cli_codex_bridge_respond_tsx__rspack_import_9 = __webpack_require__("./src/cli/codex/bridge/respond.tsx");
+/* import */ var _home_runner_work_grok_bot_cli_grok_bot_cli_src_cli_codex_bridge_run_tsx__rspack_import_10 = __webpack_require__("./src/cli/codex/bridge/run.tsx");
+/* import */ var _home_runner_work_grok_bot_cli_grok_bot_cli_src_cli_codex_bridge_start_tsx__rspack_import_11 = __webpack_require__("./src/cli/codex/bridge/start.tsx");
+/* import */ var _home_runner_work_grok_bot_cli_grok_bot_cli_src_cli_codex_bridge_status_tsx__rspack_import_12 = __webpack_require__("./src/cli/codex/bridge/status.tsx");
+/* import */ var _home_runner_work_grok_bot_cli_grok_bot_cli_src_cli_codex_bridge_stop_tsx__rspack_import_13 = __webpack_require__("./src/cli/codex/bridge/stop.tsx");
+/* import */ var _home_runner_work_grok_bot_cli_grok_bot_cli_src_cli_codex_desktop_shim_tsx__rspack_import_14 = __webpack_require__("./src/cli/codex/desktop-shim.tsx");
+/* import */ var _home_runner_work_grok_bot_cli_grok_bot_cli_src_cli_codex_list_threads_tsx__rspack_import_15 = __webpack_require__("./src/cli/codex/list-threads.tsx");
+/* import */ var _home_runner_work_grok_bot_cli_grok_bot_cli_src_cli_codex_queue_tsx__rspack_import_16 = __webpack_require__("./src/cli/codex/queue.tsx");
+/* import */ var _home_runner_work_grok_bot_cli_grok_bot_cli_src_cli_codex_send_tsx__rspack_import_17 = __webpack_require__("./src/cli/codex/send.tsx");
+/* import */ var _home_runner_work_grok_bot_cli_grok_bot_cli_src_cli_codex_status_tsx__rspack_import_18 = __webpack_require__("./src/cli/codex/status.tsx");
+/* import */ var _home_runner_work_grok_bot_cli_grok_bot_cli_src_cli_codex_wait_tsx__rspack_import_19 = __webpack_require__("./src/cli/codex/wait.tsx");
+/* import */ var _home_runner_work_grok_bot_cli_grok_bot_cli_src_cli_codex_watch_tsx__rspack_import_20 = __webpack_require__("./src/cli/codex/watch.tsx");
+/* import */ var _home_runner_work_grok_bot_cli_grok_bot_cli_src_cli_doctor_tsx__rspack_import_21 = __webpack_require__("./src/cli/doctor.tsx");
+/* import */ var _home_runner_work_grok_bot_cli_grok_bot_cli_src_cli_groups_add_tsx__rspack_import_22 = __webpack_require__("./src/cli/groups/add.tsx");
+/* import */ var _home_runner_work_grok_bot_cli_grok_bot_cli_src_cli_groups_create_tsx__rspack_import_23 = __webpack_require__("./src/cli/groups/create.tsx");
+/* import */ var _home_runner_work_grok_bot_cli_grok_bot_cli_src_cli_groups_delete_tsx__rspack_import_24 = __webpack_require__("./src/cli/groups/delete.tsx");
+/* import */ var _home_runner_work_grok_bot_cli_grok_bot_cli_src_cli_groups_get_tsx__rspack_import_25 = __webpack_require__("./src/cli/groups/get.tsx");
+/* import */ var _home_runner_work_grok_bot_cli_grok_bot_cli_src_cli_groups_list_tsx__rspack_import_26 = __webpack_require__("./src/cli/groups/list.tsx");
+/* import */ var _home_runner_work_grok_bot_cli_grok_bot_cli_src_cli_groups_members_tsx__rspack_import_27 = __webpack_require__("./src/cli/groups/members.tsx");
+/* import */ var _home_runner_work_grok_bot_cli_grok_bot_cli_src_cli_groups_remove_tsx__rspack_import_28 = __webpack_require__("./src/cli/groups/remove.tsx");
+/* import */ var _home_runner_work_grok_bot_cli_grok_bot_cli_src_cli_groups_set_tsx__rspack_import_29 = __webpack_require__("./src/cli/groups/set.tsx");
+/* import */ var _home_runner_work_grok_bot_cli_grok_bot_cli_src_cli_groups_update_tsx__rspack_import_30 = __webpack_require__("./src/cli/groups/update.tsx");
+/* import */ var _home_runner_work_grok_bot_cli_grok_bot_cli_src_cli_history_tsx__rspack_import_31 = __webpack_require__("./src/cli/history.tsx");
+/* import */ var _home_runner_work_grok_bot_cli_grok_bot_cli_src_cli_send_tsx__rspack_import_32 = __webpack_require__("./src/cli/send.tsx");
+/* import */ var _home_runner_work_grok_bot_cli_grok_bot_cli_src_cli_thread_tsx__rspack_import_33 = __webpack_require__("./src/cli/thread.tsx");
 
 
 
@@ -82921,42 +84117,56 @@ const route3 = Object.assign({}, Reflect.get(_home_runner_work_grok_bot_cli_grok
 
 const route4 = Object.assign({}, Reflect.get(_home_runner_work_grok_bot_cli_grok_bot_cli_src_cli_bots_update_tsx__rspack_import_8, 'default'), _home_runner_work_grok_bot_cli_grok_bot_cli_src_cli_bots_update_tsx__rspack_import_8);
 
-const route5 = Object.assign({}, Reflect.get(_home_runner_work_grok_bot_cli_grok_bot_cli_src_cli_codex_desktop_shim_tsx__rspack_import_9, 'default'), _home_runner_work_grok_bot_cli_grok_bot_cli_src_cli_codex_desktop_shim_tsx__rspack_import_9);
+const route5 = Object.assign({}, Reflect.get(_home_runner_work_grok_bot_cli_grok_bot_cli_src_cli_codex_bridge_respond_tsx__rspack_import_9, 'default'), _home_runner_work_grok_bot_cli_grok_bot_cli_src_cli_codex_bridge_respond_tsx__rspack_import_9);
+
+const route6 = Object.assign({}, Reflect.get(_home_runner_work_grok_bot_cli_grok_bot_cli_src_cli_codex_bridge_run_tsx__rspack_import_10, 'default'), _home_runner_work_grok_bot_cli_grok_bot_cli_src_cli_codex_bridge_run_tsx__rspack_import_10);
+
+const route7 = Object.assign({}, Reflect.get(_home_runner_work_grok_bot_cli_grok_bot_cli_src_cli_codex_bridge_start_tsx__rspack_import_11, 'default'), _home_runner_work_grok_bot_cli_grok_bot_cli_src_cli_codex_bridge_start_tsx__rspack_import_11);
+
+const route8 = Object.assign({}, Reflect.get(_home_runner_work_grok_bot_cli_grok_bot_cli_src_cli_codex_bridge_status_tsx__rspack_import_12, 'default'), _home_runner_work_grok_bot_cli_grok_bot_cli_src_cli_codex_bridge_status_tsx__rspack_import_12);
+
+const route9 = Object.assign({}, Reflect.get(_home_runner_work_grok_bot_cli_grok_bot_cli_src_cli_codex_bridge_stop_tsx__rspack_import_13, 'default'), _home_runner_work_grok_bot_cli_grok_bot_cli_src_cli_codex_bridge_stop_tsx__rspack_import_13);
 
-const route6 = Object.assign({}, Reflect.get(_home_runner_work_grok_bot_cli_grok_bot_cli_src_cli_codex_list_threads_tsx__rspack_import_10, 'default'), _home_runner_work_grok_bot_cli_grok_bot_cli_src_cli_codex_list_threads_tsx__rspack_import_10);
+const route10 = Object.assign({}, Reflect.get(_home_runner_work_grok_bot_cli_grok_bot_cli_src_cli_codex_desktop_shim_tsx__rspack_import_14, 'default'), _home_runner_work_grok_bot_cli_grok_bot_cli_src_cli_codex_desktop_shim_tsx__rspack_import_14);
 
-const route7 = Object.assign({}, Reflect.get(_home_runner_work_grok_bot_cli_grok_bot_cli_src_cli_codex_queue_tsx__rspack_import_11, 'default'), _home_runner_work_grok_bot_cli_grok_bot_cli_src_cli_codex_queue_tsx__rspack_import_11);
+const route11 = Object.assign({}, Reflect.get(_home_runner_work_grok_bot_cli_grok_bot_cli_src_cli_codex_list_threads_tsx__rspack_import_15, 'default'), _home_runner_work_grok_bot_cli_grok_bot_cli_src_cli_codex_list_threads_tsx__rspack_import_15);
 
-const route8 = Object.assign({}, Reflect.get(_home_runner_work_grok_bot_cli_grok_bot_cli_src_cli_codex_send_tsx__rspack_import_12, 'default'), _home_runner_work_grok_bot_cli_grok_bot_cli_src_cli_codex_send_tsx__rspack_import_12);
+const route12 = Object.assign({}, Reflect.get(_home_runner_work_grok_bot_cli_grok_bot_cli_src_cli_codex_queue_tsx__rspack_import_16, 'default'), _home_runner_work_grok_bot_cli_grok_bot_cli_src_cli_codex_queue_tsx__rspack_import_16);
 
-const route9 = Object.assign({}, Reflect.get(_home_runner_work_grok_bot_cli_grok_bot_cli_src_cli_codex_status_tsx__rspack_import_13, 'default'), _home_runner_work_grok_bot_cli_grok_bot_cli_src_cli_codex_status_tsx__rspack_import_13);
+const route13 = Object.assign({}, Reflect.get(_home_runner_work_grok_bot_cli_grok_bot_cli_src_cli_codex_send_tsx__rspack_import_17, 'default'), _home_runner_work_grok_bot_cli_grok_bot_cli_src_cli_codex_send_tsx__rspack_import_17);
 
-const route10 = Object.assign({}, Reflect.get(_home_runner_work_grok_bot_cli_grok_bot_cli_src_cli_doctor_tsx__rspack_import_14, 'default'), _home_runner_work_grok_bot_cli_grok_bot_cli_src_cli_doctor_tsx__rspack_import_14);
+const route14 = Object.assign({}, Reflect.get(_home_runner_work_grok_bot_cli_grok_bot_cli_src_cli_codex_status_tsx__rspack_import_18, 'default'), _home_runner_work_grok_bot_cli_grok_bot_cli_src_cli_codex_status_tsx__rspack_import_18);
 
-const route11 = Object.assign({}, Reflect.get(_home_runner_work_grok_bot_cli_grok_bot_cli_src_cli_groups_add_tsx__rspack_import_15, 'default'), _home_runner_work_grok_bot_cli_grok_bot_cli_src_cli_groups_add_tsx__rspack_import_15);
+const route15 = Object.assign({}, Reflect.get(_home_runner_work_grok_bot_cli_grok_bot_cli_src_cli_codex_wait_tsx__rspack_import_19, 'default'), _home_runner_work_grok_bot_cli_grok_bot_cli_src_cli_codex_wait_tsx__rspack_import_19);
 
-const route12 = Object.assign({}, Reflect.get(_home_runner_work_grok_bot_cli_grok_bot_cli_src_cli_groups_create_tsx__rspack_import_16, 'default'), _home_runner_work_grok_bot_cli_grok_bot_cli_src_cli_groups_create_tsx__rspack_import_16);
+const route16 = Object.assign({}, Reflect.get(_home_runner_work_grok_bot_cli_grok_bot_cli_src_cli_codex_watch_tsx__rspack_import_20, 'default'), _home_runner_work_grok_bot_cli_grok_bot_cli_src_cli_codex_watch_tsx__rspack_import_20);
 
-const route13 = Object.assign({}, Reflect.get(_home_runner_work_grok_bot_cli_grok_bot_cli_src_cli_groups_delete_tsx__rspack_import_17, 'default'), _home_runner_work_grok_bot_cli_grok_bot_cli_src_cli_groups_delete_tsx__rspack_import_17);
+const route17 = Object.assign({}, Reflect.get(_home_runner_work_grok_bot_cli_grok_bot_cli_src_cli_doctor_tsx__rspack_import_21, 'default'), _home_runner_work_grok_bot_cli_grok_bot_cli_src_cli_doctor_tsx__rspack_import_21);
 
-const route14 = Object.assign({}, Reflect.get(_home_runner_work_grok_bot_cli_grok_bot_cli_src_cli_groups_get_tsx__rspack_import_18, 'default'), _home_runner_work_grok_bot_cli_grok_bot_cli_src_cli_groups_get_tsx__rspack_import_18);
+const route18 = Object.assign({}, Reflect.get(_home_runner_work_grok_bot_cli_grok_bot_cli_src_cli_groups_add_tsx__rspack_import_22, 'default'), _home_runner_work_grok_bot_cli_grok_bot_cli_src_cli_groups_add_tsx__rspack_import_22);
 
-const route15 = Object.assign({}, Reflect.get(_home_runner_work_grok_bot_cli_grok_bot_cli_src_cli_groups_list_tsx__rspack_import_19, 'default'), _home_runner_work_grok_bot_cli_grok_bot_cli_src_cli_groups_list_tsx__rspack_import_19);
+const route19 = Object.assign({}, Reflect.get(_home_runner_work_grok_bot_cli_grok_bot_cli_src_cli_groups_create_tsx__rspack_import_23, 'default'), _home_runner_work_grok_bot_cli_grok_bot_cli_src_cli_groups_create_tsx__rspack_import_23);
 
-const route16 = Object.assign({}, Reflect.get(_home_runner_work_grok_bot_cli_grok_bot_cli_src_cli_groups_members_tsx__rspack_import_20, 'default'), _home_runner_work_grok_bot_cli_grok_bot_cli_src_cli_groups_members_tsx__rspack_import_20);
+const route20 = Object.assign({}, Reflect.get(_home_runner_work_grok_bot_cli_grok_bot_cli_src_cli_groups_delete_tsx__rspack_import_24, 'default'), _home_runner_work_grok_bot_cli_grok_bot_cli_src_cli_groups_delete_tsx__rspack_import_24);
 
-const route17 = Object.assign({}, Reflect.get(_home_runner_work_grok_bot_cli_grok_bot_cli_src_cli_groups_remove_tsx__rspack_import_21, 'default'), _home_runner_work_grok_bot_cli_grok_bot_cli_src_cli_groups_remove_tsx__rspack_import_21);
+const route21 = Object.assign({}, Reflect.get(_home_runner_work_grok_bot_cli_grok_bot_cli_src_cli_groups_get_tsx__rspack_import_25, 'default'), _home_runner_work_grok_bot_cli_grok_bot_cli_src_cli_groups_get_tsx__rspack_import_25);
 
-const route18 = Object.assign({}, Reflect.get(_home_runner_work_grok_bot_cli_grok_bot_cli_src_cli_groups_set_tsx__rspack_import_22, 'default'), _home_runner_work_grok_bot_cli_grok_bot_cli_src_cli_groups_set_tsx__rspack_import_22);
+const route22 = Object.assign({}, Reflect.get(_home_runner_work_grok_bot_cli_grok_bot_cli_src_cli_groups_list_tsx__rspack_import_26, 'default'), _home_runner_work_grok_bot_cli_grok_bot_cli_src_cli_groups_list_tsx__rspack_import_26);
 
-const route19 = Object.assign({}, Reflect.get(_home_runner_work_grok_bot_cli_grok_bot_cli_src_cli_groups_update_tsx__rspack_import_23, 'default'), _home_runner_work_grok_bot_cli_grok_bot_cli_src_cli_groups_update_tsx__rspack_import_23);
+const route23 = Object.assign({}, Reflect.get(_home_runner_work_grok_bot_cli_grok_bot_cli_src_cli_groups_members_tsx__rspack_import_27, 'default'), _home_runner_work_grok_bot_cli_grok_bot_cli_src_cli_groups_members_tsx__rspack_import_27);
 
-const route20 = Object.assign({}, Reflect.get(_home_runner_work_grok_bot_cli_grok_bot_cli_src_cli_history_tsx__rspack_import_24, 'default'), _home_runner_work_grok_bot_cli_grok_bot_cli_src_cli_history_tsx__rspack_import_24);
+const route24 = Object.assign({}, Reflect.get(_home_runner_work_grok_bot_cli_grok_bot_cli_src_cli_groups_remove_tsx__rspack_import_28, 'default'), _home_runner_work_grok_bot_cli_grok_bot_cli_src_cli_groups_remove_tsx__rspack_import_28);
 
-const route21 = Object.assign({}, Reflect.get(_home_runner_work_grok_bot_cli_grok_bot_cli_src_cli_send_tsx__rspack_import_25, 'default'), _home_runner_work_grok_bot_cli_grok_bot_cli_src_cli_send_tsx__rspack_import_25);
+const route25 = Object.assign({}, Reflect.get(_home_runner_work_grok_bot_cli_grok_bot_cli_src_cli_groups_set_tsx__rspack_import_29, 'default'), _home_runner_work_grok_bot_cli_grok_bot_cli_src_cli_groups_set_tsx__rspack_import_29);
 
-const route22 = Object.assign({}, Reflect.get(_home_runner_work_grok_bot_cli_grok_bot_cli_src_cli_thread_tsx__rspack_import_26, 'default'), _home_runner_work_grok_bot_cli_grok_bot_cli_src_cli_thread_tsx__rspack_import_26);
-const pluginRoot = (0,_agent_bundle_runtime__rspack_import_27/* .resolvePluginRoot */.E7)({
+const route26 = Object.assign({}, Reflect.get(_home_runner_work_grok_bot_cli_grok_bot_cli_src_cli_groups_update_tsx__rspack_import_30, 'default'), _home_runner_work_grok_bot_cli_grok_bot_cli_src_cli_groups_update_tsx__rspack_import_30);
+
+const route27 = Object.assign({}, Reflect.get(_home_runner_work_grok_bot_cli_grok_bot_cli_src_cli_history_tsx__rspack_import_31, 'default'), _home_runner_work_grok_bot_cli_grok_bot_cli_src_cli_history_tsx__rspack_import_31);
+
+const route28 = Object.assign({}, Reflect.get(_home_runner_work_grok_bot_cli_grok_bot_cli_src_cli_send_tsx__rspack_import_32, 'default'), _home_runner_work_grok_bot_cli_grok_bot_cli_src_cli_send_tsx__rspack_import_32);
+
+const route29 = Object.assign({}, Reflect.get(_home_runner_work_grok_bot_cli_grok_bot_cli_src_cli_thread_tsx__rspack_import_33, 'default'), _home_runner_work_grok_bot_cli_grok_bot_cli_src_cli_thread_tsx__rspack_import_33);
+const pluginRoot = (0,_agent_bundle_runtime__rspack_import_34/* .resolvePluginRoot */.E7)({
     fallback: (0,node_url__rspack_import_2.fileURLToPath)(new URL('..', import.meta.url)),
     stateAnchor: 'user-data'
 });
@@ -82981,59 +84191,80 @@ const routes = Object.freeze({
     "cli:bots/update": Object.freeze({
         module: route4
     }),
-    "cli:codex/desktop-shim": Object.freeze({
+    "cli:codex/bridge/respond": Object.freeze({
         module: route5
     }),
-    "cli:codex/list-threads": Object.freeze({
+    "cli:codex/bridge/run": Object.freeze({
         module: route6
     }),
-    "cli:codex/queue": Object.freeze({
+    "cli:codex/bridge/start": Object.freeze({
         module: route7
     }),
-    "cli:codex/send": Object.freeze({
+    "cli:codex/bridge/status": Object.freeze({
         module: route8
     }),
-    "cli:codex/status": Object.freeze({
+    "cli:codex/bridge/stop": Object.freeze({
         module: route9
     }),
-    "cli:doctor": Object.freeze({
+    "cli:codex/desktop-shim": Object.freeze({
         module: route10
     }),
-    "cli:groups/add": Object.freeze({
+    "cli:codex/list-threads": Object.freeze({
         module: route11
     }),
-    "cli:groups/create": Object.freeze({
+    "cli:codex/queue": Object.freeze({
         module: route12
     }),
-    "cli:groups/delete": Object.freeze({
+    "cli:codex/send": Object.freeze({
         module: route13
     }),
-    "cli:groups/get": Object.freeze({
+    "cli:codex/status": Object.freeze({
         module: route14
     }),
-    "cli:groups/list": Object.freeze({
+    "cli:codex/wait": Object.freeze({
         module: route15
     }),
-    "cli:groups/members": Object.freeze({
+    "cli:codex/watch": Object.freeze({
         module: route16
     }),
-    "cli:groups/remove": Object.freeze({
+    "cli:doctor": Object.freeze({
         module: route17
     }),
-    "cli:groups/set": Object.freeze({
+    "cli:groups/add": Object.freeze({
         module: route18
     }),
-    "cli:groups/update": Object.freeze({
+    "cli:groups/create": Object.freeze({
         module: route19
     }),
-    "cli:history": Object.freeze({
+    "cli:groups/delete": Object.freeze({
         module: route20
     }),
-    "cli:send": Object.freeze({
+    "cli:groups/get": Object.freeze({
         module: route21
     }),
-    "cli:thread": Object.freeze({
+    "cli:groups/list": Object.freeze({
         module: route22
+    }),
+    "cli:groups/members": Object.freeze({
+        module: route23
+    }),
+    "cli:groups/remove": Object.freeze({
+        module: route24
+    }),
+    "cli:groups/set": Object.freeze({
+        module: route25
+    }),
+    "cli:groups/update": Object.freeze({
+        module: route26
+    }),
+    "cli:history": Object.freeze({
+        module: route27
+    }),
+    "cli:send": Object.freeze({
+        module: route28
+    }),
+    "cli:thread": Object.freeze({
+        module: route29
     })
 });
 const commands = Object.freeze([
@@ -83333,6 +84564,224 @@ const commands = Object.freeze([
         "rendered": true,
         "routeId": "cli:bots/update"
     },
+    {
+        "aliases": [],
+        "description": "Managed Grok/Codex bridge respond.",
+        "exitCode": "result",
+        "options": [
+            {
+                "description": "JSON object mapping each advertised question ID to {\"answers\":[\"answer\"]}; exact IDs required.",
+                "key": "answersJson",
+                "kind": "string",
+                "option": "answers-json",
+                "repeated": false,
+                "required": false
+            },
+            {
+                "key": "bindingId",
+                "kind": "string",
+                "option": "binding-id",
+                "repeated": false,
+                "required": false
+            },
+            {
+                "choices": [
+                    "accept",
+                    "decline",
+                    "cancel"
+                ],
+                "key": "decision",
+                "kind": "enum",
+                "option": "decision",
+                "repeated": false,
+                "required": false
+            },
+            {
+                "key": "exchangeId",
+                "kind": "string",
+                "option": "exchange-id",
+                "repeated": false,
+                "required": false
+            },
+            {
+                "key": "generation",
+                "kind": "string",
+                "option": "generation",
+                "repeated": false,
+                "required": true
+            },
+            {
+                "key": "interactionId",
+                "kind": "string",
+                "option": "interaction-id",
+                "repeated": false,
+                "required": true
+            },
+            {
+                "key": "threadId",
+                "kind": "string",
+                "option": "thread-id",
+                "repeated": false,
+                "required": true
+            },
+            {
+                "key": "turnId",
+                "kind": "string",
+                "option": "turn-id",
+                "repeated": false,
+                "required": true
+            }
+        ],
+        "path": [
+            "codex",
+            "bridge",
+            "respond"
+        ],
+        "rendered": true,
+        "routeId": "cli:codex/bridge/respond"
+    },
+    {
+        "aliases": [],
+        "description": "Run a bounded foreground relay (up to 23 hours). Use the packaged gbot-relay.mjs script for unlimited service lifetime.",
+        "exitCode": "result",
+        "options": [
+            {
+                "description": "Foreground lifetime in milliseconds (100..82800000; default 23h).",
+                "key": "lifetimeMs",
+                "kind": "number",
+                "option": "lifetime-ms",
+                "repeated": false,
+                "required": false
+            }
+        ],
+        "path": [
+            "codex",
+            "bridge",
+            "run"
+        ],
+        "render": {
+            "maxElapsedMs": 86400000
+        },
+        "rendered": true,
+        "routeId": "cli:codex/bridge/run"
+    },
+    {
+        "aliases": [],
+        "description": "Managed Grok/Codex bridge start.",
+        "exitCode": "result",
+        "options": [
+            {
+                "choices": [
+                    "steer",
+                    "reject"
+                ],
+                "key": "busyPolicy",
+                "kind": "enum",
+                "option": "busy-policy",
+                "repeated": false,
+                "required": false
+            },
+            {
+                "key": "codexThreadId",
+                "kind": "string",
+                "option": "codex-thread-id",
+                "repeated": false,
+                "required": false
+            },
+            {
+                "key": "expectedCwd",
+                "kind": "string",
+                "option": "expected-cwd",
+                "repeated": false,
+                "required": false
+            },
+            {
+                "key": "grokTarget",
+                "kind": "string",
+                "option": "grok-target",
+                "positional": 0,
+                "repeated": false,
+                "required": true
+            },
+            {
+                "key": "requestId",
+                "kind": "string",
+                "option": "request-id",
+                "repeated": false,
+                "required": false
+            }
+        ],
+        "path": [
+            "codex",
+            "bridge",
+            "start"
+        ],
+        "rendered": true,
+        "routeId": "cli:codex/bridge/start"
+    },
+    {
+        "aliases": [],
+        "description": "Managed Grok/Codex bridge status.",
+        "exitCode": "result",
+        "options": [
+            {
+                "key": "bindingId",
+                "kind": "string",
+                "option": "binding-id",
+                "repeated": false,
+                "required": false
+            },
+            {
+                "key": "limit",
+                "kind": "number",
+                "option": "limit",
+                "repeated": false,
+                "required": false
+            }
+        ],
+        "path": [
+            "codex",
+            "bridge",
+            "status"
+        ],
+        "rendered": true,
+        "routeId": "cli:codex/bridge/status"
+    },
+    {
+        "aliases": [],
+        "description": "Managed Grok/Codex bridge stop.",
+        "exitCode": "result",
+        "options": [
+            {
+                "key": "all",
+                "kind": "boolean",
+                "option": "all",
+                "repeated": false,
+                "required": false
+            },
+            {
+                "key": "bindingId",
+                "kind": "string",
+                "option": "binding-id",
+                "repeated": false,
+                "required": false
+            },
+            {
+                "key": "worker",
+                "kind": "boolean",
+                "option": "worker",
+                "repeated": false,
+                "required": false
+            }
+        ],
+        "path": [
+            "codex",
+            "bridge",
+            "stop"
+        ],
+        "rendered": true,
+        "routeId": "cli:codex/bridge/stop"
+    },
     {
         "aliases": [],
         "description": "Install, remove, or check the ChatGPT Desktop shim: a CODEX_CLI_PATH wrapper that bridges Desktop stdio onto the managed Codex daemon (stock app-server proxy hangs). macOS persists via LaunchAgent; always fails open to real Codex.",
@@ -83413,11 +84862,17 @@ const commands = Object.freeze([
     },
     {
         "aliases": [],
-        "description": "Send a message to a Codex thread. Options go before <threadId>; `--` protects flag-like text.",
+        "description": "Send to Codex; acceptance is distinct from completion. Options precede threadId.",
         "exitCode": "result",
         "options": [
             {
-                "description": "Stable correlation id for multi-hop replies",
+                "key": "bindingId",
+                "kind": "string",
+                "option": "binding-id",
+                "repeated": false,
+                "required": false
+            },
+            {
                 "key": "correlationId",
                 "kind": "string",
                 "option": "correlation-id",
@@ -83425,7 +84880,6 @@ const commands = Object.freeze([
                 "required": false
             },
             {
-                "description": "Prepend the [gbot …] header to the message body",
                 "key": "envelope",
                 "kind": "boolean",
                 "option": "envelope",
@@ -83433,13 +84887,35 @@ const commands = Object.freeze([
                 "required": false
             },
             {
-                "description": "Hop count; refused at GROK_BOT_MAX_HOPS",
+                "key": "expectedCwd",
+                "kind": "string",
+                "option": "expected-cwd",
+                "repeated": false,
+                "required": false
+            },
+            {
+                "description": "Required active-turn guard for steer; stale guards reject.",
+                "key": "expectedTurnId",
+                "kind": "string",
+                "option": "expected-turn-id",
+                "repeated": false,
+                "required": false
+            },
+            {
                 "key": "hop",
                 "kind": "number",
                 "option": "hop",
                 "repeated": false,
                 "required": false
             },
+            {
+                "description": "Reply budget: 1-4194304 bytes.",
+                "key": "maxOutputBytes",
+                "kind": "number",
+                "option": "max-output-bytes",
+                "repeated": false,
+                "required": false
+            },
             {
                 "key": "message",
                 "kind": "string",
@@ -83449,13 +84925,26 @@ const commands = Object.freeze([
                 "required": true
             },
             {
-                "description": "Prior message id this send replies to",
                 "key": "replyTo",
                 "kind": "string",
                 "option": "reply-to",
                 "repeated": false,
                 "required": false
             },
+            {
+                "key": "replyToGrok",
+                "kind": "string",
+                "option": "reply-to-grok",
+                "repeated": false,
+                "required": false
+            },
+            {
+                "key": "requestId",
+                "kind": "string",
+                "option": "request-id",
+                "repeated": false,
+                "required": false
+            },
             {
                 "key": "threadId",
                 "kind": "string",
@@ -83464,12 +84953,27 @@ const commands = Object.freeze([
                 "repeated": false,
                 "required": true
             },
+            {
+                "description": "Observation timeout: 1-600000 milliseconds.",
+                "key": "timeoutMs",
+                "kind": "number",
+                "option": "timeout-ms",
+                "repeated": false,
+                "required": false
+            },
+            {
+                "key": "wait",
+                "kind": "boolean",
+                "option": "wait",
+                "repeated": false,
+                "required": false
+            },
             {
                 "choices": [
                     "reject",
-                    "queue"
+                    "queue",
+                    "steer"
                 ],
-                "description": "reject (default) or queue (needs GROK_BOT_CODEX_EXPERIMENTAL=1)",
                 "key": "whenBusy",
                 "kind": "enum",
                 "option": "when-busy",
@@ -83481,6 +84985,9 @@ const commands = Object.freeze([
             "codex",
             "send"
         ],
+        "render": {
+            "maxElapsedMs": 660000
+        },
         "rendered": true,
         "routeId": "cli:codex/send"
     },
@@ -83496,6 +85003,115 @@ const commands = Object.freeze([
         "rendered": true,
         "routeId": "cli:codex/status"
     },
+    {
+        "aliases": [],
+        "description": "Bounded Codex wait observation; never interrupts execution.",
+        "exitCode": "result",
+        "options": [
+            {
+                "key": "expectedCwd",
+                "kind": "string",
+                "option": "expected-cwd",
+                "repeated": false,
+                "required": false
+            },
+            {
+                "description": "Reply budget: 1-4194304 bytes.",
+                "key": "maxOutputBytes",
+                "kind": "number",
+                "option": "max-output-bytes",
+                "repeated": false,
+                "required": false
+            },
+            {
+                "key": "messageId",
+                "kind": "string",
+                "option": "message-id",
+                "repeated": false,
+                "required": false
+            },
+            {
+                "key": "threadId",
+                "kind": "string",
+                "option": "thread-id",
+                "positional": 0,
+                "repeated": false,
+                "required": true
+            },
+            {
+                "description": "Observation timeout: 1-600000 milliseconds.",
+                "key": "timeoutMs",
+                "kind": "number",
+                "option": "timeout-ms",
+                "repeated": false,
+                "required": false
+            },
+            {
+                "key": "turnId",
+                "kind": "string",
+                "option": "turn-id",
+                "positional": 1,
+                "repeated": false,
+                "required": true
+            }
+        ],
+        "path": [
+            "codex",
+            "wait"
+        ],
+        "render": {
+            "maxElapsedMs": 660000
+        },
+        "rendered": true,
+        "routeId": "cli:codex/wait"
+    },
+    {
+        "aliases": [],
+        "description": "Bounded Codex watch observation; never interrupts execution.",
+        "exitCode": "result",
+        "options": [
+            {
+                "key": "expectedCwd",
+                "kind": "string",
+                "option": "expected-cwd",
+                "repeated": false,
+                "required": false
+            },
+            {
+                "description": "Maximum observed events: 1-500.",
+                "key": "maxEvents",
+                "kind": "number",
+                "option": "max-events",
+                "repeated": false,
+                "required": false
+            },
+            {
+                "key": "threadId",
+                "kind": "string",
+                "option": "thread-id",
+                "positional": 0,
+                "repeated": false,
+                "required": true
+            },
+            {
+                "description": "Observation timeout: 1-600000 milliseconds.",
+                "key": "timeoutMs",
+                "kind": "number",
+                "option": "timeout-ms",
+                "repeated": false,
+                "required": false
+            }
+        ],
+        "path": [
+            "codex",
+            "watch"
+        ],
+        "render": {
+            "maxElapsedMs": 660000
+        },
+        "rendered": true,
+        "routeId": "cli:codex/watch"
+    },
     {
         "aliases": [],
         "description": "Show which agents root and auth sources gbot can see.",
@@ -84100,6 +85716,20 @@ const commands = Object.freeze([
         "description": "Send a message to a Grok Bot bot or group by name or id.",
         "exitCode": "result",
         "options": [
+            {
+                "key": "bindingId",
+                "kind": "string",
+                "option": "binding-id",
+                "repeated": false,
+                "required": false
+            },
+            {
+                "key": "codexThreadId",
+                "kind": "string",
+                "option": "codex-thread-id",
+                "repeated": false,
+                "required": false
+            },
             {
                 "description": "Stable correlation id for multi-hop replies",
                 "key": "correlationId",
@@ -84124,6 +85754,13 @@ const commands = Object.freeze([
                 "repeated": false,
                 "required": false
             },
+            {
+                "key": "expectedCwd",
+                "kind": "string",
+                "option": "expected-cwd",
+                "repeated": false,
+                "required": false
+            },
             {
                 "description": "Force the on-disk agents store",
                 "key": "files",
@@ -84172,6 +85809,17 @@ const commands = Object.freeze([
                 "repeated": false,
                 "required": false
             },
+            {
+                "choices": [
+                    "auto",
+                    "manual"
+                ],
+                "key": "replyMode",
+                "kind": "enum",
+                "option": "reply-mode",
+                "repeated": false,
+                "required": false
+            },
             {
                 "description": "Prior message id this send replies to",
                 "key": "replyTo",
@@ -84180,6 +85828,13 @@ const commands = Object.freeze([
                 "repeated": false,
                 "required": false
             },
+            {
+                "key": "requestId",
+                "kind": "string",
+                "option": "request-id",
+                "repeated": false,
+                "required": false
+            },
             {
                 "key": "target",
                 "kind": "string",
@@ -84323,27 +85978,27 @@ const execute = async (command, input, context)=>{
         instanceId: processLifetime.instanceId,
         pid: processLifetime.pid
     };
-    const result = await (0,_agent_bundle_runtime__rspack_import_28/* .runAgentRequest */.iC)({
+    const result = await (0,_agent_bundle_runtime__rspack_import_35/* .runAgentRequest */.iC)({
         capabilities: {
-            command: (0,_agent_bundle_runtime__rspack_import_28/* .unavailable */.hU)(),
-            filesystem: (0,_agent_bundle_runtime__rspack_import_28/* .unavailable */.hU)(),
-            network: (0,_agent_bundle_runtime__rspack_import_28/* .unavailable */.hU)(),
-            projectRoot: (0,_agent_bundle_runtime__rspack_import_28/* .available */.qC)({
+            command: (0,_agent_bundle_runtime__rspack_import_35/* .unavailable */.hU)(),
+            filesystem: (0,_agent_bundle_runtime__rspack_import_35/* .unavailable */.hU)(),
+            network: (0,_agent_bundle_runtime__rspack_import_35/* .unavailable */.hU)(),
+            projectRoot: (0,_agent_bundle_runtime__rspack_import_35/* .available */.qC)({
                 root: cwd
             }, 'derived')
         },
-        host: (0,_agent_bundle_runtime__rspack_import_28/* .unavailable */.hU)('unsupported-surface'),
+        host: (0,_agent_bundle_runtime__rspack_import_35/* .unavailable */.hU)('unsupported-surface'),
         invocation: {
             kind: 'cli',
             operationId: command.routeId,
             surface: command.path.join(' ')
         },
-        lineage: (0,_agent_bundle_runtime__rspack_import_28/* .unavailable */.hU)('unsupported-surface'),
+        lineage: (0,_agent_bundle_runtime__rspack_import_35/* .unavailable */.hU)('unsupported-surface'),
         plugin: pluginRoot.identity,
         process: processHit,
         signal: context.signal,
-        terminal: (0,_agent_bundle_runtime__rspack_import_28/* .available */.qC)(context.terminal, 'native'),
-        workspace: (0,_agent_bundle_runtime__rspack_import_28/* .available */.qC)({
+        terminal: (0,_agent_bundle_runtime__rspack_import_35/* .available */.qC)(context.terminal, 'native'),
+        workspace: (0,_agent_bundle_runtime__rspack_import_35/* .available */.qC)({
             root: cwd
         }, 'derived')
     }, async ()=>route.module.default({
@@ -84450,7 +86105,7 @@ const openRenderedSession = ({ invocation, limits, props, request, routeId, sign
             return stream;
         }
     });
-    const dispatcher = (0,_agent_bundle_runtime__rspack_import_29/* .createAgentRenderDispatcher */.jK)(host);
+    const dispatcher = (0,_agent_bundle_runtime__rspack_import_36/* .createAgentRenderDispatcher */.jK)(host);
     return Object.freeze({
         close: async ()=>{
             await worker.terminate();
@@ -84494,11 +86149,11 @@ const render = async (command, input, context)=>{
 if (import.meta.main) {
     await (0,agent_bundle_cli_entry__rspack_import_1/* .runGeneratedCliProcess */.yA)({
         commands,
-        description: "Message Grok Bot bots and groups and read their threads from Codex, Claude Code, and Cursor.",
+        description: "Message Grok Bot from Codex, Claude Code, and Cursor, with managed automatic replies and explicit Codex conversation links.",
         execute,
         name: "gbot",
         render,
-        version: "0.5.0"
+        version: "0.6.0"
     });
 }
 
@@ -84722,6 +86377,7 @@ function inspectGrokBotGatewaySession(options = {}) {
 __webpack_require__.d(__webpack_exports__, {
   Z2: () => (loadGrokBotGatewaySession),
   ZN: () => (hasGrokBotGatewaySession),
+  dQ: () => (grokBotGatewayDescriptorPath),
   hd: () => (inspectGrokBotGatewaySession)
 });
 
@@ -84734,7 +86390,7 @@ __webpack_require__.d(__webpack_exports__, {
 /* import */ var node_os__rspack_import_3 = __webpack_require__("node:os");
 /* import */ var node_path__rspack_import_4 = __webpack_require__("node:path");
 /* import */ var node_child_process__rspack_import_5 = __webpack_require__("node:child_process");
-/* import */ var node_module__rspack_import_6 = __webpack_require__("node:module");
+/* import */ var _package_json__rspack_import_6 = __webpack_require__("./package.json");
 /* import */ var _codex_contract_js__rspack_import_7 = __webpack_require__("./src/core/codex/contract.js");
 /* import */ var _desktop_shim_js__rspack_import_8 = __webpack_require__("./src/core/desktop-shim.js");
 
@@ -84760,10 +86416,12 @@ 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_WRITE_BYTES = 8 * 1024 * 1024;
+const CODEX_MAX_REQUESTS = 128;
+const CODEX_MAX_LISTENERS = 128;
 const textDecoder = new TextDecoder("utf-8", {
     fatal: true
 });
-const pkg = (0,node_module__rspack_import_6.createRequire)(import.meta.url)("../../package.json");
 function codexSocketPath(env = process.env) {
     // Explicit socket wins so status/send/queue agree with a shim-installed or
     // operator-exported CODEX_APP_SERVER_SOCK; otherwise derive from CODEX_HOME.
@@ -84920,7 +86578,7 @@ function attachEnvelope(error, envelope) {
         "correlationId",
         "hop"
     ]){
-        if (error[key] === undefined && envelope[key] !== undefined) error[key] = envelope[key];
+        if (envelope?.[key] !== undefined) error[key] = envelope[key];
     }
 }
 /** The route to the app-server is unavailable; `mode` is a stable machine-readable state. */ class CodexRouteError extends Error {
@@ -84967,16 +86625,44 @@ function isObject(value) {
 }
 /**
  * Open a JSON-RPC session to the app-server over its Unix socket (WebSocket framing).
- * Server-initiated requests (approvals, user input) are refused with a JSON-RPC error
- * and recorded in `refused`; gbot never approves on the user's behalf.
- */ function connectCodexAppServer(path, { timeoutMs = 15000 } = {}) {
+ * Server requests are observed without answering by default. Legacy one-shot
+ * callers arm ownership-scoped refusals; persistent sessions respond explicitly.
+ */ function connectCodexAppServer(path, { timeoutMs = 15000, signal, onNotification, onServerRequest, onClose } = {}) {
     return new Promise((resolve, reject)=>{
+        if (!Number.isInteger(timeoutMs) || timeoutMs < 1 || timeoutMs > 2147483647) {
+            throw new RangeError("timeoutMs must be an integer 1-2147483647");
+        }
+        for (const listener of [
+            onNotification,
+            onServerRequest,
+            onClose
+        ]){
+            if (listener !== undefined && typeof listener !== "function") throw new TypeError("Event listener must be a function");
+        }
+        if (signal !== undefined && !(signal instanceof AbortSignal)) throw new TypeError("signal must be an AbortSignal");
+        if (signal?.aborted) throw new Error("Codex connection aborted", {
+            cause: signal.reason
+        });
         const socket = (0,node_net__rspack_import_2.createConnection)({
             path
         });
         const key = (0,node_crypto__rspack_import_0.randomBytes)(16).toString("base64");
         const pending = new Map();
         const refused = [];
+        const serverRequests = new Map();
+        const listeners = {
+            notification: new Set(onNotification ? [
+                onNotification
+            ] : []),
+            serverRequest: new Set(onServerRequest ? [
+                onServerRequest
+            ] : []),
+            close: new Set(onClose ? [
+                onClose
+            ] : [])
+        };
+        let closeError;
+        let writeTimer;
         let nextId = 1;
         let buf = Buffer.alloc(0);
         let upgraded = false;
@@ -84991,22 +86677,127 @@ function isObject(value) {
         const failAll = (err)=>{
             if (closed) return;
             closed = true;
+            closeError = err;
             clearTimeout(handshakeTimer);
+            clearTimeout(writeTimer);
+            signal?.removeEventListener("abort", abort);
             if (err && err.delivery == null) err.delivery = pending.size ? "unknown" : "rejected";
             for (const { reject: rej } of pending.values())rej(err);
             pending.clear();
+            serverRequests.clear();
+            client.deferred.length = 0;
+            buf = Buffer.alloc(0);
+            fragParts = [];
+            fragBytes = 0;
+            const closeListeners = [
+                ...listeners.close
+            ];
+            for (const group of Object.values(listeners))group.clear();
             try {
                 socket.destroy();
             } catch  {}
             reject(err);
+            for (const listener of closeListeners)invoke(listener, err, true);
         };
+        // Observers execute synchronously to preserve order, but failures never escape
+        // the socket callback. Rejected async callbacks use the same cleanup path.
+        const invoke = (listener, message, closing = false)=>{
+            const failed = (cause)=>{
+                if (!closing) failAll(new Error("Codex event listener failed", {
+                    cause
+                }));
+            };
+            try {
+                const result = listener(message);
+                if (result && typeof result.then === "function") Promise.resolve(result).catch(failed);
+            } catch (err) {
+                failed(err);
+            }
+        };
+        const dispatch = (kind, message)=>{
+            for (const listener of [
+                ...listeners[kind]
+            ]){
+                if (closed) break;
+                if (listeners[kind].has(listener)) invoke(listener, message);
+            }
+        };
+        const subscribe = (kind, listener)=>{
+            if (typeof listener !== "function") throw new TypeError("Event listener must be a function");
+            if (closed) {
+                if (kind === "close") invoke(listener, closeError, true);
+                return ()=>{};
+            }
+            const group = listeners[kind];
+            if (!group.has(listener) && group.size >= CODEX_MAX_LISTENERS) {
+                const err = new Error("Codex listener limit exceeds " + CODEX_MAX_LISTENERS);
+                failAll(err);
+                throw err;
+            }
+            group.add(listener);
+            return ()=>group.delete(listener);
+        };
+        const abort = ()=>failAll(new Error("Codex connection aborted", {
+                cause: signal.reason
+            }));
         const failProtocol = (detail)=>failAll(new Error("Codex app-server violated the WebSocket protocol: " + detail));
         const write = (opcode, payload)=>{
-            if (!socket.destroyed) socket.write(encodeFrame(opcode, payload, (0,node_crypto__rspack_import_0.randomBytes)(4)));
+            if (closed) throw closeError;
+            const encodedBytes = payload.length + (payload.length < 126 ? 6 : payload.length < 65536 ? 8 : 14);
+            if (socket.destroyed || encodedBytes + socket.writableLength > WS_MAX_WRITE_BYTES) {
+                const err = new Error(socket.destroyed ? "Codex socket closed" : "Codex outbound write budget exceeds " + WS_MAX_WRITE_BYTES + " bytes");
+                failAll(err);
+                throw err;
+            }
+            try {
+                if (!socket.write(encodeFrame(opcode, payload, (0,node_crypto__rspack_import_0.randomBytes)(4))) && !writeTimer) {
+                    // One absolute deadline for the whole backpressured interval: more
+                    // writes must not keep an unread socket alive indefinitely.
+                    writeTimer = setTimeout(()=>failAll(new Error("Codex outbound write did not drain within " + timeoutMs + "ms")), timeoutMs);
+                    writeTimer.unref();
+                }
+            } catch (err) {
+                failAll(err);
+                throw err;
+            }
         };
         const sendJson = (obj)=>write(0x1, Buffer.from(JSON.stringify(obj)));
+        const respondToRequest = (id, payload)=>{
+            if (closed) throw closeError;
+            if (!serverRequests.has(id)) throw new Error("Unknown or resolved server request: " + id);
+            // Consume ownership before JSON.stringify can invoke caller-owned getters
+            // or toJSON hooks. A failed serialization closes rather than restoring it.
+            serverRequests.delete(id);
+            client.deferred = client.deferred.filter((entry)=>entry.id !== id);
+            try {
+                sendJson({
+                    jsonrpc: "2.0",
+                    id,
+                    ...payload
+                });
+            } catch (cause) {
+                if (closed) throw closeError;
+                const err = new Error("Codex server response serialization failed", {
+                    cause
+                });
+                failAll(err);
+                throw err;
+            }
+        };
         const client = {
             refused,
+            get closed () {
+                return closed;
+            },
+            onNotification: (listener)=>subscribe("notification", listener),
+            onServerRequest: (listener)=>subscribe("serverRequest", listener),
+            onClose: (listener)=>subscribe("close", listener),
+            respond: (id, result)=>respondToRequest(id, {
+                    result
+                }),
+            rejectRequest: (id, error)=>respondToRequest(id, {
+                    error
+                }),
             // Server-initiated requests are only *answered* once our own turn/start
             // is in flight, and then only when they name our own thread/turn:
             // anything earlier — or naming another thread or Desktop turn — belongs
@@ -85031,22 +86822,24 @@ function isObject(value) {
                     const params = entry.params && typeof entry.params === "object" && !Array.isArray(entry.params) ? entry.params : null;
                     const threadId = params ? params.threadId ?? params.thread_id : null;
                     const namedTurnId = params ? params.turnId ?? params.turn_id ?? (params.turn && params.turn.id) : null;
-                    if (threadId === client.expectedThreadId && namedTurnId === turnId) {
-                        entry.answered = true;
-                        sendJson({
-                            jsonrpc: "2.0",
-                            id: entry.id,
-                            error: {
-                                code: -32601,
-                                message: "gbot codex does not answer " + entry.method + "; configure approval_policy on the daemon"
-                            }
+                    if (threadId === client.expectedThreadId && namedTurnId === turnId && serverRequests.get(entry.id) === entry) {
+                        client.rejectRequest(entry.id, {
+                            code: -32601,
+                            message: "gbot codex does not answer " + entry.method + "; configure approval_policy on the daemon"
                         });
+                        entry.answered = true;
                     }
                 }
             },
             request (method, params) {
-                const id = nextId++;
                 return new Promise((res, rej)=>{
+                    if (closed) return rej(closeError);
+                    if (pending.size >= CODEX_MAX_REQUESTS) {
+                        const err = new Error("Codex pending request limit exceeds " + CODEX_MAX_REQUESTS);
+                        failAll(err);
+                        return rej(err);
+                    }
+                    const id = nextId++;
                     const timer = setTimeout(()=>{
                         pending.delete(id);
                         rej(new Error("Codex app-server did not answer " + method + " within " + timeoutMs + "ms"));
@@ -85062,12 +86855,18 @@ function isObject(value) {
                             rej(e);
                         }
                     });
-                    sendJson({
-                        jsonrpc: "2.0",
-                        id,
-                        method,
-                        params
-                    });
+                    try {
+                        sendJson({
+                            jsonrpc: "2.0",
+                            id,
+                            method,
+                            params
+                        });
+                    } catch (err) {
+                        const entry = pending.get(id);
+                        pending.delete(id);
+                        entry?.reject(err);
+                    }
                 });
             },
             notify (method, params) {
@@ -85079,34 +86878,34 @@ function isObject(value) {
             },
             close () {
                 if (closed) return;
-                closed = true;
-                clearTimeout(handshakeTimer);
-                const err = new Error("Codex client closed");
-                err.delivery = pending.size ? "unknown" : "rejected";
-                for (const { reject: rej } of pending.values())rej(err);
-                pending.clear();
-                // Best-effort close frame, then guaranteed destruction so no path leaks the socket.
-                if (!socket.destroyed && upgraded) write(0x8, Buffer.from([
-                    0x03,
-                    0xe8
-                ]));
-                if (socket.destroyed) return;
-                const forceDestroy = setTimeout(()=>{
-                    try {
-                        socket.destroy();
-                    } catch  {}
-                }, 1000);
-                if (typeof forceDestroy.unref === "function") forceDestroy.unref();
-                socket.end(()=>{
-                    clearTimeout(forceDestroy);
-                    try {
-                        socket.destroy();
-                    } catch  {}
-                });
+                // Best effort protocol close; cleanup never depends on the peer reading it.
+                try {
+                    if (upgraded) write(0x8, Buffer.from([
+                        0x03,
+                        0xe8
+                    ]));
+                } catch  {}
+                failAll(new Error("Codex client closed"));
             }
         };
+        signal?.addEventListener("abort", abort, {
+            once: true
+        });
         const onMessage = (msg)=>{
             if (msg.id != null && msg.method) {
+                if (serverRequests.has(msg.id)) return failProtocol("duplicate pending server request id");
+                if (serverRequests.size >= CODEX_MAX_REQUESTS || refused.length >= CODEX_MAX_REQUESTS || client.deferred.length >= CODEX_MAX_REQUESTS) {
+                    return failAll(new Error("Codex remembered server request limit exceeds " + CODEX_MAX_REQUESTS));
+                }
+                const entry = {
+                    id: msg.id,
+                    method: msg.method,
+                    params: msg.params,
+                    answered: false
+                };
+                serverRequests.set(msg.id, entry);
+                dispatch("serverRequest", msg);
+                if (closed) return;
                 let answered = client.answerServerRequests;
                 let defer = false;
                 // Approval ownership: only answer requests for the turn gbot itself
@@ -85126,28 +86925,30 @@ function isObject(value) {
                         } else if (turnId !== client.expectedTurnId) answered = false;
                     } else answered = false;
                 }
-                const entry = {
-                    id: msg.id,
-                    method: msg.method,
-                    params: msg.params,
-                    answered
-                };
+                answered = answered && serverRequests.has(msg.id);
+                defer = defer && serverRequests.has(msg.id);
+                entry.answered = answered;
                 refused.push(entry);
                 if (defer) {
                     client.deferred.push(entry);
                     return;
                 }
                 if (!answered) return;
-                sendJson({
-                    jsonrpc: "2.0",
-                    id: msg.id,
-                    error: {
-                        code: -32601,
-                        message: "gbot codex does not answer " + msg.method + "; configure approval_policy on the daemon"
-                    }
+                client.rejectRequest(msg.id, {
+                    code: -32601,
+                    message: "gbot codex does not answer " + msg.method + "; configure approval_policy on the daemon"
                 });
                 return;
             }
+            if (msg.id == null && msg.method) {
+                if (msg.method === "serverRequest/resolved") {
+                    const id = msg.params?.requestId;
+                    serverRequests.delete(id);
+                    client.deferred = client.deferred.filter((entry)=>entry.id !== id);
+                }
+                dispatch("notification", msg);
+                return;
+            }
             if (msg.id == null || !pending.has(msg.id)) return;
             const entry = pending.get(msg.id);
             pending.delete(msg.id);
@@ -85173,12 +86974,21 @@ function isObject(value) {
                 failAll(new Error("Codex app-server sent a malformed message"));
                 return;
             }
-            onMessage(msg);
+            try {
+                onMessage(msg);
+            } catch (err) {
+                failAll(err);
+            }
         };
+        socket.on("drain", ()=>{
+            clearTimeout(writeTimer);
+            writeTimer = undefined;
+        });
         socket.once("error", (err)=>failAll(new Error("Could not connect to Codex app-server at " + path + ": " + err.message)));
         socket.once("close", ()=>failAll(new Error("Codex app-server closed the connection")));
         socket.once("connect", ()=>socket.write(upgradeRequest(key)));
         socket.on("data", (chunk)=>{
+            if (closed) return;
             buf = Buffer.concat([
                 buf,
                 chunk
@@ -85198,7 +87008,7 @@ function isObject(value) {
                 clearTimeout(handshakeTimer);
                 resolve(client);
             }
-            for(;;){
+            while(!closed){
                 const frame = decodeFrame(buf);
                 if (!frame) {
                     const claimed = peekFrameLength(buf);
@@ -85214,10 +87024,18 @@ function isObject(value) {
                 if (frame.masked) return failProtocol("server frames must not be masked");
                 if (frame.opcode >= 0x8) {
                     if (!frame.fin || frame.payload.length > 125) return failProtocol("bad control frame");
-                    if (frame.opcode === 0x9) write(0xa, frame.payload);
-                    else if (frame.opcode === 0x8) {
-                        write(0x8, frame.payload);
-                        socket.end();
+                    if (frame.opcode === 0x9) {
+                        try {
+                            write(0xa, frame.payload);
+                        } catch  {
+                            return;
+                        }
+                    } else if (frame.opcode === 0x8) {
+                        try {
+                            write(0x8, frame.payload);
+                        } catch  {
+                            return;
+                        }
                         failAll(new Error("Codex app-server closed the connection"));
                     }
                     continue; // pong and other control frames carry nothing for us
@@ -85273,12 +87091,12 @@ function appServerVersion(initResult) {
     }
     throw new CodexRouteError(unreachableMessage(path), "socket-absent");
 }
-async function openSession(env = process.env, { experimental = false } = {}) {
+async function openCodexSession(env = process.env, { experimental = false, ...options } = {}) {
     const path = codexSocketPath(env);
     assertRoute(path);
     let client;
     try {
-        client = await connectCodexAppServer(path);
+        client = await connectCodexAppServer(path, options);
     } catch (err) {
         throw connectError(err, path);
     }
@@ -85287,7 +87105,7 @@ async function openSession(env = process.env, { experimental = false } = {}) {
         init = await client.request("initialize", {
             clientInfo: {
                 name: "gbot",
-                version: pkg.version
+                version: _package_json__rspack_import_6/* .version */.rE
             },
             ...experimental ? {
                 capabilities: {
@@ -85303,13 +87121,19 @@ async function openSession(env = process.env, { experimental = false } = {}) {
         client.close();
         throw new CodexProtocolError("initialize", "result is not an object");
     }
-    client.notify("initialized");
+    try {
+        client.notify("initialized");
+    } catch (err) {
+        client.close();
+        throw handshakeError(err);
+    }
     return {
         client,
         path,
         init
     };
 }
+const openSession = openCodexSession;
 const CODEX_VERSION_PROBE_TIMEOUT_MS = 3000;
 /** Bounded `codex --version` probe: `{ version, probe }` where probe is ok | missing | timeout | error. */ function probeLocalCodexVersion(timeoutMs = CODEX_VERSION_PROBE_TIMEOUT_MS) {
     const out = (0,node_child_process__rspack_import_5.spawnSync)("codex", [
@@ -85657,12 +87481,14 @@ function requireExperimental(env, what) {
         reason: "experimental-disabled"
     });
 }
-function unsupportedOrRpc(err, method, threadId, envelope) {
+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). " + "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." : "Upgrade Codex or send without --when-busy queue."), {
             delivery: "rejected",
             reason: "unsupported",
             threadId,
+            turnId,
             ...envelope
         });
     }
@@ -85670,12 +87496,14 @@ function unsupportedOrRpc(err, method, threadId, envelope) {
         delivery: "rejected",
         reason: "rejected",
         threadId,
+        turnId,
         ...envelope
     });
-    return new CodexSendError("Lost the Codex " + method + " response for thread " + threadId + ": " + (err && err.message || err) + ". Delivery is unknown; list the queue before resending.", {
+    return new CodexSendError("Lost the Codex " + method + " response for thread " + threadId + ": " + (err && err.message || err) + (guarded ? ". Delivery is unknown; check thread " + threadId + " turn " + turnId + " before resending." : ". Delivery is unknown; list the queue before resending."), {
         delivery: err && err.delivery || "unknown",
         reason: "transport",
         threadId,
+        turnId,
         ...envelope
     });
 }
@@ -85714,30 +87542,70 @@ function unsupportedOrRpc(err, method, threadId, envelope) {
 /**
  * @param {string} threadId
  * @param {string} text
- * @param {{ env?: NodeJS.ProcessEnv, envelope?: object, whenBusy?: "reject"|"queue" }} [opts]
+ * @param {{ env?: NodeJS.ProcessEnv, envelope?: object, whenBusy?: "reject"|"queue"|"steer", session?: object, expectedTurnId?: string, expectedCwd?: string, signal?: AbortSignal }} [opts]
  */ async function sendToCodexThread(threadId, text, { env = process.env, envelope = buildEnvelope({
     env
-}), whenBusy = "reject" } = {}) {
+}), whenBusy = "reject", session, expectedTurnId, expectedCwd, signal } = {}) {
     try {
         const receipt = await sendToCodexThreadInner(threadId, text, {
             env,
             envelope,
-            whenBusy
+            whenBusy,
+            session,
+            expectedTurnId,
+            expectedCwd,
+            signal
         });
         return (0,_codex_contract_js__rspack_import_7/* .outcomeFromReceipt */.Dz)(receipt);
     } catch (err) {
         // Every receipt names the message, including refusals that never reached the daemon.
-        if (err instanceof CodexSendError || err instanceof CodexRouteError || err instanceof CodexProtocolError) attachEnvelope(err, envelope);
+        if (err && typeof err === "object") {
+            attachEnvelope(err, envelope);
+            if (err.threadId === undefined) err.threadId = threadId;
+        }
         return (0,_codex_contract_js__rspack_import_7/* .outcomeFromError */.DG)(err);
     }
 }
-async function sendToCodexThreadInner(threadId, text, { env, envelope, whenBusy }) {
-    if (whenBusy !== "reject" && whenBusy !== "queue") throw new RangeError("--when-busy must be reject or queue");
+async function sendToCodexThreadInner(threadId, text, { env, envelope, whenBusy, session, expectedTurnId, expectedCwd, signal }) {
+    if (![
+        "reject",
+        "queue",
+        ...session ? [
+            "steer"
+        ] : []
+    ].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");
+    if (!envelope || typeof envelope.messageId !== "string" || !ID_PATTERN.test(envelope.messageId)) throw new RangeError("Invalid envelope messageId");
+    const validated = buildEnvelope({
+        correlationId: envelope.correlationId,
+        replyTo: envelope.replyTo,
+        hop: envelope.hop,
+        env
+    });
+    envelope = {
+        ...validated,
+        messageId: envelope.messageId,
+        header: Boolean(envelope.header)
+    };
     assertThreadAllowed(threadId, env);
     if (whenBusy === "queue") requireExperimental(env, "--when-busy queue");
+    if (signal !== undefined && !(signal instanceof AbortSignal)) throw new TypeError("signal must be an AbortSignal");
+    const assertNotCancelled = ()=>{
+        if (signal?.aborted) throw new CodexSendError("Codex submission cancelled before delivery", {
+            delivery: "rejected",
+            reason: "cancelled",
+            threadId,
+            turnId: whenBusy === "steer" ? expectedTurnId : undefined,
+            ...envelope
+        });
+    };
+    assertNotCancelled();
     const body = withEnvelopeHeader(text, envelope, env);
-    const { client } = await openSession(env, {
-        experimental: whenBusy === "queue"
+    const { client } = session ?? await openSession(env, {
+        experimental: whenBusy === "queue",
+        signal
     });
     try {
         let resumed;
@@ -85747,6 +87615,7 @@ async function sendToCodexThreadInner(threadId, text, { env, envelope, whenBusy
                 excludeTurns: true
             });
         } catch (err) {
+            assertNotCancelled();
             if (err instanceof CodexSendError) throw err;
             throw new CodexSendError(explainSendError(err, threadId).message, {
                 delivery: err instanceof CodexRpcError ? "rejected" : err && err.delivery || "unknown",
@@ -85755,9 +87624,24 @@ async function sendToCodexThreadInner(threadId, text, { env, envelope, whenBusy
                 ...envelope
             });
         }
+        // A shared session stays connected when this conversation is cancelled.
+        // Recheck after the last awaited preflight, before any submission request.
+        assertNotCancelled();
         if (!isObject(resumed) || !isObject(resumed.thread) || typeof resumed.thread.id !== "string") {
             throw new CodexProtocolError("thread/resume", "missing `thread.id`");
         }
+        if (resumed.thread.id !== threadId) throw new CodexSendError("thread/resume returned a different thread ID", {
+            delivery: "rejected",
+            reason: "bad-response",
+            threadId,
+            ...envelope
+        });
+        if (expectedCwd !== undefined && (0,node_fs__rspack_import_1.realpathSync)(resumed.cwd ?? resumed.thread.cwd) !== (0,node_fs__rspack_import_1.realpathSync)(expectedCwd)) throw new CodexSendError("Codex thread cwd does not match expectedCwd", {
+            delivery: "rejected",
+            reason: "cwd-mismatch",
+            threadId,
+            ...envelope
+        });
         const state = threadState(resumed, threadId);
         const receiptBase = {
             threadId: resumed.thread.id,
@@ -85782,6 +87666,38 @@ async function sendToCodexThreadInner(threadId, text, { env, envelope, whenBusy
                 ...envelope
             });
         }
+        if (whenBusy === "steer") {
+            let steered;
+            try {
+                steered = await client.request("turn/steer", {
+                    threadId,
+                    expectedTurnId,
+                    clientUserMessageId: envelope.messageId,
+                    input: [
+                        {
+                            type: "text",
+                            text: body
+                        }
+                    ]
+                });
+            } catch (err) {
+                throw unsupportedOrRpc(err, "turn/steer", threadId, envelope, expectedTurnId);
+            }
+            if (typeof steered?.turnId !== "string" || steered.turnId !== expectedTurnId) {
+                throw new CodexSendError("Malformed turn/steer acknowledgment", {
+                    delivery: "unknown",
+                    reason: "bad-response",
+                    threadId,
+                    turnId: expectedTurnId,
+                    ...envelope
+                });
+            }
+            return {
+                delivery: "accepted",
+                ...receiptBase,
+                turnId: steered.turnId
+            };
+        }
         if (state.busy) {
             let queued;
             try {
@@ -85825,9 +87741,11 @@ async function sendToCodexThreadInner(threadId, text, { env, envelope, whenBusy
         // that arrives before the acknowledgment supplies our turn id wait in
         // client.deferred and are adopted only on a match. Requests missing
         // thread or turn IDs remain unanswered because ownership is unknown.
-        client.expectedThreadId = threadId;
-        client.expectedTurnId = null;
-        client.answerServerRequests = true;
+        if (!session) {
+            client.expectedThreadId = threadId;
+            client.expectedTurnId = null;
+            client.answerServerRequests = true;
+        }
         let turn;
         try {
             turn = await client.request("turn/start", {
@@ -85862,7 +87780,7 @@ async function sendToCodexThreadInner(threadId, text, { env, envelope, whenBusy
                 ...envelope
             });
         }
-        client._adoptTurn(turnId);
+        if (!session) client._adoptTurn(turnId);
         const freshRefused = client.refused.slice(seenRefused).filter((r)=>{
             if (!r.answered) return false;
             const params = r.params && typeof r.params === "object" && !Array.isArray(r.params) ? r.params : null;
@@ -85891,18 +87809,22 @@ async function sendToCodexThreadInner(threadId, text, { env, envelope, whenBusy
             turnStatus: turn.turn.status
         };
     } finally{
-        client.close();
+        if (!session) client.close();
     }
 }
 
 __webpack_require__.d(__webpack_exports__, {
+  $3: () => (assertThreadAllowed),
   Bt: () => (listCodexQueue),
   MU: () => (codexStatus),
   Mr: () => (withEnvelopeHeader),
   X$: () => (listCodexThreads),
   ZS: () => (sendToCodexThread),
+  e0: () => (experimentalEnabled),
+  eC: () => (openCodexSession),
   nq: () => (buildEnvelope),
-  pF: () => (singleLine)
+  pF: () => (singleLine),
+  ql: () => (codexSocketPath)
 });
 
 
@@ -86026,6 +87948,452 @@ __webpack_require__.d(__webpack_exports__, {
 });
 
 
+},
+"./src/core/codex/conversation.js"(__unused_rspack___webpack_module__, __webpack_exports__, __webpack_require__) {
+/* import */ var _contract_js__rspack_import_0 = __webpack_require__("./src/core/codex/contract.js");
+/* import */ var node_fs__rspack_import_1 = __webpack_require__("node:fs");
+/* import */ var _codex_bridge_js__rspack_import_2 = __webpack_require__("./src/core/codex-bridge.js");
+
+
+
+const ID = /^[A-Za-z0-9_.:-]{1,128}$/;
+const BUDGET = 4 * 1024 * 1024;
+function conversationId(value, name = 'threadId') {
+    if (typeof value !== 'string' || !ID.test(value)) throw new RangeError(`${name} must be 1-128 identifier characters`);
+    return value;
+}
+function boundedInteger(value, max, name) {
+    if (!Number.isInteger(value) || value < 1 || value > max) throw new RangeError(`${name} must be an integer 1-${max}`);
+    return value;
+}
+const terminal = (status)=>[
+        'completed',
+        'failed',
+        'interrupted'
+    ].includes(status);
+const namedTurn = (p)=>p?.turnId ?? p?.turn_id ?? p?.turn?.id;
+/** Bounded traversal; a coverage failure throws and must never be interpreted as not found. */ async function visitCodexHistory(session, threadId, method, params, visit, { signal, stopped = ()=>false } = {}) {
+    if (![
+        'thread/turns/list',
+        'thread/items/list'
+    ].includes(method)) throw new RangeError('Unsupported history method');
+    conversationId(threadId);
+    const client = session.client;
+    let cursor;
+    const seen = new Set();
+    for(let page = 0; page < 20; page++){
+        if (stopped() || signal?.aborted) throw new Error('History coverage incomplete: observation cancelled');
+        const result = await client.request(method, {
+            ...params,
+            threadId,
+            limit: 100,
+            ...cursor ? {
+                cursor
+            } : {}
+        });
+        if (stopped() || signal?.aborted) throw new Error('History coverage incomplete: observation cancelled');
+        if (!Array.isArray(result?.data) || result.data.length > 100 || result.nextCursor != null && (typeof result.nextCursor !== 'string' || !result.nextCursor || result.nextCursor.length > 4096)) throw new Error(`Invalid ${method} page`);
+        if (visit(result.data)) return {
+            complete: false,
+            reason: 'matched',
+            pages: page + 1
+        };
+        if (result.nextCursor == null) return {
+            complete: true,
+            reason: 'exhausted',
+            pages: page + 1
+        };
+        if (seen.has(result.nextCursor)) throw new Error('History coverage incomplete: repeated pagination cursor');
+        seen.add(result.nextCursor);
+        cursor = result.nextCursor;
+    }
+    throw new Error('History coverage incomplete: 20 page limit');
+}
+/** A bounded observer. Cancellation ends observation, never the daemon's turn. */ async function openCodexConversation(threadId, options = {}) {
+    conversationId(threadId);
+    const { env = process.env, expectedCwd, signal, onEvent } = options;
+    (0,_codex_bridge_js__rspack_import_2/* .assertThreadAllowed */.$3)(threadId, env);
+    if (signal !== undefined && !(signal instanceof AbortSignal)) throw new TypeError('signal must be an AbortSignal');
+    if (onEvent !== undefined && typeof onEvent !== 'function') throw new TypeError('onEvent must be a function');
+    if (signal?.aborted) throw new Error('Observation cancelled');
+    const expected = expectedCwd === undefined ? undefined : (0,node_fs__rspack_import_1.realpathSync)(expectedCwd);
+    const session = options.session ?? await (0,_codex_bridge_js__rspack_import_2/* .openCodexSession */.eC)(env, {
+        signal,
+        experimental: (0,_codex_bridge_js__rspack_import_2/* .experimentalEnabled */.e0)(env)
+    });
+    const { client } = session;
+    const events = [];
+    const acceptedTurns = new Set();
+    const wake = new Set();
+    let bytes = 0, overflow = false, disconnected = client.closed, closed = false;
+    const record = (event)=>{
+        const size = Buffer.byteLength(JSON.stringify(event));
+        if (size > BUDGET) {
+            overflow = true;
+        } else {
+            while(events.length >= 500 || bytes + size > BUDGET){
+                bytes -= events.shift().bytes;
+                overflow = true;
+            }
+            events.push({
+                event,
+                bytes: size
+            });
+            bytes += size;
+        }
+        for (const listener of [
+            ...wake
+        ])listener();
+        return onEvent?.(event);
+    };
+    const observe = (kind)=>(message)=>{
+            const p = message.params;
+            if ((p?.threadId ?? p?.thread_id) !== threadId) return;
+            return record({
+                kind,
+                ...message
+            });
+        };
+    const unsubs = [
+        client.onNotification(observe('notification')),
+        client.onServerRequest(observe('interaction')),
+        client.onClose((error)=>{
+            disconnected = true;
+            return record({
+                kind: 'disconnect',
+                error: error?.message
+            });
+        })
+    ];
+    const close = async ()=>{
+        if (closed) return;
+        closed = true;
+        for (const unsubscribe of unsubs)unsubscribe();
+        for (const listener of wake)listener();
+        if (!options.session) client.close();
+    };
+    let resumed;
+    try {
+        resumed = await client.request('thread/resume', {
+            threadId,
+            excludeTurns: true
+        });
+        if (resumed?.thread?.id !== threadId) throw new Error('thread/resume returned a different thread ID');
+        const cwd = resumed.cwd ?? resumed.thread.cwd;
+        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;
+    }
+    /** @param {{turnId: string, messageId?: string, afterMessageId?: string|string[], timeoutMs?: number, signal?: AbortSignal, maxOutputBytes?: number}} options */ async function wait({ turnId, messageId, afterMessageId, timeoutMs = 120000, signal: waitSignal, maxOutputBytes = 1048576 }) {
+        conversationId(turnId, 'turnId');
+        if (messageId !== undefined) conversationId(messageId, 'messageId');
+        const anchors = afterMessageId === undefined ? [] : Array.isArray(afterMessageId) ? afterMessageId : [
+            afterMessageId
+        ];
+        if (afterMessageId !== undefined) boundedInteger(anchors.length, 200, 'afterMessageId count');
+        for (const anchor of anchors)conversationId(anchor, 'afterMessageId');
+        boundedInteger(timeoutMs, 600000, '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;
+        const items = new Map();
+        const add = (item)=>{
+            if (!item || typeof item.id !== 'string' || typeof item.type !== 'string') throw new Error('Invalid history item');
+            if (item.type !== 'agentMessage' || typeof item.text !== 'string' || item.phase !== 'final_answer' && item.phase != null) return;
+            const normalized = {
+                id: item.id,
+                type: item.type,
+                phase: item.phase ?? null,
+                text: item.text
+            };
+            const size = Buffer.byteLength(JSON.stringify(normalized));
+            const prior = items.get(item.id);
+            if (itemBytes - (prior?.bytes ?? 0) + size > BUDGET || !prior && items.size >= 2000) {
+                truncated = true;
+                return;
+            }
+            itemBytes += size - (prior?.bytes ?? 0);
+            items.set(item.id, {
+                item: normalized,
+                bytes: size
+            });
+        };
+        const scan = ()=>{
+            const interactions = new Map();
+            for (const { event } of events){
+                const p = event.params;
+                if (event.method === 'serverRequest/resolved') {
+                    interactions.delete(p.requestId);
+                    continue;
+                }
+                if (namedTurn(p) !== turnId) continue;
+                if (event.kind === 'interaction') interactions.set(event.id, event);
+                if (event.method === 'turn/started' && !terminal(status)) status = p.turn?.status;
+                if (event.method === 'item/completed' && afterMessageId === undefined) add(p.item);
+                if (event.method === 'turn/completed') {
+                    status = p.turn?.status;
+                    error = p.turn?.error;
+                    if (afterMessageId === undefined) for (const item of p.turn?.items ?? [])add(item);
+                }
+            }
+            return [
+                ...interactions.values()
+            ];
+        };
+        const result = (state, detail)=>{
+            const interactions = scan();
+            const candidates = [
+                ...items.values()
+            ].map((x)=>x.item);
+            const finals = candidates.filter((i)=>i.phase === 'final_answer');
+            // Old app-servers omit phase; use their completed agent items only at terminal status.
+            const selected = finals.length ? finals : terminal(state) ? candidates : [];
+            const reply = {
+                text: '',
+                items: [],
+                truncated: truncated || overflow
+            };
+            for (const item of selected){
+                const text = reply.text ? `${reply.text}\n${item.text}` : item.text;
+                if (Buffer.byteLength(JSON.stringify({
+                    text,
+                    items: [
+                        ...reply.items,
+                        item
+                    ]
+                })) > maxOutputBytes) {
+                    reply.truncated = true;
+                    break;
+                }
+                reply.text = text;
+                reply.items.push(item);
+            }
+            return {
+                threadId,
+                turnId,
+                ...messageId === undefined ? {} : {
+                    messageId
+                },
+                execution: {
+                    state,
+                    ...detail ? {
+                        error: detail
+                    } : {}
+                },
+                reply,
+                interactions
+            };
+        };
+        let timer, notify;
+        const abortSignals = [
+            signal,
+            waitSignal
+        ].filter(Boolean);
+        const stopped = new Promise((resolve)=>{
+            notify = ()=>{
+                if (abortSignals.some((s)=>s.aborted) || closed) resolve([
+                    'unknown',
+                    'Observation cancelled'
+                ]);
+                else if (disconnected) resolve([
+                    'disconnected',
+                    'Codex connection closed'
+                ]);
+            };
+            timer = setTimeout(()=>resolve([
+                    'timeout',
+                    'Observation deadline reached'
+                ]), timeoutMs);
+            for (const s of abortSignals)s.addEventListener('abort', notify, {
+                once: true
+            });
+            wake.add(notify);
+            notify();
+        });
+        const collect = async ()=>{
+            scan();
+            try {
+                let found = false, historyTerminal = false, anchorFound = afterMessageId === undefined;
+                const missingAnchors = new Set(anchors);
+                await visitCodexHistory(session, threadId, 'thread/turns/list', {}, (data)=>{
+                    for (const turn of data)if (!turn || typeof turn.id !== 'string' || typeof turn.status !== 'string') throw new Error('Invalid turn history');
+                    const turn = data.find((t)=>t.id === turnId);
+                    if (!turn) return false;
+                    found = true;
+                    historyTerminal = terminal(turn.status);
+                    if (!terminal(status)) {
+                        status = turn.status;
+                        error = turn.error;
+                    }
+                    return true;
+                }, {
+                    stopped: ()=>done
+                });
+                // Notifications can establish completion while the history response is in flight.
+                scan();
+                if (!found && !status) return [
+                    'unknown',
+                    'History coverage incomplete: selected turn not found'
+                ];
+                await visitCodexHistory(session, threadId, 'thread/items/list', {
+                    turnId,
+                    sortDirection: 'asc'
+                }, (data)=>{
+                    for (const row of data){
+                        if (!row || row.turnId !== turnId || !row.item) throw new Error('Invalid thread/items/list wrapper');
+                        if (row.item.type === 'userMessage' && anchors.includes(row.item.clientId)) {
+                            anchorFound = true;
+                            missingAnchors.delete(row.item.clientId);
+                        }
+                        if (anchorFound) add(row.item);
+                    }
+                    return false;
+                }, {
+                    stopped: ()=>done
+                });
+                if (!anchorFound || missingAnchors.size) {
+                    items.clear();
+                    return [
+                        'unknown',
+                        'History coverage incomplete: reply anchor not found'
+                    ];
+                }
+                if (afterMessageId !== undefined && !historyTerminal) return scan().length ? [
+                    'waiting-for-input'
+                ] : [
+                    'unknown',
+                    'Anchored reply awaits terminal history'
+                ];
+            } catch (err) {
+                historyError = err.message;
+                truncated = true;
+            }
+            if (afterMessageId !== undefined && historyError) {
+                items.clear();
+                return [
+                    'unknown',
+                    historyError
+                ];
+            }
+            while(!done){
+                const interactions = scan();
+                if (terminal(status)) return [
+                    status,
+                    error ?? historyError
+                ];
+                if (historyError || overflow) return [
+                    'unknown',
+                    historyError ?? 'Notification coverage overflow'
+                ];
+                if (interactions.length) return [
+                    'waiting-for-input'
+                ];
+                await new Promise((resolve)=>{
+                    const listener = ()=>{
+                        wake.delete(listener);
+                        resolve();
+                    };
+                    wake.add(listener);
+                });
+            }
+            return [
+                'unknown',
+                'Observation ended'
+            ];
+        };
+        try {
+            const [state, detail] = await Promise.race([
+                stopped,
+                collect()
+            ]);
+            return result(state, detail);
+        } finally{
+            done = true;
+            clearTimeout(timer);
+            wake.delete(notify);
+            for (const s of abortSignals)s.removeEventListener('abort', notify);
+            for (const listener of [
+                ...wake
+            ])listener();
+        }
+    }
+    /** @param {{timeoutMs?: number, maxEvents?: number, signal?: AbortSignal}} [options] */ async function watch({ timeoutMs = 30000, maxEvents = 100, signal: watchSignal } = {}) {
+        boundedInteger(timeoutMs, 600000, 'timeoutMs');
+        boundedInteger(maxEvents, 500, 'maxEvents');
+        if (watchSignal !== undefined && !(watchSignal instanceof AbortSignal)) throw new TypeError('signal must be an AbortSignal');
+        const signals = [
+            signal,
+            watchSignal
+        ].filter(Boolean);
+        let timer, listener;
+        const reason = await new Promise((resolve)=>{
+            listener = ()=>{
+                if (signals.some((s)=>s.aborted) || closed) resolve('cancelled');
+                else if (disconnected) resolve('disconnected');
+                else if (events.length >= maxEvents) resolve('event-limit');
+            };
+            timer = setTimeout(()=>resolve('timeout'), timeoutMs);
+            wake.add(listener);
+            for (const s of signals)s.addEventListener('abort', listener, {
+                once: true
+            });
+            listener();
+        });
+        clearTimeout(timer);
+        wake.delete(listener);
+        for (const s of signals)s.removeEventListener('abort', listener);
+        return {
+            threadId,
+            events: events.slice(0, maxEvents).map((x)=>x.event),
+            reason,
+            truncated: overflow || events.length > maxEvents
+        };
+    }
+    return {
+        threadId,
+        cwd: resumed.cwd ?? resumed.thread.cwd,
+        wait,
+        watch,
+        close,
+        /** @param {string} text
+     * @param {{envelope?: object, whenBusy?: string, expectedTurnId?: string, signal?: AbortSignal}} [options] */ async send (text, { envelope = (0,_codex_bridge_js__rspack_import_2/* .buildEnvelope */.nq)({
+            env
+        }), whenBusy = 'reject', expectedTurnId, signal: sendSignal } = {}) {
+            if (closed) return (0,_contract_js__rspack_import_0/* .outcomeFromError */.DG)(Object.assign(new Error('Conversation closed'), {
+                delivery: 'rejected',
+                reason: 'closed',
+                threadId,
+                envelope
+            }));
+            if (sendSignal !== undefined && !(sendSignal instanceof AbortSignal)) throw new TypeError('signal must be an AbortSignal');
+            const submissionSignal = signal && sendSignal ? AbortSignal.any([
+                signal,
+                sendSignal
+            ]) : sendSignal ?? signal;
+            const receipt = await (0,_codex_bridge_js__rspack_import_2/* .sendToCodexThread */.ZS)(threadId, text, {
+                env,
+                envelope,
+                whenBusy,
+                expectedTurnId,
+                session,
+                expectedCwd,
+                signal: submissionSignal
+            });
+            if (receipt.delivery === 'accepted' && receipt.turnId) {
+                acceptedTurns.add(receipt.turnId);
+                if (acceptedTurns.size > 100) acceptedTurns.delete(acceptedTurns.values().next().value);
+            }
+            return receipt;
+        }
+    };
+}
+
+__webpack_require__.d(__webpack_exports__, {
+  j: () => (openCodexConversation)
+});
+
+
 },
 "./src/core/commands.js"(__unused_rspack___webpack_module__, __webpack_exports__, __webpack_require__) {
 /* import */ var _store_js__rspack_import_0 = __webpack_require__("./src/core/store.js");
@@ -86057,7 +88425,7 @@ async function openBackend(opts) {
             setGroupMembers: (group, members)=>_gateway_js__rspack_import_1/* .setGroupMembers */.Td(session, group, members),
             addGroupMember: (group, bot)=>_gateway_js__rspack_import_1/* .addGroupMember */.zr(session, group, bot),
             removeGroupMember: (group, bot)=>_gateway_js__rspack_import_1/* .removeGroupMember */.A0(session, group, bot),
-            send: (ref, prompt)=>_gateway_js__rspack_import_1/* .sendPrompt */.LV(session, ref, prompt),
+            send: (ref, prompt, extra)=>_gateway_js__rspack_import_1/* .sendPrompt */.LV(session, ref, prompt, extra),
             transcript: (ref, limit)=>_gateway_js__rspack_import_1/* .getTranscriptTail */.bA(session, ref, limit),
             thread: (ref, rootId)=>_gateway_js__rspack_import_1/* .getThread */.fG(session, ref, rootId)
         };
@@ -86788,6 +89156,21 @@ class GatewayError extends Error {
 // ponytail: fixed 30 s deadline and buffered byte cap; upgrade path is per-method budgets plus streaming reads.
 const GATEWAY_TIMEOUT_MS = 30000;
 const GATEWAY_MAX_RESPONSE_BYTES = 2 * 1024 * 1024;
+function assertGatewayActive(signal) {
+    if (signal?.aborted) {
+        const error = new GatewayError("Gateway submission cancelled before transmission");
+        error.delivery = "rejected";
+        error.reason = "cancelled";
+        throw error;
+    }
+}
+function gatewayDeadline(signal) {
+    const timeout = AbortSignal.timeout(GATEWAY_TIMEOUT_MS);
+    return signal ? AbortSignal.any([
+        signal,
+        timeout
+    ]) : timeout;
+}
 function backendBase() {
     return (process.env.CURSOR_API_BASE_URL || "https://api2.cursor.sh").replace(/\/$/, "");
 }
@@ -86876,18 +89259,26 @@ function pick(obj, ...keys) {
     }
     return undefined;
 }
-async function ensureSandbox(accessToken) {
+async function ensureSandbox(accessToken, { signal } = {}) {
+    assertGatewayActive(signal);
     const url = (0,_url_policy_js__rspack_import_3/* .assertAllowedCredentialUrl */.Re)(backendBase(), {
         kind: "backend"
     }) + "/aiserver.v1.GrokBotService/EnsureSandBox";
-    const res = await fetch(url, {
-        method: "POST",
-        redirect: "error",
-        signal: AbortSignal.timeout(GATEWAY_TIMEOUT_MS),
-        headers: (0,_headers_js__rspack_import_4/* .ensureSandboxHeaders */._6)(accessToken),
-        body: "{}"
-    });
-    const body = await readJson(res);
+    let res, body;
+    try {
+        res = await fetch(url, {
+            method: "POST",
+            redirect: "error",
+            signal: gatewayDeadline(signal),
+            headers: (0,_headers_js__rspack_import_4/* .ensureSandboxHeaders */._6)(accessToken),
+            body: "{}"
+        });
+        body = await readJson(res);
+    } catch (error) {
+        assertGatewayActive(signal);
+        throw error;
+    }
+    assertGatewayActive(signal);
     if (!res.ok) {
         const detail = body.message || body.error || body.raw || res.statusText;
         throw new GatewayError("EnsureSandBox failed: " + res.status + " " + (0,_url_policy_js__rspack_import_3/* .redactSecrets */.fp)(detail), {
@@ -86908,7 +89299,8 @@ async function ensureSandbox(accessToken) {
         gatewayHeaders: (0,_headers_js__rspack_import_4/* .mergeGatewayHeaders */.bQ)((0,_headers_js__rspack_import_4/* .headersFromEnsureSandbox */.Ew)(body), (0,_headers_js__rspack_import_4/* .headersFromEnv */.gx)())
     };
 }
-async function connectGateway() {
+async function connectGateway({ signal } = {}) {
+    assertGatewayActive(signal);
     const override = gatewayOverride();
     if (override) return override;
     const fromApp = sessionFromApp();
@@ -86917,21 +89309,36 @@ async function connectGateway() {
     if (!token) {
         throw new GatewayError("Set CURSOR_ACCESS_TOKEN, or GROK_BOT_GATEWAY_URL + GROK_BOT_GATEWAY_TOKEN. Do not use a Cursor dashboard API key.");
     }
-    return ensureSandbox(token);
+    return ensureSandbox(token, {
+        signal
+    });
 }
-async function gatewayCall(session, method, body = {}) {
+async function gatewayCall(session, method, body = {}, { signal } = {}) {
+    assertGatewayActive(signal);
     const base = (0,_url_policy_js__rspack_import_3/* .assertAllowedCredentialUrl */.Re)(session.gatewayUrl, {
         kind: "gateway"
     });
     const url = base + "/api/" + method;
-    const res = await fetch(url, {
+    // Cancellation can abort read/auth preflights. Once a prompt request starts,
+    // observe its actual receipt (or timeout) instead of losing certainty on stop.
+    const prompt = method === "sendPrompt";
+    const options = {
         method: "POST",
         redirect: "error",
-        signal: AbortSignal.timeout(GATEWAY_TIMEOUT_MS),
+        signal: gatewayDeadline(prompt ? undefined : signal),
         headers: (0,_headers_js__rspack_import_4/* .requestHeaders */.A1)(session),
         body: JSON.stringify(body)
-    });
-    const data = await readJson(res);
+    };
+    assertGatewayActive(signal); // Final synchronous boundary before transmission.
+    let res, data;
+    try {
+        res = await fetch(url, options);
+        data = await readJson(res);
+    } catch (error) {
+        if (!prompt) assertGatewayActive(signal);
+        throw error;
+    }
+    if (!prompt) assertGatewayActive(signal);
     if (!res.ok) {
         const detail = data.message || data.error || data.raw || res.statusText;
         throw new GatewayError(method + " failed: " + res.status + " " + (0,_url_policy_js__rspack_import_3/* .redactSecrets */.fp)(String(detail).slice(0, 300)), {
@@ -86983,8 +89390,10 @@ function unwrapList(data) {
 function unwrapOne(data) {
     return asRecord(data.agent || data);
 }
-async function listAgents(session) {
-    const data = await gatewayCall(session, "listAgents", {});
+async function listAgents(session, { signal } = {}) {
+    const data = await gatewayCall(session, "listAgents", {}, {
+        signal
+    });
     return unwrapList(data).map(asRecord).filter((r)=>r && r.id);
 }
 function resolveFromList(records, ref) {
@@ -86996,8 +89405,10 @@ function resolveFromList(records, ref) {
     if (matches.length === 0) throw new GatewayError("No bot or group named \"" + ref + "\"");
     throw new GatewayError("Ambiguous name \"" + ref + "\"");
 }
-async function resolveRef(session, ref) {
-    return resolveFromList(await listAgents(session), ref);
+async function resolveRef(session, ref, { signal } = {}) {
+    return resolveFromList(await listAgents(session, {
+        signal
+    }), ref);
 }
 async function createAgent(session, input) {
     const data = await gatewayCall(session, "createAgent", {
@@ -87119,16 +89530,22 @@ async function removeGroupMember(session, groupRef, memberRef) {
     const next = group.memberIds.filter((id)=>id !== member.id);
     return setGroupMembers(session, group.id, next);
 }
-async function sendPrompt(session, ref, prompt) {
-    const rec = await resolveRef(session, ref);
+async function sendPrompt(session, ref, prompt, extra = {}) {
+    assertGatewayActive(extra.signal);
+    const rec = await resolveRef(session, ref, {
+        signal: extra.signal
+    });
     const body = {
         agentId: rec.id,
         prompt,
-        clientNonce: (0,node_crypto__rspack_import_0.randomUUID)()
+        clientNonce: extra.clientNonce || (0,node_crypto__rspack_import_0.randomUUID)()
     };
+    if (extra.replyToId) body.replyToId = extra.replyToId;
     let data;
     try {
-        data = await gatewayCall(session, "sendPrompt", body);
+        data = await gatewayCall(session, "sendPrompt", body, {
+            signal: extra.signal
+        });
     } catch (err) {
         // Delivery states: the server answered no (rejected) vs the request may have landed (unknown).
         // Never retry an unknown delivery blindly; read the thread first.
@@ -87380,6 +89797,269 @@ __webpack_require__.d(__webpack_exports__, {
 });
 
 
+},
+"./src/core/relay/control.js"(__unused_rspack___webpack_module__, __webpack_exports__, __webpack_require__) {
+/* import */ var node_string_decoder__rspack_import_0 = __webpack_require__("node:string_decoder");
+/* import */ var node_net__rspack_import_1 = __webpack_require__("node:net");
+/* import */ var node_crypto__rspack_import_2 = __webpack_require__("node:crypto");
+/* import */ var _profile_js__rspack_import_3 = __webpack_require__("./src/core/relay/profile.js");
+
+
+
+
+const RELAY_PROTOCOL = 1;
+const CONTROL_BYTES = 1024 * 1024;
+const CONTROL_TIMEOUT = 45000;
+function relayRequest(options, method, input = {}, { timeoutMs = CONTROL_TIMEOUT, signal, requestId = (0,node_crypto__rspack_import_2.randomUUID)() } = {}) {
+    const { socketPath, profile } = (0,_profile_js__rspack_import_3/* .relayLocation */.hQ)(options);
+    return new Promise((resolve, reject)=>{
+        const decoder = new node_string_decoder__rspack_import_0.StringDecoder("utf8");
+        let buffer = "", bytes = 0, settled = false, connected = false;
+        const socket = (0,node_net__rspack_import_1.connect)(socketPath);
+        const finish = (error, value)=>{
+            if (settled) return;
+            settled = true;
+            clearTimeout(timer);
+            signal?.removeEventListener("abort", abort);
+            socket.destroy();
+            error ? reject(error) : resolve(value);
+        };
+        const uncertain = ()=>Object.assign(Error(`Relay control connection lost; do not resend with a new requestId (${requestId}). Check bridge status.`), {
+                requestId
+            });
+        const abort = ()=>finish(uncertain());
+        const timer = setTimeout(abort, timeoutMs);
+        signal?.addEventListener("abort", abort, {
+            once: true
+        });
+        if (signal?.aborted) return abort();
+        socket.on("error", (error)=>finish(connected ? uncertain() : error));
+        socket.on("close", ()=>finish(uncertain()));
+        socket.on("connect", ()=>{
+            connected = true;
+            const line = JSON.stringify({
+                version: RELAY_PROTOCOL,
+                profile,
+                requestId,
+                method,
+                input
+            }) + "\n";
+            if (Buffer.byteLength(line) > CONTROL_BYTES) return finish(Error("Relay control request exceeds budget"));
+            socket.write(line);
+        });
+        socket.on("data", (chunk)=>{
+            bytes += chunk.length;
+            if (bytes > CONTROL_BYTES) return finish(Error("Relay control response exceeds budget"));
+            buffer += decoder.write(chunk);
+            const end = buffer.indexOf("\n");
+            if (end < 0) return;
+            try {
+                const reply = JSON.parse(buffer.slice(0, end));
+                if (reply.version !== RELAY_PROTOCOL || reply.requestId !== requestId) throw Error("Relay protocol identity mismatch");
+                if (reply.error) throw Error(reply.error);
+                if (reply.profile !== profile) throw Error("Relay profile mismatch");
+                finish(null, reply.result);
+            } catch (error) {
+                finish(error);
+            }
+        });
+    });
+}
+
+__webpack_require__.d(__webpack_exports__, {
+  lJ: () => (relayRequest)
+});
+
+
+},
+"./src/core/relay/managed.js"(__unused_rspack___webpack_module__, __webpack_exports__, __webpack_require__) {
+/* import */ var node_child_process__rspack_import_0 = __webpack_require__("node:child_process");
+/* import */ var node_fs_promises__rspack_import_1 = __webpack_require__("node:fs/promises");
+/* import */ var node_path__rspack_import_2 = __webpack_require__("node:path");
+/* import */ var node_url__rspack_import_3 = __webpack_require__("node:url");
+/* import */ var node_crypto__rspack_import_4 = __webpack_require__("node:crypto");
+/* import */ var _profile_js__rspack_import_5 = __webpack_require__("./src/core/relay/profile.js");
+/* import */ var _control_js__rspack_import_6 = __webpack_require__("./src/core/relay/control.js");
+
+
+
+
+
+
+
+/** @param {{pluginRoot?: string, moduleUrl?: string}} options */ async function resolveRelayWorker({ pluginRoot, moduleUrl = import.meta.url } = {}) {
+    const roots = [];
+    if (pluginRoot) roots.push(pluginRoot);
+    let path = (0,node_path__rspack_import_2.dirname)((0,node_url__rspack_import_3.fileURLToPath)(moduleUrl));
+    for(let i = 0; i < 5; i++){
+        roots.push(path);
+        path = (0,node_path__rspack_import_2.dirname)(path);
+    }
+    for (const candidate of new Set(roots)){
+        let manifest;
+        try {
+            manifest = JSON.parse(await (0,node_fs_promises__rspack_import_1.readFile)((0,node_path__rspack_import_2.join)(candidate, "agent-bundle.manifest.json"), "utf8"));
+        } catch (error) {
+            if (error.code === "ENOENT") continue;
+            throw error;
+        }
+        const relative = "scripts/gbot-relay.mjs";
+        const file = manifest.files?.find((f)=>f.path === relative);
+        if (manifest.application?.name !== "gbot" || !file || !manifest.executables?.scripts?.some((s)=>s.path === relative)) continue;
+        const root = await (0,node_fs_promises__rspack_import_1.realpath)(candidate), worker = (0,node_path__rspack_import_2.join)(root, relative), stat = await (0,node_fs_promises__rspack_import_1.lstat)(worker);
+        if (!stat.isFile() || stat.isSymbolicLink() || await (0,node_fs_promises__rspack_import_1.realpath)(worker) !== worker) throw Error("Relay worker must be a regular packaged script");
+        if (stat.size !== file.bytes || (0,_profile_js__rspack_import_5/* .digest */.br)(await (0,node_fs_promises__rspack_import_1.readFile)(worker)) !== file.sha256) throw Error("Packaged relay worker checksum mismatch");
+        return worker;
+    }
+    throw Error("Packaged relay worker not found; rebuild or reinstall the plugin");
+}
+const unavailable = (error)=>[
+        "ENOENT",
+        "ECONNREFUSED"
+    ].includes(error.code);
+async function ensureRelayWorker(options = {}) {
+    const location = (0,_profile_js__rspack_import_5/* .relayLocation */.hQ)(options);
+    try {
+        return await (0,_control_js__rspack_import_6/* .relayRequest */.lJ)(location, "hello", {}, {
+            timeoutMs: 1500
+        });
+    } catch (error) {
+        if (!unavailable(error)) throw error;
+    }
+    const workerPath = await resolveRelayWorker(options);
+    const child = (0,node_child_process__rspack_import_0.spawn)(process.execPath, [
+        workerPath
+    ], {
+        detached: true,
+        stdio: "ignore",
+        env: {
+            ...location.env,
+            GROK_BOT_RELAY_DIR: location.stateDir
+        },
+        cwd: (0,node_path__rspack_import_2.dirname)(workerPath)
+    });
+    let spawnError;
+    child.on("error", (error)=>{
+        spawnError = error;
+    });
+    child.unref();
+    const end = Date.now() + 10000;
+    while(Date.now() < end){
+        if (spawnError) throw spawnError;
+        if (options.signal?.aborted) throw Error("Relay startup cancelled before submission");
+        try {
+            return await (0,_control_js__rspack_import_6/* .relayRequest */.lJ)(location, "hello", {}, {
+                timeoutMs: 1000,
+                signal: options.signal
+            });
+        } catch (error) {
+            if (!unavailable(error)) throw error;
+        }
+        await new Promise((resolve)=>setTimeout(resolve, 75));
+    }
+    throw Error("Relay worker startup failed or timed out; no untracked send was attempted. Inspect bridge status and the relay owner lock.");
+}
+async function managedOperation(method, input, options = {}) {
+    const location = (0,_profile_js__rspack_import_5/* .relayLocation */.hQ)(options);
+    const requestId = input.requestId ?? (0,node_crypto__rspack_import_4.randomUUID)();
+    if (![
+        "status",
+        "stop",
+        "respond"
+    ].includes(method)) await ensureRelayWorker(options);
+    try {
+        return await (0,_control_js__rspack_import_6/* .relayRequest */.lJ)(location, method, input, {
+            signal: options.signal,
+            requestId
+        });
+    } catch (error) {
+        if (method === "status" && unavailable(error)) return {
+            worker: {
+                state: "stopped",
+                profile: location.profile,
+                supervised: false
+            },
+            reason: "Worker is not running. Start a route or tracked send to resume saved routes."
+        };
+        // Never retry a disconnected mutation. Its durable request ID is the recovery handle.
+        throw error;
+    }
+}
+
+__webpack_require__.d(__webpack_exports__, {
+  Bb: () => (managedOperation),
+  _v: () => (resolveRelayWorker)
+});
+
+
+},
+"./src/core/relay/profile.js"(__unused_rspack___webpack_module__, __webpack_exports__, __webpack_require__) {
+/* import */ var node_crypto__rspack_import_0 = __webpack_require__("node:crypto");
+/* import */ var node_os__rspack_import_1 = __webpack_require__("node:os");
+/* import */ var node_path__rspack_import_2 = __webpack_require__("node:path");
+/* import */ var _codex_bridge_js__rspack_import_3 = __webpack_require__("./src/core/codex-bridge.js");
+/* import */ var _app_session_js__rspack_import_4 = __webpack_require__("./src/core/app-session.js");
+
+
+
+
+
+const digest = (value)=>(0,node_crypto__rspack_import_0.createHash)("sha256").update(value).digest("hex");
+// Only explicit overrides are hashed. App-session token refresh retains its source identity.
+function relayProfile(env = process.env) {
+    const keys = [
+        "GROK_BOT_GATEWAY_URL",
+        "SAND_HOST_GATEWAY_URL",
+        "SAND_HOST_PORT",
+        "GROK_BOT_GATEWAY_TOKEN",
+        "SAND_HOST_GATEWAY_TOKEN",
+        "SAND_GATEWAY_TOKEN",
+        "CURSOR_ACCESS_TOKEN",
+        "GROK_BOT_ACCESS_TOKEN",
+        "SAND_ACCESS_TOKEN",
+        "GROK_BOT_GATEWAY_HEADERS",
+        "SAND_BACKEND_URL",
+        "CURSOR_API_BASE_URL",
+        "SAND_BOX_NAMESPACE",
+        "SAND_CLIENT_VERSION",
+        "GROK_BOT_CODEX_THREADS",
+        "GROK_BOT_MAX_HOPS",
+        "GROK_BOT_CODEX_EXPERIMENTAL",
+        "GROK_BOT_ALLOW_LOCAL_GATEWAY",
+        "GROK_BOT_ALLOW_ANY_GATEWAY",
+        "GROK_BOT_TEST",
+        "NODE_ENV"
+    ];
+    return digest(JSON.stringify([
+        (0,node_path__rspack_import_2.resolve)((0,_codex_bridge_js__rspack_import_3/* .codexSocketPath */.ql)(env)),
+        (0,_app_session_js__rspack_import_4/* .grokBotGatewayDescriptorPath */.dQ)((0,node_os__rspack_import_1.homedir)(), process.platform, env),
+        ...keys.map((key)=>[
+                key,
+                env[key] ?? ""
+            ])
+    ]));
+}
+function relayLocation({ env = process.env, stateDir, profile = relayProfile(env) } = {}) {
+    if (process.platform === "win32") throw Error("Codex relay requires Unix-domain sockets; Windows is unsupported.");
+    const dir = (0,node_path__rspack_import_2.resolve)(stateDir ?? env.GROK_BOT_RELAY_DIR ?? (0,node_path__rspack_import_2.join)((0,node_os__rspack_import_1.homedir)(), ".grok-bot-cli", "relay", profile.slice(0, 24)));
+    // macOS Unix sockets cannot use arbitrarily long installation/state paths.
+    const socketDir = Buffer.byteLength((0,node_path__rspack_import_2.join)(dir, "control.sock")) < 100 ? dir : (0,node_path__rspack_import_2.join)("/tmp", `gbot-relay-${process.getuid()}`, digest(dir).slice(0, 24));
+    return {
+        stateDir: dir,
+        profile,
+        env,
+        socketDir,
+        socketPath: (0,node_path__rspack_import_2.join)(socketDir, "control.sock")
+    };
+}
+
+__webpack_require__.d(__webpack_exports__, {
+  hQ: () => (relayLocation)
+}, {
+  br: digest
+});
+
+
 },
 "./src/core/store.js"(__unused_rspack___webpack_module__, __webpack_exports__, __webpack_require__) {
 /* import */ var node_crypto__rspack_import_0 = __webpack_require__("node:crypto");
@@ -87944,6 +90624,10 @@ __webpack_require__.d(__webpack_exports__, {
 });
 
 
+},
+"./package.json"(module) {
+module.exports = {"rE":"0.6.0"}
+
 },
 
 });