@openrig/cli 0.5.16 → 0.6.0

package/node_modules/@openrig/daemon/dist/adapters/codex-runtime-adapter.js

@@ -1,1355 +0,0 @@
-import nodePath from "node:path";
-import fs from "node:fs";
-import { createHash } from "node:crypto";
-import os from "node:os";
-import { parse as parseToml } from "smol-toml";
-import { codexPostureArg } from "./yolo-mode.js";
-import { resolveConcreteHint } from "../domain/runtime-adapter.js";
-import { observeCodexSandbox } from "../domain/permission-drift.js";
-import { defaultResolveHomeDirByPid, readCodexThreadIdFromCandidateHomes, } from "../domain/codex-thread-id.js";
-import { assessNativeResumeProbe, buildCodexResumeCore } from "../domain/native-resume-probe.js";
-import { mergeManagedBlock } from "../domain/managed-blocks.js";
-import { parseSessionName } from "../domain/session-name.js";
-import { shellQuote } from "./shell-quote.js";
-import { runSyncSite } from "../domain/sync-site-wrap.js";
-import { listNativeProcesses, observeCodexPaneProcess } from "../domain/native-process-lineage.js";
-/**
- * Codex runtime adapter. Projects resources to .agents/ targets (preserving
- * existing Codex filesystem contract) and delivers startup files.
- */
-export class CodexRuntimeAdapter {
-    runtime = "codex";
-    tmux;
-    fs;
-    listProcesses;
-    readThreadIdByPid;
-    sleep;
-    resolveHomeDirByPid;
-    codexHome;
-    launchPath;
-    // Housekeeping B1 fixback (guard-blocking, arch HK-AR-1 = whole-probe DI):
-    // the Codex profile-LOAD probe is an injectable dep in the adapter's
-    // established optional-deps shape. Default = the REAL probe
-    // (defaultProfilePreflight, module-private); tests inject a controlled probe
-    // so no real codex subprocess runs. Contract not weakened — production uses
-    // the real probe by default.
-    verifyProfilePreflight;
-    // OPR.0.4.1.10 FR-B — absolute path to the daemon's own shipped activity-relay.cjs,
-    // resolved by startup from import.meta.dirname. Used by ensureCodexActivityHooks
-    // (FR-A) to write config-layer [hooks] command entries that are cwd-independent and
-    // version-matched to the running daemon (NOT ${PLUGIN_ROOT}, NOT a per-cwd copy).
-    activityRelayPath;
-    constructor(deps) {
-        this.tmux = deps.tmux;
-        this.fs = deps.fsOps;
-        this.codexHome = deps.codexHome;
-        this.launchPath = deps.launchPath;
-        this.activityRelayPath = deps.activityRelayPath;
-        this.listProcesses = deps.listProcesses ?? defaultListProcesses;
-        this.readThreadIdByPid = deps.readThreadIdByPid ?? ((pid) => this.readThreadIdFromLogs(pid));
-        this.resolveHomeDirByPid = deps.resolveHomeDirByPid ?? defaultResolveHomeDirByPid;
-        this.sleep = deps.sleep ?? ((ms) => new Promise((resolve) => setTimeout(resolve, ms)));
-        this.verifyProfilePreflight = deps.verifyProfilePreflight ?? defaultProfilePreflight;
-    }
-    /**
-     * plugin-primitive Phase 3a slice 3.5 — ensure Codex feature flag.
-     *
-     * When `enabled` is true, idempotently writes `codex_hooks = true` under
-     * `[features]` in `~/.codex/config.toml`, creating the file if missing.
-     * When `enabled` is false, makes ZERO modifications — the operator is
-     * managing Codex config independently and the daemon does not touch it.
-     *
-     * Replaces the activity-hook-injection-coupled feature-flag set call
-     * that lived inside the auto-injected activity-hook provisioning path
-     * pre-rip (plugin-primitive Phase 3a slice 3.1).
-     */
-    ensureCodexFeatureFlag(enabled, opts) {
-        if (!enabled)
-            return;
-        if (!opts?.codexVersion)
-            return;
-        if (isCodex013xOrLater(opts.codexVersion))
-            return;
-        const configPath = this.resolveCodexConfigPath();
-        const existing = this.fs.exists(configPath) ? this.fs.readFile(configPath) : "";
-        const updated = upsertCodexHooksFeature(existing);
-        if (updated !== existing) {
-            this.fs.mkdirp(nodePath.dirname(configPath));
-            this.fs.writeFile(configPath, updated);
-        }
-    }
-    /**
-     * OPR.0.4.1.10 FR-A — write the OpenRig activity hooks into Codex's config layer
-     * (`~/.codex/config.toml` inline `[hooks]`) so an OpenRig-launched Codex seat is
-     * hook-PRIMARY from clean shipped config. Idempotent managed-block upsert for the
-     * four events SessionStart / UserPromptSubmit / Stop / PermissionRequest; each
-     * command is `node "<activityRelayPath>"` (the daemon's OWN shipped relay, FR-B —
-     * cwd-independent, version-matched, NOT `${PLUGIN_ROOT}` nor a per-cwd copy). Also
-     * pins `[features].hooks = true` (canonical key; the deprecated `codex_hooks` alias
-     * is intentionally NOT used here). Trust is scoped to the exact authored hook
-     * hashes below; remaining native review prompts require an operator decision.
-     * The relay inherits the seat's OPENRIG_* env from the tmux session.
-     *
-     * Fail-safe: skips + warns when the relay asset is missing — never writes a hook that
-     * points at a nonexistent script. Verified-firsthand (Codex 0.139, dev1-qa AC-2 proof):
-     * on the OpenRig-managed launch path — managed inline hooks + trusted + the relay env
-     * delivered into the seat (OPENRIG_URL + OPENRIG_ACTIVITY_HOOK_TOKEN + session/node/runtime)
-     * — all four events, SessionStart included, deliver as runtime_hook activity. Without the
-     * relay env the hooks are still trusted/visible but no activity rows land. (A bare/manual
-     * codex TUI launch lacks that context and may not deliver SessionStart — not how OpenRig
-     * launches seats.)
-     */
-    ensureCodexActivityHooks() {
-        const relay = this.activityRelayPath;
-        if (!relay || !this.fs.exists(relay)) {
-            if (relay) {
-                console.error(`[openrig] codex activity hooks skipped: relay asset not found at ${relay}`);
-            }
-            return;
-        }
-        const configPath = this.resolveCodexConfigPath();
-        const existing = this.fs.exists(configPath) ? this.fs.readFile(configPath) : "";
-        const withHooks = upsertCodexActivityHooks(existing, relay);
-        if (withHooks !== existing) {
-            this.fs.mkdirp(nodePath.dirname(configPath));
-            this.fs.writeFile(configPath, withHooks);
-        }
-        // OPR.0.4.3.33 hook-trust-autoclear — pre-write Codex's OWN hook trust record
-        // ([hooks.state."<key>"] trusted_hash) for exactly our 4 authored hooks, on the SAME
-        // seam that provisions them, so the daemon's unmanaged inline hooks are trusted from
-        // clean config on EVERY path a fresh Codex process reads config (launch/adopt/reconcile)
-        // — without a blanket native trust keystroke. If native identity/hash semantics
-        // change, the remaining review is surfaced for a decision. Idempotent
-        // + non-clobbering; only touches our 4 keys. See applyCodexActivityHookTrust for the RTFM.
-        const trusted = this.applyCodexActivityHookTrust(withHooks, configPath, relay);
-        if (trusted !== withHooks) {
-            this.fs.mkdirp(nodePath.dirname(configPath));
-            this.fs.writeFile(configPath, trusted);
-        }
-    }
-    /**
-     * OPR.0.4.3.33 — compute + splice Codex's `[hooks.state."<key>"] trusted_hash` for our 4
-     * authored activity hooks into `content`. `key_source` is the canonicalized config path
-     * (Codex keys trust by `std::fs::canonicalize(config.toml).display()`); we best-effort
-     * `realpathSync` the config path to match — on a miss (file not yet on real disk, or a mock
-     * fs in tests) we fall back to the plain absolute path, and any resulting key mismatch just
-     * degrades to the launch-time trust gate (Layer-2 floor), never a broken run. The command
-     * string is the value Codex deserializes from our TOML literal `'node "<relay>"'` — i.e.
-     * `node "<relay>"` WITHOUT the outer TOML quote delimiters. Timeout=5, matcher/status None.
-     */
-    applyCodexActivityHookTrust(content, configPath, relay) {
-        let keySource = configPath;
-        try {
-            keySource = fs.realpathSync(configPath);
-        }
-        catch {
-            // config.toml not on the real filesystem (first write / unit-test mock fs) — the plain
-            // absolute path is the honest best guess; a canonicalization delta is fail-safe (gate reappears).
-        }
-        const command = `node "${relay}"`;
-        let next = content;
-        for (const event of OPENRIG_ACTIVITY_HOOK_EVENTS) {
-            const { key, hash } = computeCodexHookTrust(event, { keySource, command, timeoutSec: 5 });
-            next = upsertCodexHookTrust(next, key, hash);
-        }
-        return next;
-    }
-    /**
-     * OPR.0.4.1.10 B3 — durable disable. When runtime.codex.hooks_enabled is false, strip the
-     * OpenRig-managed activity-hooks sentinel block from ~/.codex/config.toml so a seat that was
-     * previously provisioned with hooks does not keep firing them after the operator disables.
-     * Removes ONLY the managed block — preserves any user-owned hooks and leaves [features].hooks
-     * (the Codex 0.139 default) intact. Idempotent; no-op when the config or the block is absent.
-     */
-    removeCodexActivityHooks() {
-        const configPath = this.resolveCodexConfigPath();
-        if (!this.fs.exists(configPath))
-            return;
-        const existing = this.fs.readFile(configPath);
-        const updated = stripCodexActivityHooks(existing);
-        if (updated !== existing) {
-            this.fs.writeFile(configPath, updated);
-        }
-    }
-    async listInstalled(binding) {
-        const results = [];
-        const skillsDir = nodePath.join(binding.cwd, ".agents", "skills");
-        if (this.fs.exists(skillsDir) && this.fs.listFiles) {
-            for (const file of this.fs.listFiles(skillsDir)) {
-                results.push({ effectiveId: file, category: "skill", installedPath: nodePath.join(skillsDir, file) });
-            }
-        }
-        return results;
-    }
-    async project(plan, binding) {
-        const projected = [];
-        const skipped = [];
-        const failed = [];
-        for (const entry of plan.entries) {
-            if (entry.classification === "no_op") {
-                skipped.push(entry.effectiveId);
-                continue;
-            }
-            try {
-                const didProject = this.projectEntry(entry, binding.cwd);
-                if (didProject) {
-                    projected.push(entry.effectiveId);
-                }
-                else {
-                    skipped.push(entry.effectiveId);
-                }
-            }
-            catch (err) {
-                failed.push({ effectiveId: entry.effectiveId, error: err.message });
-            }
-        }
-        return { projected, skipped, failed };
-    }
-    async deliverStartup(files, binding) {
-        try {
-            this.ensureManagedBootstrap(binding);
-        }
-        catch (err) {
-            console.error(`[openrig] codex bootstrap warning: ${err.message}`);
-        }
-        let delivered = 0;
-        const failed = [];
-        for (const file of files) {
-            try {
-                const content = this.fs.readFile(file.absolutePath);
-                const hint = file.deliveryHint === "auto" ? this.detectDeliveryHint(file.path, content) : file.deliveryHint;
-                switch (hint) {
-                    case "guidance_merge": {
-                        const targetPath = nodePath.join(binding.cwd, "AGENTS.md");
-                        const merged = this.mergeGuidance(targetPath, file.path, content);
-                        if (!merged)
-                            continue; // rig-role skip: do not count as delivered
-                        break;
-                    }
-                    case "skill_install": {
-                        const targetDir = nodePath.join(binding.cwd, ".agents", "skills", nodePath.basename(nodePath.dirname(file.absolutePath)));
-                        this.fs.mkdirp(targetDir);
-                        this.fs.writeFile(nodePath.join(targetDir, nodePath.basename(file.path)), content);
-                        break;
-                    }
-                    case "send_text": {
-                        if (binding.tmuxSession) {
-                            const textResult = await this.tmux.sendText(binding.tmuxSession, content);
-                            if (!textResult.ok)
-                                throw new Error(textResult.message);
-                            await this.sleep(200);
-                            const submitResult = await this.tmux.sendKeys(binding.tmuxSession, ["C-m"]);
-                            if (!submitResult.ok)
-                                throw new Error(submitResult.message);
-                        }
-                        break;
-                    }
-                }
-                delivered++;
-            }
-            catch (err) {
-                if (file.required) {
-                    failed.push({ path: file.path, error: err.message });
-                }
-            }
-        }
-        return { delivered, failed };
-    }
-    async launchHarness(binding, opts) {
-        if (!binding.tmuxSession) {
-            return { ok: false, error: "No tmux session bound — cannot launch Codex harness" };
-        }
-        if (opts.resumeToken && opts.forkSource) {
-            return { ok: false, error: "resumeToken and forkSource are mutually exclusive — pick one" };
-        }
-        const updatePrompt = { handled: false };
-        const model = binding.model?.trim();
-        const modelArg = model ? ` -m ${shellQuote(model)}` : "";
-        const profile = binding.codexConfigProfile?.trim();
-        const profileArg = profile ? ` -p ${shellQuote(profile)}` : "";
-        const postureArg = codexPostureArg(profileArg, process.env, binding.launchPosture);
-        const appliedLaunch = observeCodexSandbox(postureArg);
-        // OPR.0.3.4.7 — profile-LOAD probe before launch/resume. A legacy
-        // [profiles.<name>] table or invalid TOML must fail BEFORE the opaque
-        // `codex -p <profile> resume` failure. An absent .config.toml passes
-        // (Codex default-layers it; advisor Option B).
-        if (profile) {
-            const probeResult = await this.verifyProfilePreflight(profile);
-            if (!probeResult.ok) {
-                return {
-                    ok: false,
-                    error: `${probeResult.error}${probeResult.migrationHint ? `\n  Fix: ${probeResult.migrationHint}` : ""}`,
-                };
-            }
-        }
-        const gitDirArg = ` --add-dir ${shellQuote(nodePath.join(binding.cwd, ".git"))}`;
-        const queueStateDirArg = this.buildQueueStateAddDirArg(opts.name);
-        // Fork branch: `codex fork <parent_thread_id>`. Captures the NEW thread id
-        // post-fork. Parent thread id is NOT persisted onto the new seat record
-        // (identity-honesty bedrock).
-        if (opts.forkSource) {
-            if (opts.forkSource.kind !== "native_id") {
-                return {
-                    ok: false,
-                    error: `codex fork: ref.kind="${opts.forkSource.kind}" is not supported in v1; use ref.kind="native_id" with the prior conversation's thread id`,
-                };
-            }
-            const parentId = opts.forkSource.value?.trim();
-            if (!parentId) {
-                return { ok: false, error: "codex fork: forkSource.value is required (parent native_id)" };
-            }
-            // OPR.0.4.8.2: the FORK path uses the SAME posture decision (codexPostureArg) — YOLO forces
-            // -s danger-full-access on every seat; otherwise the named profile, or OpenRig's explicit
-            // -s workspace-write floor flag.
-            // 0.5.2-07 A2-3: the FORK path threads the SPEC model too (fork-instantiate reverted it before).
-            const cmd = `codex${postureArg}${modelArg} fork${queueStateDirArg} ${shellQuote(parentId)}`;
-            const textResult = await this.tmux.sendShellCommand(binding.tmuxSession, this.launchPath ? `env PATH=${shellQuote(this.launchPath)} ${cmd}` : cmd);
-            if (!textResult.ok) {
-                return { ok: false, error: `Failed to send launch command: ${textResult.message}` };
-            }
-            await this.dismissSkippableCodexUpdatePrompt(binding.tmuxSession, updatePrompt, 8);
-            if (updatePrompt.failure)
-                return updatePrompt.failure;
-            const threadId = await this.captureFreshThreadId(binding, updatePrompt);
-            if (updatePrompt.failure)
-                return updatePrompt.failure;
-            if (!threadId) {
-                return {
-                    ok: false,
-                    error: "codex fork: could not capture new post-fork thread id",
-                };
-            }
-            return { ok: true, resumeToken: threadId, resumeType: "codex_id", appliedLaunch };
-        }
-        // OPR.0.4.8.2: one posture decision (codexPostureArg) for the fresh launch too — YOLO forces
-        // -s danger-full-access (overrides even a named profile); otherwise the named profile, or
-        // OpenRig's explicit -s workspace-write floor flag.
-        const cmd = opts.resumeToken
-            // 0.5.2-07 A2-3: the pod-aware RESUME path threads the SPEC model too (reverted before — the
-            // grounding map assumed codex parity with the claude adapter, but only fresh emitted -m).
-            ? buildCodexResumeCore(opts.resumeToken, profile, false, queueStateDirArg.trim() || undefined, binding.launchPosture, model, postureArg)
-            : `codex${postureArg} -C ${shellQuote(binding.cwd)}${gitDirArg}${queueStateDirArg}${modelArg}`;
-        const textResult = await this.tmux.sendShellCommand(binding.tmuxSession, this.launchPath ? `env PATH=${shellQuote(this.launchPath)} ${cmd}` : cmd);
-        if (!textResult.ok) {
-            return { ok: false, error: `Failed to send launch command: ${textResult.message}` };
-        }
-        await this.dismissSkippableCodexUpdatePrompt(binding.tmuxSession, updatePrompt);
-        if (updatePrompt.failure)
-            return updatePrompt.failure;
-        if (opts.resumeToken) {
-            const verification = await this.verifyResumeLaunch(binding.tmuxSession, updatePrompt, { resumeToken: opts.resumeToken });
-            if (!verification.ok)
-                return verification;
-            return { ok: true, resumeToken: opts.resumeToken, resumeType: "codex_id", appliedLaunch };
-        }
-        const threadId = await this.captureFreshThreadId(binding, updatePrompt);
-        if (updatePrompt.failure)
-            return updatePrompt.failure;
-        if (threadId) {
-            return { ok: true, resumeToken: threadId, resumeType: "codex_id", appliedLaunch };
-        }
-        return { ok: true, appliedLaunch };
-    }
-    buildQueueStateAddDirArg(sessionName) {
-        const identity = parseCanonicalSessionName(sessionName);
-        if (!identity)
-            return "";
-        const sharedDocsRoot = process.env.OPENRIG_SHARED_DOCS_ROOT?.trim()
-            // OPR.0.3.2.14 — subpath scrubbed (internal-team layout → generic placeholder).
-            || nodePath.join(this.fs.homedir ?? os.homedir(), ".openrig", "shared-docs");
-        const queueStateRoot = nodePath.join(sharedDocsRoot, "rigs", identity.rig, "state", identity.pod);
-        return ` --add-dir ${shellQuote(queueStateRoot)}`;
-    }
-    async captureProbeScreen(target) {
-        // Current readiness belongs to the rendered screen. Scrollback may retain
-        // dismissed prompts, loading headers, or refusals from earlier attempts.
-        if (this.tmux.capturePaneScreen)
-            return await this.tmux.capturePaneScreen(target) ?? "";
-        return await this.tmux.capturePaneContent(target, 40) ?? "";
-    }
-    async checkReady(binding) {
-        if (!binding.tmuxSession) {
-            return { ready: false, reason: "No tmux session bound" };
-        }
-        const alive = await this.tmux.hasSession(binding.tmuxSession);
-        if (!alive) {
-            return { ready: false, reason: "tmux session not responsive" };
-        }
-        const paneCommand = await this.tmux.getPaneCommand(binding.tmuxSession);
-        const paneContent = await this.captureProbeScreen(binding.tmuxSession);
-        const probe = assessNativeResumeProbe({
-            runtime: "codex",
-            paneCommand,
-            paneContent,
-        });
-        if (probe.status === "resumed")
-            return { ready: true };
-        return { ready: false, reason: probe.detail, code: probe.code };
-    }
-    async dismissSkippableCodexUpdatePrompt(tmuxSession, updatePrompt, attempts = 6) {
-        for (let attempt = 0; attempt < attempts; attempt++) {
-            const paneCommand = await this.tmux.getPaneCommand(tmuxSession);
-            const paneContent = await this.captureProbeScreen(tmuxSession);
-            const probe = assessNativeResumeProbe({ runtime: "codex", paneCommand, paneContent });
-            if (probe.code === "update_gate") {
-                if (updatePrompt.handled || !isSkippableCodexUpdatePrompt(paneContent))
-                    return false;
-                const identity = await this.observeMenuProcess(tmuxSession, paneCommand);
-                if (!identity)
-                    return false;
-                // The npm launcher may be foreground Node with a native Codex child.
-                // Recheck identity and CURRENT screen after sampling, never scrollback.
-                const currentCommand = await this.tmux.getPaneCommand(tmuxSession);
-                if (await this.observeMenuProcess(tmuxSession, currentCommand) !== identity) {
-                    updatePrompt.handled = true;
-                    return false;
-                }
-                const currentScreen = await this.tmux.capturePaneScreen?.(tmuxSession);
-                if (!currentScreen || !isSkippableCodexUpdatePrompt(currentScreen)
-                    || assessNativeResumeProbe({ runtime: "codex", paneCommand: currentCommand, paneContent: currentScreen }).code !== "update_gate") {
-                    updatePrompt.handled = true;
-                    return false;
-                }
-                // Codex 0.155.1 ignores Paste; Key3 selects AND submits DontRemind
-                // (including its version-cache write). An Enter would hit the next
-                // screen. Consume the attempt before sending, even if delivery fails.
-                updatePrompt.handled = true;
-                const result = await this.tmux.sendKeys(tmuxSession, ["3"]);
-                if (!result.ok) {
-                    updatePrompt.failure = {
-                        ok: false, recovery: "attention_required",
-                        error: `Could not skip the Codex update prompt: ${result.message}. Inspect the session before retrying.`,
-                        evidence: paneContent.split("\n").slice(-12).join("\n"),
-                    };
-                    return false;
-                }
-                await this.sleep(500);
-                continue; // Observe transition; never send a second choice on this launch.
-            }
-            // Readiness or another native decision closes update automation. A later
-            // stale capture must not reopen it. Trust/auth decisions remain in-pane.
-            if (probe.status === "resumed" || probe.status === "attention_required"
-                || probe.code === "trust_gate" || probe.code === "hook_trust_gate") {
-                updatePrompt.handled = true;
-                return probe.status === "resumed";
-            }
-            if (attempt < attempts - 1)
-                await this.sleep(200);
-        }
-        return false;
-    }
-    async observeMenuProcess(target, paneCommand) {
-        // tmux may name the shell wrapper; native ancestry and foreground group decide identity.
-        if (!paneCommand)
-            return null;
-        const observation = await observeCodexPaneProcess({ target, tmux: this.tmux, listProcesses: this.listProcesses });
-        return observation ? JSON.stringify([paneCommand, observation.fingerprint]) : null;
-    }
-    ensureManagedBootstrap(binding) {
-        this.provisionWorkspaceTrust(binding.cwd ?? null);
-    }
-    projectEntry(entry, cwd) {
-        if (entry.category === "runtime_resource" && this.applyRuntimeResource(entry)) {
-            return true;
-        }
-        if (entry.category === "guidance" && entry.mergeStrategy === "managed_block") {
-            const targetPath = nodePath.join(cwd, "AGENTS.md");
-            const content = this.fs.readFile(entry.absolutePath);
-            return this.mergeGuidance(targetPath, entry.effectiveId, content);
-        }
-        // HG-1.3 plugin runtime applicability filter (per DESIGN.md §5.1):
-        // - explicit pluginType="claude" → skip Codex projection
-        // - pluginType="auto" (or unset) + no .codex-plugin/ manifest dir → skip
-        // - explicit pluginType="codex" → project regardless of manifest presence
-        if (entry.category === "plugin" && !this.pluginAppliesToCodex(entry)) {
-            return false;
-        }
-        const targetDir = this.resolveTargetDir(entry, cwd);
-        if (!targetDir)
-            return true;
-        this.fs.mkdirp(targetDir);
-        const isDir = this.fs.listFiles ? this.fs.listFiles(entry.absolutePath).length > 0 : false;
-        if (isDir && this.fs.listFiles) {
-            for (const file of this.fs.listFiles(entry.absolutePath)) {
-                const src = nodePath.join(entry.absolutePath, file);
-                const dest = nodePath.join(targetDir, file);
-                const content = this.fs.readFile(src);
-                // Reconcile mode even when the content write is skipped: a byte-identical dest
-                // projected earlier may still carry the wrong (default) mode.
-                if (this.fs.exists(dest) && hashContent(content) === hashContent(this.fs.readFile(dest))) {
-                    this.preserveMode(src, dest);
-                    continue;
-                }
-                this.fs.mkdirp(nodePath.dirname(dest));
-                this.fs.writeFile(dest, content);
-                this.preserveMode(src, dest);
-            }
-        }
-        else {
-            const content = this.fs.readFile(entry.absolutePath);
-            const destFile = nodePath.join(targetDir, nodePath.basename(entry.absolutePath));
-            if (this.fs.exists(destFile) && hashContent(content) === hashContent(this.fs.readFile(destFile))) {
-                this.preserveMode(entry.absolutePath, destFile);
-                return true;
-            }
-            this.fs.writeFile(destFile, content);
-            this.preserveMode(entry.absolutePath, destFile);
-        }
-        return true;
-    }
-    /**
-     * Reapply the source file's permission bits to the projected dest. Plain
-     * readFile+writeFile (writeFileSync) creates the dest with the process default
-     * mode, dropping executable bits on nested plugin helpers (e.g. the
-     * claude-compaction-restore/scripts/*.mjs 0755 hooks). No-op when the fs adapter
-     * does not expose mode primitives (keeps existing mock-fs callers unaffected).
-     */
-    preserveMode(src, dest) {
-        if (!this.fs.statMode || !this.fs.chmod)
-            return;
-        const srcMode = this.fs.statMode(src) & 0o777;
-        if ((this.fs.statMode(dest) & 0o777) !== srcMode)
-            this.fs.chmod(dest, srcMode);
-    }
-    pluginAppliesToCodex(entry) {
-        const explicit = entry.pluginType ?? "auto";
-        if (explicit === "codex")
-            return true;
-        if (explicit === "claude")
-            return false;
-        // auto: detect via .codex-plugin/plugin.json presence in the source tree
-        return this.fs.exists(nodePath.join(entry.absolutePath, ".codex-plugin", "plugin.json"));
-    }
-    resolveTargetDir(entry, cwd) {
-        switch (entry.category) {
-            case "skill": return nodePath.join(cwd, ".agents", "skills", entry.effectiveId);
-            case "guidance": return null; // handled via merge
-            case "subagent": return nodePath.join(cwd, ".agents"); // .agents/{id}.yaml per preserved contract
-            case "plugin": return nodePath.join(cwd, ".codex", "plugins", entry.effectiveId);
-            case "runtime_resource": return nodePath.join(cwd, ".agents", "extensions", entry.effectiveId);
-            default: return null;
-        }
-    }
-    applyRuntimeResource(entry) {
-        if (entry.resourceType !== "codex_config_fragment") {
-            return false;
-        }
-        const configPath = this.resolveCodexConfigPath();
-        this.fs.mkdirp(nodePath.dirname(configPath));
-        const existing = this.fs.exists(configPath) ? this.fs.readFile(configPath) : "";
-        const fragment = this.fs.readFile(entry.absolutePath);
-        // Before anything is dropped: a fragment that is invalid on its own must
-        // fail loudly, never be "resolved" by the collision filter deleting it.
-        assertFragmentParsesStandalone(fragment, entry.absolutePath, entry.effectiveId);
-        // Ordered after the parse: an unparseable fragment gets the TOML error that
-        // names its line and column, not a root-scope complaint about wreckage.
-        assertFragmentOpensWithTable(fragment, entry.absolutePath, entry.effectiveId);
-        const rendered = upsertManagedCodexConfigFragment(existing, entry.effectiveId, fragment);
-        assertRendersAsLoadableToml(rendered, configPath, entry.effectiveId);
-        this.fs.writeFile(configPath, rendered);
-        return true;
-    }
-    /**
-     * Merge a managed block into the target guidance file. Returns `true` when
-     * the merge happened, `false` when intentionally skipped (rig-role). Callers
-     * propagate the skip signal so ProjectionResult and StartupDeliveryResult
-     * report honest counts.
-     */
-    mergeGuidance(targetPath, blockId, content) {
-        // Mirrors Claude Code adapter: the `rig-role` managed block collides across
-        // pod-mates because the regenerator pairs (target-file × spec) without
-        // seat correlation. Per-seat role content is delivered through `send_text`
-        // startup instead. Refuse the merge loudly; silent skip would mask the
-        // collision. See ADR-0006.
-        if (blockId === "rig-role") {
-            console.log(`[openrig] skip: effectiveId is rig-role, per-seat delivery via send_text path required (target=${targetPath})`);
-            return false;
-        }
-        mergeManagedBlock(this.fs, targetPath, blockId, content, {
-            replaceBlockIds: blockId === "openrig-start.md" ? ["using-openrig.md"] : [],
-        });
-        return true;
-    }
-    detectDeliveryHint(path, content) {
-        return resolveConcreteHint(path, content);
-    }
-    provisionWorkspaceTrust(cwd) {
-        if (!cwd)
-            return;
-        const configPath = this.resolveCodexConfigPath();
-        this.fs.mkdirp(nodePath.dirname(configPath));
-        let content = "";
-        try {
-            if (this.fs.exists(configPath))
-                content = this.fs.readFile(configPath);
-        }
-        catch {
-            content = "";
-        }
-        for (const trustKey of this.workspaceTrustKeys(cwd)) {
-            content = upsertCodexProjectTrust(content, trustKey);
-        }
-        this.fs.writeFile(configPath, content);
-    }
-    resolveCodexConfigPath() {
-        const root = this.codexHome
-            ?? nodePath.join(this.fs.homedir ?? os.homedir(), ".codex");
-        return nodePath.join(root, "config.toml");
-    }
-    readJsonObject(path) {
-        try {
-            if (!this.fs.exists(path))
-                return {};
-            const parsed = JSON.parse(this.fs.readFile(path));
-            return typeof parsed === "object" && parsed !== null && !Array.isArray(parsed)
-                ? parsed
-                : {};
-        }
-        catch {
-            return {};
-        }
-    }
-    readJsonObjectField(source, key) {
-        const value = source[key];
-        return typeof value === "object" && value !== null && !Array.isArray(value)
-            ? value
-            : {};
-    }
-    workspaceTrustKeys(cwd) {
-        const keys = new Set([nodePath.resolve(cwd)]);
-        try {
-            keys.add(fs.realpathSync.native(cwd));
-        }
-        catch {
-            // Best-effort only.
-        }
-        return Array.from(keys);
-    }
-    async captureFreshThreadId(binding, updatePrompt) {
-        const target = binding.tmuxPane ?? binding.tmuxSession;
-        if (!target || !this.tmux.getPanePid)
-            return undefined;
-        for (let attempt = 0; attempt < 20; attempt++) {
-            const shellPid = await this.tmux.getPanePid(target);
-            if (shellPid) {
-                const codexPids = await this.findCodexDescendantPids(shellPid);
-                for (const codexPid of codexPids) {
-                    const threadId = await this.readThreadIdByPid(codexPid);
-                    if (threadId)
-                        return threadId;
-                }
-            }
-            if (binding.tmuxSession) {
-                await this.dismissSkippableCodexUpdatePrompt(binding.tmuxSession, updatePrompt, 1);
-                if (updatePrompt.failure)
-                    return undefined;
-            }
-            await this.sleep(250);
-        }
-        return undefined;
-    }
-    async verifyResumeLaunch(tmuxSession, updatePrompt, opts) {
-        const quickAttempts = 6;
-        const extendedAttempts = 24;
-        const quickSleepMs = 200;
-        const extendedSleepMs = 500;
-        // OPR.0.3.3.21 (FR-2): process-alive is NOT proof of a restored
-        // conversation. verifyResumeLaunch must NOT return ok:true unless the probe
-        // proves `resumed`. Unresolved operator-action gates (update/trust/model)
-        // and a bounded poll that never reaches `resumed` are `attention_required`,
-        // not launch success.
-        //
-        // OPR.0.3.4.13: a slow-but-valid Codex resume (boot-in-progress on the
-        // original thread, no real gate) gets an extended poll window (~15s) beyond
-        // the quick 1.2s. Genuine gates (auth/trust/model/update) still classify
-        // within the quick window. Only the awaiting_runtime boot case extends.
-        let lastUnresolved = null;
-        let lastPaneContent = "";
-        let sawRealGate = false;
-        const totalAttempts = quickAttempts + extendedAttempts;
-        for (let attempt = 0; attempt < totalAttempts; attempt++) {
-            // After the quick phase, only continue if we're in the boot-in-progress
-            // case (awaiting_runtime, no real gate). Real gates won't self-resolve.
-            if (attempt >= quickAttempts && (sawRealGate || lastUnresolved?.code !== "awaiting_runtime")) {
-                break;
-            }
-            const paneCommand = await this.tmux.getPaneCommand(tmuxSession);
-            const paneContent = await this.captureProbeScreen(tmuxSession);
-            lastPaneContent = paneContent;
-            let probe = assessNativeResumeProbe({
-                runtime: "codex",
-                paneCommand,
-                paneContent,
-            });
-            if (probe.code === "no_saved_session") {
-                return {
-                    ok: false,
-                    error: "Codex resume failed: no saved session found for the requested session",
-                    recovery: "retry_fresh",
-                };
-            }
-            if (probe.code === "returned_to_shell") {
-                // sendShellCommand starts asynchronously, and a shell can remain the
-                // pane's wrapper while Codex loads. Use the existing bounded boot wait;
-                // this label proves neither launch failure nor readiness. A usable
-                // screen is still required here, followed by joined native identity
-                // proof in restore before the seat is reported resumed.
-                probe = {
-                    status: "inconclusive", code: "awaiting_runtime",
-                    detail: "Codex resume has not yet reached an interactive conversation in the launch pane.",
-                };
-            }
-            if (probe.status === "attention_required") {
-                return {
-                    ok: false,
-                    error: probe.detail,
-                    recovery: "attention_required",
-                    evidence: paneContent.split("\n").slice(-12).join("\n"),
-                };
-            }
-            if (probe.status === "resumed") {
-                return {
-                    ok: true,
-                    resumeToken: opts?.resumeToken,
-                    resumeType: opts?.resumeToken ? "codex_id" : undefined,
-                };
-            }
-            if (probe.code === "update_gate") {
-                const dismissed = await this.dismissSkippableCodexUpdatePrompt(tmuxSession, updatePrompt, 1);
-                if (updatePrompt.failure)
-                    return updatePrompt.failure;
-                if (dismissed) {
-                    lastUnresolved = null;
-                    sawRealGate = false;
-                    const sleepMs = attempt < quickAttempts ? quickSleepMs : extendedSleepMs;
-                    if (attempt < totalAttempts - 1)
-                        await this.sleep(sleepMs);
-                    continue;
-                }
-                lastUnresolved = probe;
-                sawRealGate = true;
-            }
-            else if (probe.status === "inconclusive") {
-                lastUnresolved = probe;
-                if (probe.code !== "awaiting_runtime") {
-                    sawRealGate = true;
-                }
-            }
-            const sleepMs = attempt < quickAttempts ? quickSleepMs : extendedSleepMs;
-            if (attempt < totalAttempts - 1)
-                await this.sleep(sleepMs);
-        }
-        return {
-            ok: false,
-            error: lastUnresolved?.detail
-                ?? "Codex resume could not be confirmed: the process is alive but a restored conversation was never proven.",
-            recovery: "attention_required",
-            evidence: lastPaneContent.split("\n").slice(-12).join("\n"),
-        };
-    }
-    async findCodexDescendantPids(parentPid) {
-        const processes = await this.listProcesses();
-        return findCodexDescendantPids(processes, parentPid);
-    }
-    async readThreadIdFromLogs(pid) {
-        return readCodexThreadIdFromCandidateHomes(pid, [await this.resolveHomeDirByPid(pid), this.fs.homedir, os.homedir()], (path) => this.fs.exists(path));
-    }
-}
-function hashContent(content) {
-    return createHash("sha256").update(content).digest("hex");
-}
-function upsertCodexProjectTrust(content, projectPath) {
-    const header = `[projects.${JSON.stringify(projectPath)}]`;
-    const lines = content.length > 0 ? content.split("\n") : [];
-    const headerIndex = lines.findIndex((line) => line.trim() === header);
-    if (headerIndex === -1) {
-        const trimmed = content.trimEnd();
-        const prefix = trimmed.length > 0 ? `${trimmed}\n\n` : "";
-        return `${prefix}${header}\ntrust_level = "trusted"\n`;
-    }
-    let nextSectionIndex = lines.length;
-    for (let i = headerIndex + 1; i < lines.length; i++) {
-        if (lines[i].trim().startsWith("[")) {
-            nextSectionIndex = i;
-            break;
-        }
-    }
-    const trustIndex = lines.findIndex((line, index) => index > headerIndex && index < nextSectionIndex && line.trim().startsWith("trust_level"));
-    if (trustIndex >= 0) {
-        lines[trustIndex] = 'trust_level = "trusted"';
-    }
-    else {
-        lines.splice(headerIndex + 1, 0, 'trust_level = "trusted"');
-    }
-    return `${lines.join("\n").replace(/\n*$/, "\n")}`;
-}
-// ── OPR.0.4.3.33 hook-trust-autoclear ────────────────────────────────────────────────────
-// Pre-write Codex's OWN hook trust record so the daemon's provisioned (unmanaged) inline
-// activity hooks are trusted on every path (launch/adopt/reconcile) without a manual `/hooks`
-// "Trust all" keystroke. Codex is a private impl; the key+hash below are REPRODUCED from the
-// open source (RTFM, cited) and are PROVISIONAL until pinned by a byte-for-byte read-back of a
-// real Codex `[hooks.state]` after `/hooks`->"Trust all" (the QA VM proof — see the unit test
-// fixture marked PIN-TO-VM). A mismatch is fail-safe: Codex re-shows the gate and the launch-time
-// review remains visible for the operator — never a blanket trust keystroke.
-//
-// RTFM sources (cite):
-//   - https://developers.openai.com/codex/hooks
-//   - openai/codex PR #20321 "hook trust metadata and enforcement" (merge commit 0452dca;
-//     typed-identity commit ffcc9cc) — key file codex-rs/hooks/src/engine/discovery.rs.
-//   - openai/codex issue #21615 (the `[hooks.state]` pre-write workaround for exactly this
-//     local-wrapper-installer case) + #23259 (positional path-keying fragility).
-//
-// KEY — codex-rs/hooks/src/lib.rs `hook_key`:
-//   `{key_source}:{event_label}:{group_index}:{handler_index}`
-//   - key_source: `std::fs::canonicalize(~/.codex/config.toml).display()` (the config source
-//     layer identity; confirmed by codex-rs/app-server/tests/suite/v2/hooks_list.rs which keys
-//     `{canonicalize(config.toml).display()}:pre_tool_use:0:0`).
-//   - event_label: `hook_event_key_label()` — SessionStart→session_start,
-//     UserPromptSubmit→user_prompt_submit, Stop→stop, PermissionRequest→permission_request.
-//   - group_index/handler_index: positional. Our managed block writes exactly one
-//     `[[hooks.<Ev>]]` group (0) with one `[[hooks.<Ev>.hooks]]` handler (0) per event ⇒ 0:0.
-//     (Positional keying is a known upstream fragility (#23259); if a user pre-authored hooks
-//     for the same event in the same layer our index would shift → gate reappears → fail-safe.)
-//
-// HASH — codex-rs/hooks/src/engine/discovery.rs `command_hook_hash`
-//        → codex-rs/config/src/fingerprint.rs `version_for_toml`:
-//   hash = "sha256:" + hex( sha256( canonical_json( toml_value( NormalizedHookIdentity ) ) ) )
-//   NormalizedHookIdentity { event_name: <label>, #[serde(flatten)] group: MatcherGroup }
-//   MatcherGroup { matcher: Option<String>, hooks: Vec<HookHandlerConfig> }
-//   HookHandlerConfig::Command (codex-rs/config/src/hook_config.rs, `#[serde(tag="type")]`,
-//     rename "command"): { command: String, commandWindows: Option, timeout(=timeout_sec):
-//     Option<u64>, async: bool, statusMessage: Option }
-//   Load-bearing serialization facts:
-//     * `TomlValue::try_from` DROPS None fields (TOML has no null) → matcher / commandWindows /
-//       statusMessage are omitted for our hooks; `async` is a plain bool (not Option) so
-//       `async = false` IS present.
-//     * event_name uses the snake_case label (session_start …), NOT the CamelCase event.
-//     * `version_for_toml` converts the TomlValue → serde_json Value, `canonical_json` sorts
-//       every object's keys recursively, then sha256's the COMPACT JSON bytes. serde_json's
-//       compact output (no spaces, `/` unescaped, `"`/`\` JSON-escaped) matches JSON.stringify.
-//   CONFIDENCE: the HASH is fully deterministic from the open source (JSON+sha256) — HIGH.
-//   The KEY's exact key_source canonical form + the positional indices are what the VM
-//   read-back must confirm — PROVISIONAL until then.
-/** Recursively sort object keys (mirrors codex-rs fingerprint.rs `canonical_json`). */
-function canonicalizeJsonValue(value) {
-    if (Array.isArray(value))
-        return value.map(canonicalizeJsonValue);
-    if (value !== null && typeof value === "object") {
-        const src = value;
-        const out = {};
-        for (const key of Object.keys(src).sort())
-            out[key] = canonicalizeJsonValue(src[key]);
-        return out;
-    }
-    return value;
-}
-const CODEX_HOOK_EVENT_KEY_LABEL = {
-    SessionStart: "session_start",
-    UserPromptSubmit: "user_prompt_submit",
-    Stop: "stop",
-    PermissionRequest: "permission_request",
-};
-/**
- * Reproduce Codex's persisted hook trust `{ key, trusted_hash }` for one authored activity
- * hook. Pure + deterministic. See the block comment above for the full RTFM derivation and the
- * PROVISIONAL-until-VM-read-back caveat.
- */
-export function computeCodexHookTrust(event, input) {
-    const label = CODEX_HOOK_EVENT_KEY_LABEL[event];
-    const groupIndex = input.groupIndex ?? 0;
-    const handlerIndex = input.handlerIndex ?? 0;
-    const key = `${input.keySource}:${label}:${groupIndex}:${handlerIndex}`;
-    // Build NormalizedHookIdentity exactly as `TomlValue::try_from` would: None fields dropped.
-    const handler = {
-        type: "command",
-        command: input.command,
-        timeout: input.timeoutSec,
-        async: false,
-    };
-    if (input.statusMessage != null)
-        handler.statusMessage = input.statusMessage;
-    const identity = { event_name: label, hooks: [handler] };
-    if (input.matcher != null)
-        identity.matcher = input.matcher;
-    const serialized = JSON.stringify(canonicalizeJsonValue(identity));
-    const hex = createHash("sha256").update(serialized, "utf8").digest("hex");
-    return { key, hash: `sha256:${hex}` };
-}
-/**
- * OPR.0.4.3.33 — idempotent, non-clobbering, section-scoped writer for a single
- * `[hooks.state."<key>"] trusted_hash = "<hash>"` record. Mirrors upsertCodexProjectTrust:
- * find/create the exact table header, splice ONLY its `trusted_hash` line, leave every other
- * `[hooks.state]` / `[projects]` entry and the managed hook block byte-identical. Same key+hash
- * ⇒ no-op. Only ever called for OUR 4 authored hook keys (never a blanket/wildcard trust).
- */
-export function upsertCodexHookTrust(content, key, hash) {
-    const header = `[hooks.state.${JSON.stringify(key)}]`;
-    const trustLine = `trusted_hash = ${JSON.stringify(hash)}`;
-    const lines = content.length > 0 ? content.split("\n") : [];
-    const headerIndex = lines.findIndex((line) => line.trim() === header);
-    if (headerIndex === -1) {
-        const trimmed = content.trimEnd();
-        const prefix = trimmed.length > 0 ? `${trimmed}\n\n` : "";
-        return `${prefix}${header}\n${trustLine}\n`;
-    }
-    let nextSectionIndex = lines.length;
-    for (let i = headerIndex + 1; i < lines.length; i++) {
-        if (lines[i].trim().startsWith("[")) {
-            nextSectionIndex = i;
-            break;
-        }
-    }
-    const hashIndex = lines.findIndex((line, index) => index > headerIndex && index < nextSectionIndex && line.trim().startsWith("trusted_hash"));
-    if (hashIndex >= 0) {
-        lines[hashIndex] = trustLine;
-    }
-    else {
-        lines.splice(headerIndex + 1, 0, trustLine);
-    }
-    return `${lines.join("\n").replace(/\n*$/, "\n")}`;
-}
-function parseCanonicalSessionName(sessionName) {
-    // OPR.0.4.6.MH1 FR-8: the member/rig split rides the shared parse
-    // contract. A multi-@ name now parses with a greedy rig ("rig@x"),
-    // which isSafeQueueSegment rejects ("@" is unsafe) — the same null this
-    // site returned via its old single-@ check.
-    const trimmed = sessionName.trim();
-    const parsed = parseSessionName(trimmed);
-    if (parsed.kind !== "canonical")
-        return null;
-    const rig = parsed.rig;
-    const separatorIndex = parsed.member.indexOf("-");
-    if (separatorIndex <= 0 || separatorIndex === parsed.member.length - 1)
-        return null;
-    const pod = parsed.member.slice(0, separatorIndex);
-    const member = parsed.member.slice(separatorIndex + 1);
-    if (!isSafeQueueSegment(pod) || !isSafeQueueSegment(member) || !isSafeQueueSegment(rig))
-        return null;
-    return { pod, member, rig };
-}
-function isSafeQueueSegment(segment) {
-    return /^[A-Za-z0-9][A-Za-z0-9._-]*$/.test(segment);
-}
-export function isCodex013xOrLater(version) {
-    const match = /^(\d+)\.(\d+)/.exec(version);
-    if (!match)
-        return false;
-    const major = parseInt(match[1], 10);
-    const minor = parseInt(match[2], 10);
-    if (major > 0)
-        return true;
-    return minor >= 130;
-}
-// OPR.0.4.1.10 B2 — true for a real TOML `[features]` table header in ANY valid spelling.
-// Normalize-and-compare (not incremental regex): a table header is `[ <key> ]` optionally
-// followed by a comment. Per the TOML v1.0.0 spec (toml.io/en/v1.0.0, Keys/Table): whitespace
-// around the bracketed key is ignored (`[ features ]` == `[features]`), and the key may be bare
-// (`features`) or quoted as a basic/literal string (`"features"` / `'features'`) — all denote the
-// same `features` table. A leading-`#` line is a comment, never a section. The `[^[\]]*` body
-// excludes the array-of-tables `[[...]]` form. Used by BOTH feature upserts (DRY) so no header
-// spelling is missed — a missed header appends a duplicate table that Codex 0.139 --strict-config
-// rejects (config-could-not-be-loaded).
-function isCodexFeaturesHeader(line) {
-    const trimmed = line.trim();
-    if (trimmed.startsWith("#"))
-        return false;
-    const match = /^\[([^[\]]*)\]\s*(#.*)?$/.exec(trimmed);
-    if (!match)
-        return false;
-    let key = match[1].trim();
-    if (key.length >= 2 &&
-        ((key.startsWith('"') && key.endsWith('"')) || (key.startsWith("'") && key.endsWith("'")))) {
-        key = key.slice(1, -1);
-    }
-    return key === "features";
-}
-function upsertCodexHooksFeature(content) {
-    const lines = content.length > 0 ? content.replace(/\n*$/, "").split("\n") : [];
-    const featuresIndex = lines.findIndex(isCodexFeaturesHeader);
-    if (featuresIndex === -1) {
-        const prefix = lines.length > 0 ? `${lines.join("\n")}\n\n` : "";
-        return `${prefix}[features]\ncodex_hooks = true\n`;
-    }
-    let nextSectionIndex = lines.length;
-    for (let i = featuresIndex + 1; i < lines.length; i++) {
-        if (lines[i].trim().startsWith("[")) {
-            nextSectionIndex = i;
-            break;
-        }
-    }
-    const flagIndex = lines.findIndex((line, index) => index > featuresIndex &&
-        index < nextSectionIndex &&
-        line.trim().startsWith("codex_hooks"));
-    if (flagIndex >= 0) {
-        lines[flagIndex] = "codex_hooks = true";
-    }
-    else {
-        lines.splice(featuresIndex + 1, 0, "codex_hooks = true");
-    }
-    return `${lines.join("\n")}\n`;
-}
-// OPR.0.4.1.10 FR-A — config-layer activity-hook projection.
-const OPENRIG_ACTIVITY_HOOKS_BEGIN = "# BEGIN OPENRIG MANAGED ACTIVITY HOOKS";
-const OPENRIG_ACTIVITY_HOOKS_END = "# END OPENRIG MANAGED ACTIVITY HOOKS";
-const OPENRIG_ACTIVITY_HOOK_EVENTS = ["SessionStart", "UserPromptSubmit", "Stop", "PermissionRequest"];
-/**
- * Idempotently write the OpenRig activity hooks into a Codex config.toml: pin
- * `[features].hooks = true` (canonical key) and a sentinel-wrapped managed block of
- * inline `[[hooks.<Event>]]` stanzas (one representation per layer — never a sibling
- * hooks.json). Re-running with the same relay path is a no-op; a changed daemon path
- * replaces the block. `command` is a TOML literal string so the absolute relay path
- * needs no escaping; the inner double-quotes quote the path arg for the shell Codex
- * runs the hook under. No matcher (verified on 0.139: no-matcher fires for every
- * turn-scope event).
- */
-function upsertCodexActivityHooks(content, relayPath) {
-    const command = `'node "${relayPath}"'`;
-    const stanzas = OPENRIG_ACTIVITY_HOOK_EVENTS
-        .map((ev) => `[[hooks.${ev}]]\n[[hooks.${ev}.hooks]]\ntype = "command"\ncommand = ${command}\ntimeout = 5`)
-        .join("\n\n");
-    const block = `${OPENRIG_ACTIVITY_HOOKS_BEGIN}\n${stanzas}\n${OPENRIG_ACTIVITY_HOOKS_END}\n`;
-    let next = upsertCodexFeaturesHooksEnabled(content);
-    const pattern = new RegExp(`${escapeRegExp(OPENRIG_ACTIVITY_HOOKS_BEGIN)}[\\s\\S]*?${escapeRegExp(OPENRIG_ACTIVITY_HOOKS_END)}\\n?`, "m");
-    if (pattern.test(next)) {
-        return next.replace(pattern, block);
-    }
-    const prefix = next.replace(/\n*$/, "");
-    return prefix.length > 0 ? `${prefix}\n\n${block}` : block;
-}
-/**
- * OPR.0.4.1.10 B3 — remove the OpenRig-managed activity-hooks sentinel block (durable disable).
- * Strips ONLY the BEGIN..END block (plus the leading blank-line separator it was appended with);
- * leaves all other content — user-owned hooks, [features], project trust — untouched. Returns the
- * input unchanged when the block is absent.
- */
-function stripCodexActivityHooks(content) {
-    const pattern = new RegExp(`\\n*${escapeRegExp(OPENRIG_ACTIVITY_HOOKS_BEGIN)}[\\s\\S]*?${escapeRegExp(OPENRIG_ACTIVITY_HOOKS_END)}[ \\t]*\\n?`, "m");
-    if (!pattern.test(content))
-        return content;
-    return content.replace(pattern, "\n").replace(/\n{3,}/g, "\n\n").replace(/^\n+/, "");
-}
-/** Ensure `[features].hooks = true` (canonical key; not the deprecated codex_hooks alias). */
-function upsertCodexFeaturesHooksEnabled(content) {
-    const lines = content.length > 0 ? content.replace(/\n*$/, "").split("\n") : [];
-    const featuresIndex = lines.findIndex(isCodexFeaturesHeader);
-    if (featuresIndex === -1) {
-        const prefix = lines.length > 0 ? `${lines.join("\n")}\n\n` : "";
-        return `${prefix}[features]\nhooks = true\n`;
-    }
-    let nextSectionIndex = lines.length;
-    for (let i = featuresIndex + 1; i < lines.length; i++) {
-        if (lines[i].trim().startsWith("[")) {
-            nextSectionIndex = i;
-            break;
-        }
-    }
-    const flagIndex = lines.findIndex((line, index) => index > featuresIndex && index < nextSectionIndex && /^\s*hooks\s*=/.test(line));
-    if (flagIndex >= 0) {
-        lines[flagIndex] = "hooks = true";
-    }
-    else {
-        lines.splice(featuresIndex + 1, 0, "hooks = true");
-    }
-    return `${lines.join("\n")}\n`;
-}
-/**
- * For each line, whether it BEGINS at document level — outside every string AND
- * outside every array or inline table. At document level, TOML grammar allows
- * nothing but a table header to start with `[`, so that one bit is the whole
- * header test; anywhere else a `[` is value syntax.
- *
- * Both halves were learned the hard way, each from a silent wrong answer:
- *  - strings: `\"""` inside a multiline basic string read as the string's end,
- *    promoting the next line to a header (review50-r2, 2026-09-01).
- *  - nesting: a continuation row of a multi-line array (`  [1, 2],`) read as a
- *    header, so a valid fragment was split apart and refused (review50-r2,
- *    2026-09-01). Depth is what separates the two, not the line's own text.
- */
-function lineStartsAtDocumentLevel(content) {
-    const out = [true];
-    let multiline = null;
-    let depth = 0;
-    let i = 0;
-    while (i < content.length) {
-        const ch = content[i];
-        if (multiline) {
-            // A multiline BASIC string honours backslash escapes, so `\"""` is an
-            // escaped quote followed by two more — NOT the closing delimiter. A
-            // multiline LITERAL string ('''), by contrast, has no escapes at all.
-            // Missing this read `\"""` as the string's end and promoted the next
-            // line to a table header (review50-r2, 2026-09-01).
-            if (multiline === '"""' && ch === "\\") {
-                // Count an escaped newline so the line index stays aligned.
-                if (content[i + 1] === "\n")
-                    out.push(false);
-                i += 2;
-                continue;
-            }
-            if (content.startsWith(multiline, i)) {
-                multiline = null;
-                i += 3;
-                continue;
-            }
-            if (ch === "\n")
-                out.push(false);
-            i += 1;
-            continue;
-        }
-        if (content.startsWith('"""', i)) {
-            multiline = '"""';
-            i += 3;
-            continue;
-        }
-        if (content.startsWith("'''", i)) {
-            multiline = "'''";
-            i += 3;
-            continue;
-        }
-        if (ch === "#") {
-            while (i < content.length && content[i] !== "\n")
-                i += 1;
-            continue;
-        }
-        if (ch === '"' || ch === "'") {
-            const quote = ch;
-            i += 1;
-            // Single-line strings cannot span a newline; stopping at one keeps the
-            // line index honest on malformed input instead of swallowing the rest.
-            while (i < content.length && content[i] !== quote && content[i] !== "\n") {
-                if (quote === '"' && content[i] === "\\")
-                    i += 1;
-                i += 1;
-            }
-            if (content[i] === quote)
-                i += 1;
-            continue;
-        }
-        // A header's own brackets open and close on its line, so depth is back to 0
-        // by the newline; a multi-line array leaves it raised for its whole body.
-        if (ch === "[" || ch === "{") {
-            depth += 1;
-            i += 1;
-            continue;
-        }
-        if (ch === "]" || ch === "}") {
-            depth = Math.max(0, depth - 1);
-            i += 1;
-            continue;
-        }
-        if (ch === "\n") {
-            out.push(depth === 0);
-            i += 1;
-            continue;
-        }
-        i += 1;
-    }
-    return out;
-}
-/** A fragment split at its table headers: a leading preamble, then one entry per table. */
-function splitAtTableHeaders(fragment) {
-    const structural = lineStartsAtDocumentLevel(fragment);
-    const blocks = [{ header: null, lines: [] }];
-    fragment.split("\n").forEach((line, index) => {
-        const trimmed = line.trim();
-        if (structural[index] === true && trimmed.startsWith("[")) {
-            blocks.push({ header: trimmed, lines: [line] });
-            return;
-        }
-        blocks[blocks.length - 1].lines.push(line);
-    });
-    return blocks.map((b) => ({ header: b.header, text: b.lines.join("\n") }));
-}
-function parsesAsToml(candidate) {
-    try {
-        parseToml(candidate);
-        return true;
-    }
-    catch {
-        return false;
-    }
-}
-/**
- * Refuse a fragment that declares keys before its first table header.
- *
- * TOML HAS NO ROOT-REOPEN SYNTAX. The managed block is appended at the end of
- * the user's document, so once their file has opened any table there is no way
- * for appended text to bind a key at document root — the key silently joins
- * whatever table the user was last inside. This is not a limitation we can
- * engineer around inside this seam: prepending the block inverts the same bug
- * onto the managed content, and re-serializing the whole document would destroy
- * the user's comments and formatting. So the honest contract is to refuse.
- *
- * REFUSAL IS DETERMINISTIC — it never consults the user's file. A fragment
- * author cannot see user state, so a rule that depended on it would pass in
- * testing and fail in the field for reasons the author could not reproduce.
- *
- * Detected from the fragment's PREAMBLE (everything ahead of its first
- * document-level table header) rather than from the parsed object's value
- * shapes. The ruling proposed the latter; the preamble is the same intent with
- * a tighter edge, because a parsed root key holding an inline table (`x = [{a=1}]`)
- * is indistinguishable from an array-of-tables after parsing, and would slip
- * through — while it binds into the user's table exactly like any other root key.
- */
-function assertFragmentOpensWithTable(fragment, sourcePath, id) {
-    const preamble = splitAtTableHeaders(fragment)[0];
-    const declaresSomething = (preamble?.text ?? "")
-        .split("\n")
-        .map((line) => line.trim())
-        .some((line) => line.length > 0 && !line.startsWith("#"));
-    if (!declaresSomething)
-        return;
-    throw new Error(`Codex config fragment '${id}' declares root-level keys before its first table header ` +
-        `(${sourcePath}); appended TOML cannot bind at document root — open a table first. ` +
-        `Nothing was projected and the existing config was left unchanged.`);
-}
-/**
- * A managed fragment must be a valid TOML document on its own, checked BEFORE
- * any collision filtering. Without this, an authoring error in the fragment is
- * indistinguishable from a user collision and gets silently dropped — the
- * write then succeeds precisely because the bad input was deleted, which is the
- * opposite of what the render guard is for.
- */
-function assertFragmentParsesStandalone(fragment, sourcePath, id) {
-    try {
-        parseToml(fragment);
-    }
-    catch (err) {
-        throw new Error(`Codex config fragment '${id}' is not valid TOML on its own (${sourcePath}); ` +
-            `nothing was projected and the existing config was left unchanged. ${err.message}`);
-    }
-}
-/**
- * Drop the fragment tables that would collide with the user's own.
- *
- * THE COLLISION DECISION IS THE PARSER'S, NOT OURS. For each table the fragment
- * declares, we ask smol-toml whether the user's document still parses with that
- * table appended. A duplicate declaration is exactly what TOML rejects, so the
- * question the parser answers IS the question we need, on the arbitrary input —
- * the user's file — where a lexical guess is least defensible.
- *
- * The earlier version scanned the USER's document for header lines and compared
- * paths. That scanner mishandled a backslash-escaped delimiter inside a
- * multiline basic string, so `\"""` read as the string's end, the next line read
- * as a declared table, and a genuinely non-conflicting managed table was dropped
- * while projection reported success (review50-r2, 2026-09-01, reproduced). A
- * lexer over user input can be wrong in that silent direction; the parser cannot.
- *
- * The user's values are never merged, rewritten or overwritten — a colliding
- * managed table simply stands down.
- *
- * CALLERS MUST VALIDATE THE FRAGMENT STANDALONE FIRST. "Appending this block
- * makes the document unparseable" has two causes — the user owns a conflicting
- * path, or the block is malformed on its own — and this predicate cannot tell
- * them apart. Left unguarded it answered both with "collides" and DELETED an
- * invalid authored fragment, turning a resource error into a clean-looking empty
- * managed block while the receipt said projected (review50-r2, 2026-09-01,
- * reproduced). `assertFragmentParsesStandalone` eliminates the second cause
- * before we get here, so a failure that survives to this point is a real
- * collision.
- *
- * Keys ahead of the fragment's first header never reach here: OPR.0.5.8.15
- * refuses that shape upstream in `assertFragmentOpensWithTable`, because an
- * appended root key cannot bind at document root and would silently join the
- * user's last table. Every block this function sees is therefore a table.
- */
-function dropCollidingFragmentTables(fragment, userOwned) {
-    const userParses = parsesAsToml(userOwned);
-    const kept = [];
-    const dropped = [];
-    for (const block of splitAtTableHeaders(fragment)) {
-        const collides = block.header !== null &&
-            userParses &&
-            !parsesAsToml(`${userOwned}\n${block.text}`);
-        if (collides)
-            dropped.push(block.header);
-        else
-            kept.push(block.text);
-    }
-    return {
-        kept: kept.join("\n").replace(/\n{3,}/g, "\n\n").replace(/^\n+/, "").replace(/\n*$/, ""),
-        dropped,
-    };
-}
-function upsertManagedCodexConfigFragment(content, id, fragment) {
-    const start = `# BEGIN OPENRIG MANAGED CODEX CONFIG FRAGMENT: ${id}`;
-    const end = `# END OPENRIG MANAGED CODEX CONFIG FRAGMENT: ${id}`;
-    const pattern = new RegExp(`${escapeRegExp(start)}[\\s\\S]*?${escapeRegExp(end)}\\n?`, "m");
-    // Everything outside THIS block is what the fragment must not collide with.
-    // Our own previous block is excluded because re-projection replaces it
-    // wholesale — counting it would make the second projection drop everything
-    // the first one legitimately landed.
-    const userOwned = content.replace(pattern, "");
-    const { kept } = dropCollidingFragmentTables(fragment, userOwned);
-    const block = `${start}\n${kept}\n${end}\n`;
-    if (pattern.test(content)) {
-        return content.replace(pattern, block);
-    }
-    const prefix = content.replace(/\n*$/, "");
-    return prefix.length > 0 ? `${prefix}\n\n${block}` : block;
-}
-/**
- * Refuse to hand Codex a config it cannot load. Throwing here (rather than
- * writing and hoping) is what keeps a malformed render off disk entirely:
- * `project()` records the entry as failed and the existing file is untouched.
- */
-function assertRendersAsLoadableToml(rendered, configPath, id) {
-    try {
-        parseToml(rendered);
-    }
-    catch (err) {
-        throw new Error(`Codex config projection '${id}' would write a config Codex cannot parse; ` +
-            `${configPath} left unchanged. ${err.message}`);
-    }
-}
-function escapeRegExp(value) {
-    return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-}
-// Module-private (P1 pin — NEVER exported). The REAL Codex profile-LOAD probe,
-// extracted verbatim from launchHarness: dynamic imports keep it lazy for
-// production, execFn runs the real `codex -p <profile> mcp list` via execSync
-// (utf-8, piped stdio, 10s timeout). Injected as the adapter's default
-// verifyProfilePreflight; tests substitute a controlled stub.
-async function defaultProfilePreflight(profile) {
-    const { verifyCodexProfileLoads } = await import("../domain/codex-profile-preflight.js");
-    const { execSync } = await import("node:child_process");
-    const execFn = async (cmd) => runSyncSite("codex.runtime.profile_preflight", () => execSync(cmd, { encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"], timeout: 10_000 }));
-    return verifyCodexProfileLoads(profile, execFn);
-}
-// Exported for unit test (B12-T): the REAL async sampling path — the anti-vacuity test drives
-// this default directly (every other suite injects sync stubs) and asserts the non-blocking
-// property that the pre-B12 sync implementation violated.
-export async function defaultListProcesses() {
-    return listNativeProcesses();
-}
-function findCodexDescendantPids(processes, parentPid) {
-    const childrenByParent = new Map();
-    for (const proc of processes) {
-        const siblings = childrenByParent.get(proc.ppid) ?? [];
-        siblings.push({ pid: proc.pid, command: proc.command });
-        childrenByParent.set(proc.ppid, siblings);
-    }
-    const matches = [];
-    const visit = (pid) => {
-        for (const child of childrenByParent.get(pid) ?? []) {
-            visit(child.pid);
-            if (commandLooksLikeCodex(child.command)) {
-                matches.push(child.pid);
-            }
-        }
-    };
-    visit(parentPid);
-    return matches;
-}
-function commandLooksLikeCodex(command) {
-    const tokens = command.trim().split(/\s+/).filter(Boolean);
-    return tokens.some((token) => {
-        const unquoted = token.replace(/^['"]|['"]$/g, "");
-        const base = nodePath.basename(unquoted);
-        return base === "codex";
-    });
-}
-function isSkippableCodexUpdatePrompt(paneContent) {
-    return paneContent.includes("Update available!")
-        && /^\s*[›>]?\s*3\. Skip until next version\s*$/m.test(paneContent);
-}
-//# sourceMappingURL=codex-runtime-adapter.js.map