@excitedjs/agent-runtime-codex 0.2.0-alpha.g0ddd418597ca

package/dist/runtime.js

@@ -0,0 +1,648 @@
+/**
+ * CodexRuntime — one running Codex-backed AgentRuntime instance.
+ *
+ * Owns:
+ *   - CodexProcess (child app-server)
+ *   - CodexWsClient (WS connection)
+ *   - thread_id (lazily created via thread/start or resumed)
+ *   - TurnManager (FIFO worker for this dispatcher)
+ *
+ * Lifecycle: declared → starting → ready → (degraded) → stopping → stopped.
+ *
+ * Current MVP:
+ *   - accepted inbound work is process-local and is dropped on restart;
+ *   - thread/resume failure does not degrade the whole dispatcher; we
+ *     start a fresh thread, record the lost one in last_lost_thread_id,
+ *     and post a visible warning to the next source chat.
+ */
+import { dirname, join } from 'node:path';
+import { CodexProcess, } from './supervisor.js';
+import { CodexWsClient } from './rpc.js';
+import { performInitializeHandshake } from './handshake.js';
+import { TurnManager, } from './turn-manager.js';
+import { injectThreadItems } from './events.js';
+import { renderChannelInput } from '@excitedjs/dreamux-utils';
+import { createFailFastApprovalHandler } from './approval.js';
+import { BUILTIN_CODEX_PROVIDER_REF } from './provider-ref.js';
+import { CODEX_AGENT_RUNTIME_CAPABILITIES } from './provider.js';
+import { buildCodexCompletionItem, CODEX_COMPLETION_TRIGGER_TEXT, codexProcessEnv, } from './runtime-support.js';
+/**
+ * The skill-source `layout` this runtime knows how to apply. `path` is one
+ * skill's own directory (containing `SKILL.md`); codex's `skills/extraRoots/set`
+ * takes the *parent* of such a dir as a skills root (a root whose immediate
+ * children are skill dirs — verified against codex 0.137's app-server schema).
+ * Sources with any other layout are ignored by the codex mapping.
+ */
+const CODEX_SKILL_DIR_LAYOUT = 'skill-dir';
+const DEFAULT_RESTART_BACKOFF_BASE_MS = 1000;
+const DEFAULT_RESTART_BACKOFF_MAX_MS = 30_000;
+const COMPLETION_ID_CACHE_LIMIT = 256;
+export class CodexRuntime {
+    identity;
+    deps;
+    providerRef = BUILTIN_CODEX_PROVIDER_REF;
+    process = null;
+    client = null;
+    turnManager = null;
+    threadId = null;
+    /**
+     * Whether the most recent thread resolution resumed an existing Codex thread
+     * (true) rather than starting a fresh one or recovering from a failed resume.
+     * Consulted by the server right after the slot is ready to decide whether a
+     * `daemon restart` notice should be injected (issue #78).
+     */
+    threadResumed = false;
+    status = 'declared';
+    /** Monotonic per-attempt suffix for TeamMate delivery turn dedup ids (#110 PR8). */
+    teammateDeliverySeq = 0;
+    /**
+     * Completion deliveries currently being processed. Duplicate settled events can
+     * race into `completionInput`; coalescing by completion id keeps one logical
+     * completion from injecting or triggering more than once concurrently.
+     */
+    inFlightCompletionDeliveries = new Map();
+    /**
+     * Completion ids whose trigger turn has already been accepted. A later replay
+     * of the same settled teammate turn is an idempotent success, not a new wake-up.
+     */
+    acceptedCompletionIds = new Set();
+    acceptedCompletionOrder = [];
+    /**
+     * Completion ids whose item has already been injected into the thread. The
+     * Dispatcher Service retries `completionInput` on `failed`; if the inject
+     * succeeded but the trigger turn failed, the retry must NOT re-inject the same
+     * item (that would persist a duplicate completion to the rollout). Bounded so
+     * a long-lived dispatcher does not grow this set without limit.
+     */
+    injectedCompletionIds = new Set();
+    injectedCompletionOrder = [];
+    log;
+    stopping = false;
+    restarting = false;
+    restartAttempts = 0;
+    restartTimer = null;
+    lastResult = null;
+    state;
+    paths;
+    constructor(identity, deps) {
+        this.identity = identity;
+        this.deps = deps;
+        const logger = deps.logger;
+        this.log =
+            logger !== undefined
+                ? (lvl, msg, err) => logger[lvl](msg, err !== undefined ? { err } : undefined)
+                : (lvl, msg, err) => {
+                    const prefix = `[dispatcher ${identity.runtime_id}] ${lvl}`;
+                    if (err !== undefined)
+                        console.error(prefix, msg, err);
+                    else
+                        console.error(prefix, msg);
+                };
+        this.threadId = identity.checkpoint_id ?? null;
+        this.state = deps.state;
+        this.paths = deps.paths;
+    }
+    get dispatcherId() {
+        return this.identity.runtime_id;
+    }
+    getStatus() {
+        return this.status;
+    }
+    getCapabilities() {
+        return CODEX_AGENT_RUNTIME_CAPABILITIES;
+    }
+    getThreadId() {
+        return this.threadId;
+    }
+    /** True when the live thread was resumed (not freshly started/recovered). */
+    wasThreadResumed() {
+        return this.threadResumed;
+    }
+    async getLast() {
+        return this.lastResult;
+    }
+    async getContext() {
+        return null;
+    }
+    async resume(input = {}) {
+        if (input.checkpoint !== undefined && input.checkpoint !== null) {
+            if (input.checkpoint.kind !== 'codexThread') {
+                throw new Error(`unsupported resume checkpoint for Codex runtime: ${input.checkpoint.kind}`);
+            }
+            this.threadId = input.checkpoint.id;
+        }
+        await this.start();
+    }
+    async submitRestartNotice(text) {
+        if (this.turnManager === null)
+            return { status: 'stopped' };
+        const result = await this.turnManager.injectNotice(text);
+        if (result.status === 'submitted') {
+            this.log('info', 'restart notice injected into resumed thread');
+        }
+        else if (result.status === 'skipped') {
+            this.log('info', 'restart notice skipped; a live inbound already arrived');
+        }
+        return result;
+    }
+    /**
+     * Bring the dispatcher up. Order:
+     *  1. spawn codex app-server child
+     *  2. open WS client
+     *  3. install fail-fast approval handler
+     *  4. thread/start (new) or thread/resume (existing)
+     *  5. install turn manager
+     *  6. status = ready
+     */
+    async start() {
+        this.stopping = false;
+        this.restarting = false;
+        this.clearRestartTimer();
+        this.setStatus('starting');
+        await this.state.setStatus(this.dispatcherId, 'starting', {
+            last_started_at: Date.now(),
+        });
+        try {
+            await this.startCodexRuntime();
+            await this.markReady();
+        }
+        catch (err) {
+            const msg = err instanceof Error ? err.message : String(err);
+            this.log('error', `start failed: ${msg}`, err);
+            this.setStatus('degraded');
+            await this.state.setStatus(this.dispatcherId, 'degraded', {
+                last_error: msg,
+            });
+            await this.cleanupOnFailure();
+            throw err;
+        }
+    }
+    async startCodexRuntime() {
+        const cwd = this.deps.cwd;
+        // Fresh random rendezvous socket per start (issue #182): held in memory
+        // only — never persisted to durable state, never derived from state paths.
+        const socketPath = this.deps.allocateSocketPath(this.dispatcherId);
+        const extraArgs = this.deps.resolveExtraArgs?.() ?? [];
+        if (this.deps.codexHomeDoctor !== undefined) {
+            await this.deps.codexHomeDoctor({ runtimeId: this.dispatcherId, cwd });
+        }
+        // Compose the codex app-server log subpaths under the neutral central logs
+        // root (B2): core no longer names a per-runtime log file. The host supplies
+        // a unique, filesystem-safe `runtime_id`, so `<logsDir>/codex-app-server/
+        // <id>.log` is collision-free across dispatchers and teammates.
+        const codexLogDir = join(this.paths.logsDir(), 'codex-app-server');
+        const factory = this.deps.codexProcessFactory ?? ((o) => new CodexProcess(o));
+        const process = factory({
+            socketPath,
+            cwd,
+            stdoutLogPath: join(codexLogDir, `${this.dispatcherId}.log`),
+            stderrLogPath: join(codexLogDir, `${this.dispatcherId}.stderr.log`),
+            binPath: this.deps.codexBinPath,
+            extraArgs,
+            env: codexProcessEnv(this.deps.injectEnv, this.deps.extraEnv),
+        });
+        this.process = process;
+        process.onExit((exit) => {
+            if (this.process !== process)
+                return;
+            this.handleChildExit(exit);
+        });
+        await process.start();
+        const clientFactory = this.deps.codexClientFactory ?? ((sock) => new CodexWsClient({ socketPath: sock }));
+        const client = clientFactory(socketPath);
+        this.client = client;
+        client.onClose((reason) => {
+            if (this.client !== client)
+                return;
+            this.handleClientClose(reason);
+        });
+        await client.ready();
+        const approvalHandler = createFailFastApprovalHandler({
+            onReject: async (req) => {
+                this.log('warn', `rejected Codex approval request '${req.method}'; Feishu outbound is MCP reply-only`);
+            },
+        });
+        this.client.setServerRequestHandler(approvalHandler);
+        // codex 0.134+ LSP-style handshake — must precede thread/start or
+        // any other RPC, otherwise codex answers everything with
+        // `Not initialized` (see src/codex/handshake.ts).
+        const initResponse = await performInitializeHandshake(this.client, {
+            ...(this.deps.handshakeTimeoutMs !== undefined
+                ? { timeoutMs: this.deps.handshakeTimeoutMs }
+                : {}),
+        });
+        this.log('info', `codex initialized: ${initResponse.userAgent} (home=${initResponse.codexHome}, ${initResponse.platformOs})`);
+        // Role-gated bundled skills (issue #209 slice 6): set the extra skill roots
+        // AFTER initialize and BEFORE thread start/resume, and on every restart this
+        // method runs again so the roots are reapplied to the fresh app-server.
+        await this.applySkillExtraRoots();
+        await this.resolveThread();
+        this.turnManager = new TurnManager({
+            dispatcherId: this.dispatcherId,
+            getThreadId: () => this.threadId,
+            client: this.client,
+            onTurnCompleted: (turn) => this.recordCollectedTurn(turn),
+            onTurnSettled: this.deps.onTurnSettled,
+            log: this.log,
+        });
+    }
+    /**
+     * Apply the role-gated bundled skill sources to the live app-server via
+     * `skills/extraRoots/set`. Codex treats each extra root as a directory whose
+     * immediate children are skill dirs, so a `skill-dir` source maps to the
+     * *parent* of its own directory; roots are deduped (the bundled Dreamux skills
+     * share one parent). Empty input skips the RPC entirely (a fresh per-runtime
+     * app-server starts with no extra roots, so nothing to clear).
+     *
+     * Error handling distinguishes two failure modes (issue #209 slice 6 repair):
+     *   1. The app-server does not implement `skills/extraRoots/set` at all — a
+     *      capability/version skew against an older codex backend (it answers with
+     *      an `unknown variant`/method-not-found error). This is NOT a real
+     *      failure: fail open, warn, and continue skill-blind rather than bricking
+     *      startup against every backend that predates the RPC.
+     *   2. The RPC exists but applying the given roots genuinely failed — fail
+     *      loud, exactly as before, so real misconfiguration is not masked.
+     */
+    async applySkillExtraRoots() {
+        if (this.client === null)
+            throw new Error('client not initialized');
+        const sources = this.deps.skillSources ?? [];
+        if (sources.length === 0)
+            return;
+        const extraRoots = [
+            ...new Set(sources
+                .filter((s) => s.layout === CODEX_SKILL_DIR_LAYOUT)
+                .map((s) => dirname(s.path))),
+        ];
+        if (extraRoots.length === 0)
+            return;
+        try {
+            await this.client.request('skills/extraRoots/set', { extraRoots });
+        }
+        catch (err) {
+            if (isUnsupportedRpcMethodError(err)) {
+                this.log('warn', `skills/extraRoots/set unsupported by this app-server; continuing skill-blind (${extraRoots.length} extra root(s) not applied)`, err);
+                return;
+            }
+            throw err;
+        }
+        this.log('info', `applied ${extraRoots.length} skill extra root(s): ${extraRoots.join(', ')}`);
+    }
+    async resolveThread() {
+        if (this.client === null)
+            throw new Error('client not initialized');
+        // Each resolution recomputes whether we resumed; a fresh start or a
+        // resume-failure recovery must not look like a resume to the notice gate.
+        this.threadResumed = false;
+        const existing = this.threadId ?? this.identity.checkpoint_id ?? null;
+        if (existing === null) {
+            // Fresh thread.
+            const params = {
+                baseInstructions: this.deps.systemPromptContent,
+            };
+            const res = await this.client.request('thread/start', params);
+            this.threadId = res.thread.id;
+            await this.state.setThreadId(this.dispatcherId, this.threadId);
+            this.log('info', `started fresh thread ${this.threadId}`);
+            return;
+        }
+        try {
+            const params = {
+                threadId: existing,
+                baseInstructions: this.deps.systemPromptContent,
+            };
+            await this.client.request('thread/resume', params);
+            this.threadId = existing;
+            this.threadResumed = true;
+            this.log('info', `resumed thread ${this.threadId}`);
+        }
+        catch (err) {
+            // Visible degradation (issue #2 Q11): start a fresh thread, record loss.
+            const msg = err instanceof Error ? err.message : String(err);
+            this.log('warn', `thread/resume failed for ${existing}: ${msg}; starting fresh thread`);
+            const res = await this.client.request('thread/start', { baseInstructions: this.deps.systemPromptContent });
+            this.threadId = res.thread.id;
+            if (this.state.recordLostThread !== undefined) {
+                await this.state.recordLostThread(this.dispatcherId, existing, this.threadId, `thread/resume failed: ${msg}`);
+            }
+            else {
+                await this.state.setThreadId(this.dispatcherId, this.threadId);
+                await this.state.setStatus(this.dispatcherId, 'degraded', {
+                    last_error: `thread/resume failed: ${msg}`,
+                });
+            }
+            // Park a warning to be delivered with the next outbound — best-effort
+            // queue note. For MVP we just log; full user-visible delivery on next
+            // inbound is a follow-up (see PR review).
+        }
+    }
+    /**
+     * Submit any accepted inbound message arriving for this dispatcher. Called by
+     * the Feishu inbound layer.
+     */
+    async channelInput(input, hooks = {}) {
+        if (this.turnManager === null) {
+            return { status: 'failed', error: new Error('turn manager not initialized') };
+        }
+        // This runtime owns wrapping the channel input into its delivery shape: a
+        // structured channel turn becomes the native `<channel source="…">` block
+        // (same envelope claude renders); a plain turn (e.g. the completion trigger)
+        // passes through unchanged.
+        return this.turnManager.enqueue({ ...input, text: renderChannelInput(input) }, hooks);
+    }
+    /** Inject a system-originated notice (e.g. a restart notice). */
+    async systemInput(notice) {
+        return this.submitRestartNotice(notice.text);
+    }
+    /**
+     * Codex TeamMate completion delivery — the native inbox-then-trigger idiom.
+     *
+     * Two steps, in order:
+     *  1. `thread/inject_items` appends the completion to the dispatcher thread's
+     *     model-visible history as a developer-role message (no fake user turn).
+     *     codex folds the item onto the active turn when one is running and never
+     *     rejects on a busy thread, so a failure here is a genuine RPC error.
+     *  2. a minimal trigger turn through the public `channelInput` seam wakes the
+     *     idle dispatcher so it reads the just-injected notification and acts.
+     *
+     * The trigger turn uses a fresh, non-routable source id per attempt. The turn
+     * manager commits its dedup id before `turn/start` and does not roll it back
+     * on failure, so a retry that reused one id would come back `duplicate` and be
+     * mis-counted as delivered when nothing was submitted. The Dispatcher Service
+     * only retries on `failed` (definitely not submitted), so a unique id per
+     * attempt re-submits the trigger safely.
+     */
+    async completionInput(completion) {
+        if (this.acceptedCompletionIds.has(completion.id)) {
+            return { status: 'accepted' };
+        }
+        const inFlight = this.inFlightCompletionDeliveries.get(completion.id);
+        if (inFlight !== undefined)
+            return inFlight;
+        const delivery = this.deliverCompletionInput(completion);
+        this.inFlightCompletionDeliveries.set(completion.id, delivery);
+        try {
+            const outcome = await delivery;
+            if (outcome.status === 'accepted') {
+                this.rememberAcceptedCompletion(completion.id);
+            }
+            return outcome;
+        }
+        finally {
+            this.inFlightCompletionDeliveries.delete(completion.id);
+        }
+    }
+    async deliverCompletionInput(completion) {
+        if (this.client === null || this.turnManager === null || this.stopping) {
+            return { status: 'unsupported', reason: 'dispatcher runtime stopped' };
+        }
+        const threadId = this.threadId;
+        if (threadId === null) {
+            return {
+                status: 'failed',
+                error: new Error('teammate completion delivery has no thread id'),
+            };
+        }
+        // Inject the completion item at most once per completion id. On a retry
+        // (trigger turn failed last time) the item is already in the thread, so we
+        // skip straight to re-triggering instead of persisting a duplicate.
+        if (!this.injectedCompletionIds.has(completion.id)) {
+            try {
+                await injectThreadItems(this.client, threadId, [
+                    await buildCodexCompletionItem(completion, this.paths.completionSpillDir(this.dispatcherId)),
+                ]);
+            }
+            catch (err) {
+                const cause = err instanceof Error ? err.message : String(err);
+                // `thread/inject_items` exists only on codex 0.137+. On an older codex
+                // it RPC-fails here, so surface the version requirement loudly rather
+                // than letting the dispatcher silently never see the completion.
+                return {
+                    status: 'failed',
+                    error: new Error(`teammate completion thread/inject_items failed (requires codex 0.137+): ${cause}`),
+                };
+            }
+            this.rememberInjectedCompletion(completion.id);
+        }
+        const deliverySeq = ++this.teammateDeliverySeq;
+        const delivery = await this.channelInput({
+            sourceId: `teammate:${completion.id}#${deliverySeq}`,
+            text: CODEX_COMPLETION_TRIGGER_TEXT,
+        });
+        switch (delivery.status) {
+            case 'submitted':
+                return { status: 'accepted' };
+            case 'stopped':
+                return { status: 'unsupported', reason: 'dispatcher runtime stopped' };
+            case 'failed':
+                return { status: 'failed', error: delivery.error };
+            case 'duplicate':
+                // Unreachable with the per-attempt id above; if it ever happens, the
+                // turn was NOT freshly submitted, so do not report it as delivered.
+                return {
+                    status: 'failed',
+                    error: new Error('teammate completion trigger unexpectedly deduplicated'),
+                };
+            case 'skipped':
+                return {
+                    status: 'failed',
+                    error: new Error('teammate completion trigger unexpectedly skipped'),
+                };
+        }
+    }
+    /** Graceful stop: stop accepting work, reap codex child. */
+    async stop() {
+        this.stopping = true;
+        this.clearRestartTimer();
+        this.setStatus('stopping');
+        await this.state.setStatus(this.dispatcherId, 'stopping');
+        await this.teardownCodexRuntime();
+        this.setStatus('stopped');
+        await this.state.setStatus(this.dispatcherId, 'stopped');
+    }
+    async cleanupOnFailure() {
+        this.clearRestartTimer();
+        const wasStopping = this.stopping;
+        this.stopping = true;
+        try {
+            await this.teardownCodexRuntime();
+        }
+        finally {
+            this.stopping = wasStopping;
+        }
+    }
+    async teardownCodexRuntime() {
+        const turnManager = this.turnManager;
+        this.turnManager = null;
+        if (turnManager !== null)
+            await turnManager.stop();
+        const client = this.client;
+        this.client = null;
+        if (client !== null) {
+            try {
+                client.close();
+            }
+            catch {
+                /* */
+            }
+        }
+        const process = this.process;
+        this.process = null;
+        if (process !== null) {
+            await process.reap();
+        }
+    }
+    handleChildExit(exit) {
+        const details = exit.signal !== null ? `signal=${exit.signal}` : `code=${exit.code ?? 'null'}`;
+        this.scheduleRestart(`codex app-server child exited (${details})`);
+    }
+    handleClientClose(reason) {
+        this.scheduleRestart(`codex app-server websocket closed: ${reason.message}`);
+    }
+    scheduleRestart(reason) {
+        if (this.stopping || this.restartTimer !== null || this.restarting)
+            return;
+        const attempt = this.restartAttempts + 1;
+        this.restartAttempts = attempt;
+        const delay = this.restartDelayMs(attempt);
+        this.log('warn', `${reason}; restarting in ${delay}ms`);
+        this.setStatus('degraded');
+        // scheduleRestart runs from synchronous event handlers (ws close, child
+        // exit); the durable status write is best-effort here — persist it without
+        // blocking, logging (never throwing) on failure. The restart timer's later
+        // 'starting'/'ready' writes are awaited, so they cannot be reordered behind
+        // this one within the backoff delay.
+        void this.state
+            .setStatus(this.dispatcherId, 'degraded', { last_error: reason })
+            .catch((err) => this.log('warn', 'failed to persist degraded status', err));
+        this.restartTimer = setTimeout(() => {
+            this.restartTimer = null;
+            void this.restartCodexRuntime(reason);
+        }, delay);
+    }
+    async restartCodexRuntime(reason) {
+        if (this.stopping)
+            return;
+        this.restarting = true;
+        let retryReason = null;
+        this.setStatus('starting');
+        await this.state.setStatus(this.dispatcherId, 'starting', {
+            last_started_at: Date.now(),
+        });
+        try {
+            await this.teardownCodexRuntime();
+            if (this.stopping)
+                return;
+            await this.startCodexRuntime();
+            if (this.stopping) {
+                await this.teardownCodexRuntime();
+                return;
+            }
+            this.restartAttempts = 0;
+            await this.markReady();
+            this.log('info', `restarted codex app-server after: ${reason}`);
+        }
+        catch (err) {
+            const msg = err instanceof Error ? err.message : String(err);
+            this.log('error', `restart failed: ${msg}`, err);
+            this.setStatus('degraded');
+            await this.state.setStatus(this.dispatcherId, 'degraded', {
+                last_error: msg,
+            });
+            await this.teardownCodexRuntime();
+            retryReason = `codex app-server restart failed: ${msg}`;
+        }
+        finally {
+            this.restarting = false;
+        }
+        if (retryReason !== null)
+            this.scheduleRestart(retryReason);
+    }
+    restartDelayMs(attempt) {
+        const base = Math.max(0, this.deps.restartBackoffBaseMs ?? DEFAULT_RESTART_BACKOFF_BASE_MS);
+        const max = Math.max(base, this.deps.restartBackoffMaxMs ?? DEFAULT_RESTART_BACKOFF_MAX_MS);
+        return Math.min(max, base * 2 ** Math.max(0, attempt - 1));
+    }
+    clearRestartTimer() {
+        if (this.restartTimer === null)
+            return;
+        clearTimeout(this.restartTimer);
+        this.restartTimer = null;
+    }
+    async markReady() {
+        this.setStatus('ready');
+        await this.state.setStatus(this.dispatcherId, 'ready', {
+            last_ready_at: Date.now(),
+            last_error: null,
+        });
+    }
+    recordCollectedTurn(turn) {
+        const messages = turn.items.filter((item) => item.type === 'agentMessage');
+        const last = messages[messages.length - 1];
+        if (typeof last?.text === 'string' && last.text.length > 0) {
+            this.lastResult = { text: last.text };
+        }
+        // A turn reaching `turn/completed` is the `completed` terminal state. The
+        // `stopped` settlement for interrupted turns is emitted by the turn manager
+        // on `stop()`.
+        this.deps.onTurnSettled?.({ turnId: turn.turnId, status: 'completed' });
+    }
+    /** Record a completion id as injected, evicting the oldest past a small cap. */
+    rememberInjectedCompletion(id) {
+        if (this.injectedCompletionIds.has(id))
+            return;
+        this.injectedCompletionIds.add(id);
+        this.injectedCompletionOrder.push(id);
+        while (this.injectedCompletionOrder.length > COMPLETION_ID_CACHE_LIMIT) {
+            const evicted = this.injectedCompletionOrder.shift();
+            if (evicted !== undefined)
+                this.injectedCompletionIds.delete(evicted);
+        }
+    }
+    /** Record a completion id as fully accepted, evicting the oldest past a cap. */
+    rememberAcceptedCompletion(id) {
+        if (this.acceptedCompletionIds.has(id))
+            return;
+        this.acceptedCompletionIds.add(id);
+        this.acceptedCompletionOrder.push(id);
+        while (this.acceptedCompletionOrder.length > COMPLETION_ID_CACHE_LIMIT) {
+            const evicted = this.acceptedCompletionOrder.shift();
+            if (evicted !== undefined)
+                this.acceptedCompletionIds.delete(evicted);
+        }
+    }
+    setStatus(s) {
+        this.status = s;
+    }
+}
+/**
+ * Classify an RPC rejection as a capability/version gap — the app-server does
+ * not implement the requested method at all — rather than a genuine failure of
+ * an existing method.
+ *
+ * The rpc layer collapses codex's structured error to `Error(message)` (it
+ * drops the JSON-RPC error code), so the *message* is all we have. codex
+ * surfaces an unimplemented method as a serde enum-deserialization failure of
+ * the request's `method` field — `unknown variant \`<method>\`, expected one of
+ * …` — while a spec-compliant JSON-RPC peer answers method-not-found (-32601).
+ * We match those canonical phrasings only; the test stays deliberately narrow
+ * so a real error from an *existing* method (a bad root path, a permission
+ * failure) is NOT swallowed and still fails loud.
+ *
+ * The match is message-based by necessity: the rpc layer drops the structured
+ * JSON-RPC error code, so the message is all we have. The one residual
+ * false-positive is a server that *implements* the method but rejects a bad
+ * *param value* with an "unknown variant `<value>`" serde error. That is safe
+ * for our sole caller — `skills/extraRoots/set` takes a `string[]` of paths,
+ * which codex never enum-rejects — but a future caller passing an enum-typed
+ * param should not reuse this classifier blindly.
+ */
+export function isUnsupportedRpcMethodError(err) {
+    const message = (err instanceof Error ? err.message : String(err)).toLowerCase();
+    return (message.includes('unknown variant') ||
+        message.includes('method not found') ||
+        message.includes('unknown method') ||
+        message.includes('no such method') ||
+        message.includes('unsupported method'));
+}
+//# sourceMappingURL=runtime.js.map