humanish 0.96.1 → 0.98.0

package/dist/restricted-codex-policy.js

@@ -0,0 +1,151 @@
+/** Versioned, deliberately narrow profile qualified with an account-backed vision turn.
+ * The CLI still advertises code-mode tools: disabling their host is the enforcement
+ * boundary. Feature names alone are not proof that a tool has been removed. */
+export const RESTRICTED_CODEX_ANALYSIS_IDENTITY = {
+    provider: "codex", authMode: "chatgpt", modelProvider: "openai", cliVersion: "0.154.0",
+    toolPolicy: "restricted-codex-v1", reasoningEffort: "low"
+};
+export const RESTRICTED_CODEX_ANALYSIS_MODELS = ["gpt-6-astra"];
+export const CODEX_MAX_REQUEST_BYTES = 32 * 1024 * 1024;
+export const CODEX_MAX_OUTPUT_BYTES = 2 * 1024 * 1024;
+export const CODEX_MAX_STDOUT_BYTES = 8 * 1024 * 1024;
+export const CODEX_MAX_EVENTS = 65_536;
+export const CODEX_IMAGE = /^data:image\/(png|jpeg|webp);base64,([A-Za-z0-9+/]+={0,2})$/;
+export const codexRecord = (value) => value !== null && typeof value === "object" && !Array.isArray(value) ? value : {};
+const empty = (value) => value === null || value === undefined
+    || (typeof value === "object" && Object.keys(value).length === 0);
+const count = (value) => Number.isSafeInteger(value) && value >= 0 && value <= 1e12;
+const disabledFeatures = ["apps", "plugins", "hooks", "shell_tool", "shell_snapshot", "view_image", "image_generation",
+    "skill_search", "skill_mcp_dependency_install", "multi_agent", "multi_agent_v2", "browser_use", "browser_use_external",
+    "computer_use", "memories", "external_agent_memory_import", "goals", "sleep_tool", "tool_suggest", "code_mode",
+    "code_mode_host", "code_mode_only", "default_mode_request_user_input", "unbounded_connection_retries",
+    "workspace_dependencies", "remote_plugin", "recommended_plugins", "in_app_local_automation"];
+export function restrictedCodexConfig(model) {
+    const overrides = {
+        model, model_provider: "openai", model_reasoning_effort: "low", approval_policy: "never", sandbox_mode: "read-only",
+        forced_login_method: "chatgpt", project_doc_max_bytes: 0, web_search: "disabled", "history.persistence": "none",
+        "analytics.enabled": false, "features.skip_host_skill_discovery": true, "skills.bundled.enabled": false,
+        "agents.enabled": false, "agents.max_threads": 1, "agents.max_depth": 1
+    };
+    for (const name of disabledFeatures)
+        overrides[`features.${name}`] = false;
+    const toml = `model = ${JSON.stringify(model)}
+model_provider = "openai"
+model_reasoning_effort = "low"
+approval_policy = "never"
+sandbox_mode = "read-only"
+forced_login_method = "chatgpt"
+project_doc_max_bytes = 0
+web_search = "disabled"
+[history]
+persistence = "none"
+[analytics]
+enabled = false
+[features]
+skip_host_skill_discovery = true
+${disabledFeatures.map(name => `${name} = false`).join("\n")}
+[skills.bundled]
+enabled = false
+[agents]
+enabled = false
+max_threads = 1
+max_depth = 1
+`;
+    return { toml, overrides };
+}
+/** Inspect before thread/start, which could otherwise start inherited integrations. */
+export function admitsRestrictedCodexConfig(raw, configPath, model) {
+    const root = codexRecord(raw), config = codexRecord(root.config), features = codexRecord(config.features);
+    if (!Array.isArray(root.layers) || root.layers.length === 0)
+        return false;
+    let ownLayer = false;
+    for (const rawLayer of root.layers) {
+        const layer = codexRecord(rawLayer), name = codexRecord(layer.name);
+        if (name.type === "user" && name.file === configPath && name.profile === null
+            && (layer.disabledReason === null || layer.disabledReason === undefined)) {
+            if (ownLayer)
+                return false;
+            ownLayer = true;
+        }
+        else if (name.type !== "system" || !empty(layer.config))
+            return false;
+    }
+    if (!ownLayer || config.model !== model || config.model_provider !== "openai" || config.model_reasoning_effort !== "low"
+        || config.forced_login_method !== "chatgpt" || config.sandbox_mode !== "read-only" || config.approval_policy !== "never"
+        || config.project_doc_max_bytes !== 0 || config.web_search !== "disabled" || features.skip_host_skill_discovery !== true
+        || codexRecord(config.history).persistence !== "none" || codexRecord(config.analytics).enabled !== false
+        || disabledFeatures.some(name => features[name] !== false))
+        return false;
+    const agents = codexRecord(config.agents), skills = codexRecord(config.skills);
+    if (agents.enabled !== false || agents.max_concurrent_threads_per_session !== 1 || agents.max_depth !== 1
+        || codexRecord(skills.bundled).enabled !== false || Object.keys(skills).some(key => key !== "bundled"))
+        return false;
+    for (const key of ["mcp_servers", "plugins", "hooks", "notify", "instructions", "developer_instructions", "permissions",
+        "profiles", "projects", "model_providers", "experimental_compact_prompt_file", "experimental_model_instructions_file", "model_instructions_file",
+        "model_catalog_json", "openai_base_url", "orchestrator", "experimental_thread_store", "experimental_thread_store_endpoint",
+        "experimental_realtime_ws_base_url", "experimental_realtime_webrtc_call_base_url", "forced_chatgpt_workspace_id",
+        "log_dir", "sqlite_home", "otel", "marketplaces", "js_repl_node_path", "js_repl_node_module_dirs", "responses_api_metadata",
+        "compact_prompt", "profile", "default_permissions", "auto_review", "apps", "browser_use", "computer_use", "desktop", "memories", "realtime"])
+        if (!empty(config[key]))
+            return false;
+    if (Object.values(codexRecord(config.shell_environment_policy)).some(value => !empty(value)))
+        return false;
+    return config.cli_auth_credentials_store === "file" && config.chatgpt_base_url === "https://chatgpt.com/backend-api/";
+}
+export function admitsRestrictedCodexThread(raw, model, cwd) {
+    const value = codexRecord(raw), thread = codexRecord(value.thread), sandbox = codexRecord(value.sandbox);
+    return typeof thread.id === "string" && thread.id.length > 0 && thread.id.length <= 200
+        && thread.ephemeral === true && thread.model === model && thread.modelProvider === "openai"
+        && thread.reasoningEffort === "low" && thread.cliVersion === RESTRICTED_CODEX_ANALYSIS_IDENTITY.cliVersion
+        && Array.isArray(thread.environments) && thread.environments.length === 0 && thread.path === null
+        && value.model === model && value.modelProvider === "openai" && value.reasoningEffort === "low"
+        && value.cwd === cwd && thread.cwd === cwd && value.approvalPolicy === "never"
+        && sandbox.type === "readOnly" && sandbox.networkAccess === false
+        && Array.isArray(value.instructionSources) && value.instructionSources.length === 0
+        && Array.isArray(value.runtimeWorkspaceRoots) && value.runtimeWorkspaceRoots.length === 0;
+}
+export function restrictedCodexRequestError(request) {
+    if (request.signal?.aborted)
+        return "cancelled";
+    if (!RESTRICTED_CODEX_ANALYSIS_MODELS.some(model => model === request.model))
+        return "codex_model_unavailable";
+    if (request.maxOutputTokens !== null || !Number.isSafeInteger(request.timeoutMs) || request.timeoutMs < 1 || request.timeoutMs > 600_000
+        || typeof request.instructions !== "string" || typeof request.evidence !== "string" || !Array.isArray(request.images)
+        || request.images.length > 128 || !request.schema || typeof request.schema !== "object" || Array.isArray(request.schema))
+        return "invalid_request";
+    try {
+        if (new TextEncoder().encode(JSON.stringify({ instructions: request.instructions, evidence: request.evidence,
+            images: request.images, schema: request.schema })).byteLength > CODEX_MAX_REQUEST_BYTES)
+            return "invalid_request";
+        let imageBytes = 0;
+        for (const image of request.images) {
+            if (typeof image.evidenceId !== "string" || image.evidenceId.length === 0 || image.evidenceId.length > 300
+                || typeof image.dataUrl !== "string")
+                return "invalid_request";
+            const match = CODEX_IMAGE.exec(image.dataUrl);
+            if (!match)
+                return "invalid_request";
+            const decoded = atob(match[2]);
+            imageBytes += decoded.length;
+            if (btoa(decoded) !== match[2] || imageBytes > 20 * 1024 * 1024)
+                return "invalid_request";
+        }
+        return null;
+    }
+    catch {
+        return "invalid_request";
+    }
+}
+export function restrictedCodexUsage(raw) {
+    const total = codexRecord(codexRecord(raw).total);
+    const input = total.inputTokens, output = total.outputTokens, cachedInput = total.cachedInputTokens, cacheWriteInput = total.cacheWriteInputTokens;
+    if (!count(input) || !count(output) || !count(cachedInput) || !count(cacheWriteInput) || cachedInput + cacheWriteInput > input)
+        return null;
+    return { input, output, cachedInput, cacheWriteInput };
+}
+export function restrictedCodexFailure(errorCode, dispatched = false, usage = null) {
+    return { status: errorCode === "cancelled" ? "cancelled" : errorCode === "timeout" ? "timed_out"
+            : errorCode === "refusal" ? "refused" : errorCode === "output_incomplete" ? "incomplete" : "failed",
+        output: null, usage, usageComplete: false, dispatched, errorCode };
+}
+//# sourceMappingURL=restricted-codex-policy.js.map

package/dist/restricted-codex-policy.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"restricted-codex-policy.js","sourceRoot":"","sources":["../src/restricted-codex-policy.ts"],"names":[],"mappings":"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"}

package/dist/restricted-codex-session.d.ts

@@ -0,0 +1,19 @@
+import { type RestrictedCodexRequest, type RestrictedCodexResult } from "./restricted-codex-policy.js";
+import { type RestrictedCodexSpawn } from "./restricted-codex-transport.js";
+/** Internal host dependencies. None of these options is accepted from a study artifact. */
+export interface RestrictedCodexSessionOptions {
+    executable?: string;
+    authHome?: string;
+    env?: NodeJS.ProcessEnv;
+    tempRoot?: string;
+    platform?: NodeJS.Platform;
+    arch?: string;
+    spawnFn?: RestrictedCodexSpawn;
+}
+/** Each call owns a separate process, home and thread. An unresolved child blocks
+ * new work, but ordinary participant turns may run concurrently. */
+export declare function runRestrictedCodexSession(request: RestrictedCodexRequest, options?: RestrictedCodexSessionOptions, readinessOnly?: boolean): Promise<RestrictedCodexResult>;
+export declare function checkRestrictedCodexSessionReadiness(input?: {
+    signal?: AbortSignal;
+    timeoutMs?: number;
+}, options?: RestrictedCodexSessionOptions): Promise<RestrictedCodexResult>;

package/dist/restricted-codex-session.js

@@ -0,0 +1,413 @@
+import { spawn } from "node:child_process";
+import { constants } from "node:fs";
+import { access, chmod, lstat, mkdir, mkdtemp, open, readdir, realpath, rm, stat, symlink, unlink, writeFile } from "node:fs/promises";
+import { homedir, tmpdir } from "node:os";
+import path from "node:path";
+import { CODEX_IMAGE, CODEX_MAX_OUTPUT_BYTES, RESTRICTED_CODEX_ANALYSIS_IDENTITY, RESTRICTED_CODEX_ANALYSIS_MODELS, admitsRestrictedCodexConfig, admitsRestrictedCodexThread, codexRecord, restrictedCodexConfig, restrictedCodexFailure, restrictedCodexRequestError, restrictedCodexUsage } from "./restricted-codex-policy.js";
+import { RestrictedCodexDeadline, RestrictedCodexStop, RestrictedCodexTransport, closeOwnedCodexProcess, ownCodexProcess } from "./restricted-codex-transport.js";
+function childEnvironment(source, home, scratch) {
+    const result = { HOME: home, CODEX_HOME: home, TMPDIR: scratch };
+    for (const key of ["PATH", "LANG", "USER", "LOGNAME"])
+        if (typeof source[key] === "string")
+            result[key] = source[key];
+    return result;
+}
+async function isNativeExecutable(file) {
+    try {
+        await access(file, constants.X_OK);
+        const handle = await open(file, "r");
+        try {
+            const buffer = Buffer.alloc(4);
+            const read = await handle.read(buffer, 0, 4, 0);
+            return read.bytesRead === 4 && buffer.equals(Buffer.from([0x7f, 0x45, 0x4c, 0x46]));
+        }
+        finally {
+            await handle.close();
+        }
+    }
+    catch {
+        return false;
+    }
+}
+/** Resolve PATH without running a shell. The npm launcher is resolved to its
+ * native optional package so cleanup owns the real app-server child. */
+async function resolveExecutable(options, env) {
+    let selected = options.executable;
+    if (selected === undefined) {
+        for (const directory of (env.PATH ?? "").split(path.delimiter).filter(entry => path.isAbsolute(entry))) {
+            const candidate = path.join(directory, "codex");
+            try {
+                await access(candidate, constants.X_OK);
+                selected = candidate;
+                break;
+            }
+            catch { /* Continue PATH. */ }
+        }
+    }
+    if (selected === undefined || !path.isAbsolute(selected))
+        throw new RestrictedCodexStop("codex_unavailable");
+    let resolved;
+    try {
+        resolved = await realpath(selected);
+    }
+    catch {
+        throw new RestrictedCodexStop("codex_unavailable");
+    }
+    if (await isNativeExecutable(resolved))
+        return resolved;
+    if (path.basename(resolved) === "codex.js" && path.basename(path.dirname(resolved)) === "bin") {
+        const packageRoot = path.dirname(path.dirname(resolved));
+        const triple = "x86_64-unknown-linux-musl";
+        for (const candidate of [path.join(packageRoot, "node_modules", "@openai", "codex-linux-x64", "vendor", triple, "bin", "codex"),
+            path.join(packageRoot, "vendor", triple, "bin", "codex")]) {
+            if (await isNativeExecutable(candidate))
+                return realpath(candidate);
+        }
+    }
+    throw new RestrictedCodexStop("codex_unavailable");
+}
+async function checkVersion(file, env, cwd, spawnFn, deadline) {
+    deadline.check();
+    const owned = ownCodexProcess(spawnFn(file, ["--version"], { cwd, env, detached: false, stdio: ["pipe", "pipe", "pipe"] }));
+    let text = "", bytes = 0, exitCode = null;
+    const timer = setTimeout(() => deadline.stop("timeout"), 15_000);
+    owned.child.on("error", () => deadline.stop("codex_unavailable"));
+    owned.child.stdin.on("error", () => deadline.stop("codex_unavailable"));
+    owned.child.stdout.on("data", (chunk) => {
+        bytes += chunk.length;
+        if (bytes > 4096)
+            deadline.stop("response_too_large");
+        else
+            text += chunk.toString("utf8");
+    });
+    owned.child.stderr.on("data", (chunk) => { bytes += chunk.length; if (bytes > 4096)
+        deadline.stop("response_too_large"); });
+    owned.child.on("exit", code => { exitCode = code; });
+    try {
+        await deadline.wait(owned.closed);
+        if (exitCode !== 0)
+            throw new RestrictedCodexStop("codex_unavailable");
+        if (text.trim() !== `codex-cli ${RESTRICTED_CODEX_ANALYSIS_IDENTITY.cliVersion}`)
+            throw new RestrictedCodexStop("codex_unsupported_version");
+    }
+    finally {
+        clearTimeout(timer);
+        if (!await closeOwnedCodexProcess(owned)) {
+            retainUnclosedChild(owned.closed);
+            throw new RestrictedCodexStop("codex_cleanup_failed");
+        }
+    }
+}
+const unclosedChildren = new Set();
+function retainUnclosedChild(closed) {
+    unclosedChildren.add(closed);
+    void closed.then(() => { unclosedChildren.delete(closed); });
+}
+/** Each call owns a separate process, home and thread. An unresolved child blocks
+ * new work, but ordinary participant turns may run concurrently. */
+export async function runRestrictedCodexSession(request, options = {}, readinessOnly = false) {
+    const error = restrictedCodexRequestError(request);
+    if (error)
+        return restrictedCodexFailure(error);
+    if (unclosedChildren.size)
+        return restrictedCodexFailure("codex_busy");
+    return executeRestrictedCodexSession(request, options, readinessOnly);
+}
+async function writeRecoveryMarker(work, sourceEnv, reason) {
+    const cache = sourceEnv.XDG_CACHE_HOME ?? path.join(sourceEnv.HOME ?? homedir(), ".cache");
+    if (!path.isAbsolute(cache))
+        return;
+    const markers = path.join(cache, "humanish", "codex-analysis-recovery");
+    await mkdir(markers, { recursive: true, mode: 0o700 });
+    await writeFile(path.join(markers, `${path.basename(work)}.json`), JSON.stringify({
+        schema: "humanish.codex-auth-recovery.v1", taskDirectoryName: path.basename(work),
+        homeDirectoryName: "home", authFileName: "auth.json", reason
+    }) + "\n", { mode: 0o600, flag: "wx" });
+}
+async function preserveUnexpectedAuth(work, sourceEnv) {
+    const home = path.join(work, "home");
+    await chmod(work, 0o700);
+    await chmod(home, 0o700);
+    const authPath = path.join(home, "auth.json"), auth = await lstat(authPath);
+    await chmod(authPath, auth.isDirectory() ? 0o700 : 0o600);
+    // Preserve only login state. Evidence, logs, databases and config are disposable.
+    for (const name of await readdir(home))
+        if (name !== "auth.json")
+            await rm(path.join(home, name), { recursive: true, force: true });
+    for (const name of await readdir(work))
+        if (name !== "home")
+            await rm(path.join(work, name), { recursive: true, force: true });
+    await writeRecoveryMarker(work, sourceEnv, "unexpected_auth_replacement");
+}
+function hasScopedIdentity(method, params, threadId, turnId) {
+    if (method === "turn/started" || method === "turn/completed") {
+        const id = codexRecord(params.turn).id;
+        return params.threadId === threadId && typeof id === "string" && id.length > 0 && id.length <= 200
+            && (turnId === undefined || id === turnId);
+    }
+    if (method.startsWith("item/") || method.startsWith("rawResponse") || method === "thread/tokenUsage/updated")
+        return params.threadId === threadId && typeof params.turnId === "string" && params.turnId.length > 0
+            && (turnId === undefined || params.turnId === turnId);
+    return (params.threadId === undefined || params.threadId === threadId) && (params.turnId === undefined || params.turnId === turnId);
+}
+/** Exactly one fresh thread/turn; private host auth, no participant state reuse. */
+async function executeRestrictedCodexSession(request, options = {}, readinessOnly = false) {
+    const admissionError = restrictedCodexRequestError(request);
+    if (admissionError)
+        return restrictedCodexFailure(admissionError);
+    if ((options.platform ?? process.platform) !== "linux" || (options.arch ?? process.arch) !== "x64")
+        return restrictedCodexFailure("codex_unsupported_platform");
+    const deadline = new RestrictedCodexDeadline(request.timeoutMs, request.signal);
+    const sourceEnv = options.env ?? process.env;
+    const spawnFn = options.spawnFn ?? ((file, args, settings) => spawn(file, args, settings));
+    let work, authLink, transport;
+    let threadId, turnId, earlyTurnId;
+    let dispatched = false, completed = false, usage = null;
+    let generatedDeltaBytes = 0;
+    let outputItem;
+    let result = restrictedCodexFailure("codex_process_failed");
+    const early = [];
+    let resolveTurn;
+    const finished = new Promise(resolve => { resolveTurn = resolve; });
+    const handleTurnEvent = (method, params) => {
+        if (!hasScopedIdentity(method, params, threadId, turnId)) {
+            deadline.stop("codex_protocol_error");
+            return;
+        }
+        const item = codexRecord(params.item);
+        if (method === "rawResponseItem/completed") {
+            if (!["message", "reasoning"].includes(String(item.type))) {
+                deadline.stop("codex_tool_call");
+                return;
+            }
+            if (item.type === "message" && Array.isArray(item.content)
+                && item.content.some(content => codexRecord(content).type === "refusal"))
+                deadline.stop("refusal");
+        }
+        if (method === "thread/tokenUsage/updated")
+            usage = restrictedCodexUsage(params.tokenUsage);
+        if (method === "item/started" || method === "item/completed") {
+            if (!["userMessage", "agentMessage", "reasoning"].includes(String(item.type))) {
+                deadline.stop("codex_tool_call");
+                return;
+            }
+            if (item.type === "agentMessage") {
+                if (item.delivery === "async" || (Array.isArray(item.questions) && item.questions.length > 0)) {
+                    deadline.stop("codex_tool_call");
+                    return;
+                }
+                if (method === "item/completed" && item.phase !== "commentary") {
+                    if (typeof item.id !== "string" || typeof item.text !== "string" || Buffer.byteLength(item.text) > CODEX_MAX_OUTPUT_BYTES
+                        || (item.phase !== null && item.phase !== "final_answer") || (item.delivery !== null && item.delivery !== undefined)
+                        || (outputItem && (outputItem.id !== item.id || outputItem.text !== item.text))) {
+                        deadline.stop("invalid_response");
+                        return;
+                    }
+                    outputItem = { id: item.id, text: item.text };
+                }
+            }
+        }
+        if (method === "turn/completed") {
+            const turn = codexRecord(params.turn);
+            if (turn.id !== turnId || completed) {
+                deadline.stop("codex_protocol_error");
+                return;
+            }
+            completed = true;
+            if (turn.status === "interrupted") {
+                deadline.stop("cancelled");
+                return;
+            }
+            if (turn.status !== "completed" || turn.error !== null || !outputItem) {
+                deadline.stop("invalid_response");
+                return;
+            }
+            try {
+                resolveTurn({ status: "completed", output: JSON.parse(outputItem.text), usage,
+                    usageComplete: usage !== null, dispatched: true, errorCode: null });
+            }
+            catch {
+                deadline.stop("invalid_response");
+            }
+        }
+    };
+    try {
+        deadline.check();
+        const file = await resolveExecutable(options, sourceEnv);
+        deadline.check();
+        work = await mkdtemp(path.join(options.tempRoot ?? tmpdir(), "humanish-codex-analysis-"));
+        await chmod(work, 0o700);
+        work = await realpath(work);
+        const home = path.join(work, "home"), cwd = path.join(work, "cwd"), scratch = path.join(work, "scratch");
+        for (const directory of [home, cwd, scratch])
+            await mkdir(directory, { mode: 0o700 });
+        const env = childEnvironment(sourceEnv, home, scratch);
+        await checkVersion(file, env, cwd, spawnFn, deadline);
+        const config = restrictedCodexConfig(request.model), configPath = path.join(home, "config.toml");
+        await writeFile(configPath, config.toml, { mode: 0o600, flag: "wx" });
+        const authHome = options.authHome ?? sourceEnv.CODEX_HOME ?? path.join(sourceEnv.HOME ?? homedir(), ".codex");
+        if (!path.isAbsolute(authHome))
+            throw new RestrictedCodexStop("codex_unsupported_auth");
+        let authFile;
+        try {
+            authFile = await realpath(path.join(authHome, "auth.json"));
+            if (!(await stat(authFile)).isFile())
+                throw new Error();
+        }
+        catch {
+            throw new RestrictedCodexStop("codex_login_required");
+        }
+        deadline.check();
+        authLink = path.join(home, "auth.json");
+        await symlink(authFile, authLink);
+        deadline.check();
+        const owned = ownCodexProcess(spawnFn(file, ["app-server", "--strict-config"], {
+            cwd, env, detached: false, stdio: ["pipe", "pipe", "pipe"]
+        }));
+        // Raw input notifications echo supplied image data. Bound that wire separately
+        // from the 2 MiB generated report, without dropping admitted evidence.
+        const frameLimit = Math.max(CODEX_MAX_OUTPUT_BYTES, Buffer.byteLength(JSON.stringify({ instructions: request.instructions,
+            evidence: request.evidence, images: request.images, schema: request.schema })) + 1024 * 1024);
+        transport = new RestrictedCodexTransport(owned, deadline, frameLimit);
+        transport.onNotification = (method, params) => {
+            if (!dispatched)
+                return;
+            if (!hasScopedIdentity(method, params, threadId, turnId ?? earlyTurnId)) {
+                deadline.stop("codex_protocol_error");
+                return;
+            }
+            if (method === "item/agentMessage/delta") {
+                if (typeof params.delta !== "string") {
+                    deadline.stop("codex_protocol_error");
+                    return;
+                }
+                generatedDeltaBytes += Buffer.byteLength(params.delta);
+                if (generatedDeltaBytes > CODEX_MAX_OUTPUT_BYTES) {
+                    deadline.stop("response_too_large");
+                    return;
+                }
+            }
+            const item = codexRecord(params.item);
+            // Tool requests must fail even if the turn-start acknowledgment is lost.
+            if ((method === "rawResponseItem/completed" && !["message", "reasoning"].includes(String(item.type)))
+                || (["item/started", "item/completed"].includes(method) && item.type === "agentMessage"
+                    && (item.delivery === "async" || (Array.isArray(item.questions) && item.questions.length > 0)))) {
+                deadline.stop("codex_tool_call");
+                return;
+            }
+            if (method === "turn/started") {
+                const value = codexRecord(params.turn).id;
+                if (typeof value !== "string" || value.length === 0 || (earlyTurnId !== undefined && value !== earlyTurnId))
+                    deadline.stop("codex_protocol_error");
+                else
+                    earlyTurnId = value;
+            }
+            if (turnId === undefined)
+                early.push({ method, params });
+            else
+                handleTurnEvent(method, params);
+        };
+        const initialize = await transport.rpc("initialize", {
+            clientInfo: { name: "humanish_analysis", version: "1.0.0" }, capabilities: { experimentalApi: true }
+        });
+        if (typeof initialize.userAgent !== "string" || !initialize.userAgent.includes(`/0.154.0 `)
+            || initialize.codexHome !== home || initialize.platformOs !== "linux" || initialize.platformFamily !== "unix")
+            throw new RestrictedCodexStop("codex_unsupported_version");
+        transport.notify("initialized", {});
+        const effective = await transport.rpc("config/read", { includeLayers: true, cwd });
+        if (!admitsRestrictedCodexConfig(effective, configPath, request.model))
+            throw new RestrictedCodexStop("codex_unsafe_configuration");
+        const account = await transport.rpc("account/read", { refreshToken: false });
+        if (account.account === null)
+            throw new RestrictedCodexStop("codex_login_required");
+        if (codexRecord(account.account).type !== "chatgpt" || account.requiresOpenaiAuth !== true)
+            throw new RestrictedCodexStop("codex_unsupported_auth");
+        const thread = await transport.rpc("thread/start", { cwd, ephemeral: true, experimentalRawEvents: true,
+            approvalPolicy: "never", sandbox: "read-only", model: request.model, modelProvider: "openai", allowProviderModelFallback: false,
+            environments: [], runtimeWorkspaceRoots: [], dynamicTools: [], baseInstructions: request.instructions, config: config.overrides });
+        if (!admitsRestrictedCodexThread(thread, request.model, cwd))
+            throw new RestrictedCodexStop("codex_unsafe_configuration");
+        threadId = String(codexRecord(thread.thread).id);
+        const mcp = await transport.rpc("mcpServerStatus/list", { limit: 100 });
+        if (!Array.isArray(mcp.data) || mcp.data.length !== 0 || mcp.nextCursor !== null)
+            throw new RestrictedCodexStop("codex_unsafe_configuration");
+        if (readinessOnly) {
+            result = { status: "completed", output: null, usage: null, usageComplete: false, dispatched: false, errorCode: null };
+        }
+        else {
+            const input = [{ type: "text", text: request.evidence, text_elements: [] }];
+            for (const [index, image] of request.images.entries()) {
+                deadline.check();
+                const match = CODEX_IMAGE.exec(image.dataUrl);
+                const imagePath = path.join(scratch, `evidence-${index}.${match[1] === "jpeg" ? "jpg" : match[1]}`);
+                await writeFile(imagePath, Buffer.from(match[2], "base64"), { mode: 0o600, flag: "wx" });
+                input.push({ type: "text", text: JSON.stringify({ captureEvidenceId: image.evidenceId }), text_elements: [] }, { type: "localImage", path: imagePath });
+            }
+            deadline.check();
+            // Even a lost acknowledgment may have dispatched the request. Never claim zero cost.
+            dispatched = true;
+            const turn = await transport.rpc("turn/start", { threadId, cwd, approvalPolicy: "never", sandboxPolicy: { type: "readOnly" },
+                environments: [], runtimeWorkspaceRoots: [], effort: "low", model: request.model, outputSchema: request.schema, input });
+            const returnedTurnId = codexRecord(turn.turn).id;
+            if (typeof returnedTurnId !== "string" || returnedTurnId.length === 0 || returnedTurnId.length > 200
+                || (earlyTurnId !== undefined && earlyTurnId !== returnedTurnId))
+                throw new RestrictedCodexStop("codex_protocol_error");
+            turnId = returnedTurnId;
+            for (const event of early)
+                handleTurnEvent(event.method, event.params);
+            early.length = 0;
+            result = await deadline.wait(finished);
+            deadline.check();
+        }
+    }
+    catch (error) {
+        const code = error instanceof RestrictedCodexStop ? error.code : "codex_process_failed";
+        result = restrictedCodexFailure(code === "codex_cleanup_failed" ? code : deadline.code ?? code, dispatched, usage);
+    }
+    finally {
+        // Deadline remains authoritative until acceptance; teardown has its own small grace.
+        deadline.close();
+        let cleaned = result.errorCode !== "codex_cleanup_failed";
+        if (transport) {
+            const cleanupTurn = turnId ?? earlyTurnId;
+            cleaned = await transport.close(dispatched && !completed && threadId && cleanupTurn
+                ? { threadId, turnId: cleanupTurn } : undefined).catch(() => false);
+            if (!cleaned)
+                retainUnclosedChild(transport.owned.closed);
+        }
+        let authReplaced = false;
+        if (authLink && cleaned) {
+            try {
+                const info = await lstat(authLink);
+                authReplaced = !info.isSymbolicLink();
+                if (!authReplaced)
+                    await unlink(authLink);
+            }
+            catch (error) {
+                if (codexRecord(error).code !== "ENOENT")
+                    cleaned = false;
+            }
+        }
+        // An unexpected replacement may contain rotated login state. Do not discard it
+        // or overwrite the host login. Leave this private control-plane directory for
+        // recovery and fail closed; no path or credential is included in the result.
+        if (authReplaced) {
+            cleaned = false;
+            if (work)
+                await preserveUnexpectedAuth(work, sourceEnv).catch(() => undefined);
+        }
+        if (work && cleaned && !authReplaced)
+            await rm(work, { recursive: true, force: true }).catch(() => { cleaned = false; });
+        if (work && !cleaned && !authReplaced)
+            await writeRecoveryMarker(work, sourceEnv, "process_cleanup_unconfirmed").catch(() => undefined);
+        if (!cleaned)
+            result = restrictedCodexFailure("codex_cleanup_failed", dispatched, usage);
+    }
+    return result;
+}
+export async function checkRestrictedCodexSessionReadiness(input = {}, options = {}) {
+    return runRestrictedCodexSession({ model: RESTRICTED_CODEX_ANALYSIS_MODELS[0], instructions: "Analyze only supplied study evidence.",
+        evidence: "", images: [], schema: { type: "object", additionalProperties: false, properties: {} }, maxOutputTokens: null,
+        timeoutMs: input.timeoutMs ?? 15_000, ...(input.signal === undefined ? {} : { signal: input.signal }) }, options, true);
+}
+//# sourceMappingURL=restricted-codex-session.js.map