talentos 1.1.5 → 1.1.6

package/dist/agent/adapters.js

@@ -1,7 +1,6 @@
 import { execFile, spawn } from "node:child_process";
 import { existsSync } from "node:fs";
-import { mkdtemp, rm } from "node:fs/promises";
-import { tmpdir } from "node:os";
+import { rm } from "node:fs/promises";
 import { dirname, join } from "node:path";
 import { createInterface } from "node:readline";
 import { fileURLToPath } from "node:url";
@@ -10,6 +9,8 @@ import { writePrivateFile } from "../agent-config.js";
 import { redactAgentOutput, } from "../agent-link.js";
 import { gatewayLauncherPath } from "../gateway-install.js";
 import { providerPathEnv, resolveProviderBinary } from "../provider-binary.js";
+import { codexRoomArgs, ROOM_TOOLS } from "./codex-policy.js";
+import { CodexBoundaryError, probeCodexBoundary } from "./codex-probe.js";
 const CHILD_ENV = [
     "HOME",
     "PATH",
@@ -26,26 +27,9 @@ const CHILD_ENV = [
     "CODEX_HOME",
     "CLAUDE_CONFIG_DIR",
 ];
-// Shared with the preflight: older Codex parses agents.enabled as a role.
-const CODEX_ROOM_GATES = ["agents.enabled=false", "features.goals=false"];
 const CLAUDE_VERSION = /^\d+\.\d+\.\d+/u;
 const CODEX_VERSION = /\b\d+\.\d+\.\d+\b/u;
 const DONT_ASK = /\bdontAsk\b/u;
-// Kept package-local for the published CLI. The launch tests compare both
-// adapters against the server's exported ROOM_AGENT_TOOLS contract.
-const ROOM_TOOLS = [
-    "list_rooms",
-    "read_room",
-    "list_room_files",
-    "read_file",
-    "get_skill",
-    "suggest_change",
-    "create_file",
-    "create_deck",
-    "post_message",
-    "share_link",
-    "whoami",
-];
 const CLAUDE_TOOLS = ROOM_TOOLS.map((tool) => `mcp__talentos__${tool}`).join(",");
 export function childEnvironment(source = process.env, binary) {
     return {
@@ -78,12 +62,13 @@ export async function verifyClaudeCode(configured) {
     }
     throw new Error(`Update Claude Code (${version}) to a version that supports --permission-mode dontAsk.`);
 }
-export async function verifyCodex(configured) {
+export async function verifyCodex(configured, signal) {
     const binary = resolveProviderBinary("codex", configured);
     const execute = promisify(execFile);
     const options = {
         env: childEnvironment(process.env, binary),
         timeout: 5000,
+        signal,
         maxBuffer: 256_000,
     };
     let version = "unknown";
@@ -105,26 +90,14 @@ export async function verifyCodex(configured) {
             }
         }
         if (version !== "unknown") {
-            await codexRoomCatalog(binary);
-            const directory = await mkdtemp(join(tmpdir(), "talentos-codex-probe-"));
-            try {
-                await execute(binary, [
-                    ...CODEX_ROOM_GATES.flatMap((gate) => ["-c", gate]),
-                    "features",
-                    "list",
-                ], {
-                    ...options,
-                    cwd: directory,
-                    env: { ...options.env, CODEX_HOME: directory },
-                });
-            }
-            finally {
-                await rm(directory, { recursive: true, force: true });
-            }
+            await probeCodexBoundary(binary, version, await codexRoomCatalog(binary), signal);
             return;
         }
     }
-    catch {
+    catch (error) {
+        if (error instanceof CodexBoundaryError) {
+            throw error;
+        }
         // Provider diagnostics can contain login details.
     }
     throw new Error(`Update Codex (${version}) to a version supporting isolated room turns, exec/resume flags and a local model catalog.`);
@@ -157,6 +130,7 @@ async function codexRoomCatalog(binary) {
                 // Code-mode-only models route MCP through native execution. Expose
                 // allowed MCP functions directly while native execution stays off.
                 tool_mode: "direct",
+                supports_search_tool: false,
             };
         });
         return JSON.stringify({ ...catalog, models });
@@ -258,49 +232,21 @@ export async function runProvider(input) {
         await writePrivateFile(catalogPath, await codexRoomCatalog(binary));
         // Resume has a different flag surface. Root overrides are inherited by
         // both exec paths; shell_tool=false enforces ADR 0093's default no-Bash.
-        args = [
-            "-c",
-            'sandbox_mode="read-only"',
-            "-c",
-            'approval_policy="never"',
-            "-c",
-            "features.shell_tool=false",
-            "-c",
-            "features.unified_exec=false",
-            "-c",
-            'web_search="disabled"',
-            "-c",
-            "features.view_image=false",
-            "-c",
-            "features.image_generation=false",
-            "-c",
-            "features.apps=false",
-            "-c",
-            "features.plugins=false",
-            "-c",
-            "features.multi_agent=false",
-            // Codex also gates collaboration separately from the legacy feature.
-            ...CODEX_ROOM_GATES.flatMap((gate) => ["-c", gate]),
-            "-c",
-            "features.skip_host_skill_discovery=true",
-            "-c",
-            "memories.use_memories=false",
-            "-c",
-            "memories.generate_memories=false",
-            "-c",
-            `model_catalog_json=${JSON.stringify(catalogPath)}`,
-            "-c",
-            `mcp_servers.talentos.enabled_tools=${JSON.stringify(ROOM_TOOLS)}`,
-            "-c",
-            `mcp_servers.talentos.command=${JSON.stringify(useLauncher ? launcher : process.execPath)}`,
-            "-c",
-            `mcp_servers.talentos.args=${JSON.stringify([...(useLauncher ? [] : [fileURLToPath(new URL("../index.js", import.meta.url))]), "agent", "mcp", "--agent", config.agentId])}`,
-            "exec",
-        ];
-        if (sessionId) {
-            args.push("resume", sessionId);
-        }
-        args.push("--json", "--skip-git-repo-check", "--ignore-user-config", "--ignore-rules", prompt);
+        args = codexRoomArgs({
+            catalogPath,
+            mcpCommand: useLauncher ? launcher : process.execPath,
+            mcpArgs: [
+                ...(useLauncher
+                    ? []
+                    : [fileURLToPath(new URL("../index.js", import.meta.url))]),
+                "agent",
+                "mcp",
+                "--agent",
+                config.agentId,
+            ],
+            prompt,
+            sessionId,
+        });
     }
     const child = spawn(command, args, {
         cwd: workDir,

package/dist/agent/codex-policy.js

@@ -0,0 +1,67 @@
+export const ROOM_TOOLS = [
+    "list_rooms",
+    "read_room",
+    "list_room_files",
+    "read_file",
+    "get_skill",
+    "suggest_change",
+    "create_file",
+    "create_deck",
+    "post_message",
+    "share_link",
+    "whoami",
+];
+export function codexRoomArgs(input) {
+    const { catalogPath, mcpCommand, mcpArgs, prompt, sessionId } = input;
+    const args = [
+        "-c",
+        'sandbox_mode="read-only"',
+        "-c",
+        'approval_policy="never"',
+        "-c",
+        "features.shell_tool=false",
+        "-c",
+        "features.unified_exec=false",
+        "-c",
+        'web_search="disabled"',
+        "-c",
+        "features.view_image=false",
+        "-c",
+        "features.image_generation=false",
+        "-c",
+        "features.apps=false",
+        "-c",
+        "features.plugins=false",
+        "-c",
+        "features.multi_agent=false",
+        // Codex also gates collaboration separately from the legacy feature.
+        "-c",
+        "agents.enabled=false",
+        "-c",
+        "features.goals=false",
+        "-c",
+        "tools.experimental_request_user_input.enabled=false",
+        "-c",
+        "features.tool_search=false",
+        "-c",
+        "features.skip_host_skill_discovery=true",
+        "-c",
+        "memories.use_memories=false",
+        "-c",
+        "memories.generate_memories=false",
+        "-c",
+        `model_catalog_json=${JSON.stringify(catalogPath)}`,
+        "-c",
+        `mcp_servers.talentos.enabled_tools=${JSON.stringify(ROOM_TOOLS)}`,
+        "-c",
+        `mcp_servers.talentos.command=${JSON.stringify(mcpCommand)}`,
+        "-c",
+        `mcp_servers.talentos.args=${JSON.stringify(mcpArgs)}`,
+        "exec",
+    ];
+    if (sessionId) {
+        args.push("resume", sessionId);
+    }
+    args.push("--json", "--skip-git-repo-check", "--ignore-user-config", "--ignore-rules", prompt);
+    return args;
+}

package/dist/agent/codex-probe.js

@@ -0,0 +1,424 @@
+import { spawn } from "node:child_process";
+import { createHash, randomUUID } from "node:crypto";
+import { mkdtemp, readFile, realpath, rm, stat, writeFile, } from "node:fs/promises";
+import { createServer } from "node:http";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { pathToFileURL } from "node:url";
+import { writePrivateFile } from "../agent-config.js";
+import { homeDir } from "../install.js";
+import { ProviderBinaryError, providerPathEnv } from "../provider-binary.js";
+import { codexRoomArgs, ROOM_TOOLS } from "./codex-policy.js";
+const PROBE_MS = 30_000;
+const MAX_BYTES = 4_000_000;
+const PROBE_REVISION = 2;
+const RESOURCE_REFUSAL = /Method not found|unknown MCP server/u;
+const INPUT_TYPES = new Set([
+    "message",
+    "reasoning",
+    "compaction",
+    "function_call",
+    "function_call_output",
+    "tool_search_call",
+    "additional_tools",
+    "tool_search_output",
+]);
+// These route only to the sole tools-only MCP server, which has no resource
+// handlers. The loopback probe exercises their refusal on fresh and resume.
+const RESOURCE_HELPERS = [
+    "list_mcp_resources", // Sole tools-only MCP server: no resources to list.
+    "list_mcp_resource_templates", // Sole tools-only MCP server: no templates.
+    "read_mcp_resource", // MCP RPC only; the proxy has no resources/read handler.
+];
+export class CodexBoundaryError extends ProviderBinaryError {
+    constructor(version) {
+        super(`Codex ${version} cannot safely run room jobs. Update Codex, then run talentos agent repair. If this persists, report this version to TalentOS support.`);
+    }
+}
+function record(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value)) {
+        throw new Error("Invalid tool envelope");
+    }
+    return value;
+}
+/** Names retain their namespace: another MCP server cannot impersonate a room tool. */
+export function codexAdvertisedTools(value) {
+    const request = record(value);
+    if (request.functions !== undefined) {
+        throw new Error("Unknown top-level schema container");
+    }
+    const names = [];
+    function inspect(value, namespace = "") {
+        if (!Array.isArray(value)) {
+            throw new Error("Invalid tools");
+        }
+        for (const item of value) {
+            const tool = record(item);
+            if (tool.type === "namespace") {
+                if (namespace ||
+                    tool.functions !== undefined ||
+                    tool.function !== undefined ||
+                    tool.namespace !== undefined ||
+                    !["functions", "mcp__talentos"].includes(String(tool.name))) {
+                    throw new Error("Unknown namespace");
+                }
+                inspect(tool.tools, String(tool.name));
+            }
+            else if (tool.type === "function" && typeof tool.name === "string") {
+                if (tool.tools !== undefined ||
+                    tool.functions !== undefined ||
+                    tool.function !== undefined ||
+                    (namespace &&
+                        tool.namespace !== undefined &&
+                        tool.namespace !== namespace)) {
+                    throw new Error("Conflicting tool envelope");
+                }
+                const ns = namespace ||
+                    (typeof tool.namespace === "string" ? tool.namespace : "");
+                const name = tool.name;
+                const allowed = ns === "mcp__talentos"
+                    ? ROOM_TOOLS.includes(name)
+                    : ns === "functions" && RESOURCE_HELPERS.includes(name);
+                if (!(allowed && tool.parameters) ||
+                    typeof tool.parameters !== "object" ||
+                    Array.isArray(tool.parameters)) {
+                    throw new Error("Unexpected callable tool");
+                }
+                names.push(`${ns}.${name}`);
+            }
+            else {
+                throw new Error("Unknown tool schema");
+            }
+        }
+    }
+    if (request.tools !== undefined) {
+        inspect(request.tools);
+    }
+    if (!Array.isArray(request.input)) {
+        throw new Error("Missing input");
+    }
+    for (const item of request.input) {
+        const input = record(item);
+        if (typeof input.type !== "string" || !INPUT_TYPES.has(input.type)) {
+            throw new Error("Unknown input envelope");
+        }
+        if (input.type === "additional_tools" ||
+            input.type === "tool_search_output") {
+            inspect(input.tools);
+        }
+        else if (input.tools !== undefined || input.functions !== undefined) {
+            throw new Error("Unknown schema envelope");
+        }
+    }
+    return names;
+}
+export function probeResponse(response, item) {
+    const result = {
+        id: "probe",
+        object: "response",
+        status: "completed",
+        output: [item],
+        usage: { input_tokens: 0, output_tokens: 0, total_tokens: 0 },
+    };
+    response.writeHead(200, { "Content-Type": "text/event-stream" });
+    for (const event of [
+        {
+            type: "response.created",
+            response: { ...result, status: "in_progress", output: [] },
+        },
+        { type: "response.output_item.added", output_index: 0, item },
+        { type: "response.output_item.done", output_index: 0, item },
+        { type: "response.completed", response: result },
+    ]) {
+        response.write(`event: ${event.type}\ndata: ${JSON.stringify(event)}\n\n`);
+    }
+    response.end();
+}
+async function execute(binary, args, cwd, env, signal) {
+    signal.throwIfAborted();
+    const child = spawn(binary, args, {
+        cwd,
+        env,
+        detached: process.platform !== "win32",
+        stdio: ["ignore", "pipe", "ignore"],
+    });
+    const kill = () => {
+        try {
+            if (process.platform === "win32") {
+                child.kill("SIGKILL");
+            }
+            else if (child.pid) {
+                process.kill(-child.pid, "SIGKILL");
+            }
+        }
+        catch {
+            /* The child may already have exited. */
+        }
+    };
+    signal.addEventListener("abort", kill, { once: true });
+    try {
+        return await new Promise((resolve, reject) => {
+            let output = "";
+            child.stdout.on("data", (chunk) => {
+                output += chunk.toString();
+                if (Buffer.byteLength(output) > MAX_BYTES) {
+                    kill();
+                    reject(new Error("Probe output limit"));
+                }
+            });
+            child.once("error", reject);
+            child.once("close", (code) => code === 0 && !signal.aborted
+                ? resolve(output)
+                : reject(new Error("Probe failed")));
+        });
+    }
+    finally {
+        signal.removeEventListener("abort", kill);
+        kill();
+    }
+}
+function digest(value) {
+    return createHash("sha256").update(value).digest("hex");
+}
+async function identity(binary) {
+    const target = await realpath(binary);
+    const info = await stat(target);
+    return JSON.stringify([
+        binary,
+        target,
+        info.dev,
+        info.ino,
+        info.size,
+        info.mtimeMs,
+        info.ctimeMs,
+    ]);
+}
+/** A synthetic turn uses no owner login or live API. Inconclusive probes never permit service. */
+export async function probeCodexBoundary(binary, version, catalog, stop) {
+    try {
+        await proveCodexBoundary(binary, version, catalog, stop);
+    }
+    catch {
+        throw new CodexBoundaryError(version);
+    }
+}
+async function proveCodexBoundary(binary, version, catalog, stop) {
+    const before = await identity(binary);
+    const key = digest(JSON.stringify([
+        PROBE_REVISION,
+        RESOURCE_HELPERS,
+        before,
+        version,
+        catalog,
+        codexRoomArgs({
+            catalogPath: "catalog",
+            mcpCommand: "mcp",
+            mcpArgs: [],
+            prompt: "probe",
+        }),
+    ]));
+    const cache = join(homeDir(), ".talentos", "codex-boundary", `${key}.json`);
+    try {
+        if ((await readFile(cache, "utf8")) === JSON.stringify({ key, safe: true })) {
+            return;
+        }
+    }
+    catch {
+        /* Missing or corrupt cache requires a new proof. */
+    }
+    const directory = await mkdtemp(join(tmpdir(), "talentos-codex-boundary-"));
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), PROBE_MS);
+    const signal = stop
+        ? AbortSignal.any([stop, controller.signal])
+        : controller.signal;
+    const server = createServer();
+    let failure;
+    let turn = 0;
+    let requests = 0;
+    const observations = [new Set(), new Set()];
+    const nonce = randomUUID();
+    const marker = `room-probe-${nonce}`;
+    const calls = [[], []];
+    const finished = [false, false];
+    const turnSteps = [];
+    let canaryUrl = "";
+    const canary = join(directory, "private-canary");
+    try {
+        await writeFile(canary, nonce, { mode: 0o600 });
+        const catalogPath = join(directory, "catalog.json");
+        await writeFile(catalogPath, catalog, { mode: 0o600 });
+        const mcp = join(directory, "mcp.mjs");
+        // Match startMcpProxy's sole capability and handlers. No resources, owner
+        // credentials, filesystem readers or generic network tool can be reached.
+        await writeFile(mcp, `import {Server} from ${JSON.stringify(import.meta.resolve("@modelcontextprotocol/sdk/server/index.js"))};
+import {StdioServerTransport} from ${JSON.stringify(import.meta.resolve("@modelcontextprotocol/sdk/server/stdio.js"))};
+import {ListToolsRequestSchema,CallToolRequestSchema} from ${JSON.stringify(import.meta.resolve("@modelcontextprotocol/sdk/types.js"))};
+const server=new Server({name:'talentos',version:'probe'},{capabilities:{tools:{}}});
+server.setRequestHandler(ListToolsRequestSchema,async()=>({tools:${JSON.stringify([...ROOM_TOOLS, "search_memory", "run_routine"].map((name) => ({ name, description: name, inputSchema: { type: "object", properties: {} }, annotations: { readOnlyHint: true, destructiveHint: false, openWorldHint: false } })))}}));
+server.setRequestHandler(CallToolRequestSchema,async r=>({content:[{type:'text',text:r.params.name==='read_room'?${JSON.stringify(marker)}:'private-tool-refused'}]}));
+await server.connect(new StdioServerTransport());`, { mode: 0o600 });
+        server.on("request", async (request, response) => {
+            try {
+                if (request.method !== "POST" ||
+                    request.url !== "/v1/responses" ||
+                    ++requests > 20) {
+                    throw new Error("Unexpected probe request");
+                }
+                let raw = "";
+                for await (const chunk of request) {
+                    raw += chunk.toString();
+                    if (Buffer.byteLength(raw) > MAX_BYTES) {
+                        throw new Error("Request limit");
+                    }
+                }
+                const body = record(JSON.parse(raw));
+                for (const name of codexAdvertisedTools(body)) {
+                    observations[turn]?.add(name);
+                }
+                const helpers = RESOURCE_HELPERS.filter((name) => observations[turn]?.has(`functions.${name}`));
+                const steps = turnSteps[turn] ?? [
+                    "read_room",
+                    ...helpers,
+                    ...(helpers.includes("read_mcp_resource")
+                        ? ["read_mcp_resource", "read_mcp_resource"]
+                        : []),
+                ];
+                turnSteps[turn] = steps;
+                if (helpers.some((name) => !steps.includes(name))) {
+                    throw new Error("Helper surface changed during proof");
+                }
+                const input = body.input;
+                const completed = calls[turn] ?? [];
+                if (completed.length) {
+                    const output = input.find((item) => item.type === "function_call_output" &&
+                        item.call_id === `${turn}-${completed.length - 1}`);
+                    if (!output) {
+                        throw new Error("Missing tool result");
+                    }
+                    const text = JSON.stringify(output.output);
+                    const previous = completed.at(-1);
+                    if (previous === "read_room") {
+                        if (!text.includes(marker)) {
+                            throw new Error("Room tool did not execute");
+                        }
+                    }
+                    else if (previous === "list_mcp_resources" ||
+                        previous === "list_mcp_resource_templates") {
+                        const field = previous === "list_mcp_resources"
+                            ? "resources"
+                            : "resourceTemplates";
+                        if (output.output !== JSON.stringify({ [field]: [] })) {
+                            throw new Error("Resource listing is not empty");
+                        }
+                    }
+                    else if (typeof output.output !== "string" ||
+                        !output.output.startsWith("resources/read failed:") ||
+                        !RESOURCE_REFUSAL.test(output.output) ||
+                        text.includes(nonce)) {
+                        throw new Error("Resource helper did not refuse");
+                    }
+                }
+                const name = steps[completed.length];
+                if (!name) {
+                    finished[turn] = true;
+                    probeResponse(response, {
+                        type: "message",
+                        id: "answer",
+                        role: "assistant",
+                        status: "completed",
+                        content: [
+                            {
+                                type: "output_text",
+                                text: "Boundary verified.",
+                                annotations: [],
+                            },
+                        ],
+                    });
+                    return;
+                }
+                completed.push(name);
+                const reads = completed.filter((tool) => tool === "read_mcp_resource").length;
+                probeResponse(response, {
+                    type: "function_call",
+                    id: `${turn}-${completed.length - 1}`,
+                    call_id: `${turn}-${completed.length - 1}`,
+                    name,
+                    namespace: name === "read_room" ? "mcp__talentos" : "functions",
+                    arguments: JSON.stringify(name === "read_mcp_resource"
+                        ? {
+                            server: reads === 3 ? "unknown_owner_server" : "talentos",
+                            uri: reads > 1 ? canaryUrl : pathToFileURL(canary).href,
+                        }
+                        : {}),
+                    status: "completed",
+                });
+            }
+            catch (error) {
+                failure = error;
+                response.writeHead(400).end();
+                controller.abort();
+            }
+        });
+        await new Promise((resolve, reject) => {
+            server.once("error", reject);
+            server.listen(0, "127.0.0.1", resolve);
+        });
+        const address = server.address();
+        if (!address || typeof address === "string") {
+            throw new Error("Missing probe port");
+        }
+        canaryUrl = `http://127.0.0.1:${address.port}/private-canary`;
+        const env = {
+            HOME: directory,
+            CODEX_HOME: directory,
+            XDG_CONFIG_HOME: directory,
+            XDG_CACHE_HOME: directory,
+            PATH: providerPathEnv(binary, directory),
+            TALENTOS_PROBE_KEY: "loopback-only",
+            ...(process.env.SystemRoot ? { SystemRoot: process.env.SystemRoot } : {}),
+        };
+        let session;
+        for (turn = 0; turn < 2; turn++) {
+            const args = codexRoomArgs({
+                catalogPath,
+                mcpCommand: process.execPath,
+                mcpArgs: [mcp],
+                prompt: "Verify the room boundary.",
+                sessionId: session,
+            });
+            args.unshift("-c", 'model_provider="talentos_probe"', "-c", 'model_providers.talentos_probe.name="Loopback"', "-c", `model_providers.talentos_probe.base_url="http://127.0.0.1:${address.port}/v1"`, "-c", 'model_providers.talentos_probe.wire_api="responses"', "-c", 'model_providers.talentos_probe.env_key="TALENTOS_PROBE_KEY"');
+            const output = await execute(binary, args, directory, env, signal);
+            if (failure ||
+                !finished[turn] ||
+                calls[turn]?.length !== turnSteps[turn]?.length ||
+                !observations[turn]?.has("mcp__talentos.read_room")) {
+                throw new Error("Incomplete boundary proof");
+            }
+            const events = output
+                .trim()
+                .split("\n")
+                .map((line) => record(JSON.parse(line)));
+            const thread = events.find((event) => event.type === "thread.started")?.thread_id;
+            if (typeof thread !== "string" ||
+                (session && session !== thread) ||
+                !events.some((event) => event.type === "turn.completed")) {
+                throw new Error("Missing resumed session");
+            }
+            session = thread;
+        }
+        if ((await identity(binary)) !== before) {
+            throw new Error("Codex changed during probe");
+        }
+        signal.throwIfAborted();
+        // Failure to persist an optimization does not invalidate a completed proof.
+        await writePrivateFile(cache, JSON.stringify({ key, safe: true })).catch(() => undefined);
+    }
+    finally {
+        clearTimeout(timer);
+        controller.abort();
+        server.closeAllConnections();
+        await new Promise((resolve) => server.close(() => resolve()));
+        await rm(directory, { recursive: true, force: true });
+    }
+}

package/dist/agent/serve.js

@@ -154,6 +154,9 @@ export async function serveAgent(config, directory, version, stop, verify) {
                         console.error("Gateway update unavailable. Serving the current version; retrying in one minute.");
                     }
                 }
+                if (config.provider === "codex") {
+                    await verify?.();
+                }
                 wakePending = false;
                 let job;
                 const claimStartedAt = Date.now();

package/dist/commands/agent-serve.js

@@ -1,6 +1,7 @@
 import { readFileSync } from "node:fs";
 import { dirname } from "node:path";
 import { verifyClaudeCode, verifyCodex } from "../agent/adapters.js";
+import { CodexBoundaryError } from "../agent/codex-probe.js";
 import { AgentGateway, GatewayError } from "../agent/gateway.js";
 import { serveAgent } from "../agent/serve.js";
 import { agentWorkDir, localAgents, storeAgent, } from "../agent-config.js";
@@ -36,7 +37,7 @@ export async function runAgentServe(parsed, options = {}) {
     try {
         // Authenticate without publishing presence, including when the binary is gone.
         await fetchAgentStatus(config);
-        await serveAgent(config, dirname(agentWorkDir(config.agentId, options.home)), version, stop.signal, () => verifyAgent(agent, options));
+        await serveAgent(config, dirname(agentWorkDir(config.agentId, options.home)), version, stop.signal, () => verifyAgent(agent, options, stop.signal));
     }
     catch (error) {
         if ((error instanceof GatewayError || error instanceof AgentHttpError) &&
@@ -52,7 +53,7 @@ export async function runAgentServe(parsed, options = {}) {
         process.removeListener("SIGINT", abort);
     }
 }
-async function verifyAgent(config, options) {
+async function verifyAgent(config, options, signal) {
     try {
         let binary;
         try {
@@ -70,20 +71,22 @@ async function verifyAgent(config, options) {
             await verifyClaudeCode(binary);
         }
         else {
-            await verifyCodex(binary);
+            await verifyCodex(binary, signal);
         }
     }
     catch (error) {
         if (error instanceof ProviderBinaryError) {
-            try {
-                await new AgentGateway(config).request("/agent-gateway/provider-unavailable");
-            }
-            catch (reportError) {
-                if (reportError instanceof GatewayError &&
-                    (reportError.status === 401 || reportError.status === 410)) {
-                    throw reportError;
+            if (!(error instanceof CodexBoundaryError)) {
+                try {
+                    await new AgentGateway(config).request("/agent-gateway/provider-unavailable");
+                }
+                catch (reportError) {
+                    if (reportError instanceof GatewayError &&
+                        (reportError.status === 401 || reportError.status === 410)) {
+                        throw reportError;
+                    }
+                    // Older servers may not support diagnostics; local shutdown still applies.
                 }
-                // Older servers may not support diagnostics; local shutdown still applies.
             }
             console.error(error.message);
             // launchd cannot exclude exit 78; unload but retain the plist for repair.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "talentos",
-  "version": "1.1.5",
+  "version": "1.1.6",
   "type": "module",
   "description": "TalentOS CLI: push and pull skills, read and write team memory, and delegate work to your Talent from any coding agent.",
   "repository": {