grok-bot-cli 0.4.5 → 0.6.0

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

@@ -4,9 +4,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_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_process_ee535471 from "node:process";
+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";
@@ -10983,6 +10985,412 @@ if (process.env.NODE_ENV === 'production') {
 }
 
 
+},
+"./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 (0,_codex_bridge_js__rspack_import_0/* .listCodexThreads */.X$)(input),
+            exitCode: 0
+        };
+    } catch (error) {
+        return (0,_contract_js__rspack_import_1/* .outcomeFromError */.DG)(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__, {
+  $c: () => (threadsOperation),
+  D6: () => (resultText),
+  UP: () => (sendOperation),
+  gT: () => (observeOperation)
+}, {
+  FD: resultSchema,
+  P3: threadsSchema,
+  R9: watchSchema,
+  Wi: sendSchema,
+  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__, {
+  bv: () => (grokSendOperation),
+  lt: () => (codexReturnOperation),
+  n1: () => (bridgeOperation)
+}, {
+  Ax: relayResultSchema,
+  bw: grokSendSchema,
+  d5: bridgeStopSchema,
+  np: bridgeStatusSchema,
+  v1: respondSchema,
+  xD: bridgeStartSchema
+});
+
+
 },
 "./src/gbot.ts"(__unused_rspack_module, __webpack_exports__, __webpack_require__) {
 /* import */ var zod__rspack_import_3 = __webpack_require__("./node_modules/zod/v4/classic/schemas.js");
@@ -10996,7 +11404,7 @@ if (process.env.NODE_ENV === 'production') {
 
 // Hosts and the CLI print thrown error text (and stack), and a fetch or proxy failure can echo
 // a credential. Rewrap with a redacted message; keep `name` and own fields such as `reason`,
-// `delivery`, `mode`, and `envelope` so outcome documents still classify the failure.
+// `delivery`, `mode`, and correlation ids so outcome documents still classify the failure.
 const withRedactedErrors = async (run)=>{
     try {
         return await run();
@@ -11095,40 +11503,645 @@ __webpack_require__.d(__webpack_exports__, {
 }, {
   Oo: entrySchema,
   rW: summarizeTarget,
-  tX: targetSchema,
   xw: transcriptEntries,
   yF: withRedactedErrors
 });
 
 
 },
-"./src/mcp/grok-bot/tools/gbot_send.tsx"(__unused_rspack_module, __webpack_exports__, __webpack_require__) {
+"./src/mcp/grok-bot/tools/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_5 = __webpack_require__("./node_modules/@agent-bundle/runtime/dist/736.js");
+/* import */ var _agent_bundle_runtime__rspack_import_6 = __webpack_require__("./node_modules/@agent-bundle/runtime/dist/506.js");
+/* import */ var agent_bundle_routes__rspack_import_1 = __webpack_require__("./node_modules/agent-bundle/dist/routes.js");
+/* import */ var _core_codex_routes_js__rspack_import_2 = __webpack_require__("./src/core/codex/routes.ts");
+/* import */ var zod__rspack_import_4 = __webpack_require__("./node_modules/zod/v4/classic/schemas.js");
+/* import */ var _core_relay_routes_js__rspack_import_3 = __webpack_require__("./src/core/relay/routes.ts");
+
+
+
+
+
+
+const inputSchema = _core_codex_routes_js__rspack_import_2/* .sendSchema.extend */.Wi.extend({
+    whenBusy: zod__rspack_import_4/* ["enum"] */.k5n([
+        'reject',
+        'queue',
+        'steer'
+    ]).optional(),
+    replyToGrok: zod__rspack_import_4/* .string */.YjP().min(1).optional(),
+    bindingId: zod__rspack_import_4/* .string */.YjP().min(1).optional(),
+    requestId: zod__rspack_import_4/* .string */.YjP().min(1).max(128).optional()
+});
+const resultSchema = zod__rspack_import_4/* .union */.KCZ([
+    _core_codex_routes_js__rspack_import_2/* .resultSchema */.FD,
+    _core_relay_routes_js__rspack_import_3/* .relayResultSchema */.Ax
+]);
+/* export default */ const __rspack_default_export = ((0,agent_bundle_routes__rspack_import_1/* .defineTool */.uO)({
+    description: 'Send to Codex. With replyToGrok or bindingId, managed delivery returns the terminal answer to Grok automatically. Otherwise optional wait observes completion and explicit steer requires expectedTurnId. Acceptance is not completion.',
+    title: 'Codex send',
+    annotations: {
+        readOnlyHint: false
+    },
+    render: {
+        maxElapsedMs: 660000
+    },
+    inputSchema,
+    resultSchema,
+    inputJsonSchema: {
+        type: 'object',
+        properties: {
+            expectedCwd: {
+                type: 'string'
+            },
+            threadId: {
+                type: 'string'
+            },
+            timeoutMs: {
+                type: 'number'
+            },
+            correlationId: {
+                type: 'string'
+            },
+            envelope: {
+                type: 'boolean'
+            },
+            hop: {
+                type: 'number'
+            },
+            replyTo: {
+                type: 'string'
+            },
+            expectedTurnId: {
+                type: 'string'
+            },
+            whenBusy: {
+                type: 'string',
+                enum: [
+                    'reject',
+                    'queue',
+                    'steer'
+                ]
+            },
+            wait: {
+                default: false,
+                type: 'boolean'
+            },
+            maxOutputBytes: {
+                type: 'number'
+            },
+            message: {
+                type: 'string'
+            },
+            replyToGrok: {
+                type: 'string'
+            },
+            bindingId: {
+                type: 'string'
+            },
+            requestId: {
+                type: 'string'
+            }
+        },
+        required: [
+            'threadId',
+            'message'
+        ],
+        additionalProperties: false
+    }
+}, async (input)=>{
+    const context = await (0,_agent_bundle_runtime__rspack_import_5/* .agent */.MA)();
+    if (input.replyToGrok || input.bindingId) {
+        const out = await (0,_core_relay_routes_js__rspack_import_3/* .codexReturnOperation */.lt)(input, context);
+        return /*#__PURE__*/ (0,react_jsx_runtime__rspack_import_0.jsx)(_agent_bundle_runtime__rspack_import_6/* .Agent.Result */.g6.Result, {
+            value: out,
+            children: /*#__PURE__*/ (0,react_jsx_runtime__rspack_import_0.jsx)(_agent_bundle_runtime__rspack_import_6/* .Agent.Text */.g6.Text, {
+                children: `Delivery ${out.delivery}; terminal answer returns to Grok automatically.`
+            })
+        });
+    }
+    const out = await (0,_core_codex_routes_js__rspack_import_2/* .sendOperation */.UP)({
+        ...input,
+        whenBusy: input.whenBusy ?? 'reject'
+    }, context.signal, (message)=>context.progress.report({
+            message
+        }));
+    return /*#__PURE__*/ (0,react_jsx_runtime__rspack_import_0.jsx)(_agent_bundle_runtime__rspack_import_6/* .Agent.Result */.g6.Result, {
+        value: out,
+        children: /*#__PURE__*/ (0,react_jsx_runtime__rspack_import_0.jsx)(_agent_bundle_runtime__rspack_import_6/* .Agent.Text */.g6.Text, {
+            children: (0,_core_codex_routes_js__rspack_import_2/* .resultText */.D6)(out)
+        })
+    });
+}));
+
+__webpack_require__.d(__webpack_exports__, {
+}, {
+  "default": __rspack_default_export,
+  inputSchema: inputSchema
+});
+
+
+},
+"./src/mcp/grok-bot/tools/codex_threads.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 agent_bundle_routes__rspack_import_1 = __webpack_require__("./node_modules/agent-bundle/dist/routes.js");
-/* import */ var zod__rspack_import_3 = __webpack_require__("./node_modules/zod/v4/classic/schemas.js");
-/* import */ var _gbot_js__rspack_import_2 = __webpack_require__("./src/gbot.ts");
+/* import */ var _core_codex_routes_js__rspack_import_2 = __webpack_require__("./src/core/codex/routes.ts");
 
 
 
 
 
-const inputSchema = zod__rspack_import_3/* .object */.Ikc({
-    message: zod__rspack_import_3/* .string */.YjP().min(1),
-    target: zod__rspack_import_3/* .string */.YjP().min(1)
+/* export default */ const __rspack_default_export = ((0,agent_bundle_routes__rspack_import_1/* .defineTool */.uO)({
+    description: 'Discover a bounded page of Codex daemon threads.',
+    title: 'Codex threads',
+    annotations: {
+        readOnlyHint: true
+    },
+    render: {
+        maxElapsedMs: 660000
+    },
+    inputSchema: _core_codex_routes_js__rspack_import_2/* .threadsSchema */.P3,
+    resultSchema: _core_codex_routes_js__rspack_import_2/* .resultSchema */.FD,
+    inputJsonSchema: {
+        type: 'object',
+        additionalProperties: false,
+        properties: {
+            "limit": {
+                "type": "number",
+                "description": "Maximum threads in this page: 1-200."
+            },
+            "cursor": {
+                "type": "string"
+            }
+        },
+        required: []
+    }
+}, async (input)=>{
+    const context = await (0,_agent_bundle_runtime__rspack_import_3/* .agent */.MA)();
+    const out = await (0,_core_codex_routes_js__rspack_import_2/* .threadsOperation */.$c)(input);
+    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: (0,_core_codex_routes_js__rspack_import_2/* .resultText */.D6)(out)
+        })
+    });
+}));
+
+__webpack_require__.d(__webpack_exports__, {
+  inputSchema: () => (/* reexport safe */ _core_codex_routes_js__rspack_import_2.P3)
+}, {
+  "default": __rspack_default_export
 });
+
+
+},
+"./src/mcp/grok-bot/tools/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_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 agent_bundle_routes__rspack_import_1 = __webpack_require__("./node_modules/agent-bundle/dist/routes.js");
+/* import */ var _core_codex_routes_js__rspack_import_2 = __webpack_require__("./src/core/codex/routes.ts");
+
+
+
+
+
 /* export default */ const __rspack_default_export = ((0,agent_bundle_routes__rspack_import_1/* .defineTool */.uO)({
-    description: 'Send a message to a Grok Bot bot or group by name or id, like `gbot send`. The bot answers asynchronously; read its reply later with gbot_thread.',
+    description: 'Explicit diagnostic observation of one Codex turn; returns execution and final reply without interrupting it.',
+    title: 'Codex wait',
+    annotations: {
+        readOnlyHint: true
+    },
+    render: {
+        maxElapsedMs: 660000
+    },
+    inputSchema: _core_codex_routes_js__rspack_import_2/* .waitSchema */.jS,
+    resultSchema: _core_codex_routes_js__rspack_import_2/* .resultSchema */.FD,
     inputJsonSchema: {
+        type: 'object',
         additionalProperties: false,
         properties: {
-            message: {
-                description: 'Message text. Say who you are and what you need in the first line.',
+            "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 (input)=>{
+    const context = await (0,_agent_bundle_runtime__rspack_import_3/* .agent */.MA)();
+    const out = await (0,_core_codex_routes_js__rspack_import_2/* .observeOperation */.gT)('wait', input, context.signal, (message)=>context.progress.report({
+            message
+        }));
+    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: (0,_core_codex_routes_js__rspack_import_2/* .resultText */.D6)(out)
+        })
+    });
+}));
+
+__webpack_require__.d(__webpack_exports__, {
+  inputSchema: () => (/* reexport safe */ _core_codex_routes_js__rspack_import_2.jS)
+}, {
+  "default": __rspack_default_export
+});
+
+
+},
+"./src/mcp/grok-bot/tools/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_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 agent_bundle_routes__rspack_import_1 = __webpack_require__("./node_modules/agent-bundle/dist/routes.js");
+/* import */ var _core_codex_routes_js__rspack_import_2 = __webpack_require__("./src/core/codex/routes.ts");
+
+
+
+
+
+/* export default */ const __rspack_default_export = ((0,agent_bundle_routes__rspack_import_1/* .defineTool */.uO)({
+    description: 'Watch bounded Codex thread events for diagnostics without answering approvals.',
+    title: 'Codex watch',
+    annotations: {
+        readOnlyHint: true
+    },
+    render: {
+        maxElapsedMs: 660000
+    },
+    inputSchema: _core_codex_routes_js__rspack_import_2/* .watchSchema */.R9,
+    resultSchema: _core_codex_routes_js__rspack_import_2/* .resultSchema */.FD,
+    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 (input)=>{
+    const context = await (0,_agent_bundle_runtime__rspack_import_3/* .agent */.MA)();
+    const out = await (0,_core_codex_routes_js__rspack_import_2/* .observeOperation */.gT)('watch', input, context.signal, (message)=>context.progress.report({
+            message
+        }));
+    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: (0,_core_codex_routes_js__rspack_import_2/* .resultText */.D6)(out)
+        })
+    });
+}));
+
+__webpack_require__.d(__webpack_exports__, {
+  inputSchema: () => (/* reexport safe */ _core_codex_routes_js__rspack_import_2.R9)
+}, {
+  "default": __rspack_default_export
+});
+
+
+},
+"./src/mcp/grok-bot/tools/gbot_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 agent_bundle_routes__rspack_import_1 = __webpack_require__("./node_modules/agent-bundle/dist/routes.js");
+/* import */ var _core_relay_routes_js__rspack_import_2 = __webpack_require__("./src/core/relay/routes.ts");
+
+
+
+
+
+/* export default */ const __rspack_default_export = ((0,agent_bundle_routes__rspack_import_1/* .defineTool */.uO)({
+    description: 'Link a Grok conversation to Codex once. New visible Grok messages arrive automatically and Codex final answers return to Grok.',
+    title: 'gbot_bridge_start',
+    annotations: {
+        readOnlyHint: false
+    },
+    inputSchema: _core_relay_routes_js__rspack_import_2/* .bridgeStartSchema */.xD,
+    resultSchema: _core_relay_routes_js__rspack_import_2/* .relayResultSchema */.Ax,
+    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 (input)=>{
+    const out = await (0,_core_relay_routes_js__rspack_import_2/* .bridgeOperation */.n1)('startBinding', input, await (0,_agent_bundle_runtime__rspack_import_3/* .agent */.MA)());
+    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__, {
+  inputSchema: () => (/* reexport safe */ _core_relay_routes_js__rspack_import_2.xD)
+}, {
+  "default": __rspack_default_export
+});
+
+
+},
+"./src/mcp/grok-bot/tools/gbot_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 agent_bundle_routes__rspack_import_1 = __webpack_require__("./node_modules/agent-bundle/dist/routes.js");
+/* import */ var _core_relay_routes_js__rspack_import_2 = __webpack_require__("./src/core/relay/routes.ts");
+
+
+
+
+
+/* export default */ const __rspack_default_export = ((0,agent_bundle_routes__rspack_import_1/* .defineTool */.uO)({
+    description: 'Inspect worker health, route coverage, bounded receipts and scoped pending operator interactions.',
+    title: 'gbot_bridge_status',
+    annotations: {
+        readOnlyHint: true
+    },
+    inputSchema: _core_relay_routes_js__rspack_import_2/* .bridgeStatusSchema */.np,
+    resultSchema: _core_relay_routes_js__rspack_import_2/* .relayResultSchema */.Ax,
+    inputJsonSchema: {
+        type: 'object',
+        properties: {
+            bindingId: {
+                type: 'string'
+            },
+            limit: {
+                type: 'number'
+            }
+        },
+        additionalProperties: false
+    }
+}, async (input)=>{
+    const out = await (0,_core_relay_routes_js__rspack_import_2/* .bridgeOperation */.n1)('status', input, await (0,_agent_bundle_runtime__rspack_import_3/* .agent */.MA)());
+    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__, {
+  inputSchema: () => (/* reexport safe */ _core_relay_routes_js__rspack_import_2.np)
+}, {
+  "default": __rspack_default_export
+});
+
+
+},
+"./src/mcp/grok-bot/tools/gbot_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 agent_bundle_routes__rspack_import_1 = __webpack_require__("./node_modules/agent-bundle/dist/routes.js");
+/* import */ var _core_relay_routes_js__rspack_import_2 = __webpack_require__("./src/core/relay/routes.ts");
+
+
+
+
+
+/* export default */ const __rspack_default_export = ((0,agent_bundle_routes__rspack_import_1/* .defineTool */.uO)({
+    description: 'Stop a binding without deleting receipts or interrupting Codex. all stops all bindings; worker explicitly shuts down the worker.',
+    title: 'gbot_bridge_stop',
+    annotations: {
+        readOnlyHint: false
+    },
+    inputSchema: _core_relay_routes_js__rspack_import_2/* .bridgeStopSchema */.d5,
+    resultSchema: _core_relay_routes_js__rspack_import_2/* .relayResultSchema */.Ax,
+    inputJsonSchema: {
+        type: 'object',
+        properties: {
+            bindingId: {
+                type: 'string'
+            },
+            all: {
+                type: 'boolean'
+            },
+            worker: {
+                type: 'boolean'
+            }
+        },
+        additionalProperties: false
+    }
+}, async (input)=>{
+    const out = await (0,_core_relay_routes_js__rspack_import_2/* .bridgeOperation */.n1)('stop', input, await (0,_agent_bundle_runtime__rspack_import_3/* .agent */.MA)());
+    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__, {
+  inputSchema: () => (/* reexport safe */ _core_relay_routes_js__rspack_import_2.d5)
+}, {
+  "default": __rspack_default_export
+});
+
+
+},
+"./src/mcp/grok-bot/tools/gbot_codex_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 agent_bundle_routes__rspack_import_1 = __webpack_require__("./node_modules/agent-bundle/dist/routes.js");
+/* import */ var _core_relay_routes_js__rspack_import_2 = __webpack_require__("./src/core/relay/routes.ts");
+
+
+
+
+
+/* export default */ const __rspack_default_export = ((0,agent_bundle_routes__rspack_import_1/* .defineTool */.uO)({
+    description: 'Explicit operator response to a current scoped Codex interaction. Supports only one-time accept/decline/cancel or exact question-ID answers. Never auto-approve.',
+    title: 'gbot_codex_respond',
+    annotations: {
+        readOnlyHint: false
+    },
+    inputSchema: _core_relay_routes_js__rspack_import_2/* .respondSchema */.v1,
+    resultSchema: _core_relay_routes_js__rspack_import_2/* .relayResultSchema */.Ax,
+    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 (input)=>{
+    const out = await (0,_core_relay_routes_js__rspack_import_2/* .bridgeOperation */.n1)('respond', input, await (0,_agent_bundle_runtime__rspack_import_3/* .agent */.MA)());
+    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__, {
+  inputSchema: () => (/* reexport safe */ _core_relay_routes_js__rspack_import_2.v1)
+}, {
+  "default": __rspack_default_export
+});
+
+
+},
+"./src/mcp/grok-bot/tools/gbot_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_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 agent_bundle_routes__rspack_import_1 = __webpack_require__("./node_modules/agent-bundle/dist/routes.js");
+/* import */ var _core_relay_routes_js__rspack_import_2 = __webpack_require__("./src/core/relay/routes.ts");
+
+
+
+
+
+/* export default */ const __rspack_default_export = ((0,agent_bundle_routes__rspack_import_1/* .defineTool */.uO)({
+    description: 'Send to Grok Bot. Native Codex calls automatically receive replies in their originating thread; send once and continue work. Without a native source, supply codexThreadId or use manual gbot_thread reading.',
+    title: 'Send a message to Grok Bot',
+    annotations: {
+        readOnlyHint: false
+    },
+    inputSchema: _core_relay_routes_js__rspack_import_2/* .grokSendSchema */.bw,
+    resultSchema: _core_relay_routes_js__rspack_import_2/* .relayResultSchema */.Ax,
+    inputJsonSchema: {
+        type: 'object',
+        properties: {
+            hop: {
+                type: 'number',
+                description: 'Explicit chain hop count, refused at the configured bound.'
+            },
+            correlationId: {
                 type: 'string'
             },
             target: {
-                description: 'Bot or group name or id, for example "General".',
+                type: 'string'
+            },
+            message: {
+                type: 'string'
+            },
+            replyMode: {
+                type: 'string',
+                enum: [
+                    'auto',
+                    'manual'
+                ]
+            },
+            codexThreadId: {
+                type: 'string'
+            },
+            expectedCwd: {
+                type: 'string'
+            },
+            bindingId: {
+                type: 'string'
+            },
+            requestId: {
                 type: 'string'
             }
         },
@@ -11136,44 +12149,22 @@ const inputSchema = zod__rspack_import_3/* .object */.Ikc({
             'target',
             'message'
         ],
-        type: 'object'
-    },
-    inputSchema,
-    resultSchema: zod__rspack_import_3/* .object */.Ikc({
-        result: zod__rspack_import_3/* .record */.g1P(zod__rspack_import_3/* .string */.YjP(), zod__rspack_import_3/* .json */.Pq9()),
-        target: _gbot_js__rspack_import_2/* .targetSchema */.tX,
-        delivery: zod__rspack_import_3/* ["enum"] */.k5n([
-            'accepted',
-            'unknown'
-        ]),
-        messageId: zod__rspack_import_3/* .string */.YjP().optional()
-    }),
-    title: 'Send a message to Grok Bot'
-}, async ({ message, target })=>{
-    const sent = await (0,_gbot_js__rspack_import_2/* .withRedactedErrors */.yF)(async ()=>(0,_gbot_js__rspack_import_2/* .sendPrompt */.LV)(await (0,_gbot_js__rspack_import_2/* .connectGateway */.Vq)(), target, message));
-    // Never claim acceptance the gateway didn't confirm; no-receipt sends stay unknown.
-    const delivery = sent.delivery === 'accepted' ? 'accepted' : 'unknown';
-    const messageId = delivery === 'accepted' && typeof sent.messageId === 'string' ? sent.messageId : undefined;
-    const value = {
-        result: sent.result,
-        target: (0,_gbot_js__rspack_import_2/* .summarizeTarget */.rW)(sent.target),
-        delivery,
-        ...messageId === undefined ? {} : {
-            messageId
-        }
-    };
+        additionalProperties: false
+    }
+}, async (input)=>{
+    const out = await (0,_core_relay_routes_js__rspack_import_2/* .grokSendOperation */.bv)(input, await (0,_agent_bundle_runtime__rspack_import_3/* .agent */.MA)());
     return /*#__PURE__*/ (0,react_jsx_runtime__rspack_import_0.jsx)(_agent_bundle_runtime__rspack_import_4/* .Agent.Result */.g6.Result, {
-        value: value,
+        value: out,
         children: /*#__PURE__*/ (0,react_jsx_runtime__rspack_import_0.jsx)(_agent_bundle_runtime__rspack_import_4/* .Agent.Text */.g6.Text, {
-            children: `Sent to ${value.target.kind} ${value.target.name} (${value.target.id})${messageId === undefined ? ' (no receipt; check the thread before resending)' : ` as ${messageId}`}. Read the reply with gbot_thread.`
+            children: out.replyRoute.mode === 'auto' ? `Delivery ${out.delivery}; replies will arrive in Codex thread ${out.replyRoute.threadId}. Continue work; no polling needed.` : `Delivery ${out.delivery}${out.delivery === 'unknown' ? ' (no receipt; check the thread before resending)' : ''}; read the reply with gbot_thread.`
         })
     });
 }));
 
 __webpack_require__.d(__webpack_exports__, {
+  inputSchema: () => (/* reexport safe */ _core_relay_routes_js__rspack_import_2.bw)
 }, {
-  "default": __rspack_default_export,
-  inputSchema: inputSchema
+  "default": __rspack_default_export
 });
 
 
@@ -11245,7 +12236,9 @@ const inputSchema = zod__rspack_import_3/* .object */.Ikc({
         after,
         limit
     });
-    const entries = (0,_gbot_js__rspack_import_2/* .transcriptEntries */.xw)(delta.entries);
+    const entries = (0,_gbot_js__rspack_import_2/* .transcriptEntries */.xw)({
+        entries: delta.entries
+    });
     const summary = delta.gapReset ? `${delta.entryCount} entries; gap reset` : after === undefined ? `${delta.entryCount} entries` : `${delta.entryCount} new`;
     const receipt = {
         cursor: delta.cursor,
@@ -11316,6 +12309,12 @@ module.exports = __rspack_external_node_fs_1b05aee1;
 module.exports = __rspack_external_node_fs_promises_3b710708;
 
 
+},
+"node:net"(module) {
+
+module.exports = __rspack_external_node_net_5ed819e1;
+
+
 },
 "node:os"(module) {
 
@@ -11334,6 +12333,12 @@ module.exports = __rspack_external_node_path_806ed179;
 module.exports = __rspack_external_node_process_ee535471;
 
 
+},
+"node:string_decoder"(module) {
+
+module.exports = __rspack_external_node_string_decoder_69b9bd04;
+
+
 },
 "node:url"(module) {
 
@@ -106187,43 +107192,435 @@ __webpack_require__.d(__webpack_exports__, {
 "./.agent-bundle-virtual/mcp-grok-bot-b8c2461e-1.mjs"(__unused_rspack___webpack_module__, __webpack_exports__, __webpack_require__) {
 __webpack_require__.r(__webpack_exports__);
 /* import */ var node_url__rspack_import_0 = __webpack_require__("node:url");
-/* import */ var _agent_bundle_runtime__rspack_import_5 = __webpack_require__("./node_modules/@agent-bundle/runtime/dist/49.js");
+/* import */ var _agent_bundle_runtime__rspack_import_13 = __webpack_require__("./node_modules/@agent-bundle/runtime/dist/49.js");
 /* import */ var agent_bundle_mcp_server_runtime__rspack_import_1 = __webpack_require__("./node_modules/agent-bundle/dist/mcp-server-runtime.js");
-/* import */ var _agent_bundle_runtime_lineage__rspack_import_6 = __webpack_require__("./node_modules/@agent-bundle/runtime/dist/lineage.js");
+/* import */ var _agent_bundle_runtime_lineage__rspack_import_14 = __webpack_require__("./node_modules/@agent-bundle/runtime/dist/lineage.js");
 /* import */ var agent_bundle_mcp_apps__rspack_import_2 = __webpack_require__("./.agent-bundle-virtual/mcp-grok-bot-b8c2461e-0.mjs");
-/* import */ var _home_runner_work_grok_bot_cli_grok_bot_cli_src_mcp_grok_bot_tools_gbot_send_tsx__rspack_import_3 = __webpack_require__("./src/mcp/grok-bot/tools/gbot_send.tsx");
-/* import */ var _home_runner_work_grok_bot_cli_grok_bot_cli_src_mcp_grok_bot_tools_gbot_thread_tsx__rspack_import_4 = __webpack_require__("./src/mcp/grok-bot/tools/gbot_thread.tsx");
+/* import */ var _home_runner_work_grok_bot_cli_grok_bot_cli_src_mcp_grok_bot_tools_codex_send_tsx__rspack_import_3 = __webpack_require__("./src/mcp/grok-bot/tools/codex_send.tsx");
+/* import */ var _home_runner_work_grok_bot_cli_grok_bot_cli_src_mcp_grok_bot_tools_codex_threads_tsx__rspack_import_4 = __webpack_require__("./src/mcp/grok-bot/tools/codex_threads.tsx");
+/* import */ var _home_runner_work_grok_bot_cli_grok_bot_cli_src_mcp_grok_bot_tools_codex_wait_tsx__rspack_import_5 = __webpack_require__("./src/mcp/grok-bot/tools/codex_wait.tsx");
+/* import */ var _home_runner_work_grok_bot_cli_grok_bot_cli_src_mcp_grok_bot_tools_codex_watch_tsx__rspack_import_6 = __webpack_require__("./src/mcp/grok-bot/tools/codex_watch.tsx");
+/* import */ var _home_runner_work_grok_bot_cli_grok_bot_cli_src_mcp_grok_bot_tools_gbot_bridge_start_tsx__rspack_import_7 = __webpack_require__("./src/mcp/grok-bot/tools/gbot_bridge_start.tsx");
+/* import */ var _home_runner_work_grok_bot_cli_grok_bot_cli_src_mcp_grok_bot_tools_gbot_bridge_status_tsx__rspack_import_8 = __webpack_require__("./src/mcp/grok-bot/tools/gbot_bridge_status.tsx");
+/* import */ var _home_runner_work_grok_bot_cli_grok_bot_cli_src_mcp_grok_bot_tools_gbot_bridge_stop_tsx__rspack_import_9 = __webpack_require__("./src/mcp/grok-bot/tools/gbot_bridge_stop.tsx");
+/* import */ var _home_runner_work_grok_bot_cli_grok_bot_cli_src_mcp_grok_bot_tools_gbot_codex_respond_tsx__rspack_import_10 = __webpack_require__("./src/mcp/grok-bot/tools/gbot_codex_respond.tsx");
+/* import */ var _home_runner_work_grok_bot_cli_grok_bot_cli_src_mcp_grok_bot_tools_gbot_send_tsx__rspack_import_11 = __webpack_require__("./src/mcp/grok-bot/tools/gbot_send.tsx");
+/* import */ var _home_runner_work_grok_bot_cli_grok_bot_cli_src_mcp_grok_bot_tools_gbot_thread_tsx__rspack_import_12 = __webpack_require__("./src/mcp/grok-bot/tools/gbot_thread.tsx");
 
 
 
 
 
 
-const route0 = Object.assign({}, Reflect.get(_home_runner_work_grok_bot_cli_grok_bot_cli_src_mcp_grok_bot_tools_gbot_send_tsx__rspack_import_3, 'default'), _home_runner_work_grok_bot_cli_grok_bot_cli_src_mcp_grok_bot_tools_gbot_send_tsx__rspack_import_3);
+const route0 = Object.assign({}, Reflect.get(_home_runner_work_grok_bot_cli_grok_bot_cli_src_mcp_grok_bot_tools_codex_send_tsx__rspack_import_3, 'default'), _home_runner_work_grok_bot_cli_grok_bot_cli_src_mcp_grok_bot_tools_codex_send_tsx__rspack_import_3);
 
-const route1 = Object.assign({}, Reflect.get(_home_runner_work_grok_bot_cli_grok_bot_cli_src_mcp_grok_bot_tools_gbot_thread_tsx__rspack_import_4, 'default'), _home_runner_work_grok_bot_cli_grok_bot_cli_src_mcp_grok_bot_tools_gbot_thread_tsx__rspack_import_4);
-const ARTIFACT_EPOCH = "gbot@0.4.5";
-const pluginRoot = (0,_agent_bundle_runtime__rspack_import_5/* .resolvePluginRoot */.E7)({
+const route1 = Object.assign({}, Reflect.get(_home_runner_work_grok_bot_cli_grok_bot_cli_src_mcp_grok_bot_tools_codex_threads_tsx__rspack_import_4, 'default'), _home_runner_work_grok_bot_cli_grok_bot_cli_src_mcp_grok_bot_tools_codex_threads_tsx__rspack_import_4);
+
+const route2 = Object.assign({}, Reflect.get(_home_runner_work_grok_bot_cli_grok_bot_cli_src_mcp_grok_bot_tools_codex_wait_tsx__rspack_import_5, 'default'), _home_runner_work_grok_bot_cli_grok_bot_cli_src_mcp_grok_bot_tools_codex_wait_tsx__rspack_import_5);
+
+const route3 = Object.assign({}, Reflect.get(_home_runner_work_grok_bot_cli_grok_bot_cli_src_mcp_grok_bot_tools_codex_watch_tsx__rspack_import_6, 'default'), _home_runner_work_grok_bot_cli_grok_bot_cli_src_mcp_grok_bot_tools_codex_watch_tsx__rspack_import_6);
+
+const route4 = Object.assign({}, Reflect.get(_home_runner_work_grok_bot_cli_grok_bot_cli_src_mcp_grok_bot_tools_gbot_bridge_start_tsx__rspack_import_7, 'default'), _home_runner_work_grok_bot_cli_grok_bot_cli_src_mcp_grok_bot_tools_gbot_bridge_start_tsx__rspack_import_7);
+
+const route5 = Object.assign({}, Reflect.get(_home_runner_work_grok_bot_cli_grok_bot_cli_src_mcp_grok_bot_tools_gbot_bridge_status_tsx__rspack_import_8, 'default'), _home_runner_work_grok_bot_cli_grok_bot_cli_src_mcp_grok_bot_tools_gbot_bridge_status_tsx__rspack_import_8);
+
+const route6 = Object.assign({}, Reflect.get(_home_runner_work_grok_bot_cli_grok_bot_cli_src_mcp_grok_bot_tools_gbot_bridge_stop_tsx__rspack_import_9, 'default'), _home_runner_work_grok_bot_cli_grok_bot_cli_src_mcp_grok_bot_tools_gbot_bridge_stop_tsx__rspack_import_9);
+
+const route7 = Object.assign({}, Reflect.get(_home_runner_work_grok_bot_cli_grok_bot_cli_src_mcp_grok_bot_tools_gbot_codex_respond_tsx__rspack_import_10, 'default'), _home_runner_work_grok_bot_cli_grok_bot_cli_src_mcp_grok_bot_tools_gbot_codex_respond_tsx__rspack_import_10);
+
+const route8 = Object.assign({}, Reflect.get(_home_runner_work_grok_bot_cli_grok_bot_cli_src_mcp_grok_bot_tools_gbot_send_tsx__rspack_import_11, 'default'), _home_runner_work_grok_bot_cli_grok_bot_cli_src_mcp_grok_bot_tools_gbot_send_tsx__rspack_import_11);
+
+const route9 = Object.assign({}, Reflect.get(_home_runner_work_grok_bot_cli_grok_bot_cli_src_mcp_grok_bot_tools_gbot_thread_tsx__rspack_import_12, 'default'), _home_runner_work_grok_bot_cli_grok_bot_cli_src_mcp_grok_bot_tools_gbot_thread_tsx__rspack_import_12);
+const ARTIFACT_EPOCH = "gbot@0.6.0";
+const pluginRoot = (0,_agent_bundle_runtime__rspack_import_13/* .resolvePluginRoot */.E7)({
     fallback: (0,node_url__rspack_import_0.fileURLToPath)(new URL('..', import.meta.url)),
     stateAnchor: 'user-data'
 });
 const openLineage = async ()=>({
         dispose: async ()=>undefined,
-        registry: (0,_agent_bundle_runtime_lineage__rspack_import_6/* .createAgentLineageRegistry */.Q5)()
+        registry: (0,_agent_bundle_runtime_lineage__rspack_import_14/* .createAgentLineageRegistry */.Q5)()
     });
 const routes = Object.freeze({
+    "tool:grok-bot/codex_send": Object.freeze({
+        config: {
+            "annotations": {
+                "readOnlyHint": false
+            },
+            "description": "Send to Codex. With replyToGrok or bindingId, managed delivery returns the terminal answer to Grok automatically. Otherwise optional wait observes completion and explicit steer requires expectedTurnId. Acceptance is not completion.",
+            "inputJsonSchema": {
+                "additionalProperties": false,
+                "properties": {
+                    "bindingId": {
+                        "type": "string"
+                    },
+                    "correlationId": {
+                        "type": "string"
+                    },
+                    "envelope": {
+                        "type": "boolean"
+                    },
+                    "expectedCwd": {
+                        "type": "string"
+                    },
+                    "expectedTurnId": {
+                        "type": "string"
+                    },
+                    "hop": {
+                        "type": "number"
+                    },
+                    "maxOutputBytes": {
+                        "type": "number"
+                    },
+                    "message": {
+                        "type": "string"
+                    },
+                    "replyTo": {
+                        "type": "string"
+                    },
+                    "replyToGrok": {
+                        "type": "string"
+                    },
+                    "requestId": {
+                        "type": "string"
+                    },
+                    "threadId": {
+                        "type": "string"
+                    },
+                    "timeoutMs": {
+                        "type": "number"
+                    },
+                    "wait": {
+                        "default": false,
+                        "type": "boolean"
+                    },
+                    "whenBusy": {
+                        "enum": [
+                            "reject",
+                            "queue",
+                            "steer"
+                        ],
+                        "type": "string"
+                    }
+                },
+                "required": [
+                    "threadId",
+                    "message"
+                ],
+                "type": "object"
+            },
+            "render": {
+                "maxElapsedMs": 660000
+            },
+            "title": "Codex send"
+        },
+        id: "tool:grok-bot/codex_send",
+        kind: "tool",
+        module: route0,
+        name: "codex_send"
+    }),
+    "tool:grok-bot/codex_threads": Object.freeze({
+        config: {
+            "annotations": {
+                "readOnlyHint": true
+            },
+            "description": "Discover a bounded page of Codex daemon threads.",
+            "inputJsonSchema": {
+                "additionalProperties": false,
+                "properties": {
+                    "cursor": {
+                        "type": "string"
+                    },
+                    "limit": {
+                        "description": "Maximum threads in this page: 1-200.",
+                        "type": "number"
+                    }
+                },
+                "required": [],
+                "type": "object"
+            },
+            "render": {
+                "maxElapsedMs": 660000
+            },
+            "title": "Codex threads"
+        },
+        id: "tool:grok-bot/codex_threads",
+        kind: "tool",
+        module: route1,
+        name: "codex_threads"
+    }),
+    "tool:grok-bot/codex_wait": Object.freeze({
+        config: {
+            "annotations": {
+                "readOnlyHint": true
+            },
+            "description": "Explicit diagnostic observation of one Codex turn; returns execution and final reply without interrupting it.",
+            "inputJsonSchema": {
+                "additionalProperties": false,
+                "properties": {
+                    "expectedCwd": {
+                        "type": "string"
+                    },
+                    "maxOutputBytes": {
+                        "description": "Reply budget: 1-4194304 bytes.",
+                        "type": "number"
+                    },
+                    "messageId": {
+                        "type": "string"
+                    },
+                    "threadId": {
+                        "type": "string"
+                    },
+                    "timeoutMs": {
+                        "description": "Observation timeout: 1-600000 milliseconds.",
+                        "type": "number"
+                    },
+                    "turnId": {
+                        "type": "string"
+                    }
+                },
+                "required": [
+                    "threadId",
+                    "turnId"
+                ],
+                "type": "object"
+            },
+            "render": {
+                "maxElapsedMs": 660000
+            },
+            "title": "Codex wait"
+        },
+        id: "tool:grok-bot/codex_wait",
+        kind: "tool",
+        module: route2,
+        name: "codex_wait"
+    }),
+    "tool:grok-bot/codex_watch": Object.freeze({
+        config: {
+            "annotations": {
+                "readOnlyHint": true
+            },
+            "description": "Watch bounded Codex thread events for diagnostics without answering approvals.",
+            "inputJsonSchema": {
+                "additionalProperties": false,
+                "properties": {
+                    "expectedCwd": {
+                        "type": "string"
+                    },
+                    "maxEvents": {
+                        "description": "Maximum observed events: 1-500.",
+                        "type": "number"
+                    },
+                    "threadId": {
+                        "type": "string"
+                    },
+                    "timeoutMs": {
+                        "description": "Observation timeout: 1-600000 milliseconds.",
+                        "type": "number"
+                    }
+                },
+                "required": [
+                    "threadId"
+                ],
+                "type": "object"
+            },
+            "render": {
+                "maxElapsedMs": 660000
+            },
+            "title": "Codex watch"
+        },
+        id: "tool:grok-bot/codex_watch",
+        kind: "tool",
+        module: route3,
+        name: "codex_watch"
+    }),
+    "tool:grok-bot/gbot_bridge_start": Object.freeze({
+        config: {
+            "annotations": {
+                "readOnlyHint": false
+            },
+            "description": "Link a Grok conversation to Codex once. New visible Grok messages arrive automatically and Codex final answers return to Grok.",
+            "inputJsonSchema": {
+                "additionalProperties": false,
+                "properties": {
+                    "busyPolicy": {
+                        "enum": [
+                            "steer",
+                            "reject"
+                        ],
+                        "type": "string"
+                    },
+                    "codexThreadId": {
+                        "type": "string"
+                    },
+                    "expectedCwd": {
+                        "type": "string"
+                    },
+                    "grokTarget": {
+                        "type": "string"
+                    },
+                    "requestId": {
+                        "type": "string"
+                    }
+                },
+                "required": [
+                    "grokTarget"
+                ],
+                "type": "object"
+            },
+            "title": "gbot_bridge_start"
+        },
+        id: "tool:grok-bot/gbot_bridge_start",
+        kind: "tool",
+        module: route4,
+        name: "gbot_bridge_start"
+    }),
+    "tool:grok-bot/gbot_bridge_status": Object.freeze({
+        config: {
+            "annotations": {
+                "readOnlyHint": true
+            },
+            "description": "Inspect worker health, route coverage, bounded receipts and scoped pending operator interactions.",
+            "inputJsonSchema": {
+                "additionalProperties": false,
+                "properties": {
+                    "bindingId": {
+                        "type": "string"
+                    },
+                    "limit": {
+                        "type": "number"
+                    }
+                },
+                "type": "object"
+            },
+            "title": "gbot_bridge_status"
+        },
+        id: "tool:grok-bot/gbot_bridge_status",
+        kind: "tool",
+        module: route5,
+        name: "gbot_bridge_status"
+    }),
+    "tool:grok-bot/gbot_bridge_stop": Object.freeze({
+        config: {
+            "annotations": {
+                "readOnlyHint": false
+            },
+            "description": "Stop a binding without deleting receipts or interrupting Codex. all stops all bindings; worker explicitly shuts down the worker.",
+            "inputJsonSchema": {
+                "additionalProperties": false,
+                "properties": {
+                    "all": {
+                        "type": "boolean"
+                    },
+                    "bindingId": {
+                        "type": "string"
+                    },
+                    "worker": {
+                        "type": "boolean"
+                    }
+                },
+                "type": "object"
+            },
+            "title": "gbot_bridge_stop"
+        },
+        id: "tool:grok-bot/gbot_bridge_stop",
+        kind: "tool",
+        module: route6,
+        name: "gbot_bridge_stop"
+    }),
+    "tool:grok-bot/gbot_codex_respond": Object.freeze({
+        config: {
+            "annotations": {
+                "readOnlyHint": false
+            },
+            "description": "Explicit operator response to a current scoped Codex interaction. Supports only one-time accept/decline/cancel or exact question-ID answers. Never auto-approve.",
+            "inputJsonSchema": {
+                "additionalProperties": false,
+                "properties": {
+                    "answersJson": {
+                        "description": "JSON object mapping each advertised question ID to {\"answers\":[\"answer\"]}; exact IDs required.",
+                        "type": "string"
+                    },
+                    "bindingId": {
+                        "type": "string"
+                    },
+                    "decision": {
+                        "enum": [
+                            "accept",
+                            "decline",
+                            "cancel"
+                        ],
+                        "type": "string"
+                    },
+                    "exchangeId": {
+                        "type": "string"
+                    },
+                    "generation": {
+                        "type": "string"
+                    },
+                    "interactionId": {
+                        "type": "string"
+                    },
+                    "threadId": {
+                        "type": "string"
+                    },
+                    "turnId": {
+                        "type": "string"
+                    }
+                },
+                "required": [
+                    "interactionId",
+                    "generation",
+                    "threadId",
+                    "turnId"
+                ],
+                "type": "object"
+            },
+            "title": "gbot_codex_respond"
+        },
+        id: "tool:grok-bot/gbot_codex_respond",
+        kind: "tool",
+        module: route7,
+        name: "gbot_codex_respond"
+    }),
     "tool:grok-bot/gbot_send": Object.freeze({
         config: {
-            "description": "Send a message to a Grok Bot bot or group by name or id, like `gbot send`. The bot answers asynchronously; read its reply later with gbot_thread.",
+            "annotations": {
+                "readOnlyHint": false
+            },
+            "description": "Send to Grok Bot. Native Codex calls automatically receive replies in their originating thread; send once and continue work. Without a native source, supply codexThreadId or use manual gbot_thread reading.",
             "inputJsonSchema": {
                 "additionalProperties": false,
                 "properties": {
+                    "bindingId": {
+                        "type": "string"
+                    },
+                    "codexThreadId": {
+                        "type": "string"
+                    },
+                    "correlationId": {
+                        "type": "string"
+                    },
+                    "expectedCwd": {
+                        "type": "string"
+                    },
+                    "hop": {
+                        "description": "Explicit chain hop count, refused at the configured bound.",
+                        "type": "number"
+                    },
                     "message": {
-                        "description": "Message text. Say who you are and what you need in the first line.",
+                        "type": "string"
+                    },
+                    "replyMode": {
+                        "enum": [
+                            "auto",
+                            "manual"
+                        ],
+                        "type": "string"
+                    },
+                    "requestId": {
                         "type": "string"
                     },
                     "target": {
-                        "description": "Bot or group name or id, for example \"General\".",
                         "type": "string"
                     }
                 },
@@ -106237,7 +107634,7 @@ const routes = Object.freeze({
         },
         id: "tool:grok-bot/gbot_send",
         kind: "tool",
-        module: route0,
+        module: route8,
         name: "gbot_send"
     }),
     "tool:grok-bot/gbot_thread": Object.freeze({
@@ -106277,7 +107674,7 @@ const routes = Object.freeze({
         },
         id: "tool:grok-bot/gbot_thread",
         kind: "tool",
-        module: route1,
+        module: route9,
         name: "gbot_thread"
     })
 });
@@ -106291,7 +107688,7 @@ const routes = Object.freeze({
         lineage: lineage.registry,
         plugin: {
             "name": "gbot",
-            "version": "0.4.5"
+            "version": "0.6.0"
         },
         pluginRoot: pluginRoot.identity,
         routes
@@ -106544,10 +107941,2511 @@ function inspectGrokBotGatewaySession(options = {}) {
 }
 
 __webpack_require__.d(__webpack_exports__, {
-  Z2: () => (loadGrokBotGatewaySession)
+  Z2: () => (loadGrokBotGatewaySession),
+  dQ: () => (grokBotGatewayDescriptorPath)
+});
+
+
+},
+"./src/core/codex-bridge.js"(__unused_rspack___webpack_module__, __webpack_exports__, __webpack_require__) {
+/* import */ var node_crypto__rspack_import_0 = __webpack_require__("node:crypto");
+/* import */ var node_fs__rspack_import_1 = __webpack_require__("node:fs");
+/* import */ var node_net__rspack_import_2 = __webpack_require__("node:net");
+/* 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 _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");
+
+
+
+
+
+
+
+
+
+// Method and param names below come from `codex app-server generate-json-schema`
+// of this Codex release. Newer daemons usually keep them; `gbot codex status`
+// reports the running daemon's version next to this one.
+const PINNED_CODEX_VERSION = "0.154.0";
+const UPSTREAM_DESKTOP_ISSUES = [
+    "https://github.com/openai/codex/issues/41014",
+    "https://github.com/openai/codex/issues/41112"
+];
+const WS_GUID = "258EAFA5-E914-47DA-95CA-C5AB0DC85B11";
+// Transport budgets: fail fast instead of buffering unbounded attacker-controlled bytes.
+// ponytail: raise these only with streaming/pagination support; the app-server sends small JSON-RPC frames.
+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
+});
+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.
+    if (env.CODEX_APP_SERVER_SOCK) return env.CODEX_APP_SERVER_SOCK;
+    const home = env.CODEX_HOME || (0,node_path__rspack_import_4.join)((0,node_os__rspack_import_3.homedir)(), ".codex");
+    return (0,node_path__rspack_import_4.join)(home, "app-server-control", "app-server-control.sock");
+}
+/** `socket` | `absent` | `permission-denied` | `not-a-socket`; permission failures are not absence. */ function socketState(path) {
+    try {
+        return (0,node_fs__rspack_import_1.statSync)(path).isSocket() ? "socket" : "not-a-socket";
+    } catch (err) {
+        return err && (err.code === "EACCES" || err.code === "EPERM") ? "permission-denied" : "absent";
+    }
+}
+/** Strip ANSI/OSC sequences and C0/C1 controls (tab and newline stay) from server-supplied text. */ function stripTerminalControls(text) {
+    return String(text).replace(/\u001b\[[0-9;?]*[ -/]*[@-~]/g, "").replace(/\u001b\][^\u0007\u001b]*(?:\u0007|\u001b\\)/g, "").replace(/\u001b./g, "").replace(/[\u0000-\u0008\u000B-\u001F\u007F-\u009F]/g, "");
+}
+/** Single-line fields (ids, names, paths, cursors, header tokens): no line breaks or tabs survive. */ function singleLine(text) {
+    return stripTerminalControls(text).replace(/[\t\n\r\u2028\u2029]+/g, " ");
+}
+function unreachableMessage(path, desktopAttached = "unknown") {
+    if (desktopAttached === "private-stdio") {
+        return [
+            "ChatGPT Desktop is running its private stdio app-server, which external clients cannot reach",
+            "(" + UPSTREAM_DESKTOP_ISSUES.join(", ") + ").",
+            "No Codex app-server control socket at " + path + ": start a managed standalone daemon with `codex app-server daemon start`.",
+            "gbot codex targets daemon-managed threads only."
+        ].join("\n");
+    }
+    return [
+        "No Codex app-server control socket at " + path + ".",
+        "Either no daemon is running (start one with `codex app-server daemon start`),",
+        "or ChatGPT Desktop is running a private stdio app-server that external clients cannot reach",
+        "(" + UPSTREAM_DESKTOP_ISSUES.join(", ") + ").",
+        "gbot codex targets daemon-managed threads only."
+    ].join("\n");
+}
+function windowsUnsupportedMessage() {
+    return [
+        "gbot codex does not support native Windows yet.",
+        "Codex's control socket is AF_UNIX; this CLI's Node client only dials Unix domain sockets.",
+        "Use WSL, Linux, or macOS (or a future stdio proxy path)."
+    ].join("\n");
+}
+function encodeFrame(opcode, payload, mask) {
+    const len = payload.length;
+    const head = Buffer.alloc(len < 126 ? 2 : len < 65536 ? 4 : 10);
+    head[0] = 0x80 | opcode;
+    if (len < 126) head[1] = len;
+    else if (len < 65536) {
+        head[1] = 126;
+        head.writeUInt16BE(len, 2);
+    } else {
+        head[1] = 127;
+        head.writeBigUInt64BE(BigInt(len), 2);
+    }
+    if (!mask) return Buffer.concat([
+        head,
+        payload
+    ]);
+    head[1] |= 0x80;
+    const body = Buffer.from(payload);
+    for(let i = 0; i < body.length; i++)body[i] ^= mask[i & 3];
+    return Buffer.concat([
+        head,
+        mask,
+        body
+    ]);
+}
+function decodeFrame(buf) {
+    if (buf.length < 2) return null;
+    const fin = (buf[0] & 0x80) !== 0;
+    const opcode = buf[0] & 0x0f;
+    const masked = (buf[1] & 0x80) !== 0;
+    let len = buf[1] & 0x7f;
+    let offset = 2;
+    if (len === 126) {
+        if (buf.length < 4) return null;
+        len = buf.readUInt16BE(2);
+        offset = 4;
+    } else if (len === 127) {
+        if (buf.length < 10) return null;
+        len = Number(buf.readBigUInt64BE(2));
+        offset = 10;
+    }
+    const mask = masked ? buf.subarray(offset, offset + 4) : null;
+    if (masked) offset += 4;
+    if (buf.length < offset + len) return null;
+    const payload = Buffer.from(buf.subarray(offset, offset + len));
+    if (mask) for(let i = 0; i < payload.length; i++)payload[i] ^= mask[i & 3];
+    return {
+        fin,
+        opcode,
+        masked,
+        payload,
+        rest: buf.subarray(offset + len)
+    };
+}
+/** Claimed frame length without consuming; null when the length prefix is incomplete. */ function peekFrameLength(buf) {
+    if (buf.length < 2) return null;
+    const marker = buf[1] & 0x7f;
+    if (marker < 126) return marker;
+    if (marker === 126) {
+        if (buf.length < 4) return null;
+        return buf.readUInt16BE(2);
+    }
+    if (buf.length < 10) return null;
+    const big = buf.readBigUInt64BE(2);
+    return big > BigInt(Number.MAX_SAFE_INTEGER) ? Infinity : Number(big);
+}
+function validateUpgradeHead(head, key) {
+    const lines = head.split("\r\n");
+    if (!/^HTTP\/1\.1 101/.test(lines[0])) return false;
+    const headers = new Map();
+    for (const line of lines.slice(1)){
+        const i = line.indexOf(":");
+        if (i === -1) return false;
+        headers.set(line.slice(0, i).trim().toLowerCase(), line.slice(i + 1).trim());
+    }
+    return headers.get("sec-websocket-accept") === websocketAccept(key) && (headers.get("upgrade") || "").toLowerCase() === "websocket" && (headers.get("connection") || "").toLowerCase().includes("upgrade");
+}
+function upgradeRequest(key) {
+    return "GET / HTTP/1.1\r\nHost: localhost\r\nUpgrade: websocket\r\nConnection: Upgrade\r\n" + "Sec-WebSocket-Key: " + key + "\r\nSec-WebSocket-Version: 13\r\n\r\n";
+}
+function websocketAccept(key) {
+    return (0,node_crypto__rspack_import_0.createHash)("sha1").update(key + WS_GUID).digest("base64");
+}
+class CodexRpcError extends Error {
+    constructor(method, error){
+        super("Codex app-server rejected " + method + ": " + (error && error.message ? error.message : JSON.stringify(error)));
+        this.name = "CodexRpcError";
+        this.method = method;
+        this.rpc = error;
+    }
+}
+class CodexSendError extends Error {
+    constructor(message, { correlationId, delivery, hop, messageId, reason, refused, threadId, turnId } = {}){
+        super(message);
+        this.name = "CodexSendError";
+        this.delivery = delivery;
+        if (correlationId !== undefined) this.correlationId = correlationId;
+        if (hop !== undefined) this.hop = hop;
+        if (messageId !== undefined) this.messageId = messageId;
+        if (reason !== undefined) this.reason = reason;
+        if (refused !== undefined) this.refused = refused;
+        if (threadId !== undefined) this.threadId = threadId;
+        if (turnId !== undefined) this.turnId = turnId;
+    }
+}
+function attachEnvelope(error, envelope) {
+    if (!error || typeof error !== "object") return;
+    for (const key of [
+        "messageId",
+        "correlationId",
+        "hop"
+    ]){
+        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 {
+    constructor(message, mode){
+        super(message);
+        this.name = "CodexRouteError";
+        this.mode = mode;
+        this.delivery = "rejected";
+        this.reason = mode;
+    }
+}
+/** The app-server answered with a shape this pinned schema does not describe. */ class CodexProtocolError extends Error {
+    constructor(method, detail){
+        super("Codex app-server returned an unexpected " + method + " response: " + detail + ". gbot is pinned to app-server schema " + PINNED_CODEX_VERSION + "; run `gbot codex status --json` to compare versions.");
+        this.name = "CodexProtocolError";
+        this.method = method;
+        this.mode = "bad-response";
+        this.reason = "bad-response";
+    }
+}
+function isObject(value) {
+    return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
+/** Failures before the WebSocket upgrade completes: the socket is present but unusable. */ function connectError(err, path) {
+    const code = err && err.cause && err.cause.code ? err.cause.code : err && err.code;
+    const message = err && err.message ? err.message : String(err);
+    if (code === "EACCES" || code === "EPERM" || /\bEACCES\b|\bEPERM\b/.test(message)) {
+        return new CodexRouteError("Codex app-server control socket at " + path + " refused the connection for this user (" + code + "). " + "gbot runs as the user who owns CODEX_HOME; check the socket's owner and mode.", "permission-denied");
+    }
+    if (/refused the WebSocket upgrade|violated the WebSocket protocol|handshake headers exceed/.test(message)) {
+        return new CodexRouteError(message, "handshake-failed");
+    }
+    return new CodexRouteError(message + " (socket present at " + path + ", but no app-server completed the connection).", "connect-failed");
+}
+/** Failures while initializing an upgraded connection: reachable transport, unusable session. */ function handshakeError(err) {
+    if (err instanceof CodexProtocolError) return err;
+    const message = err && err.message ? err.message : String(err);
+    return new CodexRouteError("Codex app-server accepted the connection but initialize failed: " + message, "handshake-failed");
+}
+/** Failures after a session exists: the request may or may not have been processed. */ function transportError(err) {
+    if (err instanceof CodexRpcError || err instanceof CodexProtocolError || err instanceof CodexSendError || err instanceof CodexRouteError) return err;
+    if (err && typeof err === "object" && err.reason === undefined) err.reason = "transport";
+    return err;
+}
+/**
+ * Open a JSON-RPC session to the app-server over its Unix socket (WebSocket framing).
+ * 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;
+        let closed = false;
+        let fragOpcode = null;
+        let fragParts = [];
+        let fragBytes = 0;
+        // Absolute handshake deadline: socket timeouts reset on any bytes, so trickled
+        // headers must not extend this. Per-request timers stay absolute after upgrade.
+        const handshakeTimer = setTimeout(()=>failAll(new Error("Timed out connecting to Codex app-server at " + path)), timeoutMs);
+        if (typeof handshakeTimer.unref === "function") handshakeTimer.unref();
+        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 (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
+            // to another client and must never be rejected on their behalf. Early
+            // and foreign requests are still recorded; the connection closes right
+            // after, so a pending request simply dies with it instead of denying
+            // someone's approval.
+            answerServerRequests: false,
+            expectedThreadId: null,
+            expectedTurnId: null,
+            // Approvals that name a turn while our own turn id is still unknown
+            // (arriving before — or in the same socket batch as — the turn/start
+            // acknowledgment) wait here instead of being classified foreign: once
+            // the acknowledgment supplies the turn id, matching ones are answered
+            // and the rest stay silent.
+            deferred: [],
+            // Adopt the acknowledged turn id, answering deferred requests that
+            // prove to be ours. Runs inside the connection closure so it can send.
+            _adoptTurn (turnId) {
+                client.expectedTurnId = turnId;
+                for (const entry of client.deferred.splice(0)){
+                    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 && 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) {
+                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"));
+                    }, timeoutMs);
+                    pending.set(id, {
+                        method,
+                        resolve: (v)=>{
+                            clearTimeout(timer);
+                            res(v);
+                        },
+                        reject: (e)=>{
+                            clearTimeout(timer);
+                            rej(e);
+                        }
+                    });
+                    try {
+                        sendJson({
+                            jsonrpc: "2.0",
+                            id,
+                            method,
+                            params
+                        });
+                    } catch (err) {
+                        const entry = pending.get(id);
+                        pending.delete(id);
+                        entry?.reject(err);
+                    }
+                });
+            },
+            notify (method, params) {
+                sendJson({
+                    jsonrpc: "2.0",
+                    method,
+                    params
+                });
+            },
+            close () {
+                if (closed) return;
+                // 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
+                // started. A request naming another thread — or naming a turn that is
+                // not ours — is recorded foreign-silent, never rejected. A request
+                // naming a turn while our turn id is still unknown is deferred, not
+                // classified: the turn/start acknowledgment decides it.
+                if (answered) {
+                    const params = msg.params && typeof msg.params === "object" && !Array.isArray(msg.params) ? msg.params : null;
+                    if (params) {
+                        const threadId = params.threadId ?? params.thread_id;
+                        const turnId = params.turnId ?? params.turn_id ?? (params.turn && params.turn.id);
+                        if (threadId !== client.expectedThreadId || turnId == null) answered = false;
+                        else if (client.expectedTurnId == null) {
+                            answered = false;
+                            defer = true;
+                        } else if (turnId !== client.expectedTurnId) answered = false;
+                    } else answered = false;
+                }
+                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;
+                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);
+            if (msg.error) entry.reject(new CodexRpcError(entry.method, msg.error));
+            else entry.resolve(msg.result);
+        };
+        const onText = (payload)=>{
+            let text;
+            try {
+                text = textDecoder.decode(payload);
+            } catch  {
+                failAll(new Error("Codex app-server sent a non-UTF-8 text message"));
+                return;
+            }
+            let msg;
+            try {
+                msg = JSON.parse(text);
+            } catch (err) {
+                failAll(new Error("Codex app-server sent an unreadable message: " + err.message));
+                return;
+            }
+            if (!msg || typeof msg !== "object" || Array.isArray(msg)) {
+                failAll(new Error("Codex app-server sent a malformed message"));
+                return;
+            }
+            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
+            ]);
+            if (!upgraded) {
+                const end = buf.indexOf("\r\n\r\n");
+                if (end === -1) {
+                    if (buf.length > WS_MAX_HEADER_BYTES) failAll(new Error("Codex app-server handshake headers exceed " + WS_MAX_HEADER_BYTES + " bytes"));
+                    return;
+                }
+                // Terminated headers hit the cap too; size is checked before any decoding.
+                if (end > WS_MAX_HEADER_BYTES) return failAll(new Error("Codex app-server handshake headers exceed " + WS_MAX_HEADER_BYTES + " bytes"));
+                const head = buf.subarray(0, end).toString();
+                buf = buf.subarray(end + 4);
+                if (!validateUpgradeHead(head, key)) return failAll(new Error("Codex app-server refused the WebSocket upgrade: " + head.split("\r\n")[0]));
+                upgraded = true;
+                clearTimeout(handshakeTimer);
+                resolve(client);
+            }
+            while(!closed){
+                const frame = decodeFrame(buf);
+                if (!frame) {
+                    const claimed = peekFrameLength(buf);
+                    if (claimed != null && claimed > WS_MAX_MESSAGE_BYTES) {
+                        failAll(new Error("Codex app-server frame exceeds " + WS_MAX_MESSAGE_BYTES + " bytes"));
+                    } else if (buf.length > WS_MAX_BUFFER_BYTES) {
+                        failAll(new Error("Codex app-server buffer exceeds " + WS_MAX_BUFFER_BYTES + " bytes"));
+                    }
+                    return;
+                }
+                buf = frame.rest;
+                if (frame.payload.length > WS_MAX_MESSAGE_BYTES) return failAll(new Error("Codex app-server frame exceeds " + WS_MAX_MESSAGE_BYTES + " bytes"));
+                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) {
+                        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
+                }
+                if (frame.opcode === 0x0) {
+                    if (fragOpcode == null) return failProtocol("continuation with nothing to continue");
+                    fragParts.push(frame.payload);
+                    fragBytes += frame.payload.length;
+                    if (fragBytes > WS_MAX_MESSAGE_BYTES) return failAll(new Error("Codex app-server message exceeds " + WS_MAX_MESSAGE_BYTES + " bytes"));
+                    if (!frame.fin) continue;
+                    const whole = Buffer.concat(fragParts, fragBytes);
+                    const opcode = fragOpcode;
+                    fragOpcode = null;
+                    fragParts = [];
+                    fragBytes = 0;
+                    // ponytail: binary frames are unused by the app-server; only text is delivered.
+                    if (opcode === 0x1) onText(whole);
+                    continue;
+                }
+                if (frame.opcode === 0x1 || frame.opcode === 0x2) {
+                    if (fragOpcode != null) return failProtocol("new message before finishing fragments");
+                    if (!frame.fin) {
+                        fragOpcode = frame.opcode;
+                        fragParts = [
+                            frame.payload
+                        ];
+                        fragBytes = frame.payload.length;
+                        continue;
+                    }
+                    // ponytail: binary frames are unused by the app-server; only text is delivered.
+                    if (frame.opcode === 0x1) onText(frame.payload);
+                    continue;
+                }
+                return failProtocol("unknown opcode " + frame.opcode);
+            }
+        });
+    });
+}
+function appServerVersion(initResult) {
+    const ua = initResult && typeof initResult.userAgent === "string" ? initResult.userAgent : "";
+    const m = /^[^/\s]+\/(\S+)/.exec(ua);
+    return m ? m[1] : null;
+}
+/** Throws CodexRouteError when the operator's socket cannot be used; the path comes only from CODEX_HOME. */ function assertRoute(path) {
+    if (process.platform === "win32") throw new CodexRouteError(windowsUnsupportedMessage(), "windows-unsupported");
+    const state = socketState(path);
+    if (state === "socket") return;
+    if (state === "permission-denied") {
+        throw new CodexRouteError("Codex app-server control socket at " + path + " exists but this user may not access it. " + "gbot runs as the user who owns CODEX_HOME; check the socket's owner and mode.", "permission-denied");
+    }
+    if (state === "not-a-socket") {
+        throw new CodexRouteError(path + " exists but is not a Unix socket; remove the stale file and restart the daemon.", "not-a-socket");
+    }
+    throw new CodexRouteError(unreachableMessage(path), "socket-absent");
+}
+async function openCodexSession(env = process.env, { experimental = false, ...options } = {}) {
+    const path = codexSocketPath(env);
+    assertRoute(path);
+    let client;
+    try {
+        client = await connectCodexAppServer(path, options);
+    } catch (err) {
+        throw connectError(err, path);
+    }
+    let init;
+    try {
+        init = await client.request("initialize", {
+            clientInfo: {
+                name: "gbot",
+                version: _package_json__rspack_import_6/* .version */.rE
+            },
+            ...experimental ? {
+                capabilities: {
+                    experimentalApi: true
+                }
+            } : {}
+        });
+    } catch (err) {
+        client.close();
+        throw handshakeError(err);
+    }
+    if (!isObject(init)) {
+        client.close();
+        throw new CodexProtocolError("initialize", "result is not an object");
+    }
+    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 = spawnSync("codex", [
+        "--version"
+    ], {
+        encoding: "utf8",
+        timeout: timeoutMs
+    });
+    if (out.error) {
+        if (out.error.code === "ENOENT") return {
+            version: null,
+            probe: "missing"
+        };
+        if (out.error.code === "ETIMEDOUT") return {
+            version: null,
+            probe: "timeout"
+        };
+        return {
+            version: null,
+            probe: "error"
+        };
+    }
+    const m = out.status === 0 ? /(\d+\.\d+\.\d+\S*)/.exec(out.stdout) : null;
+    return m ? {
+        version: m[1],
+        probe: "ok"
+    } : {
+        version: null,
+        probe: "error"
+    };
+}
+/** Bounded `ps` snapshot for Desktop detection: process names only, never pipes or sockets. */ const DESKTOP_PROCESS_LIST_TIMEOUT_MS = 3000;
+function listDesktopProcesses(timeoutMs = DESKTOP_PROCESS_LIST_TIMEOUT_MS) {
+    if (process.platform === "win32") return "";
+    try {
+        const out = spawnSync("ps", [
+            "-eo",
+            "args"
+        ], {
+            encoding: "utf8",
+            timeout: timeoutMs
+        });
+        if (out.error || out.status !== 0 || typeof out.stdout !== "string") return "";
+        return out.stdout;
+    } catch  {
+        return "";
+    }
+}
+/**
+ * Pure Desktop private-stdio detector. Returns `"private-stdio"` when the process list
+ * shows Desktop's bundled `.../ChatGPT.app/.../Resources/codex` running `app-server`
+ * (the `codex_app` override corroborates, the Resources path alone suffices); `"unknown"`
+ * otherwise. Never `"detached"`: absence of a match means "not observed", not "not running".
+ * Windows stays `"unknown"` (unsupported route, unchanged).
+ *
+ * @param {{ platform?: string, listProcesses?: string | string[] | null }} [opts]
+ */ function detectDesktopPrivateAppServer({ platform = process.platform, listProcesses = "" } = {}) {
+    if (platform === "win32") return "unknown";
+    const lines = Array.isArray(listProcesses) ? listProcesses : String(listProcesses ?? "").split(/\r?\n/);
+    for (const line of lines){
+        if (!/app-server/.test(line)) continue;
+        // Desktop's bundled binary, Mac or Windows-style separators with optional .exe.
+        if (/ChatGPT\.app[\\/].*Resources[\\/]codex(\.exe)?(["'\s]|$)/.test(line)) return "private-stdio";
+        // Same app-server line owned by ChatGPT.app carrying the app-tools override.
+        if (/ChatGPT\.app/.test(line) && /(codex_app|mcp_servers\.codex_app|codex-app-tools)/.test(line)) return "private-stdio";
+    }
+    return "unknown";
+}
+/**
+ * Status contract: `reachable` is endpoint reachability only. `schema.compatibility` is
+ * `exact` when the daemon reports the pinned version, otherwise `unverified` (methods
+ * usually survive upgrades) or `unknown`. `desktopShimConfigured` records an installed
+ * wrapper selected by Desktop-facing CODEX_CLI_PATH (the GUI domain on Darwin).
+ * Configuration does not prove a running Desktop inherited it or connected.
+ * `desktopAttached` is `"private-stdio"` when a Desktop-bundled app-server process
+ * is visible, otherwise `"unknown"`. Managed attachment is not observable here.
+ *
+ * @param {NodeJS.ProcessEnv} [env]
+ * @param {{ listProcesses?: string | string[], shim?: { installed?: boolean, wrapperPointsAtShim?: boolean } | null }} [opts]
+ *   injected process list and shim state for tests; defaults to a live `ps` snapshot and
+ *   `desktopShimStatus`. Never reads pipes or connects to Desktop.
+ */ async function codexStatus(env = process.env, { listProcesses, shim } = {}) {
+    const path = codexSocketPath(env);
+    const cli = probeLocalCodexVersion();
+    let desktopShimConfigured = Boolean(shim && shim.installed && shim.wrapperPointsAtShim);
+    if (shim === undefined) {
+        try {
+            const live = desktopShimStatus({
+                env
+            });
+            desktopShimConfigured = Boolean(live.installed && live.wrapperPointsAtShim);
+        } catch  {
+            desktopShimConfigured = false;
+        }
+    }
+    const desktopAttached = detectDesktopPrivateAppServer({
+        platform: process.platform,
+        listProcesses: listProcesses ?? listDesktopProcesses()
+    });
+    const base = {
+        socketPath: path,
+        socketState: socketState(path),
+        pinnedVersion: PINNED_CODEX_VERSION,
+        cliVersion: cli.version,
+        cliVersionProbe: cli.probe,
+        desktopAttached,
+        desktopShimConfigured
+    };
+    let session;
+    try {
+        session = await openSession(env);
+    } catch (err) {
+        if (err instanceof CodexRouteError) {
+            // Name the private-stdio case explicitly: Desktop is up but unreachable, so the
+            // operator needs a managed standalone daemon, not a Desktop reconnect.
+            const message = err.mode === "socket-absent" ? unreachableMessage(path, desktopAttached) : err.message;
+            return withStatusExitCode({
+                ...base,
+                reachable: false,
+                mode: err.mode,
+                message
+            });
+        }
+        // The endpoint answered; what it said does not match the pinned schema.
+        if (err instanceof CodexProtocolError) return withStatusExitCode({
+            ...base,
+            reachable: true,
+            mode: err.mode,
+            message: err.message
+        });
+        throw err;
+    }
+    session.client.close();
+    const daemonVersion = appServerVersion(session.init);
+    return withStatusExitCode({
+        ...base,
+        reachable: true,
+        mode: "daemon",
+        daemonVersion,
+        codexHome: typeof session.init.codexHome === "string" ? session.init.codexHome : null,
+        schema: {
+            pinned: PINNED_CODEX_VERSION,
+            daemon: daemonVersion,
+            compatibility: daemonVersion == null ? "unknown" : daemonVersion === PINNED_CODEX_VERSION ? "exact" : "unverified"
+        },
+        versionMismatch: Boolean(base.cliVersion && daemonVersion && base.cliVersion !== daemonVersion)
+    });
+}
+const THREAD_STATUSES = new Set([
+    "notLoaded",
+    "idle",
+    "active",
+    "systemError"
+]);
+function lineField(value) {
+    return value == null ? null : singleLine(value);
+}
+/** Server text fields are sanitized; structured values (Codex's `source: { custom }`) pass through untouched. */ function sourceField(value) {
+    if (value == null) return null;
+    return typeof value === "string" ? singleLine(value) : value;
+}
+function summarizeThread(t) {
+    if (!isObject(t) || typeof t.id !== "string" || !t.id) throw new CodexProtocolError("thread/list", "entry without a string `id`");
+    const type = isObject(t.status) && typeof t.status.type === "string" ? t.status.type : "unknown";
+    return {
+        id: singleLine(t.id),
+        status: THREAD_STATUSES.has(type) ? type : "unknown",
+        activeFlags: isObject(t.status) && Array.isArray(t.status.activeFlags) ? t.status.activeFlags.map((f)=>singleLine(f)) : [],
+        name: lineField(t.name),
+        preview: typeof t.preview === "string" ? stripTerminalControls(t.preview) : "",
+        cwd: lineField(t.cwd),
+        source: sourceField(t.source),
+        updatedAt: typeof t.updatedAt === "number" ? t.updatedAt : null
+    };
+}
+const THREAD_LIST_MAX_LIMIT = 200;
+/**
+ * @param {{ limit?: number, cursor?: string, env?: NodeJS.ProcessEnv }} [opts]
+ */ async function listCodexThreads({ limit = 20, cursor, env = process.env } = {}) {
+    if (!Number.isInteger(limit) || limit < 1 || limit > THREAD_LIST_MAX_LIMIT) {
+        throw new RangeError("--limit must be an integer 1-" + THREAD_LIST_MAX_LIMIT);
+    }
+    if (cursor !== undefined && (typeof cursor !== "string" || !cursor)) throw new RangeError("--cursor must be a non-empty string");
+    const { client } = await openSession(env);
+    try {
+        // The default listing rescans every rollout file to repair metadata (26 s on a busy machine);
+        // the state DB already holds what we print.
+        const params = {
+            limit,
+            useStateDbOnly: true,
+            ...cursor !== undefined ? {
+                cursor
+            } : {}
+        };
+        let out;
+        try {
+            out = await client.request("thread/list", params);
+        } catch (err) {
+            throw transportError(err);
+        }
+        if (!isObject(out) || !Array.isArray(out.data)) throw new CodexProtocolError("thread/list", "missing `data` array");
+        if (out.nextCursor != null && typeof out.nextCursor !== "string") throw new CodexProtocolError("thread/list", "`nextCursor` is not a string");
+        const threads = out.data.map(summarizeThread);
+        return {
+            threads,
+            nextCursor: out.nextCursor ?? null,
+            limit
+        };
+    } finally{
+        client.close();
+    }
+}
+function explainSendError(err, threadId) {
+    if (!(err instanceof CodexRpcError)) return err;
+    const msg = String(err.rpc && err.rpc.message || "");
+    if (/no rollout found|thread not found/i.test(msg)) {
+        return new Error("Unknown Codex thread " + threadId + ". Run `gbot codex list-threads` to see reachable threads.");
+    }
+    if (/active writer/i.test(msg)) {
+        return new Error("Codex thread " + threadId + " is open in another client (VS Code, TUI, or Desktop), which owns its turns. Close it there first.");
+    }
+    return err;
+}
+const DEFAULT_MAX_HOPS = 4;
+const ID_PATTERN = /^[A-Za-z0-9_.:-]{1,128}$/;
+/**
+ * Delivery envelope: `messageId` names this send, `correlationId` names the conversation it
+ * belongs to, `replyTo` names the message it answers, `hop` counts agent-to-agent forwards.
+ * `maxHops` (GROK_BOT_MAX_HOPS) bounds relays: a reply must carry hop = incoming hop + 1, and a
+ * send at or past the bound is refused, so two agents cannot ack each other forever.
+ * The textual header is caller-authored provenance for the reader, not authentication.
+ * @param {{ correlationId?: string, replyTo?: string, hop?: number, envelope?: boolean, env?: NodeJS.ProcessEnv }} [opts]
+ */ function buildEnvelope({ correlationId, replyTo, hop, envelope = false, env = process.env } = {}) {
+    const maxHops = Number.parseInt(env.GROK_BOT_MAX_HOPS ?? "", 10);
+    const bound = Number.isInteger(maxHops) && maxHops >= 0 ? maxHops : DEFAULT_MAX_HOPS;
+    for (const [name, value] of [
+        [
+            "--correlation-id",
+            correlationId
+        ],
+        [
+            "--reply-to",
+            replyTo
+        ]
+    ]){
+        if (value !== undefined && !ID_PATTERN.test(value)) throw new RangeError(name + " must be 1-128 characters of [A-Za-z0-9_.:-]");
+    }
+    const hopCount = hop === undefined ? 0 : hop;
+    if (!Number.isInteger(hopCount) || hopCount < 0) throw new RangeError("--hop must be a non-negative integer");
+    if (replyTo !== undefined && correlationId === undefined) {
+        throw new RangeError("--reply-to needs the original --correlation-id so the reply stays in its conversation");
+    }
+    const messageId = (0,node_crypto__rspack_import_0.randomUUID)();
+    const out = {
+        messageId,
+        correlationId: correlationId ?? messageId,
+        hop: hopCount,
+        maxHops: bound,
+        header: envelope || replyTo !== undefined || hop !== undefined || correlationId !== undefined
+    };
+    if (replyTo !== undefined) out.replyTo = replyTo;
+    if (hopCount >= bound) {
+        throw new CodexSendError("Refusing to send: hop " + hopCount + " reaches the relay bound " + bound + " (GROK_BOT_MAX_HOPS). " + "This message is an agent-to-agent relay that has already been forwarded too many times.", {
+            delivery: "rejected",
+            reason: "hop-limit",
+            ...out
+        });
+    }
+    return out;
+}
+/** One-line header a receiving agent can read to reply with `--reply-to` and `--hop N+1`. */ const identityToken = (value)=>String(value ?? "").replace(/[^A-Za-z0-9_.:-]/g, "").slice(0, 64) || "unknown";
+function envelopeHeader(envelope, env = process.env) {
+    const from = identityToken(env.USER || env.USERNAME) + "@" + hostnameSafe();
+    const parts = [
+        "msg=" + envelope.messageId,
+        "corr=" + envelope.correlationId
+    ];
+    if (envelope.replyTo) parts.push("reply-to=" + envelope.replyTo);
+    parts.push("hop=" + envelope.hop, "from=" + from);
+    return "[gbot " + parts.join(" ") + "]";
+}
+function hostnameSafe() {
+    try {
+        return identityToken((0,node_os__rspack_import_3.hostname)());
+    } catch  {
+        return "unknown";
+    }
+}
+function withEnvelopeHeader(text, envelope, env = process.env) {
+    return envelope.header ? envelopeHeader(envelope, env) + "\n" + text : text;
+}
+/** Operator-controlled destinations: GROK_BOT_CODEX_THREADS="id,id" restricts `codex send`. */ function assertThreadAllowed(threadId, env = process.env) {
+    const raw = env.GROK_BOT_CODEX_THREADS;
+    if (raw == null || raw.trim() === "") return;
+    const allowed = raw.split(",").map((s)=>s.trim()).filter(Boolean);
+    if (!allowed.includes(threadId)) {
+        throw new CodexSendError("Codex thread " + threadId + " is not in GROK_BOT_CODEX_THREADS; the operator allows only: " + allowed.join(", "), {
+            delivery: "rejected",
+            reason: "route-not-allowed",
+            threadId
+        });
+    }
+}
+/**
+ * Busy destinations. In app-server 0.154.0 `turn/start` on a thread with an active turn steers
+ * that turn instead of queueing (TurnStartParams.turnTrigger: "Ignored when this request steers
+ * an already-active turn"). gbot never steers or interrupts human work: an `active` thread is
+ * refused with a `busy` receipt, or, with `whenBusy: "queue"`, handed to the daemon's own queue
+ * through the experimental `thread/queue/add`. See docs/codex-busy-threads.md.
+ */ function threadState(resumed, threadId) {
+    const status = resumed.thread.status;
+    const type = isObject(status) && typeof status.type === "string" ? status.type : "unknown";
+    if (type === "idle" || type === "notLoaded") return {
+        type,
+        busy: false
+    };
+    if (type === "active") {
+        const flags = Array.isArray(status.activeFlags) ? status.activeFlags.map((f)=>singleLine(f)) : [];
+        return {
+            type,
+            busy: true,
+            flags
+        };
+    }
+    if (type === "systemError") {
+        throw new CodexSendError("Codex thread " + threadId + " is in systemError state; open it in a Codex client first.", {
+            delivery: "rejected",
+            reason: "thread-error",
+            threadId
+        });
+    }
+    throw new CodexSendError("Codex thread " + threadId + " reports status " + JSON.stringify(type) + ", which this gbot (pinned to app-server " + PINNED_CODEX_VERSION + ") does not know; not sending.", {
+        delivery: "rejected",
+        reason: "unknown-status",
+        threadId
+    });
+}
+function experimentalEnabled(env = process.env) {
+    return /^(1|true|on)$/i.test(env.GROK_BOT_CODEX_EXPERIMENTAL || "");
+}
+function requireExperimental(env, what) {
+    if (experimentalEnabled(env)) return;
+    throw new CodexSendError(what + " uses Codex's experimental app-server API (thread/queue/*), which is off by default. " + "Set GROK_BOT_CODEX_EXPERIMENTAL=1 to opt in; method names are pinned to Codex " + PINNED_CODEX_VERSION + ".", {
+        delivery: "rejected",
+        reason: "experimental-disabled"
+    });
+}
+function unsupportedOrRpc(err, method, threadId, envelope, turnId) {
+    const guarded = method === "turn/steer";
+    if (err instanceof CodexRpcError && err.rpc && err.rpc.code === -32601) {
+        return new CodexSendError("Codex app-server does not offer " + method + " (daemon predates it, or experimentalApi was not granted). " + (guarded ? "Upgrade Codex before retrying guarded steering." : "Upgrade Codex or send without --when-busy queue."), {
+            delivery: "rejected",
+            reason: "unsupported",
+            threadId,
+            turnId,
+            ...envelope
+        });
+    }
+    if (err instanceof CodexRpcError) return new CodexSendError(err.message, {
+        delivery: "rejected",
+        reason: "rejected",
+        threadId,
+        turnId,
+        ...envelope
+    });
+    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
+    });
+}
+/** Read the daemon's queue for one thread (experimental `thread/queue/list`). */ async function listCodexQueue(threadId, { env = process.env, limit = 50, cursor } = {}) {
+    requireExperimental(env, "gbot codex queue");
+    const { client } = await openSession(env, {
+        experimental: true
+    });
+    try {
+        let out;
+        try {
+            out = await client.request("thread/queue/list", {
+                threadId,
+                limit,
+                ...cursor !== undefined ? {
+                    cursor
+                } : {}
+            });
+        } catch (err) {
+            throw unsupportedOrRpc(err, "thread/queue/list", threadId);
+        }
+        if (!isObject(out) || !Array.isArray(out.data)) throw new CodexProtocolError("thread/queue/list", "missing `data` array");
+        return {
+            threadId,
+            queued: out.data.map((q)=>({
+                    id: isObject(q) && typeof q.id === "string" ? singleLine(q.id) : null,
+                    clientUserMessageId: isObject(q) && typeof q.clientUserMessageId === "string" ? singleLine(q.clientUserMessageId) : null,
+                    text: isObject(q) && Array.isArray(q.input) ? q.input.map((part)=>isObject(part) && typeof part.text === "string" ? part.text : "").filter(Boolean).join("\n") : ""
+                })),
+            nextCursor: typeof out.nextCursor === "string" ? out.nextCursor : null
+        };
+    } finally{
+        client.close();
+    }
+}
+/**
+ * @param {string} threadId
+ * @param {string} text
+ * @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", session, expectedTurnId, expectedCwd, signal } = {}) {
+    try {
+        const receipt = await sendToCodexThreadInner(threadId, text, {
+            env,
+            envelope,
+            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 && 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, 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 } = session ?? await openSession(env, {
+        experimental: whenBusy === "queue",
+        signal
+    });
+    try {
+        let resumed;
+        try {
+            resumed = await client.request("thread/resume", {
+                threadId,
+                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",
+                reason: err instanceof CodexRpcError ? /no rollout found|thread not found/i.test(String(err.rpc && err.rpc.message)) ? "unknown-thread" : /active writer/i.test(String(err.rpc && err.rpc.message)) ? "external-owner" : "rejected" : "transport",
+                threadId,
+                ...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,
+            threadStatus: state.type,
+            model: resumed.model,
+            cwd: resumed.cwd,
+            approvalPolicy: resumed.approvalPolicy,
+            messageId: envelope.messageId,
+            correlationId: envelope.correlationId,
+            ...envelope.replyTo ? {
+                replyTo: envelope.replyTo
+            } : {},
+            hop: envelope.hop,
+            maxHops: envelope.maxHops
+        };
+        if (state.busy && whenBusy === "reject") {
+            const flags = state.flags.length ? " (" + state.flags.join(", ") + ")" : "";
+            throw new CodexSendError("Codex thread " + threadId + " has an active turn" + flags + "; sending now would steer that turn. " + "Wait for it to go idle (`gbot codex list-threads`) and resend, or pass --when-busy queue.", {
+                delivery: "rejected",
+                reason: "busy",
+                threadId,
+                ...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 {
+                queued = await client.request("thread/queue/add", {
+                    threadId,
+                    clientUserMessageId: envelope.messageId,
+                    input: [
+                        {
+                            type: "text",
+                            text: body
+                        }
+                    ]
+                });
+            } catch (err) {
+                throw unsupportedOrRpc(err, "thread/queue/add", threadId, envelope);
+            }
+            const submission = isObject(queued) && isObject(queued.queuedSubmission) && typeof queued.queuedSubmission.id === "string" ? queued.queuedSubmission : null;
+            if (!submission) {
+                throw new CodexSendError("Codex app-server sent a malformed thread/queue/add acknowledgment for thread " + threadId + ". Delivery is unknown; list the queue before resending.", {
+                    delivery: "unknown",
+                    reason: "bad-response",
+                    threadId,
+                    ...envelope
+                });
+            }
+            return {
+                delivery: "queued",
+                ...receiptBase,
+                queuedSubmissionId: submission.id,
+                activeFlags: state.flags
+            };
+        }
+        // ponytail: idle-at-resume then turn/start is a small race with a human starting a turn first;
+        // the daemon exposes no compare-and-start request. Upgrade path: thread/queue/add + thread/queue/start once stable.
+        // Scope refusals to this turn: server requests from earlier calls belong to another context.
+        const seenRefused = client.refused.length;
+        // Arm refusal replies only now that our own turn/start is in flight, scoped
+        // to our own thread/turn: anything recorded earlier (resume, busy reject,
+        // queue) — or naming another thread or Desktop turn — stays unanswered so
+        // gbot never rejects another client's approval. Requests naming a turn
+        // 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.
+        if (!session) {
+            client.expectedThreadId = threadId;
+            client.expectedTurnId = null;
+            client.answerServerRequests = true;
+        }
+        let turn;
+        try {
+            turn = await client.request("turn/start", {
+                threadId,
+                input: [
+                    {
+                        type: "text",
+                        text: body
+                    }
+                ],
+                clientUserMessageId: envelope.messageId,
+                turnTrigger: "gbot"
+            });
+        } catch (err) {
+            if (err instanceof CodexSendError) throw err;
+            const delivery = err instanceof CodexRpcError ? "rejected" : err && err.delivery || "unknown";
+            const detail = err instanceof CodexRpcError ? err.message : "Lost the Codex turn/start response for thread " + threadId + ": " + (err && err.message || err) + ". Delivery is unknown; check the thread before resending.";
+            // No blind retry: the receipt carries messageId so the caller can look for it before resending.
+            throw new CodexSendError(detail, {
+                delivery,
+                reason: delivery === "rejected" ? "rejected" : "transport",
+                threadId,
+                ...envelope
+            });
+        }
+        const turnId = turn && turn.turn && typeof turn.turn.id === "string" && turn.turn.id ? turn.turn.id : null;
+        if (!turnId) {
+            throw new CodexSendError("Codex app-server sent a malformed turn/start acknowledgment for thread " + threadId + ". Delivery is unknown; check the thread before resending.", {
+                delivery: "unknown",
+                reason: "bad-response",
+                threadId,
+                ...envelope
+            });
+        }
+        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;
+            if (!params) return true;
+            const refusedThreadId = params.threadId ?? params.thread_id;
+            const refusedTurnId = params.turnId ?? params.turn_id ?? (params.turn && params.turn.id);
+            if (refusedThreadId != null && refusedThreadId !== threadId) return false;
+            if (refusedTurnId != null && refusedTurnId !== turnId) return false;
+            return true;
+        });
+        if (freshRefused.length) {
+            const methods = freshRefused.map((r)=>r.method).join(", ");
+            throw new CodexSendError("Turn " + turnId + " started on thread " + threadId + " but Codex asked for " + methods + ", which gbot refused. " + "Answer it in a Codex client, or set `approval_policy = \"never\"` in the daemon's config.toml for unattended sends.", {
+                delivery: "accepted",
+                reason: "approval-refused",
+                threadId,
+                turnId,
+                refused: freshRefused.map((r)=>r.method),
+                ...envelope
+            });
+        }
+        return {
+            delivery: "accepted",
+            ...receiptBase,
+            turnId,
+            turnStatus: turn.turn.status
+        };
+    } finally{
+        if (!session) client.close();
+    }
+}
+
+__webpack_require__.d(__webpack_exports__, {
+  $3: () => (assertThreadAllowed),
+  Mr: () => (withEnvelopeHeader),
+  X$: () => (listCodexThreads),
+  ZS: () => (sendToCodexThread),
+  e0: () => (experimentalEnabled),
+  eC: () => (openCodexSession),
+  nq: () => (buildEnvelope),
+  ql: () => (codexSocketPath)
+});
+
+
+},
+"./src/core/codex/contract.js"(__unused_rspack___webpack_module__, __webpack_exports__, __webpack_require__) {
+/* import */ var _url_policy_js__rspack_import_0 = __webpack_require__("./src/core/url-policy.js");
+/**
+ * #46 Codex contract documents and exit-code derivation.
+ * The bridge and the CLI routes flatten through these helpers so reason/delivery
+ * spelling stays one owner. No process I/O here.
+ */ 
+/** @typedef {'accepted' | 'queued' | 'rejected' | 'unknown'} CodexDelivery */ /**
+ * @typedef {{
+ *   delivery: CodexDelivery,
+ *   exitCode: 0 | 1,
+ *   error?: string,
+ *   reason?: string,
+ *   mode?: string,
+ *   threadId?: string,
+ *   turnId?: string,
+ *   turnStatus?: string,
+ *   queuedSubmissionId?: string,
+ *   refused?: string[],
+ *   messageId?: string,
+ *   correlationId?: string,
+ *   hop?: number,
+ *   replyTo?: string,
+ *   threadStatus?: string,
+ *   model?: string,
+ *   cwd?: string,
+ *   approvalPolicy?: string,
+ *   maxHops?: number,
+ * }} CodexSendOutcome
+ */ /**
+ * Exit 0 iff the daemon is usable.
+ * @param {{ reachable: boolean, mode: string }} status
+ * @returns {0 | 1}
+ */ function statusExitCode(status) {
+    return status.reachable && status.mode === "daemon" ? 0 : 1;
+}
+/**
+ * Attach derived exitCode to a status document (never mutates input).
+ * @param {Record<string, unknown>} status
+ */ function withStatusExitCode(status) {
+    return {
+        ...status,
+        exitCode: statusExitCode(/** @type {{ reachable: boolean, mode: string }} */ status)
+    };
+}
+/**
+ * @param {{
+ *   delivery: CodexDelivery,
+ *   reason?: string,
+ *   error?: string,
+ * }} outcome
+ * @returns {0 | 1}
+ */ function sendExitCode(outcome) {
+    if (outcome.error !== undefined) return 1;
+    if (outcome.delivery === "accepted" && outcome.reason === "approval-refused") return 1;
+    if (outcome.delivery === "rejected" || outcome.delivery === "unknown") return 1;
+    return 0;
+}
+/**
+ * Flatten a thrown error into the #46 send/failure document (plus exitCode).
+ *
+ * @param {unknown} error
+ * @param {{ isUsage?: (err: unknown) => boolean }} [opts]
+ * @returns {CodexSendOutcome & { error: string, exitCode: 1 }}
+ */ function outcomeFromError(error, opts = {}) {
+    const isUsage = opts.isUsage ?? ((err)=>err instanceof RangeError || Boolean(err && typeof err === "object" && err.name === "StoreError"));
+    const message = (0,_url_policy_js__rspack_import_0/* .redactSecrets */.fp)(error instanceof Error ? error.message : String(error));
+    /** @type {Record<string, unknown>} */ const out = {
+        error: message
+    };
+    if (error && typeof error === "object") {
+        for (const key of [
+            "delivery",
+            "reason",
+            "mode",
+            "threadId",
+            "turnId",
+            "targetId",
+            "messageId",
+            "correlationId",
+            "refused",
+            "hop"
+        ]){
+            if (error[key] !== undefined) out[key] = error[key];
+        }
+        if (out.reason === undefined && isUsage(error)) out.reason = "usage";
+    }
+    if (out.delivery === undefined) out.delivery = "rejected";
+    return /** @type {CodexSendOutcome & { error: string, exitCode: 1 }} */ {
+        ...out,
+        exitCode: 1
+    };
+}
+/**
+ * Normalize a successful send receipt into a document with exitCode.
+ * @param {Record<string, unknown>} receipt
+ * @returns {CodexSendOutcome}
+ */ function outcomeFromReceipt(receipt) {
+    const base = {
+        ...receipt
+    };
+    if (base.delivery === undefined) base.delivery = "accepted";
+    const exitCode = sendExitCode(/** @type {{ delivery: CodexDelivery, reason?: string, error?: string }} */ base);
+    if (exitCode === 1 && base.error === undefined && base.reason === "approval-refused") {
+        base.error = typeof base.message === "string" ? base.message : "Codex refused one or more approvals.";
+    }
+    return /** @type {CodexSendOutcome} */ {
+        ...base,
+        exitCode
+    };
+}
+
+__webpack_require__.d(__webpack_exports__, {
+  DG: () => (outcomeFromError),
+  Dz: () => (outcomeFromReceipt)
+});
+
+
+},
+"./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/desktop-shim.js"(__unused_rspack___webpack_module__, __unused_rspack___webpack_exports__, __webpack_require__) {
+/* import */ var node_child_process__rspack_import_0 = __webpack_require__("node:child_process");
+/* import */ var node_fs__rspack_import_1 = __webpack_require__("node:fs");
+/* import */ var node_os__rspack_import_2 = __webpack_require__("node:os");
+/* import */ var node_path__rspack_import_3 = __webpack_require__("node:path");
+
+
+
+
+
+/**
+ * ChatGPT Desktop -> managed Codex daemon shim (CODEX_CLI_PATH bridge).
+ *
+ * Desktop injects `codex_app` overrides so CODEX_APP_SERVER_USE_LOCAL_DAEMON=1
+ * alone cannot select the managed daemon, and stock `codex app-server proxy`
+ * hangs for Desktop stdio. The winning path is a wrapper on CODEX_CLI_PATH
+ * that rewrites Desktop's `codex ... app-server` spawn into the stdio<->WS
+ * bridge (desktop-shim-bridge.js) onto the managed control socket.
+ * Provenance: uploads/codex-desktop-to-daemon + codex-desktop-shared-daemon-env.sh.
+ *
+ * Fail-open is the hard rule: the wrapper execs the real standalone `codex`
+ * for non-app-server spawns and whenever the bridge/python/socket side is
+ * missing or broken. Never touches Desktop binaries, /tmp/codex-browser-use/,
+ * or CODEX_APP_TOOLS_PIPE_PATH. No protocol change: gbot already speaks the
+ * managed control socket.
+ */ const SHIM_LABEL = "com.zackjackson.codex-desktop-shared-daemon";
+const WRAPPER_FILENAME = "codex-desktop-to-daemon";
+const BRIDGE_FILENAME = "codex-stdio-to-daemon-ws.py";
+const ENV_SCRIPT_FILENAME = "codex-desktop-shared-daemon-env.sh";
+const BRIDGE_LOG_FILENAME = "codex-stdio-to-daemon-ws.log";
+const WRAPPER_LOG_FILENAME = "codex-desktop-to-daemon.log";
+const ENV_LOG_FILENAME = "codex-desktop-shared-daemon-env.log";
+const STANDALONE_REAL_SUFFIX = (0,node_path__rspack_import_3.join)("packages", "standalone", "current", "bin", "codex");
+function codexHomeDir(env = process.env) {
+    return env.CODEX_HOME || join(env.HOME || homedir(), ".codex");
+}
+function userHomeDir(env = process.env) {
+    return env.HOME || homedir();
+}
+function defaultPaths({ env = process.env, home = userHomeDir(env) } = {}) {
+    const codexHome = env.CODEX_HOME || join(home, ".codex");
+    const binDir = join(codexHome, "bin");
+    return {
+        binDir,
+        bridgeLogPath: join(binDir, BRIDGE_LOG_FILENAME),
+        bridgePath: join(binDir, BRIDGE_FILENAME),
+        codexHome,
+        envLogPath: join(binDir, ENV_LOG_FILENAME),
+        envScriptPath: join(binDir, ENV_SCRIPT_FILENAME),
+        label: SHIM_LABEL,
+        launchAgentsDir: join(home, "Library", "LaunchAgents"),
+        plistPath: join(home, "Library", "LaunchAgents", `${SHIM_LABEL}.plist`),
+        realPath: join(codexHome, STANDALONE_REAL_SUFFIX),
+        socketPath: join(codexHome, "app-server-control", "app-server-control.sock"),
+        wrapperLogPath: join(binDir, WRAPPER_LOG_FILENAME),
+        wrapperPath: join(binDir, WRAPPER_FILENAME)
+    };
+}
+/**
+ * Pure passthrough decision, mirroring the wrapper's argv scan. True only for
+ * a bare `app-server` spawn: Desktop's private-stdio case. `daemon`, `proxy`,
+ * and schema generations always exec the real Codex.
+ */ function shouldBridge(argv) {
+    let appServer = false;
+    let daemon = false;
+    let proxy = false;
+    let generate = false;
+    for (const arg of argv ?? []){
+        if (arg === "app-server") appServer = true;
+        else if (arg === "daemon") daemon = true;
+        else if (arg === "proxy") proxy = true;
+        else if (arg === "generate-ts" || arg === "generate-json-schema") generate = true;
+    }
+    return appServer && !daemon && !proxy && !generate;
+}
+function renderWrapperScript({ realPath, bridgePath, wrapperLogPath, codexHome, bridgeLogPath }) {
+    return `#!/bin/bash
+# Installed by \`gbot codex desktop-shim install\`. Rewrites ChatGPT Desktop's
+# \`codex ... app-server\` spawn into a stdio<->WebSocket bridge onto the managed
+# daemon's control socket. Reversible: \`gbot codex desktop-shim uninstall\`.
+# The daemon is kept up by the LaunchAgent login script, not here: this hot path
+# never starts the daemon itself, so a wedged daemon lock cannot hang
+# Desktop. Fail-open runs ONLY while stdio is still pristine (no stdin
+# consumed, no stdout written): an absent socket fails the preflight and a
+# pre-session bridge failure (exit 1) falls through
+# to the real standalone codex on pristine stdio. A mid-session bridge failure
+# (exit 2+) exits promptly so Desktop reconnects; the fallback never runs on
+# half-consumed stdin or dirty stdout. Bridge exit 0 means it served the session. Never touches
+# Desktop binaries or its private tool pipe.
+set -u
+REAL="\${CODEX_DESKTOP_WRAPPER_REAL:-${realPath}}"
+BRIDGE="\${CODEX_DESKTOP_BRIDGE:-${bridgePath}}"
+export CODEX_HOME="\${CODEX_HOME:-${codexHome}}"
+SOCK="\${CODEX_APP_SERVER_SOCK:-$CODEX_HOME/app-server-control/app-server-control.sock}"
+BRIDGE_LOG="\${CODEX_STDIO_BRIDGE_LOG:-${bridgeLogPath}}"
+LOG="\${CODEX_DESKTOP_WRAPPER_LOG:-${wrapperLogPath}}"
+export CODEX_APP_SERVER_SOCK="$SOCK"
+export CODEX_STDIO_BRIDGE_LOG="$BRIDGE_LOG"
+ts() { date -u +%Y-%m-%dT%H:%M:%SZ; }
+echo "$(ts) argv: $*" >>"$LOG" 2>/dev/null || true
+
+if [[ ! -x "$REAL" ]]; then
+  FALLBACK="$(command -v codex 2>/dev/null || true)"
+  if [[ -n "$FALLBACK" && -x "$FALLBACK" ]]; then
+    if [[ "$FALLBACK" -ef "$0" ]] 2>/dev/null || { [[ -n "\${CODEX_CLI_PATH:-}" ]] && [[ "$FALLBACK" -ef "\${CODEX_CLI_PATH}" ]] 2>/dev/null; }; then
+      echo "$(ts) refusing self fallback $FALLBACK" >>"$LOG" 2>/dev/null || true
+    else
+      REAL="$FALLBACK"
+    fi
+  fi
+fi
+
+has_app_server=0; has_daemon=0; has_proxy=0; has_generate=0
+for a in "$@"; do
+  case "$a" in
+    app-server) has_app_server=1 ;;
+    daemon) has_daemon=1 ;;
+    proxy) has_proxy=1 ;;
+    generate-ts|generate-json-schema) has_generate=1 ;;
+  esac
+done
+
+# Preflight the daemon socket with a short deadline: a refused/absent socket
+# means starting the bridge could never succeed, so skip straight to real codex.
+preflight() {
+  python3 -c 'import os,socket,sys; s=socket.socket(socket.AF_UNIX,socket.SOCK_STREAM); s.settimeout(float(os.environ.get("CODEX_DESKTOP_PREFLIGHT_TIMEOUT","3"))); s.connect(sys.argv[1]); s.close()' "$SOCK" 2>/dev/null
+}
+
+if [[ "$has_app_server" -eq 1 && "$has_daemon" -eq 0 && "$has_proxy" -eq 0 && "$has_generate" -eq 0 ]]; then
+  if [[ -f "$BRIDGE" ]] && command -v python3 >/dev/null 2>&1; then
+    if preflight; then
+      echo "$(ts) rewrite -> stdio-ws bridge" >>"$LOG" 2>/dev/null || true
+      python3 "$BRIDGE"
+      rc=$?
+      case "$rc" in
+        0)
+          echo "$(ts) bridge served session" >>"$LOG" 2>/dev/null || true
+          exit 0
+          ;;
+        1)
+          echo "$(ts) bridge failed before session start, falling through to real codex" >>"$LOG" 2>/dev/null || true
+          ;;
+        *)
+          echo "$(ts) bridge failed mid-session (rc=$rc); exiting so Desktop reconnects" >>"$LOG" 2>/dev/null || true
+          exit "$rc"
+          ;;
+      esac
+    else
+      echo "$(ts) daemon socket unreachable, passthrough to real codex" >>"$LOG" 2>/dev/null || true
+    fi
+  else
+    echo "$(ts) bridge unavailable, passthrough to real codex" >>"$LOG" 2>/dev/null || true
+  fi
+fi
+if [[ -x "$REAL" ]]; then
+  exec "$REAL" "$@"
+fi
+echo "codex-desktop-to-daemon: no runnable codex found" >&2
+exit 1
+`;
+}
+function renderEnvScript({ wrapperPath, realPath, envLogPath, codexHome }) {
+    return `#!/bin/bash
+# Installed by \`gbot codex desktop-shim install\`. Re-applies the GUI-domain env
+# so ChatGPT.app inherits CODEX_CLI_PATH after login, then best-effort starts the
+# managed daemon (this login script — never Desktop's spawn hot path — owns
+# daemon upkeep). No -e: every step is best-effort so login never breaks.
+# Revert: \`gbot codex desktop-shim uninstall\`.
+set -u
+WRAPPER="${wrapperPath}"
+REAL="${realPath}"
+LOG="${envLogPath}"
+CODEX_HOME_DIR="${codexHome}"
+# One CODEX_HOME for the GUI domain and this script's own daemon start, so the
+# daemon that is kept up is the one the wrapper bridges to.
+export CODEX_HOME="$CODEX_HOME_DIR"
+ts() { date -u +%Y-%m-%dT%H:%M:%SZ; }
+{
+  echo "$(ts) start"
+  if [[ ! -x "$WRAPPER" ]]; then
+    echo "$(ts) missing wrapper: $WRAPPER"
+    exit 0
+  fi
+  # GUI domain setenv so ChatGPT.app inherits CODEX_CLI_PATH after login
+  launchctl setenv CODEX_CLI_PATH "$WRAPPER"
+  launchctl setenv CODEX_HOME "$CODEX_HOME_DIR"
+  launchctl setenv CODEX_APP_SERVER_USE_LOCAL_DAEMON 1
+  launchctl unsetenv CODEX_APP_SERVER_WS_URL 2>/dev/null || true
+  echo "$(ts) CODEX_CLI_PATH=$(launchctl getenv CODEX_CLI_PATH)"
+  if [[ -x "$REAL" ]]; then
+    "$REAL" app-server daemon start >/dev/null 2>&1 || true
+    echo "$(ts) daemon start attempted"
+  fi
+  echo "$(ts) done"
+} >>"$LOG" 2>&1
+`;
+}
+function renderPlist({ envScriptPath, label = SHIM_LABEL }) {
+    return `<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+\t<key>Label</key>
+\t<string>${label}</string>
+\t<key>ProgramArguments</key>
+\t<array>
+\t\t<string>/bin/bash</string>
+\t\t<string>${envScriptPath}</string>
+\t</array>
+\t<key>RunAtLoad</key>
+\t<true/>
+\t<key>LimitLoadToSessionType</key>
+\t<string>Aqua</string>
+</dict>
+</plist>
+`;
+}
+const defaultRunner = (file, args)=>{
+    try {
+        return spawnSync(file, args, {
+            encoding: "utf8",
+            timeout: 15000
+        });
+    } catch (error) {
+        return {
+            error,
+            status: null
+        };
+    }
+};
+function runBestEffort(runner, warnings, what, file, args) {
+    const out = runner(file, args);
+    if (out && (out.error || typeof out.status === "number" && out.status !== 0)) {
+        const detail = out.error && out.error.message || out.stderr && String(out.stderr).trim() || `exit ${out.status}`;
+        warnings.push(`${what} failed (${detail}); continuing`);
+    }
+    return out;
+}
+function writeExecutable(path, content) {
+    writeFileSync(path, content, {
+        mode: 493
+    });
+    chmodSync(path, 493);
+}
+function isExecutable(path) {
+    try {
+        statSync(path);
+    } catch  {
+        return false;
+    }
+    try {
+        // X_OK without throwing: accessSync is clearer; stat mode bit check is sync-safe.
+        return (statSync(path).mode & 73) !== 0;
+    } catch  {
+        return false;
+    }
+}
+function fileExists(path) {
+    try {
+        statSync(path);
+        return true;
+    } catch  {
+        return false;
+    }
+}
+/**
+ * Copy the wrapper + bridge + login env script out of the package into durable
+ * ~/.codex paths (never a git checkout), then persist CODEX_CLI_PATH for the
+ * macOS Aqua session via LaunchAgent. Idempotent.
+ */ function installDesktopShim({ env = process.env, home = userHomeDir(env), platform = process.platform, runner = defaultRunner } = {}) {
+    const paths = defaultPaths({
+        env,
+        home
+    });
+    const warnings = [];
+    mkdirSync(paths.binDir, {
+        recursive: true
+    });
+    writeExecutable(paths.wrapperPath, renderWrapperScript(paths));
+    writeFileSync(paths.bridgePath, BRIDGE_SOURCE.endsWith("\n") ? BRIDGE_SOURCE : `${BRIDGE_SOURCE}\n`, {
+        mode: 420
+    });
+    writeExecutable(paths.envScriptPath, renderEnvScript(paths));
+    let persisted = false;
+    if (platform === "darwin") {
+        mkdirSync(paths.launchAgentsDir, {
+            recursive: true
+        });
+        writeFileSync(paths.plistPath, renderPlist({
+            envScriptPath: paths.envScriptPath
+        }), {
+            mode: 420
+        });
+        const uid = typeof process.getuid === "function" ? process.getuid() : null;
+        if (uid === null || uid === undefined) {
+            warnings.push("could not determine uid; LaunchAgent file written but not bootstrapped — log out/in or bootstrap it manually");
+        } else {
+            const target = `gui/${uid}/${paths.label}`;
+            runBestEffort(runner, warnings, "launchctl bootout (previous agent)", "launchctl", [
+                "bootout",
+                target
+            ]);
+            runBestEffort(runner, warnings, "launchctl bootstrap", "launchctl", [
+                "bootstrap",
+                `gui/${uid}`,
+                paths.plistPath
+            ]);
+        }
+        runBestEffort(runner, warnings, "launchctl setenv CODEX_CLI_PATH", "launchctl", [
+            "setenv",
+            "CODEX_CLI_PATH",
+            paths.wrapperPath
+        ]);
+        runBestEffort(runner, warnings, "launchctl setenv CODEX_APP_SERVER_USE_LOCAL_DAEMON", "launchctl", [
+            "setenv",
+            "CODEX_APP_SERVER_USE_LOCAL_DAEMON",
+            "1"
+        ]);
+        runBestEffort(runner, warnings, "launchctl unsetenv CODEX_APP_SERVER_WS_URL", "launchctl", [
+            "unsetenv",
+            "CODEX_APP_SERVER_WS_URL"
+        ]);
+        persisted = true;
+    } else {
+        warnings.push("LaunchAgent persistence is macOS-only; wrapper and bridge installed — export CODEX_CLI_PATH manually");
+    }
+    if (isExecutable(paths.realPath)) {
+        runBestEffort(runner, warnings, "codex app-server daemon start", paths.realPath, [
+            "app-server",
+            "daemon",
+            "start"
+        ]);
+    } else {
+        warnings.push(`managed daemon not started: no executable at ${paths.realPath}`);
+    }
+    return {
+        action: "install",
+        bridgePath: paths.bridgePath,
+        envScriptPath: paths.envScriptPath,
+        exitCode: 0,
+        persisted,
+        plistPath: platform === "darwin" ? paths.plistPath : null,
+        realPath: paths.realPath,
+        warnings,
+        wrapperPath: paths.wrapperPath
+    };
+}
+/** Remove what install wrote and unset the GUI env; Desktop/Codex fall back to stock. */ function uninstallDesktopShim({ env = process.env, home = userHomeDir(env), platform = process.platform, runner = defaultRunner } = {}) {
+    const paths = defaultPaths({
+        env,
+        home
+    });
+    const warnings = [];
+    const removed = [];
+    for (const path of [
+        paths.wrapperPath,
+        paths.bridgePath,
+        paths.envScriptPath
+    ]){
+        const existed = fileExists(path);
+        try {
+            if (rmSync(path, {
+                force: true
+            }) === undefined && fileExists(path)) warnings.push(`could not remove ${path}`);
+            else if (existed && !fileExists(path)) removed.push(path);
+        } catch (error) {
+            warnings.push(`could not remove ${path} (${error instanceof Error ? error.message : String(error)})`);
+        }
+    }
+    let plistRemoved = false;
+    if (platform === "darwin") {
+        const uid = typeof process.getuid === "function" ? process.getuid() : null;
+        if (uid !== null && uid !== undefined) {
+            runBestEffort(runner, warnings, "launchctl bootout", "launchctl", [
+                "bootout",
+                `gui/${uid}/${paths.label}`
+            ]);
+        }
+        try {
+            rmSync(paths.plistPath, {
+                force: true
+            });
+            plistRemoved = !fileExists(paths.plistPath);
+        } catch (error) {
+            warnings.push(`could not remove ${paths.plistPath} (${error instanceof Error ? error.message : String(error)})`);
+        }
+        runBestEffort(runner, warnings, "launchctl unsetenv CODEX_CLI_PATH", "launchctl", [
+            "unsetenv",
+            "CODEX_CLI_PATH"
+        ]);
+        runBestEffort(runner, warnings, "launchctl unsetenv CODEX_HOME", "launchctl", [
+            "unsetenv",
+            "CODEX_HOME"
+        ]);
+        runBestEffort(runner, warnings, "launchctl unsetenv CODEX_APP_SERVER_USE_LOCAL_DAEMON", "launchctl", [
+            "unsetenv",
+            "CODEX_APP_SERVER_USE_LOCAL_DAEMON"
+        ]);
+        runBestEffort(runner, warnings, "launchctl unsetenv CODEX_APP_SERVER_WS_URL", "launchctl", [
+            "unsetenv",
+            "CODEX_APP_SERVER_WS_URL"
+        ]);
+    }
+    return {
+        action: "uninstall",
+        exitCode: 0,
+        plistPath: platform === "darwin" ? paths.plistPath : null,
+        plistRemoved,
+        removed,
+        warnings,
+        wrapperPath: paths.wrapperPath
+    };
+}
+function socketStateOf(path) {
+    try {
+        return statSync(path).isSocket() ? "socket" : "not-a-socket";
+    } catch (error) {
+        return error && (error.code === "EACCES" || error.code === "EPERM") ? "permission-denied" : "absent";
+    }
+}
+/**
+ * Inspect the shim without touching Desktop, pipes, or sockets beyond a stat.
+ * On macOS the Desktop-facing CODEX_CLI_PATH lives in launchd's GUI domain,
+ * which a shell-spawned `gbot` does not inherit — so status queries
+ * `launchctl getenv` there (via the injectable runner) and reports the caller
+ * environment separately. Elsewhere the process env is the whole story.
+ */ function desktopShimStatus({ env = process.env, home = userHomeDir(env), platform = process.platform, runner = defaultRunner } = {}) {
+    const paths = defaultPaths({
+        env,
+        home
+    });
+    const warnings = [];
+    const wrapperPresent = fileExists(paths.wrapperPath);
+    const bridgePresent = fileExists(paths.bridgePath);
+    const envScriptPresent = fileExists(paths.envScriptPath);
+    const plistPresent = platform === "darwin" ? fileExists(paths.plistPath) : false;
+    const cliPath = env.CODEX_CLI_PATH || null;
+    let guiCliPath = null;
+    if (platform === "darwin") {
+        try {
+            const out = runner("launchctl", [
+                "getenv",
+                "CODEX_CLI_PATH"
+            ]);
+            const value = out && typeof out.stdout === "string" ? out.stdout.trim() : "";
+            guiCliPath = value || null;
+            if (out && (out.error || typeof out.status === "number" && out.status !== 0)) {
+                warnings.push("launchctl getenv CODEX_CLI_PATH failed; GUI-domain state unknown");
+                guiCliPath = null;
+            }
+        } catch (error) {
+            warnings.push(`launchctl getenv CODEX_CLI_PATH failed (${error instanceof Error ? error.message : String(error)})`);
+            guiCliPath = null;
+        }
+    }
+    // Desktop-facing value: the GUI domain on macOS, the caller env elsewhere.
+    const desktopCliPath = platform === "darwin" ? guiCliPath : cliPath;
+    const installed = wrapperPresent && isExecutable(paths.wrapperPath) && bridgePresent;
+    // Effective socket, resolved exactly like gbot's own client (CODEX_APP_SERVER_SOCK
+    // wins, else the install-time CODEX_HOME) so status and send/queue/status never
+    // disagree. Inlined here so codex-bridge can reuse desktopShimStatus without a cycle.
+    const socketPath = env.CODEX_APP_SERVER_SOCK || join(paths.codexHome, "app-server-control", "app-server-control.sock");
+    return {
+        action: "status",
+        bridgePath: paths.bridgePath,
+        bridgePresent,
+        cliPath,
+        codexHome: paths.codexHome,
+        desktopCliPath,
+        envScriptPath: paths.envScriptPath,
+        envScriptPresent,
+        exitCode: installed ? 0 : 1,
+        guiCliPath,
+        installed,
+        persisted: platform === "darwin" ? plistPresent : null,
+        platform,
+        plistPath: platform === "darwin" ? paths.plistPath : null,
+        plistPresent,
+        realPath: paths.realPath,
+        socketPath,
+        socketSource: env.CODEX_APP_SERVER_SOCK ? "CODEX_APP_SERVER_SOCK" : "CODEX_HOME",
+        socketState: socketStateOf(socketPath),
+        warnings,
+        wrapperExecutable: wrapperPresent && isExecutable(paths.wrapperPath),
+        wrapperPath: paths.wrapperPath,
+        wrapperPointsAtShim: desktopCliPath === paths.wrapperPath,
+        wrapperPresent
+    };
+}
+
+
 },
 "./src/core/gateway.js"(__unused_rspack___webpack_module__, __webpack_exports__, __webpack_require__) {
 /* import */ var node_crypto__rspack_import_0 = __webpack_require__("node:crypto");
@@ -106571,20 +110469,33 @@ 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.SAND_BACKEND_URL || process.env.CURSOR_API_BASE_URL || "https://api2.cursor.sh").replace(/\/$/, "");
+    return (process.env.CURSOR_API_BASE_URL || "https://api2.cursor.sh").replace(/\/$/, "");
 }
 function accessTokenFromEnv() {
-    return (process.env.CURSOR_ACCESS_TOKEN || process.env.GROK_BOT_ACCESS_TOKEN || process.env.SAND_ACCESS_TOKEN || "").trim();
+    return (process.env.CURSOR_ACCESS_TOKEN || "").trim();
 }
 function gatewayTokenFromEnv() {
-    return (process.env.GROK_BOT_GATEWAY_TOKEN || process.env.SAND_HOST_GATEWAY_TOKEN || process.env.SAND_GATEWAY_TOKEN || "").trim();
+    return (process.env.GROK_BOT_GATEWAY_TOKEN || "").trim();
 }
 function gatewayOverride() {
     const token = gatewayTokenFromEnv();
-    const explicitUrl = (process.env.GROK_BOT_GATEWAY_URL || process.env.SAND_HOST_GATEWAY_URL || "").trim();
-    const localUrl = token ? "http://127.0.0.1:" + (process.env.SAND_HOST_PORT || "1340") : "";
-    const url = explicitUrl || localUrl;
+    const url = (process.env.GROK_BOT_GATEWAY_URL || "").trim();
     if (url && token) {
         return {
             gatewayUrl: (0,_url_policy_js__rspack_import_3/* .assertAllowedCredentialUrl */.Re)(url.replace(/\/$/, ""), {
@@ -106661,18 +110572,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), {
@@ -106693,7 +110612,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();
@@ -106702,21 +110622,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)), {
@@ -106768,8 +110703,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) {
@@ -106781,8 +110718,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", {
@@ -106905,7 +110844,10 @@ async function removeGroupMember(session, groupRef, memberRef) {
     return setGroupMembers(session, group.id, next);
 }
 async function sendPrompt(session, ref, prompt, extra = {}) {
-    const rec = await resolveRef(session, ref);
+    assertGatewayActive(extra.signal);
+    const rec = await resolveRef(session, ref, {
+        signal: extra.signal
+    });
     const body = {
         agentId: rec.id,
         prompt,
@@ -106914,7 +110856,9 @@ async function sendPrompt(session, ref, prompt, extra = {}) {
     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.
@@ -107035,6 +110979,268 @@ __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)
+});
+
+
+},
+"./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__, __unused_rspack___webpack_exports__, __webpack_require__) {
 /* import */ var node_crypto__rspack_import_0 = __webpack_require__("node:crypto");
@@ -107102,10 +111308,7 @@ function isUuid(value) {
 function defaultCandidateRoots() {
     const home = homedir();
     const env = [
-        process.env.GROK_BOT_AGENTS_DIR,
-        process.env.SAND_AGENTS_DIR,
-        process.env.SAND_DATA_ROOT && join(process.env.SAND_DATA_ROOT, "agents"),
-        process.env.SAND_DATA_ROOT && join(process.env.SAND_DATA_ROOT, "agent-data", "agents")
+        process.env.GROK_BOT_AGENTS_DIR
     ].filter(Boolean);
     return [
         ...env,
@@ -107365,7 +111568,6 @@ function removeGroupMember(root, groupRef, memberRef) {
 
 },
 "./src/core/transcript.js"(__unused_rspack___webpack_module__, __webpack_exports__, __webpack_require__) {
-// Shared by `gbot thread` and the grok-bot plugin's gbot_thread tool.
 /** Coerce anything to a string without throwing (numbers, BigInt, unserializable objects). */ function toSafeText(value) {
     if (typeof value === "string") return value;
     if (value == null) return "";
@@ -107403,15 +111605,12 @@ function entryTextRaw(e) {
     return typeof e.preview === "string" ? e.preview : "";
 }
 function transcriptEntries(payload) {
-    if (Array.isArray(payload)) return payload;
     if (!payload || typeof payload !== "object") return [];
-    const entries = payload.entries || payload.messages || payload.items;
-    return Array.isArray(entries) ? entries : [];
+    return Array.isArray(payload.entries) ? payload.entries : [];
 }
 function sourceEntryId(entry) {
     if (!entry || typeof entry !== "object") return "";
-    if (typeof entry.id === "string" && entry.id) return entry.id;
-    return typeof entry.messageId === "string" ? entry.messageId : "";
+    return typeof entry.id === "string" ? entry.id : "";
 }
 function lastSourceId(entries, fallback = "") {
     for(let index = entries.length - 1; index >= 0; index -= 1){
@@ -107587,6 +111786,10 @@ __webpack_require__.d(__webpack_exports__, {
 });
 
 
+},
+"./package.json"(module) {
+module.exports = {"rE":"0.6.0"}
+
 },
 
 });