@roamcode.ai/server 1.0.0

package/dist/providers/codex-profile-client.d.ts

@@ -0,0 +1,16 @@
+import type { ZodType } from "zod";
+import { type SpawnCodexAppServerTransport } from "./codex-app-server-client.js";
+export interface CodexProfileClientLifecycle {
+    readConfig<T>(profile: string, codexHome: string, cwd: string, schema: ZodType<T>): Promise<T>;
+}
+export interface CreateCodexProfileClientLifecycleOptions {
+    readonly codexBin: string;
+    readonly env?: NodeJS.ProcessEnv;
+    readonly spawnTransport?: SpawnCodexAppServerTransport;
+    readonly timeoutMs?: number;
+}
+/** Required selected-profile lifecycle. It owns Task 6 client construction, canonical env, start, and stop. */
+export declare function createCodexProfileClientLifecycle(options: CreateCodexProfileClientLifecycleOptions): CodexProfileClientLifecycle;
+/** Isolated protocol seam for service tests; unavailable outside the test process. */
+export declare function createCodexProfileClientLifecycleForTests(readConfig: CodexProfileClientLifecycle["readConfig"]): CodexProfileClientLifecycle;
+export declare function isCodexProfileClientLifecycle(value: unknown): value is CodexProfileClientLifecycle;

package/dist/providers/codex-profile-client.js

@@ -0,0 +1,52 @@
+import { CodexAppServerClient, } from "./codex-app-server-client.js";
+import { ProviderError } from "./types.js";
+const lifecycles = new WeakSet();
+function unavailable() {
+    return new ProviderError("OSS_PROVIDER_DEFERRED", "Codex profile capability proof is unavailable");
+}
+function brand(lifecycle) {
+    lifecycles.add(lifecycle);
+    return lifecycle;
+}
+/** Required selected-profile lifecycle. It owns Task 6 client construction, canonical env, start, and stop. */
+export function createCodexProfileClientLifecycle(options) {
+    return brand({
+        async readConfig(profile, codexHome, cwd, schema) {
+            const clientOptions = {
+                codexBin: options.codexBin,
+                profile,
+                env: { ...(options.env ?? process.env), CODEX_HOME: codexHome },
+                ...(options.spawnTransport ? { spawnTransport: options.spawnTransport } : {}),
+                ...(options.timeoutMs === undefined ? {} : { timeoutMs: options.timeoutMs }),
+            };
+            const client = new CodexAppServerClient(clientOptions);
+            let result;
+            let failed = false;
+            try {
+                await client.start();
+                result = await client.request("config/read", { cwd, includeLayers: false }, schema);
+            }
+            catch {
+                failed = true;
+            }
+            try {
+                await client.stop();
+            }
+            catch {
+                failed = true;
+            }
+            if (failed || result === undefined)
+                throw unavailable();
+            return result;
+        },
+    });
+}
+/** Isolated protocol seam for service tests; unavailable outside the test process. */
+export function createCodexProfileClientLifecycleForTests(readConfig) {
+    if (process.env.NODE_ENV !== "test")
+        throw unavailable();
+    return brand({ readConfig });
+}
+export function isCodexProfileClientLifecycle(value) {
+    return typeof value === "object" && value !== null && lifecycles.has(value);
+}

package/dist/providers/codex-profile-security.d.ts

@@ -0,0 +1,23 @@
+export interface CodexProfileFingerprint {
+    readonly path: string;
+    readonly realPath: string;
+    readonly dev: bigint;
+    readonly ino: bigint;
+    readonly size: bigint;
+    readonly mtimeNs: bigint;
+    readonly digest: string;
+}
+export interface CodexLaunchConfigFingerprint {
+    readonly homeDev: bigint;
+    readonly homeIno: bigint;
+    readonly homeSize: bigint;
+    readonly homeMtimeNs: bigint;
+    readonly base: CodexProfileFingerprint | null;
+    readonly profile: CodexProfileFingerprint;
+}
+export declare function resolveSecureCodexHome(configured: string | undefined): Promise<string | undefined>;
+export declare function listSecureProfileNames(codexHome: string, validName: (name: string) => boolean): Promise<string[]>;
+export declare function captureProfileFingerprint(codexHome: string, profile: string): Promise<CodexProfileFingerprint | undefined>;
+export declare function sameProfileFingerprint(left: CodexProfileFingerprint, right: CodexProfileFingerprint | undefined): boolean;
+export declare function captureLaunchConfigFingerprint(codexHome: string, profile: string): Promise<CodexLaunchConfigFingerprint | undefined>;
+export declare function sameLaunchConfigFingerprint(left: CodexLaunchConfigFingerprint, right: CodexLaunchConfigFingerprint | undefined): boolean;

package/dist/providers/codex-profile-security.js

@@ -0,0 +1,161 @@
+import { createHash } from "node:crypto";
+import { lstat, readFile, readdir, realpath } from "node:fs/promises";
+import { isAbsolute, join, parse, relative, resolve, sep } from "node:path";
+const PROFILE_SUFFIX = ".config.toml";
+const MAX_DIRECTORY_ENTRIES = 1_024;
+const MAX_CONFIG_BYTES = 1024 * 1024;
+async function hasSymlinkComponent(path) {
+    const absolute = resolve(path);
+    const root = parse(absolute).root;
+    const segments = absolute.slice(root.length).split(sep).filter(Boolean);
+    let current = root;
+    for (const segment of segments) {
+        current = join(current, segment);
+        if ((await lstat(current)).isSymbolicLink())
+            return true;
+    }
+    return false;
+}
+export async function resolveSecureCodexHome(configured) {
+    if (!configured || !isAbsolute(configured))
+        return undefined;
+    try {
+        if (await hasSymlinkComponent(configured))
+            return undefined;
+        const stat = await lstat(configured, { bigint: true });
+        if (!stat.isDirectory() || stat.isSymbolicLink())
+            return undefined;
+        const canonical = await realpath(configured);
+        const after = await lstat(configured, { bigint: true });
+        return canonical === resolve(configured) &&
+            after.isDirectory() &&
+            !after.isSymbolicLink() &&
+            stat.dev === after.dev &&
+            stat.ino === after.ino
+            ? canonical
+            : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+export async function listSecureProfileNames(codexHome, validName) {
+    if ((await resolveSecureCodexHome(codexHome)) !== codexHome)
+        return [];
+    const before = await lstat(codexHome, { bigint: true });
+    const entries = await readdir(codexHome, { withFileTypes: true });
+    const profiles = [];
+    for (const entry of entries.slice(0, MAX_DIRECTORY_ENTRIES)) {
+        if (!entry.isFile() || entry.isSymbolicLink() || !entry.name.endsWith(PROFILE_SUFFIX))
+            continue;
+        const profile = entry.name.slice(0, -PROFILE_SUFFIX.length);
+        if (!validName(profile))
+            continue;
+        const fingerprint = await captureProfileFingerprint(codexHome, profile);
+        if (fingerprint)
+            profiles.push(profile);
+    }
+    const after = await lstat(codexHome, { bigint: true });
+    if ((await resolveSecureCodexHome(codexHome)) !== codexHome ||
+        before.dev !== after.dev ||
+        before.ino !== after.ino ||
+        before.size !== after.size ||
+        before.mtimeNs !== after.mtimeNs) {
+        return [];
+    }
+    return [...new Set(profiles)].sort((left, right) => left.localeCompare(right));
+}
+export async function captureProfileFingerprint(codexHome, profile) {
+    return captureConfigFileFingerprint(codexHome, join(codexHome, `${profile}${PROFILE_SUFFIX}`));
+}
+async function captureConfigFileFingerprint(codexHome, path) {
+    try {
+        if (relative(codexHome, path).startsWith(".."))
+            return undefined;
+        const stat = await lstat(path, { bigint: true });
+        if (!stat.isFile() || stat.isSymbolicLink())
+            return undefined;
+        if (stat.size > BigInt(MAX_CONFIG_BYTES))
+            return undefined;
+        const realPath = await realpath(path);
+        if (realPath !== path)
+            return undefined;
+        const contents = await readFile(path);
+        const after = await lstat(path, { bigint: true });
+        if (!after.isFile() ||
+            after.isSymbolicLink() ||
+            stat.dev !== after.dev ||
+            stat.ino !== after.ino ||
+            stat.size !== after.size ||
+            stat.mtimeNs !== after.mtimeNs) {
+            return undefined;
+        }
+        return {
+            path,
+            realPath,
+            dev: stat.dev,
+            ino: stat.ino,
+            size: stat.size,
+            mtimeNs: stat.mtimeNs,
+            digest: createHash("sha256").update(contents).digest("hex"),
+        };
+    }
+    catch {
+        return undefined;
+    }
+}
+export function sameProfileFingerprint(left, right) {
+    return Boolean(right &&
+        left.path === right.path &&
+        left.realPath === right.realPath &&
+        left.dev === right.dev &&
+        left.ino === right.ino &&
+        left.size === right.size &&
+        left.mtimeNs === right.mtimeNs &&
+        left.digest === right.digest);
+}
+export async function captureLaunchConfigFingerprint(codexHome, profile) {
+    try {
+        if ((await resolveSecureCodexHome(codexHome)) !== codexHome)
+            return undefined;
+        const home = await lstat(codexHome, { bigint: true });
+        const selected = await captureProfileFingerprint(codexHome, profile);
+        if (!selected)
+            return undefined;
+        const basePath = join(codexHome, "config.toml");
+        let base = null;
+        try {
+            const baseStat = await lstat(basePath);
+            if (!baseStat.isFile() || baseStat.isSymbolicLink())
+                return undefined;
+            const capturedBase = await captureConfigFileFingerprint(codexHome, basePath);
+            if (!capturedBase)
+                return undefined;
+            base = capturedBase;
+        }
+        catch (error) {
+            if (error.code !== "ENOENT")
+                return undefined;
+        }
+        return {
+            homeDev: home.dev,
+            homeIno: home.ino,
+            homeSize: home.size,
+            homeMtimeNs: home.mtimeNs,
+            base,
+            profile: selected,
+        };
+    }
+    catch {
+        return undefined;
+    }
+}
+export function sameLaunchConfigFingerprint(left, right) {
+    return Boolean(right &&
+        left.homeDev === right.homeDev &&
+        left.homeIno === right.homeIno &&
+        left.homeSize === right.homeSize &&
+        left.homeMtimeNs === right.homeMtimeNs &&
+        (left.base === null ? right.base === null : right.base !== null && sameProfileFingerprint(left.base, right.base)) &&
+        sameProfileFingerprint(left.profile, right.profile));
+}

package/dist/providers/codex-provider.d.ts

@@ -0,0 +1,15 @@
+import { type AttachSpawnOptions } from "../config.js";
+import { type AgentProvider, type CodexProfileLaunchProof, type ProviderProcessContext, type ProviderAvailability } from "./types.js";
+export interface CreateCodexProviderOptions {
+    codexBin: string;
+    env?: NodeJS.ProcessEnv;
+    attach?: AttachSpawnOptions;
+    getAttach?: () => AttachSpawnOptions | undefined;
+    probe?: () => Promise<ProviderAvailability>;
+    /** Task 7 supplies the effective-provider capability check; this adapter never reads profile files. */
+    validateProfile?(profile: string, cwd: string): CodexProfileLaunchProof | Promise<CodexProfileLaunchProof>;
+}
+type CodexAttachContext = Pick<AttachSpawnOptions, "baseUrl" | "token" | "mcpScriptPath">;
+export declare function buildCodexArgs(context: ProviderProcessContext, attach?: CodexAttachContext): string[];
+export declare function createCodexProvider(options: CreateCodexProviderOptions): AgentProvider;
+export {};

package/dist/providers/codex-provider.js

@@ -0,0 +1,174 @@
+import { codexMcpTokenPathFor } from "../config.js";
+import { isAbsolute } from "node:path";
+import { classifyCodexPane, createCodexOscParser, parseCodexOscNotifications, parseCodexRuntimeMetadata, } from "./codex-activity.js";
+import { assertExactCodexResumeArgs } from "./codex-thread-resolver.js";
+import { cleanupProviderArtifacts, writeProviderArtifact0600 } from "./provider-artifacts.js";
+import { ProviderError, } from "./types.js";
+function configArg(key, value) {
+    return ["-c", `${key}=${JSON.stringify(value)}`];
+}
+function validResumeId(id) {
+    return (id !== undefined &&
+        id.trim().length > 0 &&
+        id.length <= 2048 &&
+        !/[\p{Cc}\p{Zl}\p{Zp}]/u.test(id) &&
+        !id.trimStart().startsWith("-"));
+}
+function usableAttach(attach) {
+    return Boolean(attach?.baseUrl &&
+        attach.token &&
+        Buffer.byteLength(attach.token, "utf8") <= 4096 &&
+        !/[\p{Cc}\p{Zl}\p{Zp}]/u.test(attach.token) &&
+        attach.mcpScriptPath &&
+        attach.dataDir);
+}
+function profileUnavailable() {
+    return new ProviderError("OSS_PROVIDER_DEFERRED", "Codex profile capability proof is unavailable");
+}
+export function buildCodexArgs(context, attach) {
+    if (context.options.provider !== "codex") {
+        throw new ProviderError("INVALID_PROVIDER_OPTIONS", "Codex provider received non-Codex options");
+    }
+    if (context.intent === "fresh" && context.providerSessionId !== undefined) {
+        throw new ProviderError("INVALID_PROVIDER_OPTIONS", "Fresh Codex launch cannot include a resume identity");
+    }
+    const options = context.options;
+    const args = [];
+    let resumeId;
+    if (context.intent === "resume") {
+        resumeId = context.providerSessionId;
+        if (!validResumeId(resumeId)) {
+            throw new ProviderError("RESUME_IDENTITY_UNAVAILABLE", "Codex resume requires an exact safe session id");
+        }
+        args.push("resume");
+    }
+    if (options.model)
+        args.push("--model", options.model);
+    if (options.profile)
+        args.push("--profile", options.profile);
+    if (options.dangerouslyBypassApprovalsAndSandbox) {
+        args.push("--dangerously-bypass-approvals-and-sandbox");
+    }
+    else {
+        if (options.sandbox)
+            args.push("--sandbox", options.sandbox);
+        if (options.approvalPolicy)
+            args.push("--ask-for-approval", options.approvalPolicy);
+    }
+    if (options.webSearch)
+        args.push("--search");
+    for (const dir of options.addDirs ?? [])
+        args.push("--add-dir", dir);
+    if (options.reasoningEffort)
+        args.push(...configArg("model_reasoning_effort", options.reasoningEffort));
+    if (attach) {
+        args.push(...configArg("mcp_servers.roamcode.command", process.execPath));
+        args.push(...configArg("mcp_servers.roamcode.args", [attach.mcpScriptPath]));
+        args.push(...configArg("mcp_servers.roamcode.env_vars", ["RC_BASE_URL", "RC_SESSION_ID", "RC_TOKEN_FILE"]));
+    }
+    args.push(...configArg("tui.notifications", ["agent-turn-complete", "approval-requested", "plan-mode-prompt"]));
+    args.push(...configArg("tui.notification_method", "osc9"));
+    args.push(...configArg("tui.notification_condition", "always"));
+    // Keep the conversation in tmux's ordinary pane history. With tmux mouse mode enabled, wheel/trackpad
+    // and mobile scroll can read that history in place instead of opening Codex's separate transcript UI.
+    args.push("--no-alt-screen");
+    if (resumeId)
+        args.push("--", resumeId);
+    if (context.intent === "resume")
+        assertExactCodexResumeArgs(args);
+    return args;
+}
+export function createCodexProvider(options) {
+    return {
+        id: "codex",
+        displayName: "Codex",
+        resumeIdentity: "required",
+        probe: options.probe ?? (() => Promise.resolve({ terminalAvailable: true, metadataAvailable: false })),
+        buildProcess: async (context) => {
+            if (context.options.provider !== "codex") {
+                throw new ProviderError("INVALID_PROVIDER_OPTIONS", "Codex provider received non-Codex options");
+            }
+            let profileProof;
+            if (context.options.profile) {
+                let validateProfile;
+                try {
+                    validateProfile = options.validateProfile;
+                }
+                catch {
+                    throw profileUnavailable();
+                }
+                if (!validateProfile)
+                    throw profileUnavailable();
+                try {
+                    profileProof = await validateProfile(context.options.profile, context.cwd);
+                }
+                catch {
+                    throw profileUnavailable();
+                }
+                if (profileProof.profile !== context.options.profile ||
+                    !isAbsolute(profileProof.codexHome) ||
+                    /[\p{Cc}\p{Zl}\p{Zp}]/u.test(profileProof.codexHome) ||
+                    typeof profileProof.assertUnchanged !== "function") {
+                    throw profileUnavailable();
+                }
+            }
+            const env = { ...(options.env ?? process.env) };
+            delete env.RC_TOKEN;
+            delete env.RC_TOKEN_FILE;
+            if (profileProof)
+                env.CODEX_HOME = profileProof.codexHome;
+            const preSpawnCheck = profileProof
+                ? async () => {
+                    try {
+                        await profileProof.assertUnchanged();
+                    }
+                    catch {
+                        throw profileUnavailable();
+                    }
+                }
+                : undefined;
+            const ownedPaths = [];
+            const candidateAttach = context.attach ?? options.getAttach?.() ?? options.attach;
+            let attach;
+            try {
+                if (usableAttach(candidateAttach)) {
+                    const tokenPath = codexMcpTokenPathFor(candidateAttach.dataDir, context.roamSessionId);
+                    if (writeProviderArtifact0600(tokenPath, candidateAttach.token, context, ownedPaths)) {
+                        attach = candidateAttach;
+                        env.RC_BASE_URL = candidateAttach.baseUrl;
+                        env.RC_SESSION_ID = context.roamSessionId;
+                        env.RC_TOKEN_FILE = tokenPath;
+                    }
+                }
+                const args = buildCodexArgs(context, attach);
+                return {
+                    executable: options.codexBin,
+                    args,
+                    env,
+                    cleanupPaths: ownedPaths,
+                    ...(preSpawnCheck ? { preSpawnCheck } : {}),
+                    integration: attach
+                        ? {
+                            attachments: "ready",
+                            activity: "degraded",
+                            detail: "Codex activity uses display-text signals with pane fallback",
+                        }
+                        : {
+                            attachments: "degraded",
+                            activity: "degraded",
+                            detail: "RoamCode attachment MCP is not configured; Codex activity uses display-text signals with pane fallback",
+                        },
+                };
+            }
+            catch (error) {
+                cleanupProviderArtifacts(ownedPaths);
+                throw error;
+            }
+        },
+        createRuntimeSignalParser: createCodexOscParser,
+        runtimeSignals: parseCodexOscNotifications,
+        classifyPane: classifyCodexPane,
+        runtimeMetadata: parseCodexRuntimeMetadata,
+        cleanup: cleanupProviderArtifacts,
+    };
+}

package/dist/providers/codex-thread-coordinator.d.ts

@@ -0,0 +1,18 @@
+export interface CodexSpawnLease {
+    readonly started: Promise<void>;
+    cancel(): Promise<void>;
+}
+declare class CodexThreadResolutionCoordinator {
+    private locked;
+    private poisoned;
+    private readonly queue;
+    acquire(signal?: AbortSignal): Promise<() => void>;
+    acknowledgeCancellation(lease: CodexSpawnLease, timeoutMs: number): Promise<void>;
+    /** A launch callback ran but did not return a cancellable lease, so later discovery is permanently unsafe. */
+    poisonUnknownSpawnOutcome(): void;
+    resetForTests(): void;
+    private poison;
+    private grant;
+}
+export declare const codexThreadResolutionCoordinator: CodexThreadResolutionCoordinator;
+export {};

package/dist/providers/codex-thread-coordinator.js

@@ -0,0 +1,93 @@
+import { ProviderError } from "./types.js";
+function unavailable() {
+    return new ProviderError("RESUME_IDENTITY_UNAVAILABLE", "Codex resume identity is unavailable");
+}
+class CodexThreadResolutionCoordinator {
+    locked = false;
+    poisoned = false;
+    queue = [];
+    acquire(signal) {
+        if (this.poisoned || signal?.aborted)
+            return Promise.reject(unavailable());
+        return new Promise((resolve, reject) => {
+            const waiter = { resolve, reject, signal };
+            if (signal) {
+                waiter.abort = () => {
+                    const index = this.queue.indexOf(waiter);
+                    if (index >= 0)
+                        this.queue.splice(index, 1);
+                    reject(unavailable());
+                };
+                signal.addEventListener("abort", waiter.abort, { once: true });
+            }
+            if (!this.locked) {
+                this.locked = true;
+                this.grant(waiter);
+            }
+            else {
+                this.queue.push(waiter);
+            }
+        });
+    }
+    async acknowledgeCancellation(lease, timeoutMs) {
+        let timer;
+        try {
+            const acknowledgement = lease.cancel();
+            if (!(acknowledgement instanceof Promise))
+                throw unavailable();
+            await Promise.race([
+                acknowledgement,
+                new Promise((_, reject) => {
+                    timer = setTimeout(() => reject(unavailable()), timeoutMs);
+                    timer.unref?.();
+                }),
+            ]);
+        }
+        catch {
+            this.poison();
+            throw unavailable();
+        }
+        finally {
+            if (timer)
+                clearTimeout(timer);
+        }
+    }
+    /** A launch callback ran but did not return a cancellable lease, so later discovery is permanently unsafe. */
+    poisonUnknownSpawnOutcome() {
+        this.poison();
+    }
+    resetForTests() {
+        if (process.env.NODE_ENV !== "test" || this.locked || this.queue.length > 0)
+            throw unavailable();
+        this.poisoned = false;
+    }
+    poison() {
+        this.poisoned = true;
+        for (const waiter of this.queue.splice(0)) {
+            if (waiter.abort)
+                waiter.signal?.removeEventListener("abort", waiter.abort);
+            waiter.reject(unavailable());
+        }
+    }
+    grant(waiter) {
+        if (waiter.abort)
+            waiter.signal?.removeEventListener("abort", waiter.abort);
+        if (this.poisoned) {
+            waiter.reject(unavailable());
+            this.locked = false;
+            return;
+        }
+        let released = false;
+        waiter.resolve(() => {
+            if (released)
+                return;
+            released = true;
+            const next = this.queue.shift();
+            if (next)
+                this.grant(next);
+            else
+                this.locked = false;
+        });
+    }
+}
+export const codexThreadResolutionCoordinator = new CodexThreadResolutionCoordinator();

package/dist/providers/codex-thread-persistence.d.ts

@@ -0,0 +1,9 @@
+import { type SessionStore } from "../session-store.js";
+export interface CodexThreadPersistence {
+    markProvisional(id: string): void;
+    clear(id: string): void;
+    commit(id: string): void;
+}
+/** Creates the only persistence object accepted by the exact-thread resolver. */
+export declare function createCodexThreadPersistence(store: SessionStore, roamSessionId: string): CodexThreadPersistence;
+export declare function isCodexThreadPersistence(value: unknown): value is CodexThreadPersistence;

package/dist/providers/codex-thread-persistence.js

@@ -0,0 +1,45 @@
+import { isConcreteSessionStore } from "../session-store.js";
+const capabilities = new WeakSet();
+class StoreBoundCodexThreadPersistence {
+    store;
+    roamSessionId;
+    constructor(store, roamSessionId) {
+        this.store = store;
+        this.roamSessionId = roamSessionId;
+    }
+    markProvisional(id) {
+        this.requireCodexSession();
+        this.store.markProvisionalProviderSessionId(this.roamSessionId, id);
+        if (this.store.get(this.roamSessionId)?.providerSessionId !== undefined)
+            throw new Error("Persistence failed");
+    }
+    clear(id) {
+        this.requireCodexSession();
+        this.store.clearProvisionalProviderSessionId(this.roamSessionId, id);
+        if (this.store.get(this.roamSessionId)?.providerSessionId !== undefined)
+            throw new Error("Rollback failed");
+    }
+    commit(id) {
+        this.requireCodexSession();
+        this.store.commitProvisionalProviderSessionId(this.roamSessionId, id);
+        if (this.store.get(this.roamSessionId)?.providerSessionId !== id)
+            throw new Error("Persistence identity changed");
+    }
+    requireCodexSession() {
+        const session = this.store.get(this.roamSessionId);
+        if (!session || session.provider !== "codex")
+            throw new Error("Codex session is unavailable");
+        return session;
+    }
+}
+/** Creates the only persistence object accepted by the exact-thread resolver. */
+export function createCodexThreadPersistence(store, roamSessionId) {
+    if (!isConcreteSessionStore(store) || roamSessionId.length === 0)
+        throw new Error("Invalid Codex persistence");
+    const capability = new StoreBoundCodexThreadPersistence(store, roamSessionId);
+    capabilities.add(capability);
+    return capability;
+}
+export function isCodexThreadPersistence(value) {
+    return typeof value === "object" && value !== null && capabilities.has(value);
+}

package/dist/providers/codex-thread-resolver.d.ts

@@ -0,0 +1,59 @@
+import { type ZodType } from "zod";
+import { type CodexSpawnLease } from "./codex-thread-coordinator.js";
+import { type CodexThreadPersistence } from "./codex-thread-persistence.js";
+export interface CodexThreadInventoryEntry {
+    readonly id: string;
+    readonly cwd: string;
+    readonly source: "cli" | "vscode" | "exec" | "appServer" | "unknown" | Record<string, unknown>;
+    /** Current protocol uses Unix seconds; milliseconds are normalized defensively for compatible revisions. */
+    readonly createdAt: number;
+}
+export type ReadCodexThreadInventory = () => Promise<readonly CodexThreadInventoryEntry[]>;
+export interface CodexThreadRpc {
+    request<T>(method: string, params: unknown, schema: ZodType<T>): Promise<T>;
+}
+export interface CreateCodexThreadInventoryOptions {
+    readonly cwd: string;
+    readonly maxPages?: number;
+    readonly maxItems?: number;
+}
+export interface CodexThreadResolverOptions {
+    readonly inventory: ReadCodexThreadInventory;
+    readonly now?: () => number;
+    readonly sleep?: (milliseconds: number, signal?: AbortSignal) => Promise<void>;
+    readonly deadlineMs?: number;
+    readonly pollIntervalMs?: number;
+    readonly maxInventoryItems?: number;
+    readonly creationSkewMs?: number;
+    readonly cancellationAckMs?: number;
+}
+export interface ResolveCodexThreadOptions {
+    readonly cwd: string;
+    /** The launch callback is intentionally inside the process-wide identity mutex. */
+    readonly spawn: (signal: AbortSignal) => CodexSpawnLease;
+    readonly persistence: CodexThreadPersistence;
+    readonly signal?: AbortSignal;
+}
+export declare function resetCodexThreadResolutionCoordinatorForTests(): void;
+/** Shared assertion used by the provider's generated resume argv regression. */
+export declare function assertExactCodexResumeArgs(args: readonly string[]): void;
+/** Creates the bounded current-protocol `thread/list` reader used by resolver snapshots and polls. */
+export declare function createCodexThreadInventory(rpc: CodexThreadRpc, options: CreateCodexThreadInventoryOptions): ReadCodexThreadInventory;
+export declare class CodexThreadResolver {
+    private readonly inventory;
+    private readonly now;
+    private readonly sleep;
+    private readonly deadlineMs;
+    private readonly pollIntervalMs;
+    private readonly maxInventoryItems;
+    private readonly creationSkewMs;
+    private readonly cancellationAckMs;
+    private readonly maxPolls;
+    constructor(options: CodexThreadResolverOptions);
+    resolveAfterSpawn(options: ResolveCodexThreadOptions): Promise<string>;
+    private resolveLocked;
+    private readInventory;
+    private candidates;
+    private sameIdentity;
+    private throwIfCancelled;
+}