oh-my-super-agent 0.1.0

package/dist/src/workers/delivery.js

@@ -0,0 +1,876 @@
+import { existsSync, lstatSync, mkdirSync, realpathSync, symlinkSync } from "node:fs";
+import { isAbsolute, join } from "node:path";
+import { readOmsConfig } from "../config.js";
+import { captureStoredDispatchIntent, deriveWorktreeId, dispatchWorktreeStartCommit, } from "../dispatch/authority.js";
+import { assertStoredAdvisorEvidenceProvenance } from "../dispatch/advice-source.js";
+import { loadTrackedRolePolicyGate } from "../domain/role-policy.js";
+import { assertOpaqueId } from "../domain/records.js";
+import { deriveOperationNonce } from "../outbox/store.js";
+import { SUPPORTED_PROVIDER_HOOK_VERSIONS } from "../hooks/provider.js";
+import { discloseLiveContact, readLiveDeliveryAuthorization } from "../live/contact-journal.js";
+import { prepareClaudeInteractiveLaunch } from "../providers/claude-interactive.js";
+import { prepareCodexGoalLaunch } from "../providers/native-dispatch.js";
+import { probeClaudeCodeCompatibility, resolveConfiguredRole } from "../providers/preflight.js";
+import { runProcess } from "../providers/process.js";
+import { createStableId } from "../runtime/stable-id.js";
+import { errorMessage, lstatIfExists, readJsonFileNoFollow, validateExistingDirectory, writeJsonAtomicNoReplace, } from "../utils/fs.js";
+import { parseTicketWorktreeRecord } from "../worktrees/manager.js";
+import { createWorkerPaneAdapter } from "./panes.js";
+import { createRuntimeWorkerAuthorities } from "./runtime.js";
+const DELIVERY_CONSUMER = "oms-worker-delivery";
+const HEARTBEAT_MS = 15 * 60 * 1_000;
+export function createWorkerDeliveryService(options) {
+    const packageRoot = validateExistingDirectory(options.packageRoot, "package root");
+    const configRoot = validateExistingDirectory(options.configRoot ?? packageRoot, "configuration root");
+    const workspaceRoot = validateExistingDirectory(options.workspaceRoot, "worker workspace root");
+    const stateRoot = validateExistingDirectory(options.stateRoot, "worker state root");
+    const executablePath = validateExecutable(options.executablePath);
+    const env = options.env ?? process.env;
+    const runner = options.runner ?? runProcess;
+    const panes = options.panes ?? createWorkerPaneAdapter({ env, runner });
+    const clock = options.clock ?? (() => new Date().toISOString());
+    const runtime = createRuntimeWorkerAuthorities({
+        packageRoot,
+        configRoot,
+        workspaceRoot,
+        stateRoot,
+        actorId: "oms-conductor",
+        clock,
+    });
+    function launch(dispatch, sourceEventId) {
+        if (dispatch.state !== "accepted")
+            throw new Error(`worker delivery requires an accepted dispatch, got ${dispatch.state}`);
+        try {
+            assertApprovedDispatchAdvice(dispatch, runtime.tickets.evidenceStore, stateRoot);
+        }
+        catch (error) {
+            parkWorker(dispatch, sourceEventId, "wkr-adv-park");
+            return Object.freeze({
+                status: "parked",
+                dispatch_id: dispatch.record_id,
+                reason: boundedReason(errorMessage(error)),
+            });
+        }
+        const worker = runtime.workers.read(dispatch.record_id);
+        if (worker.state !== "idle" || (worker.payload.health !== "healthy" && worker.payload.health !== "parked")) {
+            throw new Error("worker delivery requires one idle healthy or parked reservation");
+        }
+        if (dispatch.payload.capabilities.length !== 2
+            || dispatch.payload.capabilities[0] !== "repository-read"
+            || dispatch.payload.capabilities[1] !== "ticket-worktree-write")
+            throw new Error("worker delivery received expanded capabilities");
+        let providerLaunch;
+        let liveDeliveryRepository = null;
+        try {
+            const config = readOmsConfig(configRoot);
+            const currentPolicy = loadTrackedRolePolicyGate(configRoot);
+            const configured = resolveConfiguredRole(config, dispatch.payload.role_id);
+            const ticket = runtime.tickets.lifecycle.read(dispatch.payload.ticket_id);
+            if (ticket.payload.source === "github") {
+                const content = runtime.tickets.materializer.readContent({
+                    ticket_id: ticket.record_id,
+                    sha256: ticket.payload.content_sha256,
+                    file_name: ticket.payload.content_file,
+                });
+                if (content.repository === null)
+                    throw new Error("GitHub worker ticket lacks its repository");
+                liveDeliveryRepository = content.repository.toLowerCase();
+            }
+            const worktree = parseTicketWorktreeRecord(readJsonFileNoFollow(join(stateRoot, "worktree-records", `${dispatch.payload.ticket_id}.json`), 64 * 1024), "worker delivery worktree record");
+            if (currentPolicy.digest !== dispatch.payload.policy_digest
+                || configured.modelId !== dispatch.payload.model_id
+                || configured.role.transport !== dispatch.payload.provider_mode
+                || configured.role.sandbox !== "ticket-worktree-write"
+                || runtime.tickets.lifecycle.authorityStatus(dispatch.payload.ticket_id) !== "current"
+                || ticket.state !== "leased"
+                || ticket.version !== dispatch.payload.ticket_version
+                || ticket.attempt !== dispatch.payload.attempt
+                || ticket.actor !== dispatch.payload.worker_id
+                || ticket.lease_token === null
+                || ticket.lease_token !== dispatch.payload.lease_token
+                || ticket.payload.session_id !== dispatch.payload.session_id
+                || ticket.payload.lease_expires_at === null
+                || Date.parse(ticket.payload.lease_expires_at) <= Date.parse(clock())
+                || worktree.ticket_id !== dispatch.payload.ticket_id
+                || worktree.repository_root !== workspaceRoot
+                || worktree.worktree_root !== dispatch.payload.worktree_path
+                || worktree.branch !== dispatch.payload.worktree_branch
+                || worktree.base_commit !== dispatch.payload.worktree_base_commit
+                || deriveWorktreeId(worktree) !== dispatch.payload.worktree_id) {
+                throw new Error("worker delivery authority changed after dispatch acceptance");
+            }
+            restoreLeaseExpiredCheckout({
+                dispatch,
+                evidenceStore: runtime.tickets.evidenceStore,
+                hasBoundSession: runtime.sessions.readIfExists(dispatch.payload.session_id) !== undefined,
+                hasBoundPane: panes.observe(dispatch.record_id) !== undefined,
+                env,
+                runner,
+            });
+            verifyWorkerCheckout(dispatch, env, runner);
+            const workerBridge = {
+                command: executablePath,
+                args: [
+                    "worker",
+                    "bridge",
+                    "--dispatch-id",
+                    dispatch.record_id,
+                    "--session-id",
+                    dispatch.payload.session_id,
+                    "--state-root",
+                    stateRoot,
+                    "--workspace-root",
+                    workspaceRoot,
+                    "--config-root",
+                    configRoot,
+                ],
+            };
+            if (dispatch.payload.role_id === "oms.ticket-executor") {
+                probeClaudeCodeCompatibility({ cwd: dispatch.payload.worktree_path, env, runner });
+                const prepared = prepareClaudeInteractiveLaunch({
+                    config,
+                    roleId: "oms.ticket-executor",
+                    cwd: dispatch.payload.worktree_path,
+                    sessionName: dispatch.payload.session_id,
+                    env,
+                    runner,
+                    workerBridge,
+                    workerInstructionsPath: join(configRoot, ".agents", "agents", "executor.md"),
+                    dispatchId: dispatch.record_id,
+                });
+                providerLaunch = {
+                    dispatchId: dispatch.record_id,
+                    command: prepared.command,
+                    args: prepared.args,
+                    cwd: prepared.cwd,
+                    env: prepared.env,
+                    nativeAction: "claude",
+                };
+            }
+            else {
+                const prepared = prepareCodexGoalLaunch({
+                    config,
+                    roleId: "oms.goal-long-executor",
+                    cwd: dispatch.payload.worktree_path,
+                    env,
+                    runner,
+                });
+                providerLaunch = {
+                    dispatchId: dispatch.record_id,
+                    command: prepared.command,
+                    args: [
+                        ...prepared.args,
+                        "--enable",
+                        "goals",
+                        "--enable",
+                        "hooks",
+                        "--disable",
+                        "apps",
+                        "--disable",
+                        "browser_use",
+                        "--disable",
+                        "computer_use",
+                        "--disable",
+                        "image_generation",
+                        "--disable",
+                        "plugins",
+                        "--strict-config",
+                        "--ask-for-approval",
+                        "never",
+                        "--dangerously-bypass-hook-trust",
+                        "--config",
+                        `mcp_servers={oms_worker={command=${tomlString(workerBridge.command)},args=${tomlArray(workerBridge.args)},enabled_tools=${tomlArray(["read_dispatch", "acknowledge_dispatch", "record_dispatch_result"])},default_tools_approval_mode="approve",required=true}}`,
+                        "--config",
+                        "sandbox_workspace_write.exclude_slash_tmp=true",
+                        "--config",
+                        "sandbox_workspace_write.exclude_tmpdir_env_var=true",
+                    ],
+                    cwd: prepared.cwd,
+                    env: {
+                        ...prepared.env,
+                        CODEX_HOME: prepareIsolatedCodexHome({
+                            stateRoot,
+                            sessionId: dispatch.payload.session_id,
+                            dispatchId: dispatch.record_id,
+                            executablePath,
+                            workspaceRoot,
+                            configRoot,
+                            env: prepared.env,
+                        }),
+                    },
+                    nativeAction: "goal",
+                };
+            }
+        }
+        catch (error) {
+            parkWorker(dispatch, sourceEventId, "wkr-pre-park");
+            return Object.freeze({
+                status: "parked",
+                dispatch_id: dispatch.record_id,
+                reason: boundedReason(errorMessage(error)),
+            });
+        }
+        if (liveDeliveryRepository !== null) {
+            const authorization = readLiveDeliveryAuthorization(stateRoot);
+            if (!authorization || authorization.repository !== liveDeliveryRepository) {
+                parkWorker(dispatch, sourceEventId, "wkr-auth-park");
+                return Object.freeze({
+                    status: "parked",
+                    dispatch_id: dispatch.record_id,
+                    reason: "worker delivery lacks matching human-started live authorization",
+                });
+            }
+            try {
+                discloseLiveContact({
+                    stateRoot,
+                    authorization,
+                    operation: "worker-session",
+                    contactSurface: providerLaunch.nativeAction === "goal" ? "codex-goal" : "claude-interactive",
+                    subjectId: dispatch.payload.session_id,
+                    request: {
+                        dispatch_id: dispatch.record_id,
+                        ticket_id: dispatch.payload.ticket_id,
+                        role_id: dispatch.payload.role_id,
+                        model_id: dispatch.payload.model_id,
+                        provider_mode: dispatch.payload.provider_mode,
+                        worktree_id: dispatch.payload.worktree_id,
+                    },
+                    disclosedAt: clock(),
+                });
+            }
+            catch (error) {
+                parkWorker(dispatch, sourceEventId, "wkr-disc-park");
+                return Object.freeze({
+                    status: "parked",
+                    dispatch_id: dispatch.record_id,
+                    reason: boundedReason(errorMessage(error)),
+                });
+            }
+        }
+        let ensured;
+        try {
+            ensured = panes.ensure(providerLaunch);
+        }
+        catch (error) {
+            parkWorker(dispatch, sourceEventId, "wkr-lch-park");
+            return Object.freeze({ status: "parked", dispatch_id: dispatch.record_id, reason: boundedReason(errorMessage(error)) });
+        }
+        try {
+            const observedAt = dispatch.payload.created_at;
+            runtime.sessions.register({
+                sessionId: dispatch.payload.session_id,
+                roleId: dispatch.payload.role_id,
+                engine: dispatch.payload.engine,
+                mode: dispatch.payload.provider_mode === "codex_goal" ? "goal" : "pane",
+                runId: null,
+                ticketId: dispatch.payload.ticket_id,
+                nativeSessionRef: dispatch.payload.session_id,
+                tmuxPaneId: ensured.observation.pane_id,
+                actorId: "oms-system",
+                sourceEventId,
+                observedAt,
+                heartbeatDeadlineAt: addMilliseconds(observedAt, HEARTBEAT_MS),
+            });
+        }
+        catch (error) {
+            if (ensured.status === "created") {
+                try {
+                    panes.stop(dispatch.record_id);
+                }
+                catch {
+                    // A later recovery pass will observe the unregistered pane.
+                }
+            }
+            parkWorker(dispatch, sourceEventId, "wkr-reg-park");
+            return Object.freeze({ status: "parked", dispatch_id: dispatch.record_id, reason: boundedReason(errorMessage(error)) });
+        }
+        try {
+            panes.activate(dispatch.record_id, providerLaunch.nativeAction);
+        }
+        catch (error) {
+            let pane;
+            try {
+                pane = panes.observe(dispatch.record_id);
+            }
+            catch {
+                pane = undefined;
+            }
+            if (pane && !pane.dead) {
+                parkWorker(dispatch, sourceEventId, "wkr-act-park");
+                return Object.freeze({
+                    status: "parked",
+                    dispatch_id: dispatch.record_id,
+                    activation_pending: true,
+                    reason: boundedReason(errorMessage(error)),
+                });
+            }
+            const session = runtime.sessions.readIfExists(dispatch.payload.session_id);
+            const at = clock();
+            if (session && session.state !== "stopped") {
+                runtime.sessions.stop({
+                    sessionId: session.record_id,
+                    expectedVersion: session.version,
+                    operationId: createStableId("wkr-act-stop", dispatch.record_id, sourceEventId),
+                    actorId: "oms-system",
+                    eventId: createStableId("wkr-act-evt", dispatch.record_id, sourceEventId),
+                    observedAt: nextTimestamp(session.payload.last_observed_at, at),
+                    reason: boundedReason(errorMessage(error)),
+                });
+            }
+            const current = runtime.workers.read(dispatch.record_id);
+            if (current.payload.health !== "stopped") {
+                runtime.workers.setHealth({
+                    dispatchId: dispatch.record_id,
+                    expectedVersion: current.version,
+                    operationId: createStableId("wkr-act-hstop", dispatch.record_id, sourceEventId),
+                    actorId: "oms-system",
+                    observedAt: nextTimestamp(current.payload.updated_at, at),
+                    health: "stopped",
+                });
+            }
+            return Object.freeze({ status: "stopped", dispatch_id: dispatch.record_id, reason: boundedReason(errorMessage(error)) });
+        }
+        let currentWorker = runtime.workers.read(dispatch.record_id);
+        if (currentWorker.payload.health === "parked") {
+            currentWorker = runtime.workers.setHealth({
+                dispatchId: dispatch.record_id,
+                expectedVersion: currentWorker.version,
+                operationId: createStableId("wkr-pre-res", dispatch.record_id, sourceEventId),
+                actorId: "oms-system",
+                observedAt: nextTimestamp(currentWorker.payload.updated_at, clock()),
+                health: "healthy",
+            }).record;
+        }
+        if (currentWorker.state === "idle") {
+            runtime.workers.setActivity({
+                dispatchId: dispatch.record_id,
+                expectedVersion: currentWorker.version,
+                operationId: createStableId("wkr-act-work", dispatch.record_id, sourceEventId),
+                actorId: "oms-system",
+                observedAt: nextTimestamp(currentWorker.payload.updated_at, clock()),
+                activity: "working",
+            });
+        }
+        return Object.freeze({
+            status: ensured.status,
+            dispatch_id: dispatch.record_id,
+            session_id: dispatch.payload.session_id,
+            pane_id: ensured.observation.pane_id,
+            provider_mode: dispatch.payload.provider_mode,
+        });
+    }
+    function observe(dispatchId) {
+        const dispatch = runtime.dispatch.read(assertOpaqueId(dispatchId, "dispatch id"));
+        const worker = runtime.workers.read(dispatch.record_id);
+        const session = runtime.sessions.readIfExists(dispatch.payload.session_id);
+        const pane = panes.observe(dispatch.record_id);
+        return Object.freeze({
+            dispatch_id: dispatch.record_id,
+            worker_activity: worker.state,
+            worker_health: worker.payload.health,
+            session_state: session?.state ?? null,
+            pane_id: pane?.pane_id ?? session?.payload.tmux_pane_id ?? null,
+            pane_live: pane !== undefined && !pane.dead,
+        });
+    }
+    const service = Object.freeze({
+        deliver(eventId) {
+            const id = assertOpaqueId(eventId, "delivery event id");
+            const lock = runtime.outbox.acquireProcessingLock(id, DELIVERY_CONSUMER);
+            try {
+                const event = runtime.events.read(id, "dispatch-delivery-requested");
+                const existing = runtime.outbox.readReceipt(id, DELIVERY_CONSUMER);
+                if (existing)
+                    return Object.freeze({ status: "replayed", outcome: existing.result });
+                const dispatch = runtime.dispatch.read(event.payload.dispatch_id);
+                if (dispatch.version < event.payload.dispatch_version
+                    || !dispatch.transition_outcomes.some((transition) => (transition.version === event.payload.dispatch_version && transition.state === "accepted"))
+                    || dispatch.payload.delivery_event_id !== event.event_id
+                    || dispatch.payload.accepted_at === null
+                    || dispatch.payload.worker_record_id !== event.payload.worker_record_id
+                    || dispatch.payload.ticket_id !== event.payload.ticket_id
+                    || dispatch.payload.attempt !== event.payload.attempt
+                    || dispatch.payload.lease_token !== event.payload.lease_token)
+                    throw new Error("delivery event changed its accepted dispatch binding");
+                const outcome = dispatch.state === "accepted"
+                    ? launch(dispatch, event.event_id)
+                    : recoverDeliveredDispatch(dispatch, event.event_id);
+                const receipt = runtime.outbox.commitReceipt({
+                    eventId: event.event_id,
+                    consumerId: DELIVERY_CONSUMER,
+                    processedAt: clock(),
+                    result: { ...outcome, operation_nonce: deriveOperationNonce(event.event_id, DELIVERY_CONSUMER) },
+                }).receipt;
+                return Object.freeze({ status: "processed", outcome: receipt.result });
+            }
+            finally {
+                lock.release();
+            }
+        },
+        park(dispatchId, reason, parkedUntil) {
+            const dispatch = runtime.dispatch.read(assertOpaqueId(dispatchId, "dispatch id"));
+            const at = clock();
+            let session = runtime.sessions.read(dispatch.payload.session_id);
+            let worker = runtime.workers.read(dispatch.record_id);
+            if (session.state !== "running" && session.state !== "stalled" && session.state !== "parked") {
+                throw new Error(`worker cannot park from session ${session.state}`);
+            }
+            if (worker.payload.health !== "healthy" && worker.payload.health !== "stalled" && worker.payload.health !== "parked") {
+                throw new Error(`worker cannot park from health ${worker.payload.health}`);
+            }
+            const parkedUntilMs = Date.parse(parkedUntil);
+            if (!Number.isFinite(parkedUntilMs) || parkedUntilMs <= Date.parse(at)) {
+                throw new Error("worker parked-until must be a future timestamp");
+            }
+            if (session.state === "parked" && session.payload.parked_until !== parkedUntil) {
+                throw new Error("worker is already parked until a different timestamp");
+            }
+            panes.park(dispatch.record_id, nativeAction(dispatch));
+            if (session.state !== "parked") {
+                session = runtime.sessions.park({
+                    sessionId: session.record_id,
+                    expectedVersion: session.version,
+                    operationId: createStableId("wkr-park", dispatch.record_id, boundedReason(reason), parkedUntil),
+                    actorId: "oms-system",
+                    eventId: createStableId("wkr-park-evt", dispatch.record_id, parkedUntil),
+                    observedAt: nextTimestamp(session.payload.last_observed_at, at),
+                    parkedUntil,
+                }).record;
+            }
+            if (worker.payload.health !== "parked") {
+                worker = runtime.workers.setHealth({
+                    dispatchId: dispatch.record_id,
+                    expectedVersion: worker.version,
+                    operationId: createStableId("wkr-hlth-park", dispatch.record_id, boundedReason(reason), parkedUntil),
+                    actorId: "oms-system",
+                    observedAt: nextTimestamp(worker.payload.updated_at, at),
+                    health: "parked",
+                }).record;
+            }
+            return observe(dispatch.record_id);
+        },
+        resume(dispatchId) {
+            const dispatch = runtime.dispatch.read(assertOpaqueId(dispatchId, "dispatch id"));
+            let session = runtime.sessions.readIfExists(dispatch.payload.session_id);
+            if (!session) {
+                const eventId = dispatch.payload.delivery_event_id;
+                if (!eventId)
+                    throw new Error("dispatch has no delivery event");
+                launch(dispatch, eventId);
+                return observe(dispatch.record_id);
+            }
+            const at = clock();
+            let worker = runtime.workers.read(dispatch.record_id);
+            if ((session.state !== "parked" && session.state !== "running") || (worker.payload.health !== "parked" && worker.payload.health !== "healthy")) {
+                throw new Error(`worker cannot resume from session ${session.state} and health ${worker.payload.health}`);
+            }
+            const pane = panes.observe(dispatch.record_id);
+            if (!pane || pane.dead)
+                throw new Error("worker cannot resume without its live bound pane");
+            const deliveryEventId = dispatch.payload.delivery_event_id;
+            const deliveryReceipt = deliveryEventId
+                ? runtime.outbox.readReceipt(deliveryEventId, DELIVERY_CONSUMER)
+                : undefined;
+            const parkedUntil = session.payload.parked_until;
+            if (session.state === "parked" && (parkedUntil === null || Date.parse(at) < Date.parse(parkedUntil))) {
+                throw new Error("worker resume is not due");
+            }
+            if (session.state === "running"
+                && session.version === 0
+                && worker.payload.health === "parked"
+                && deliveryReceipt?.result.activation_pending === true) {
+                panes.activate(dispatch.record_id, nativeAction(dispatch));
+            }
+            else if (session.state === "parked" || worker.payload.health === "parked") {
+                panes.resume(dispatch.record_id, nativeAction(dispatch));
+            }
+            if (session.state === "parked") {
+                if (parkedUntil === null)
+                    throw new Error("parked worker lost its resume timestamp");
+                session = runtime.sessions.resume({
+                    sessionId: session.record_id,
+                    expectedVersion: session.version,
+                    operationId: createStableId("wkr-resume", dispatch.record_id, parkedUntil),
+                    actorId: "oms-system",
+                    eventId: createStableId("wkr-res-evt", dispatch.record_id, parkedUntil),
+                    observedAt: nextTimestamp(session.payload.last_observed_at, at),
+                    heartbeatDeadlineAt: addMilliseconds(nextTimestamp(session.payload.last_observed_at, at), HEARTBEAT_MS),
+                }).record;
+            }
+            if (worker.payload.health === "parked") {
+                worker = runtime.workers.setHealth({
+                    dispatchId: dispatch.record_id,
+                    expectedVersion: worker.version,
+                    operationId: createStableId("wkr-hlth-res", dispatch.record_id, String(session.version)),
+                    actorId: "oms-system",
+                    observedAt: nextTimestamp(worker.payload.updated_at, at),
+                    health: "healthy",
+                }).record;
+            }
+            if (worker.state === "idle") {
+                worker = runtime.workers.setActivity({
+                    dispatchId: dispatch.record_id,
+                    expectedVersion: worker.version,
+                    operationId: createStableId("wkr-act-res", dispatch.record_id, String(session.version)),
+                    actorId: "oms-system",
+                    observedAt: nextTimestamp(worker.payload.updated_at, at),
+                    activity: "working",
+                }).record;
+            }
+            return observe(dispatch.record_id);
+        },
+        stop(dispatchId, reason) {
+            const dispatch = runtime.dispatch.read(assertOpaqueId(dispatchId, "dispatch id"));
+            const session = runtime.sessions.readIfExists(dispatch.payload.session_id);
+            let worker = runtime.workers.read(dispatch.record_id);
+            if (panes.observe(dispatch.record_id))
+                panes.stop(dispatch.record_id);
+            const at = clock();
+            if (session && session.state !== "stopped") {
+                runtime.sessions.stop({
+                    sessionId: session.record_id,
+                    expectedVersion: session.version,
+                    operationId: createStableId("wkr-stop", dispatch.record_id, boundedReason(reason)),
+                    actorId: "oms-system",
+                    eventId: createStableId("wkr-stop-evt", dispatch.record_id, at),
+                    observedAt: at,
+                    reason: boundedReason(reason),
+                });
+            }
+            if (worker.payload.health !== "stopped") {
+                worker = runtime.workers.setHealth({
+                    dispatchId: dispatch.record_id,
+                    expectedVersion: worker.version,
+                    operationId: createStableId("wkr-hlth-stop", dispatch.record_id, boundedReason(reason)),
+                    actorId: "oms-system",
+                    observedAt: nextTimestamp(worker.payload.updated_at, at),
+                    health: "stopped",
+                }).record;
+            }
+            if (worker.state !== "done" && worker.state !== "blocked") {
+                runtime.workers.setActivity({
+                    dispatchId: dispatch.record_id,
+                    expectedVersion: worker.version,
+                    operationId: createStableId("wkr-stop-block", dispatch.record_id, boundedReason(reason)),
+                    actorId: "oms-system",
+                    observedAt: nextTimestamp(worker.payload.updated_at, at),
+                    activity: "blocked",
+                });
+            }
+            return observe(dispatch.record_id);
+        },
+        observe,
+    });
+    function parkWorker(dispatch, sourceEventId, prefix) {
+        const current = runtime.workers.read(dispatch.record_id);
+        if (current.payload.health === "parked")
+            return;
+        runtime.workers.setHealth({
+            dispatchId: dispatch.record_id,
+            expectedVersion: current.version,
+            operationId: createStableId(prefix, dispatch.record_id, sourceEventId),
+            actorId: "oms-system",
+            observedAt: nextTimestamp(current.payload.updated_at, clock()),
+            health: "parked",
+        });
+    }
+    function recoverDeliveredDispatch(dispatch, sourceEventId) {
+        if (dispatch.state !== "acknowledged" && dispatch.state !== "result-received" && dispatch.state !== "resolved") {
+            throw new Error(`delivery cannot recover dispatch state ${dispatch.state}`);
+        }
+        const session = runtime.sessions.readIfExists(dispatch.payload.session_id);
+        const worker = runtime.workers.read(dispatch.record_id);
+        if (!session
+            || session.payload.source_event_id !== sourceEventId
+            || session.payload.ticket_id !== dispatch.payload.ticket_id
+            || session.payload.role_id !== dispatch.payload.role_id
+            || session.payload.engine !== dispatch.payload.engine
+            || session.payload.native_session_ref !== dispatch.payload.session_id
+            || session.payload.tmux_pane_id === null
+            || worker.record_id !== dispatch.payload.worker_record_id
+            || worker.payload.dispatch_id !== dispatch.record_id
+            || worker.payload.ticket_id !== dispatch.payload.ticket_id
+            || worker.payload.session_id !== dispatch.payload.session_id
+            || worker.payload.role_id !== dispatch.payload.role_id
+            || worker.payload.provider_mode !== dispatch.payload.provider_mode
+            || worker.payload.worktree_id !== dispatch.payload.worktree_id)
+            throw new Error("advanced dispatch has no exact canonical worker delivery binding");
+        return Object.freeze({
+            status: "recovered",
+            dispatch_id: dispatch.record_id,
+            dispatch_state: dispatch.state,
+            session_id: session.record_id,
+            session_state: session.state,
+            pane_id: session.payload.tmux_pane_id,
+            provider_mode: dispatch.payload.provider_mode,
+        });
+    }
+    return service;
+}
+function assertApprovedDispatchAdvice(dispatch, evidenceStore, stateRoot) {
+    const digest = dispatch.payload.dispatch_intent_sha256;
+    const reference = dispatch.payload.advisor_evidence;
+    if (typeof digest !== "string" || !reference) {
+        throw new Error("worker delivery requires approved advisor evidence");
+    }
+    const evidence = evidenceStore.read(reference);
+    const intent = captureStoredDispatchIntent(dispatch.payload);
+    try {
+        if (digest !== intent.dispatch_intent_sha256) {
+            throw new Error("worker delivery dispatch intent digest changed");
+        }
+        assertStoredAdvisorEvidenceProvenance({ stateRoot, evidence, intent });
+        if (evidence.evidence_kind !== "advisor-output"
+            || evidence.producer_role !== "oms.exec-advisor"
+            || evidence.ticket_id !== dispatch.payload.ticket_id
+            || evidence.payload.dispatch_intent_sha256 !== digest
+            || evidence.payload.verdict !== "approve")
+            throw new Error("advisor verdict is not approve");
+    }
+    catch (error) {
+        throw new Error("worker delivery advisor evidence does not approve this dispatch intent", { cause: error });
+    }
+}
+function validateExecutable(path) {
+    if (!isAbsolute(path) || !existsSync(path))
+        throw new Error("OMS executable path must be an existing absolute file");
+    const entry = lstatSync(path);
+    if (entry.isSymbolicLink() || !entry.isFile() || (entry.mode & 0o111) === 0) {
+        throw new Error("OMS executable path must be a non-symbolic executable file");
+    }
+    return realpathSync.native(path);
+}
+function boundedReason(value) {
+    const normalized = value.trim().replace(/[\0\r\n]+/gu, " ");
+    return (normalized || "worker lifecycle request").slice(0, 512);
+}
+function addMilliseconds(timestamp, milliseconds) {
+    const value = Date.parse(timestamp);
+    if (!Number.isFinite(value))
+        throw new Error("invalid worker lifecycle timestamp");
+    return new Date(value + milliseconds).toISOString();
+}
+function nextTimestamp(previous, candidate) {
+    const previousMs = Date.parse(previous);
+    const candidateMs = Date.parse(candidate);
+    if (!Number.isFinite(previousMs) || !Number.isFinite(candidateMs))
+        throw new Error("invalid worker transition timestamp");
+    return new Date(Math.max(previousMs + 1, candidateMs)).toISOString();
+}
+function tomlString(value) {
+    if (/[\0\r\n]/u.test(value))
+        throw new Error("worker MCP argument contains control characters");
+    return JSON.stringify(value);
+}
+function tomlArray(values) {
+    return `[${values.map(tomlString).join(",")}]`;
+}
+function prepareIsolatedCodexHome(options) {
+    const { stateRoot, sessionId, dispatchId, executablePath, workspaceRoot, configRoot, env } = options;
+    const sourceHomePath = env.CODEX_HOME ?? (env.HOME ? join(env.HOME, ".codex") : undefined);
+    if (!sourceHomePath)
+        throw new Error("Codex subscription home is unavailable");
+    const sourceHome = validateExistingDirectory(sourceHomePath, "Codex subscription home");
+    const sourceAuth = join(sourceHome, "auth.json");
+    const sourceAuthEntry = lstatSync(sourceAuth);
+    if (sourceAuthEntry.isSymbolicLink() || !sourceAuthEntry.isFile()) {
+        throw new Error("Codex subscription auth must be one regular file");
+    }
+    const sourceAuthTarget = realpathSync.native(sourceAuth);
+    const runtimeHomePath = join(stateRoot, "tmp", `codex-${assertOpaqueId(sessionId, "Codex session id")}`);
+    const runtimeHomeEntry = lstatIfExists(runtimeHomePath);
+    if (!runtimeHomeEntry)
+        mkdirSync(runtimeHomePath, { mode: 0o700 });
+    const runtimeHome = validateExistingDirectory(runtimeHomePath, "isolated Codex home");
+    if ((lstatSync(runtimeHome).mode & 0o077) !== 0)
+        throw new Error("isolated Codex home is not private");
+    const runtimeAuth = join(runtimeHome, "auth.json");
+    const runtimeAuthEntry = lstatIfExists(runtimeAuth);
+    if (!runtimeAuthEntry) {
+        symlinkSync(sourceAuthTarget, runtimeAuth, "file");
+    }
+    else if (!runtimeAuthEntry.isSymbolicLink() || realpathSync.native(runtimeAuth) !== sourceAuthTarget) {
+        throw new Error("isolated Codex auth binding changed");
+    }
+    const hookArgs = [
+        executablePath,
+        "hook",
+        "provider",
+        "--provider",
+        "codex",
+        "--provider-version",
+        SUPPORTED_PROVIDER_HOOK_VERSIONS.codex,
+        "--dispatch-id",
+        dispatchId,
+        "--session-id",
+        sessionId,
+        "--state-root",
+        stateRoot,
+        "--workspace-root",
+        workspaceRoot,
+        "--config-root",
+        configRoot,
+    ];
+    const command = hookArgs.map(shellQuote).join(" ");
+    const hooks = {
+        hooks: {
+            SessionStart: [{ matcher: "startup|resume", hooks: [{ type: "command", command, timeout: 10 }] }],
+            UserPromptSubmit: [{ hooks: [{ type: "command", command, timeout: 10 }] }],
+            Stop: [{ hooks: [{ type: "command", command, timeout: 10 }] }],
+        },
+    };
+    const hooksPath = join(runtimeHome, "hooks.json");
+    const hooksEntry = lstatIfExists(hooksPath);
+    if (!hooksEntry) {
+        writeJsonAtomicNoReplace(hooksPath, hooks);
+    }
+    else {
+        if (hooksEntry.isSymbolicLink() || !hooksEntry.isFile())
+            throw new Error("isolated Codex hooks binding changed");
+        if (JSON.stringify(readJsonFileNoFollow(hooksPath, 64 * 1024)) !== JSON.stringify(hooks)) {
+            throw new Error("isolated Codex hooks binding changed");
+        }
+    }
+    return runtimeHome;
+}
+function shellQuote(value) {
+    if (/[^\x20-\x7e]/u.test(value))
+        throw new Error("Codex hook argument contains control characters");
+    return `'${value.replaceAll("'", `'"'"'`)}'`;
+}
+function verifyWorkerCheckout(dispatch, env, runner) {
+    const result = runner({
+        command: "git",
+        args: ["rev-parse", "--show-toplevel", "HEAD"],
+        cwd: dispatch.payload.worktree_path,
+        env,
+        timeoutMs: 10_000,
+        maxBufferBytes: 64 * 1024,
+    });
+    if (result.error || result.status !== 0)
+        throw new Error("worker checkout probe failed");
+    const [root, head, ...extra] = result.stdout.trim().split(/\r?\n/u);
+    const branchResult = runner({
+        command: "git",
+        args: ["symbolic-ref", "--short", "HEAD"],
+        cwd: dispatch.payload.worktree_path,
+        env,
+        timeoutMs: 10_000,
+        maxBufferBytes: 64 * 1024,
+    });
+    const branch = branchResult.stdout.trim();
+    if (!root
+        || branchResult.error
+        || branchResult.status !== 0
+        || realpathSync.native(root) !== realpathSync.native(dispatch.payload.worktree_path)
+        || branch !== dispatch.payload.worktree_branch
+        || head !== dispatchWorktreeStartCommit(dispatch.payload)
+        || extra.length > 0)
+        throw new Error("worker checkout changed after dispatch acceptance");
+    const lineage = runner({
+        command: "git",
+        args: [
+            "merge-base",
+            "--is-ancestor",
+            dispatch.payload.worktree_base_commit,
+            dispatchWorktreeStartCommit(dispatch.payload),
+        ],
+        cwd: dispatch.payload.worktree_path,
+        env,
+        timeoutMs: 10_000,
+        maxBufferBytes: 64 * 1024,
+    });
+    if (lineage.error || lineage.status !== 0)
+        throw new Error("worker checkout start is outside the trusted base lineage");
+    const statusResult = runner({
+        command: "git",
+        args: ["status", "--porcelain=v1", "--untracked-files=all"],
+        cwd: dispatch.payload.worktree_path,
+        env,
+        timeoutMs: 10_000,
+        maxBufferBytes: 64 * 1024,
+    });
+    if (statusResult.error || statusResult.status !== 0)
+        throw new Error("worker checkout cleanliness probe failed");
+    if (statusResult.stdout.trim() !== "")
+        throw new Error("worker checkout is not clean before provider launch");
+}
+function restoreLeaseExpiredCheckout(options) {
+    const reference = options.dispatch.payload.prior_failure_evidence;
+    if (reference === null)
+        return;
+    const evidence = options.evidenceStore.read(reference);
+    if (evidence.evidence_kind !== "lease-expiry")
+        return;
+    const startCommit = dispatchWorktreeStartCommit(options.dispatch.payload);
+    if (evidence.ticket_id !== options.dispatch.payload.ticket_id
+        || evidence.payload.attempt !== options.dispatch.payload.attempt - 1
+        || evidence.payload.worktree_start_commit !== startCommit)
+        throw new Error("expired lease restart evidence changed after dispatch acceptance");
+    const binding = options.runner({
+        command: "git",
+        args: ["rev-parse", "--show-toplevel", "HEAD"],
+        cwd: options.dispatch.payload.worktree_path,
+        env: options.env,
+        timeoutMs: 10_000,
+        maxBufferBytes: 64 * 1024,
+    });
+    const branchResult = options.runner({
+        command: "git",
+        args: ["symbolic-ref", "--short", "HEAD"],
+        cwd: options.dispatch.payload.worktree_path,
+        env: options.env,
+        timeoutMs: 10_000,
+        maxBufferBytes: 64 * 1024,
+    });
+    const [root, head, ...extra] = binding.stdout.trim().split(/\r?\n/u);
+    if (binding.error
+        || binding.status !== 0
+        || branchResult.error
+        || branchResult.status !== 0
+        || branchResult.stdout.trim() !== options.dispatch.payload.worktree_branch
+        || !root
+        || !head
+        || extra.length > 0
+        || realpathSync.native(root) !== realpathSync.native(options.dispatch.payload.worktree_path))
+        throw new Error("expired lease checkout binding changed");
+    if (head === startCommit)
+        return;
+    if (options.hasBoundSession || options.hasBoundPane) {
+        throw new Error("expired lease checkout cannot reset while a worker binding is live");
+    }
+    const lineage = options.runner({
+        command: "git",
+        args: ["merge-base", "--is-ancestor", options.dispatch.payload.worktree_base_commit, startCommit],
+        cwd: options.dispatch.payload.worktree_path,
+        env: options.env,
+        timeoutMs: 10_000,
+        maxBufferBytes: 64 * 1024,
+    });
+    if (lineage.error || lineage.status !== 0)
+        throw new Error("expired lease restart is outside the trusted base lineage");
+    const reset = options.runner({
+        command: "git",
+        args: ["reset", "--hard", startCommit],
+        cwd: options.dispatch.payload.worktree_path,
+        env: options.env,
+        timeoutMs: 30_000,
+        maxBufferBytes: 256 * 1024,
+    });
+    if (reset.error || reset.status !== 0)
+        throw new Error("expired lease checkout reset failed");
+    const clean = options.runner({
+        command: "git",
+        args: ["clean", "-fd", "--", "."],
+        cwd: options.dispatch.payload.worktree_path,
+        env: options.env,
+        timeoutMs: 30_000,
+        maxBufferBytes: 256 * 1024,
+    });
+    if (clean.error || clean.status !== 0)
+        throw new Error("expired lease checkout clean failed");
+}
+function nativeAction(dispatch) {
+    return dispatch.payload.provider_mode === "codex_goal" ? "goal" : "claude";
+}
+//# sourceMappingURL=delivery.js.map