@openrig/cli 0.5.0 → 0.5.2

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

@@ -0,0 +1,1126 @@
+import nodePath from "node:path";
+import fs from "node:fs";
+import { createHash } from "node:crypto";
+import os from "node:os";
+import { execFile } from "node:child_process";
+import { promisify } from "node:util";
+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, runAsyncSite } from "../domain/sync-site-wrap.js";
+const execFileAsync = promisify(execFile);
+/**
+ * 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;
+    // 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.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 granted at launch by the hook_trust_gate
+     * auto-clear (dismissCodexInteractiveGates → "2" Trust all and continue, verified on
+     * Codex 0.139). 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)
+        // — not just the launch keystroke gate. Layer-2 floor (dismissCodexInteractiveGates)
+        // stays as the fail-safe if a Codex-version drift changes the identity/hash. 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 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.sendText(binding.tmuxSession, cmd);
+            if (!textResult.ok) {
+                return { ok: false, error: `Failed to send launch command: ${textResult.message}` };
+            }
+            const enterResult = await this.tmux.sendKeys(binding.tmuxSession, ["Enter"]);
+            if (!enterResult.ok) {
+                return { ok: false, error: `Failed to send Enter: ${enterResult.message}` };
+            }
+            await this.dismissCodexInteractiveGates(binding.tmuxSession);
+            const threadId = await this.captureFreshThreadId(binding);
+            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.sendText(binding.tmuxSession, cmd);
+        if (!textResult.ok) {
+            return { ok: false, error: `Failed to send launch command: ${textResult.message}` };
+        }
+        const enterResult = await this.tmux.sendKeys(binding.tmuxSession, ["Enter"]);
+        if (!enterResult.ok) {
+            return { ok: false, error: `Failed to send Enter: ${enterResult.message}` };
+        }
+        await this.dismissSkippableCodexUpdatePrompt(binding.tmuxSession);
+        if (opts.resumeToken) {
+            const verification = await this.verifyResumeLaunch(binding.tmuxSession, { resumeToken: opts.resumeToken });
+            if (!verification.ok)
+                return verification;
+            return { ok: true, resumeToken: opts.resumeToken, resumeType: "codex_id", appliedLaunch };
+        }
+        const threadId = await this.captureFreshThreadId(binding);
+        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 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.tmux.capturePaneContent(binding.tmuxSession, 40)) ?? "";
+        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, attempts = 6) {
+        for (let attempt = 0; attempt < attempts; attempt++) {
+            const paneCommand = await this.tmux.getPaneCommand(tmuxSession);
+            const paneContent = (await this.tmux.capturePaneContent(tmuxSession, 40)) ?? "";
+            const probe = assessNativeResumeProbe({
+                runtime: "codex",
+                paneCommand,
+                paneContent,
+            });
+            if (probe.code === "update_gate") {
+                if (!isSkippableCodexUpdatePrompt(paneContent))
+                    return false;
+                const textResult = await this.tmux.sendText(tmuxSession, "3");
+                if (!textResult.ok)
+                    return false;
+                const enterResult = await this.tmux.sendKeys(tmuxSession, ["Enter"]);
+                if (!enterResult.ok)
+                    return false;
+                await this.sleep(500);
+                return true;
+            }
+            if (probe.status === "resumed" || probe.code === "trust_gate") {
+                return false;
+            }
+            if (attempt < attempts - 1) {
+                await this.sleep(200);
+            }
+        }
+        return false;
+    }
+    async dismissCodexInteractiveGates(tmuxSession, attempts = 8) {
+        for (let attempt = 0; attempt < attempts; attempt++) {
+            const paneCommand = await this.tmux.getPaneCommand(tmuxSession);
+            const paneContent = (await this.tmux.capturePaneContent(tmuxSession, 40)) ?? "";
+            const probe = assessNativeResumeProbe({
+                runtime: "codex",
+                paneCommand,
+                paneContent,
+            });
+            if (probe.code === "update_gate") {
+                if (!isSkippableCodexUpdatePrompt(paneContent))
+                    return;
+                const textResult = await this.tmux.sendText(tmuxSession, "3");
+                if (!textResult.ok)
+                    return;
+                const enterResult = await this.tmux.sendKeys(tmuxSession, ["Enter"]);
+                if (!enterResult.ok)
+                    return;
+                await this.sleep(500);
+                continue;
+            }
+            if (probe.code === "hook_trust_gate") {
+                const textResult = await this.tmux.sendText(tmuxSession, "2");
+                if (!textResult.ok)
+                    return;
+                const enterResult = await this.tmux.sendKeys(tmuxSession, ["Enter"]);
+                if (!enterResult.ok)
+                    return;
+                await this.sleep(500);
+                continue;
+            }
+            if (probe.status === "resumed" || probe.code === "trust_gate") {
+                return;
+            }
+            if (attempt < attempts - 1) {
+                await this.sleep(200);
+            }
+        }
+    }
+    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);
+        this.fs.writeFile(configPath, upsertManagedCodexConfigFragment(existing, entry.effectiveId, fragment));
+        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) {
+        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.dismissCodexInteractiveGates(binding.tmuxSession, 1);
+            }
+            await this.sleep(250);
+        }
+        return undefined;
+    }
+    async verifyResumeLaunch(tmuxSession, 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.tmux.capturePaneContent(tmuxSession, 40)) ?? "";
+            lastPaneContent = paneContent;
+            const 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") {
+                return {
+                    ok: false,
+                    error: "Codex resume failed: pane returned to shell instead of entering Codex",
+                    recovery: "retry_fresh",
+                };
+            }
+            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, 1);
+                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
+// Layer-2 keystroke floor (dismissCodexInteractiveGates) clears it — never a false-trusted run.
+//
+// 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`;
+}
+function upsertManagedCodexConfigFragment(content, id, fragment) {
+    const start = `# BEGIN OPENRIG MANAGED CODEX CONFIG FRAGMENT: ${id}`;
+    const end = `# END OPENRIG MANAGED CODEX CONFIG FRAGMENT: ${id}`;
+    const block = `${start}\n${fragment.replace(/\n*$/, "")}\n${end}\n`;
+    const pattern = new RegExp(`${escapeRegExp(start)}[\\s\\S]*?${escapeRegExp(end)}\\n?`, "m");
+    if (pattern.test(content)) {
+        return content.replace(pattern, block);
+    }
+    const prefix = content.replace(/\n*$/, "");
+    return prefix.length > 0 ? `${prefix}\n\n${block}` : block;
+}
+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() {
+    try {
+        const output = await runAsyncSite("codex.runtime.list_processes", async () => {
+            const { stdout } = await execFileAsync("ps", ["-Ao", "pid,ppid,command"], { encoding: "utf-8", maxBuffer: 8 * 1024 * 1024 });
+            return stdout;
+        });
+        return output
+            .split("\n")
+            .slice(1)
+            .map((line) => line.trim())
+            .filter(Boolean)
+            .map((line) => {
+            const match = line.match(/^(\d+)\s+(\d+)\s+(.*)$/);
+            if (!match)
+                return null;
+            return {
+                pid: Number(match[1]),
+                ppid: Number(match[2]),
+                command: match[3] ?? "",
+            };
+        })
+            .filter((row) => row !== null);
+    }
+    catch {
+        return [];
+    }
+}
+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!")
+        && paneContent.includes("Skip until next version");
+}
+//# sourceMappingURL=codex-runtime-adapter.js.map