intentdna 1.9.0 → 1.9.1

package/dist/runtime/local-execution-authority.js

@@ -0,0 +1,2877 @@
+import { spawn, spawnSync } from "node:child_process";
+import { createHash, randomUUID } from "node:crypto";
+import { chmodSync, closeSync, constants as fsConstants, existsSync, fstatSync, fsyncSync, lstatSync, mkdirSync, openSync, readdirSync, readFileSync, renameSync, rmSync, unlinkSync, writeFileSync, } from "node:fs";
+import { connect } from "node:net";
+import { basename, dirname, join, relative, resolve, win32 as win32Path } from "node:path";
+import { canonicalizeJson } from "./canonical-json.js";
+import { validateCanonicalAttemptOutcome } from "./canonical-attempt-outcome.js";
+import { createWorkerAlreadyStoppedEvidence, createWorkerStopReceipt, workerAlreadyStoppedEvidenceDigest, workerAlreadyStoppedEvidenceMatchesStop, workerNonlaunchAttestationDigest, workerStopReceiptDigest, } from "./execution-authority.js";
+import { LOCAL_EXECUTION_SUPERVISOR_DIGEST, LOCAL_EXECUTION_SUPERVISOR_SOURCE, } from "./local-execution-supervisor-script.js";
+import { LOCAL_WINDOWS_EXECUTION_SUPERVISOR_DIGEST, LOCAL_WINDOWS_EXECUTION_SUPERVISOR_SOURCE, } from "./local-windows-execution-supervisor-script.js";
+import { resolveProcessCommand, } from "./process-tree.js";
+import { resolveWindowsJobKeeperArtifact, WindowsJobKeeperArtifactError, } from "./windows-job-keeper.js";
+const RECORD_SCHEMA_VERSION = "intentdna.local_execution_record.v1";
+const CONTROL_SCHEMA_VERSION = "intentdna.local_execution_control.v1";
+const AUTHORITY_SCHEMA_VERSION = "intentdna.local_execution_authority.v1";
+const PREPARATION_SCHEMA_VERSION = "intentdna.local_execution_preparation.v1";
+const PREPARATION_HANDLE_SCHEMA_VERSION = "intentdna.local_execution_preparation_handle.v1";
+const NONLAUNCH_EVIDENCE_SCHEMA_VERSION = "intentdna.local_nonlaunch_evidence.v1";
+const DIRECTORY_MODE = 0o700;
+const PRIVATE_FILE_MODE = 0o600;
+const SCRIPT_FILE_MODE = 0o500;
+const DEFAULT_CONTROL_TIMEOUT_MS = 10_000;
+const DEFAULT_POLL_INTERVAL_MS = 10;
+const DEFAULT_MAX_OUTPUT_BYTES = 16 * 1024 * 1024;
+const MAX_CONTROL_RESPONSE_BYTES = 1024 * 1024;
+export class LocalExecutionAuthorityError extends Error {
+    code;
+    constructor(code, message, options) {
+        super(message, options);
+        this.name = "LocalExecutionAuthorityError";
+        this.code = code;
+    }
+}
+function durableLockOwnersEqual(left, right) {
+    return left !== null && canonicalizeJson(left) === canonicalizeJson(right);
+}
+function durableLockOwnerDigest(owner) {
+    return createHash("sha256").update(canonicalizeJson(owner), "utf8").digest("hex");
+}
+function recoveryIdentity(request) {
+    return {
+        run_id: request.run_id,
+        step_id: request.step_id,
+        activation_id: request.activation_id,
+        attempt_id: request.attempt_id,
+        claim_epoch: request.execution_claim_epoch,
+        worker_session_id: request.executor.worker_session_id,
+        started_at: request.started_at,
+    };
+}
+function requirePreparationRequest(request) {
+    for (const [name, value] of Object.entries({
+        run_id: request.run_id,
+        step_id: request.step_id,
+        activation_id: request.activation_id,
+        attempt_id: request.attempt_id,
+        worker_session_id: request.worker_session_id,
+    })) {
+        if (typeof value !== "string" || value.length === 0 || value.includes("\0")) {
+            throw new TypeError(`${name} must be a non-empty string without NUL bytes`);
+        }
+    }
+    if (!Number.isSafeInteger(request.execution_claim_epoch) || request.execution_claim_epoch <= 0) {
+        throw new TypeError("execution_claim_epoch must be a positive safe integer");
+    }
+    if (request.execution_instance_id !== undefined
+        && (request.execution_instance_id.length === 0 || request.execution_instance_id.includes("\0"))) {
+        throw new TypeError("execution_instance_id must be a non-empty string without NUL bytes");
+    }
+}
+function preparationCoreIdentity(value) {
+    return {
+        run_id: value.run_id,
+        step_id: value.step_id,
+        activation_id: value.activation_id,
+        attempt_id: value.attempt_id,
+        execution_claim_epoch: value.execution_claim_epoch,
+        worker_session_id: value.worker_session_id,
+    };
+}
+function preparationDigest(value) {
+    return digest({
+        schema_version: PREPARATION_SCHEMA_VERSION,
+        identity: preparationCoreIdentity(value),
+        execution_instance_id: value.execution_instance_id,
+    });
+}
+function preparedHandle(preparation) {
+    return {
+        schema_version: PREPARATION_HANDLE_SCHEMA_VERSION,
+        ...preparationCoreIdentity(preparation.identity),
+        execution_instance_id: preparation.execution_instance_id,
+        preparation_digest: preparation.preparation_digest,
+    };
+}
+function digest(value) {
+    return `sha256:${createHash("sha256").update(canonicalizeJson(value), "utf8").digest("hex")}`;
+}
+function textDigest(value) {
+    return `sha256:${createHash("sha256").update(value, "utf8").digest("hex")}`;
+}
+function digestBytes(value) {
+    return `sha256:${createHash("sha256").update(value).digest("hex")}`;
+}
+function isErrno(error, code) {
+    return error instanceof Error
+        && "code" in error
+        && error.code === code;
+}
+function requirePositiveInteger(value, label) {
+    if (!Number.isSafeInteger(value) || value <= 0) {
+        throw new LocalExecutionAuthorityError("invalid_configuration", `${label} must be a positive safe integer`);
+    }
+    return value;
+}
+function isCanonicalTimestamp(value) {
+    return typeof value === "string"
+        && Number.isFinite(Date.parse(value))
+        && new Date(Date.parse(value)).toISOString() === value;
+}
+function isCanonicalDigest(value) {
+    return typeof value === "string" && /^sha256:[0-9a-f]{64}$/.test(value);
+}
+function isPositiveSafeInteger(value) {
+    return Number.isSafeInteger(value) && value > 0;
+}
+function isCanonicalWorkerOutcome(value, workerSessionId) {
+    try {
+        validateCanonicalAttemptOutcome({ kind: "worker", worker_session_id: workerSessionId }, value);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function requireIdentity(identity) {
+    for (const [name, value] of Object.entries({
+        run_id: identity.run_id,
+        step_id: identity.step_id,
+        activation_id: identity.activation_id,
+        attempt_id: identity.attempt_id,
+        worker_session_id: identity.worker_session_id,
+        started_at: identity.started_at,
+    })) {
+        if (typeof value !== "string" || value.length === 0 || value.includes("\0")) {
+            throw new TypeError(`${name} must be a non-empty string without NUL bytes`);
+        }
+    }
+    if (!Number.isSafeInteger(identity.claim_epoch) || identity.claim_epoch <= 0) {
+        throw new TypeError("claim_epoch must be a positive safe integer");
+    }
+    if (!isCanonicalTimestamp(identity.started_at)) {
+        throw new TypeError("started_at must be a canonical RFC 3339 timestamp");
+    }
+}
+function coreIdentity(value) {
+    return {
+        run_id: value.run_id,
+        step_id: value.step_id,
+        activation_id: value.activation_id,
+        attempt_id: value.attempt_id,
+        claim_epoch: value.claim_epoch,
+        worker_session_id: value.worker_session_id,
+        started_at: value.started_at,
+    };
+}
+function identityDigest(value) {
+    return digest(coreIdentity(value));
+}
+function attemptDigest(value) {
+    return digest({
+        schema_version: "intentdna.local_execution_attempt_key.v1",
+        run_id: value.run_id,
+        step_id: value.step_id,
+        attempt_id: value.attempt_id,
+    });
+}
+function executionRecordDigest(value) {
+    return digest({
+        schema_version: "intentdna.local_execution_record_key.v2",
+        run_id: value.run_id,
+        step_id: value.step_id,
+        attempt_id: value.attempt_id,
+        claim_epoch: value.claim_epoch,
+    });
+}
+function requestIdentity(value) {
+    return {
+        run_id: value.run_id,
+        step_id: value.step_id,
+        activation_id: value.activation_id,
+        attempt_id: value.attempt_id,
+        claim_epoch: value.claim_epoch,
+        worker_session_id: value.executor.worker_session_id,
+        started_at: "started_at" in value ? value.started_at : value.reported_execution.started_at,
+    };
+}
+function processMatchesCanonical(actual, canonical) {
+    return canonical.kind === "worker_process"
+        && canonicalizeJson(actual) === canonicalizeJson(canonical.process);
+}
+function terminalOutcomeToCanonical(process) {
+    if (process.kind === "success") {
+        return {
+            kind: "worker_process",
+            status: "succeeded",
+            reason_code: null,
+            message: null,
+            process,
+        };
+    }
+    if (process.kind === "cancelled") {
+        return {
+            kind: "worker_process",
+            status: "cancelled",
+            reason_code: "cancelled",
+            message: process.reason,
+            process,
+        };
+    }
+    return {
+        kind: "worker_process",
+        status: "failed",
+        reason_code: process.kind,
+        message: process.kind === "malformed_result" || process.kind === "launch_error"
+            ? process.error
+            : null,
+        process,
+    };
+}
+function ensureRealPrivateDirectory(path) {
+    mkdirSync(path, { recursive: true, mode: DIRECTORY_MODE });
+    const metadata = lstatSync(path);
+    if (!metadata.isDirectory() || metadata.isSymbolicLink()) {
+        throw new LocalExecutionAuthorityError("corrupt_state", `authority path is not a real directory: ${path}`);
+    }
+    chmodSync(path, DIRECTORY_MODE);
+}
+function syncDirectory(path) {
+    let descriptor = null;
+    try {
+        descriptor = openSync(path, "r");
+        fsyncSync(descriptor);
+    }
+    catch (error) {
+        if (!isErrno(error, "EINVAL")
+            && !isErrno(error, "ENOTSUP")
+            && !isErrno(error, "EPERM")
+            && !isErrno(error, "EACCES")
+            && !isErrno(error, "EISDIR"))
+            throw error;
+    }
+    finally {
+        if (descriptor !== null)
+            closeSync(descriptor);
+    }
+}
+function atomicWriteJson(path, value) {
+    const directory = dirname(path);
+    const temporary = join(directory, `.${basename(path)}.tmp.${process.pid}.${randomUUID()}`);
+    const descriptor = openSync(temporary, "wx", PRIVATE_FILE_MODE);
+    try {
+        writeFileSync(descriptor, `${canonicalizeJson(value)}\n`, "utf8");
+        fsyncSync(descriptor);
+    }
+    finally {
+        closeSync(descriptor);
+    }
+    renameSync(temporary, path);
+    syncDirectory(directory);
+}
+function readJson(path) {
+    try {
+        const metadata = lstatSync(path);
+        if (!metadata.isFile()
+            || metadata.isSymbolicLink()
+            || (process.platform !== "win32" && (metadata.mode & 0o077) !== 0)) {
+            throw new LocalExecutionAuthorityError("corrupt_state", `authority file is not private: ${path}`);
+        }
+        return JSON.parse(readFileSync(path, "utf8"));
+    }
+    catch (error) {
+        if (error instanceof LocalExecutionAuthorityError)
+            throw error;
+        throw new LocalExecutionAuthorityError("corrupt_state", `cannot read authority file ${path}`, { cause: error });
+    }
+}
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function hasExactKeys(value, keys) {
+    const actual = Object.keys(value).sort();
+    const expected = [...keys].sort();
+    return actual.length === expected.length
+        && actual.every((key, index) => key === expected[index]);
+}
+function isDurablePosixProvider(value) {
+    return isRecord(value)
+        && hasExactKeys(value, ["pid", "process_group_id", "child_pid", "launched_at"])
+        && Number.isSafeInteger(value.pid)
+        && value.pid > 0
+        && value.process_group_id === value.pid
+        && Number.isSafeInteger(value.child_pid)
+        && value.child_pid > 0
+        && isCanonicalTimestamp(value.launched_at);
+}
+function isPositiveFiletime(value) {
+    return typeof value === "string" && /^[1-9][0-9]*$/.test(value);
+}
+function isDurableWindowsProvider(value) {
+    return isRecord(value)
+        && hasExactKeys(value, [
+            "pid",
+            "keeper_pid",
+            "keeper_creation_filetime",
+            "root_pid",
+            "root_creation_filetime",
+            "job_identifier",
+            "containment_nonce",
+            "contained_at",
+            "released_at",
+        ])
+        && Number.isSafeInteger(value.pid)
+        && value.pid > 0
+        && value.pid === value.root_pid
+        && Number.isSafeInteger(value.keeper_pid)
+        && value.keeper_pid > 0
+        && isPositiveFiletime(value.keeper_creation_filetime)
+        && Number.isSafeInteger(value.root_pid)
+        && value.root_pid > 0
+        && isPositiveFiletime(value.root_creation_filetime)
+        && isCanonicalDigest(value.job_identifier)
+        && typeof value.containment_nonce === "string"
+        && /^[0-9a-f]{64}$/.test(value.containment_nonce)
+        && isCanonicalTimestamp(value.contained_at)
+        && (value.released_at === null || isCanonicalTimestamp(value.released_at));
+}
+function isDurableWindowsJobCompletion(value) {
+    return isRecord(value)
+        && hasExactKeys(value, [
+            "schema_version",
+            "kind",
+            "reason",
+            "root_exit_observed",
+            "root_exit_code",
+            "windows_signal",
+            "active_processes",
+            "process_tree_drained",
+        ])
+        && value.schema_version === "intentdna.windows_job_keeper_fact.v1"
+        && value.kind === "completed"
+        && ["root_exit", "terminate", "parent_eof", "protocol_error", "drain_timeout", "output_limit"].includes(String(value.reason))
+        && typeof value.root_exit_observed === "boolean"
+        && Number.isSafeInteger(value.root_exit_code)
+        && value.root_exit_code >= 0
+        && value.root_exit_code <= 0xffff_ffff
+        && value.windows_signal === null
+        && value.active_processes === 0
+        && value.process_tree_drained === true;
+}
+function isDurableRawCompletion(value) {
+    return isRecord(value)
+        && hasExactKeys(value, [
+            "stdout",
+            "stderr",
+            "max_output_bytes",
+            "timeout_ms",
+            "status",
+            "signal",
+            "timed_out",
+            "cancelled",
+            "cancellation_reason",
+            "process_limit_exceeded",
+            "output_limit_exceeded",
+            "termination_reason",
+            "process_id",
+            "process_tree_drained",
+            "completed_at",
+            "error",
+            ...(value.windows_job_completion === undefined ? [] : ["windows_job_completion"]),
+        ])
+        && isDurableStreamEvidence(value.stdout)
+        && isDurableStreamEvidence(value.stderr)
+        && Number.isSafeInteger(value.max_output_bytes)
+        && value.max_output_bytes > 0
+        && (value.timeout_ms === null
+            || (Number.isSafeInteger(value.timeout_ms) && value.timeout_ms > 0))
+        && (value.status === null || Number.isSafeInteger(value.status))
+        && (value.signal === null || typeof value.signal === "string")
+        && typeof value.timed_out === "boolean"
+        && typeof value.cancelled === "boolean"
+        && (value.cancellation_reason === null || typeof value.cancellation_reason === "string")
+        && typeof value.process_limit_exceeded === "boolean"
+        && typeof value.output_limit_exceeded === "boolean"
+        && (value.termination_reason === null
+            || ["timeout", "cancellation", "process_limit", "output_limit"].includes(String(value.termination_reason)))
+        && (value.process_id === null || (Number.isSafeInteger(value.process_id) && value.process_id > 0))
+        && value.process_tree_drained === true
+        && isCanonicalTimestamp(value.completed_at)
+        && (value.error === null || (isRecord(value.error)
+            && hasExactKeys(value.error, ["code", "message"])
+            && typeof value.error.code === "string"
+            && value.error.code.length > 0
+            && typeof value.error.message === "string"
+            && value.error.message.length > 0))
+        && rawCompletionFlagsAreConsistent(value);
+}
+function isDurableStreamEvidence(value) {
+    return isRecord(value)
+        && hasExactKeys(value, ["path", "byte_count", "sha256", "device", "inode", "birthtime_ns"])
+        && typeof value.path === "string"
+        && value.path.length > 0
+        && Number.isSafeInteger(value.byte_count)
+        && value.byte_count >= 0
+        && isCanonicalDigest(value.sha256)
+        && typeof value.device === "string"
+        && /^(0|[1-9][0-9]*)$/.test(value.device)
+        && typeof value.inode === "string"
+        && /^(0|[1-9][0-9]*)$/.test(value.inode)
+        && typeof value.birthtime_ns === "string"
+        && /^(0|[1-9][0-9]*)$/.test(value.birthtime_ns);
+}
+function rawCompletionFlagsAreConsistent(raw) {
+    if (raw.stdout.byte_count > raw.max_output_bytes || raw.stderr.byte_count > raw.max_output_bytes) {
+        return false;
+    }
+    if ((raw.status !== null && raw.signal !== null) || (raw.error !== null && raw.termination_reason !== null)) {
+        return false;
+    }
+    if (raw.cancelled !== (raw.termination_reason === "cancellation")
+        || raw.timed_out !== (raw.termination_reason === "timeout")
+        || raw.process_limit_exceeded !== (raw.termination_reason === "process_limit")
+        || raw.output_limit_exceeded !== (raw.termination_reason === "output_limit")) {
+        return false;
+    }
+    if ((raw.cancelled ? true : raw.cancellation_reason === null) === false)
+        return false;
+    if (raw.timed_out && raw.timeout_ms === null)
+        return false;
+    if (raw.output_limit_exceeded
+        && raw.stdout.byte_count < raw.max_output_bytes
+        && raw.stderr.byte_count < raw.max_output_bytes)
+        return false;
+    if (raw.termination_reason === null && raw.error === null) {
+        if (raw.signal !== null)
+            return raw.status === null;
+        return raw.status !== null;
+    }
+    return true;
+}
+function windowsCanonicalStopMode(value) {
+    if (!isRecord(value)
+        || value.kind !== "worker_process"
+        || !isRecord(value.process))
+        return null;
+    if (value.status === "failed"
+        && value.process.kind === "timeout"
+        && hasExactKeys(value.process, ["kind", "exit_code", "signal", "timeout_ms"])
+        && value.process.exit_code === null
+        && value.process.signal === null
+        && Number.isSafeInteger(value.process.timeout_ms)
+        && value.process.timeout_ms > 0)
+        return { kind: "timeout", reason: null };
+    if (value.status === "cancelled"
+        && value.process.kind === "cancelled"
+        && hasExactKeys(value.process, ["kind", "exit_code", "signal", "reason"])
+        && value.process.exit_code === null
+        && value.process.signal === null
+        && (value.process.reason === null || typeof value.process.reason === "string"))
+        return { kind: "cancellation", reason: value.process.reason };
+    return null;
+}
+function windowsStopExpectation(value) {
+    if (value === null) {
+        return {
+            timedOut: false,
+            cancelled: false,
+            outputLimited: false,
+            cancellationReason: null,
+            terminationReason: null,
+        };
+    }
+    if (value.kind === "timeout") {
+        if (!hasExactKeys(value, ["kind", "reason"])
+            || value.reason !== "timeout")
+            return null;
+        return {
+            timedOut: true,
+            cancelled: false,
+            outputLimited: false,
+            cancellationReason: null,
+            terminationReason: "timeout",
+        };
+    }
+    if (value.kind === "local_cancel") {
+        if (!hasExactKeys(value, ["kind", "reason"])
+            || (value.reason !== null && typeof value.reason !== "string"))
+            return null;
+        return {
+            timedOut: false,
+            cancelled: true,
+            outputLimited: false,
+            cancellationReason: value.reason ?? null,
+            terminationReason: "cancellation",
+        };
+    }
+    if (value.kind === "output_limit") {
+        if (!hasExactKeys(value, ["kind", "reason"])
+            || value.reason !== "output_limit")
+            return null;
+        return {
+            timedOut: false,
+            cancelled: false,
+            outputLimited: true,
+            cancellationReason: null,
+            terminationReason: "output_limit",
+        };
+    }
+    if (value.kind !== "canonical_stop"
+        || !hasExactKeys(value, [
+            "kind",
+            "stop_idempotency_key",
+            "requested_at",
+            "requested_outcome",
+        ])
+        || !isCanonicalDigest(value.stop_idempotency_key)
+        || !isCanonicalTimestamp(value.requested_at))
+        return null;
+    const mode = windowsCanonicalStopMode(value.requested_outcome);
+    return mode === null ? null : {
+        timedOut: mode.kind === "timeout",
+        cancelled: mode.kind === "cancellation",
+        outputLimited: false,
+        cancellationReason: mode.reason,
+        terminationReason: mode.kind,
+    };
+}
+function windowsCompletionMatchesRecord(record) {
+    if (record.backend.kind !== "windows_job" || record.raw_completion === null)
+        return true;
+    const raw = record.raw_completion;
+    const provider = record.provider;
+    const fact = raw.windows_job_completion;
+    const expected = windowsStopExpectation(record.stop_fact);
+    if (!isDurableWindowsProvider(provider)
+        || provider.released_at === null
+        || !isDurableWindowsJobCompletion(fact)
+        || expected === null
+        || raw.process_id !== provider.root_pid
+        || raw.signal !== null
+        || raw.error !== null
+        || raw.completed_at < provider.released_at
+        || fact.reason === "parent_eof"
+        || fact.reason === "protocol_error")
+        return false;
+    const stopped = expected.timedOut || expected.cancelled || expected.outputLimited;
+    return raw.timed_out === expected.timedOut
+        && raw.cancelled === expected.cancelled
+        && raw.cancellation_reason === expected.cancellationReason
+        && raw.process_limit_exceeded === false
+        && raw.output_limit_exceeded === expected.outputLimited
+        && (stopped
+            ? fact.reason === (expected.outputLimited ? "output_limit" : "terminate")
+                && raw.status === null
+                && raw.termination_reason === expected.terminationReason
+            : (fact.reason === "root_exit" || fact.reason === "drain_timeout")
+                && fact.root_exit_observed
+                && raw.status === fact.root_exit_code
+                && raw.termination_reason === null);
+}
+function windowsPhaseMatchesRecord(record) {
+    if (record.backend.kind !== "windows_job")
+        return true;
+    const supervisorReady = record.supervisor.pid !== null && record.supervisor.ready_at !== null;
+    if (record.phase === "never_launched" || record.phase === "prepared" || record.phase === "launching") {
+        return !supervisorReady
+            && record.provider === null
+            && record.raw_completion === null
+            && record.stop_fact === null;
+    }
+    if (record.phase === "running") {
+        return supervisorReady && record.raw_completion === null;
+    }
+    if (["raw_completed", "normalized_completed", "receipted"].includes(record.phase)) {
+        return supervisorReady
+            && isDurableWindowsProvider(record.provider)
+            && record.provider.released_at !== null
+            && record.raw_completion !== null;
+    }
+    return record.phase === "unsupported";
+}
+function isDurableBackend(value) {
+    if (!isRecord(value) || typeof value.kind !== "string")
+        return false;
+    if (value.kind === "posix_process_group") {
+        return hasExactKeys(value, ["kind"]);
+    }
+    return value.kind === "windows_job"
+        && hasExactKeys(value, [
+            "kind",
+            "architecture",
+            "helper_path",
+            "helper_digest",
+            "helper_source_digest",
+            "helper_protocol_version",
+            "containment_nonce",
+        ])
+        && ["x86_64", "aarch64"].includes(String(value.architecture))
+        && typeof value.helper_path === "string"
+        && value.helper_path.length > 0
+        && isCanonicalDigest(value.helper_digest)
+        && isCanonicalDigest(value.helper_source_digest)
+        && value.helper_protocol_version === "IDNA_WINDOWS_JOB_KEEPER_V1"
+        && typeof value.containment_nonce === "string"
+        && /^[0-9a-f]{64}$/.test(value.containment_nonce);
+}
+function isDurableSupervisor(value, backend) {
+    if (!isRecord(value) || !hasExactKeys(value, [
+        "kind",
+        "socket_path",
+        "script_digest",
+        "pid",
+        "ready_at",
+    ]))
+        return false;
+    const expectedKind = backend.kind === "windows_job" ? "windows" : "posix";
+    const expectedDigest = backend.kind === "windows_job"
+        ? LOCAL_WINDOWS_EXECUTION_SUPERVISOR_DIGEST
+        : LOCAL_EXECUTION_SUPERVISOR_DIGEST;
+    return value.kind === expectedKind
+        && typeof value.socket_path === "string"
+        && value.socket_path.length > 0
+        && value.script_digest === expectedDigest
+        && (value.pid === null || (Number.isSafeInteger(value.pid) && value.pid > 0))
+        && (value.ready_at === null || isCanonicalTimestamp(value.ready_at));
+}
+function nonlaunchSourceEvidenceDigest(record) {
+    const { nonlaunch_attestation: _attestation, ...durableEvidence } = record;
+    return digest({
+        schema_version: NONLAUNCH_EVIDENCE_SCHEMA_VERSION,
+        durable_record: durableEvidence,
+    });
+}
+function alreadyStoppedSourceEvidenceDigest(record) {
+    return digest({
+        schema_version: "intentdna.local_already_stopped_source_evidence.v1",
+        identity_digest: record.identity_digest,
+        execution_instance_id: record.execution_instance_id,
+        authority_instance_id: record.authority_instance_id,
+        backend: record.backend,
+        supervisor: record.supervisor,
+        provider: record.provider,
+        raw_completion: record.raw_completion,
+        normalized_process_outcome: record.normalized_process_outcome,
+    });
+}
+function stopReceiptSourceEvidenceDigest(record) {
+    return digest({
+        identity_digest: record.identity_digest,
+        supervisor: record.supervisor,
+        provider: record.provider,
+        raw_completion: record.raw_completion,
+        normalized_process_outcome: record.normalized_process_outcome,
+        stop_fact: record.stop_fact,
+    });
+}
+function isDurableStopFact(value, workerSessionId) {
+    if (!isRecord(value) || typeof value.kind !== "string")
+        return false;
+    if (value.kind === "canonical_stop") {
+        return hasExactKeys(value, [
+            "kind",
+            "stop_idempotency_key",
+            "requested_at",
+            "requested_outcome",
+        ])
+            && isCanonicalDigest(value.stop_idempotency_key)
+            && isCanonicalTimestamp(value.requested_at)
+            && isCanonicalWorkerOutcome(value.requested_outcome, workerSessionId);
+    }
+    if (!hasExactKeys(value, ["kind", "reason"]))
+        return false;
+    if (value.kind === "local_cancel") {
+        return value.reason === null || typeof value.reason === "string";
+    }
+    return (value.kind === "timeout" && value.reason === "timeout")
+        || (value.kind === "process_limit" && value.reason === "process_limit")
+        || (value.kind === "output_limit" && value.reason === "output_limit");
+}
+function isDurableStopReceipt(value, record) {
+    if (!isRecord(value)
+        || !hasExactKeys(value, ["receipt_digest", "payload"])
+        || !isCanonicalDigest(value.receipt_digest)
+        || !isRecord(value.payload)
+        || !hasExactKeys(value.payload, [
+            "schema_version",
+            "run_id",
+            "step_id",
+            "activation_id",
+            "attempt_id",
+            "claim_epoch",
+            "worker_session_id",
+            "execution_instance_id",
+            "authority_kind",
+            "authority_instance_id",
+            "fencing_epoch",
+            "started_at",
+            "stopped_at",
+            "terminal_outcome",
+            "process_tree_drained",
+            "source_evidence_digest",
+        ]))
+        return false;
+    const receipt = value;
+    const payload = receipt.payload;
+    if (payload.schema_version !== "intentdna.worker_stop_receipt.v1"
+        || payload.run_id !== record.identity.run_id
+        || payload.step_id !== record.identity.step_id
+        || payload.activation_id !== record.identity.activation_id
+        || payload.attempt_id !== record.identity.attempt_id
+        || payload.claim_epoch !== record.identity.claim_epoch
+        || payload.worker_session_id !== record.identity.worker_session_id
+        || payload.execution_instance_id !== record.execution_instance_id
+        || payload.authority_kind !== "local_process"
+        || payload.authority_instance_id !== record.authority_instance_id
+        || !isPositiveSafeInteger(payload.fencing_epoch)
+        || payload.fencing_epoch !== record.fencing_epoch
+        || payload.started_at !== record.identity.started_at
+        || !isCanonicalTimestamp(payload.stopped_at)
+        || payload.stopped_at < payload.started_at
+        || record.raw_completion === null
+        || payload.stopped_at < record.raw_completion.completed_at
+        || !isCanonicalWorkerOutcome(payload.terminal_outcome, record.identity.worker_session_id)
+        || payload.process_tree_drained !== true
+        || !isCanonicalDigest(payload.source_evidence_digest)
+        || payload.source_evidence_digest !== stopReceiptSourceEvidenceDigest(record)
+        || receipt.receipt_digest !== workerStopReceiptDigest(payload))
+        return false;
+    if (record.stop_fact?.kind === "canonical_stop") {
+        return payload.stopped_at >= record.stop_fact.requested_at
+            && canonicalizeJson(payload.terminal_outcome)
+                === canonicalizeJson(record.stop_fact.requested_outcome);
+    }
+    return record.normalized_process_outcome !== null
+        && processMatchesCanonical(record.normalized_process_outcome, payload.terminal_outcome);
+}
+function parseRecord(value) {
+    if (!isRecord(value)
+        || !hasExactKeys(value, [
+            "schema_version",
+            "revision",
+            "phase",
+            "identity",
+            "identity_digest",
+            "execution_instance_id",
+            "challenge",
+            "authority_instance_id",
+            "backend",
+            "supervisor",
+            "provider",
+            "raw_completion",
+            "normalized_process_outcome",
+            "stop_fact",
+            "stop_receipt",
+            "already_stopped_evidence",
+            "nonlaunch_attestation",
+            "fencing_epoch",
+            "supervisor_error",
+            "created_at",
+            "updated_at",
+        ])
+        || value.schema_version !== RECORD_SCHEMA_VERSION) {
+        throw new LocalExecutionAuthorityError("corrupt_state", "execution authority record has an invalid schema");
+    }
+    const record = value;
+    const nonlaunchAttestation = record.nonlaunch_attestation;
+    requireIdentity(record.identity);
+    const hasFencedEvidence = record.stop_receipt !== null
+        || record.already_stopped_evidence !== null
+        || record.nonlaunch_attestation !== null;
+    if (record.identity_digest !== identityDigest(record.identity)
+        || record.execution_instance_id !== record.identity.execution_instance_id
+        || !Number.isSafeInteger(record.revision)
+        || record.revision <= 0
+        || !["never_launched", "prepared", "launching", "running", "raw_completed", "normalized_completed", "receipted", "unsupported"].includes(record.phase)
+        || typeof record.challenge !== "string"
+        || record.challenge.length < 32
+        || typeof record.authority_instance_id !== "string"
+        || record.authority_instance_id.length === 0
+        || !isDurableBackend(record.backend)
+        || !isDurableSupervisor(record.supervisor, record.backend)
+        || ((record.supervisor.pid === null) !== (record.supervisor.ready_at === null))
+        || (record.raw_completion !== null && !isDurableRawCompletion(record.raw_completion))
+        || (record.stop_fact !== null
+            && !isDurableStopFact(record.stop_fact, record.identity.worker_session_id))
+        || (hasFencedEvidence
+            ? !isPositiveSafeInteger(record.fencing_epoch)
+            : record.fencing_epoch !== null)
+        || !isCanonicalTimestamp(record.created_at)
+        || !isCanonicalTimestamp(record.updated_at)
+        || record.updated_at < record.created_at) {
+        throw new LocalExecutionAuthorityError("corrupt_state", "execution authority record failed identity validation");
+    }
+    if ((record.phase === "never_launched" && (nonlaunchAttestation === null
+        || record.provider !== null
+        || record.raw_completion !== null
+        || record.supervisor.pid !== null
+        || nonlaunchAttestation.attestation_digest
+            !== workerNonlaunchAttestationDigest(nonlaunchAttestation.payload)
+        || nonlaunchAttestation.payload.execution_instance_id !== record.execution_instance_id
+        || nonlaunchAttestation.payload.authority_instance_id !== record.authority_instance_id
+        || nonlaunchAttestation.payload.run_id !== record.identity.run_id
+        || nonlaunchAttestation.payload.step_id !== record.identity.step_id
+        || nonlaunchAttestation.payload.activation_id !== record.identity.activation_id
+        || nonlaunchAttestation.payload.attempt_id !== record.identity.attempt_id
+        || nonlaunchAttestation.payload.claim_epoch !== record.identity.claim_epoch
+        || nonlaunchAttestation.payload.worker_session_id !== record.identity.worker_session_id
+        || nonlaunchAttestation.payload.started_at !== record.identity.started_at
+        || nonlaunchAttestation.payload.launch_state !== "never_launched"
+        || nonlaunchAttestation.payload.authority_kind !== "local_process"
+        || nonlaunchAttestation.payload.schema_version !== "intentdna.worker_nonlaunch_attestation.v1"
+        || !Number.isSafeInteger(nonlaunchAttestation.payload.fencing_epoch)
+        || nonlaunchAttestation.payload.fencing_epoch <= 0
+        || nonlaunchAttestation.payload.fencing_epoch !== record.fencing_epoch
+        || !isCanonicalTimestamp(nonlaunchAttestation.payload.attested_at)
+        || !isCanonicalDigest(nonlaunchAttestation.payload.failure_idempotency_key)
+        || !isCanonicalDigest(nonlaunchAttestation.payload.source_evidence_digest)
+        || nonlaunchAttestation.payload.source_evidence_digest
+            !== nonlaunchSourceEvidenceDigest(record)))
+        || (record.phase !== "never_launched" && nonlaunchAttestation !== null)
+        || (record.already_stopped_evidence !== null && (record.raw_completion === null
+            || record.stop_receipt !== null
+            || record.fencing_epoch === null
+            || record.already_stopped_evidence.evidence_digest
+                !== workerAlreadyStoppedEvidenceDigest(record.already_stopped_evidence.payload)
+            || record.already_stopped_evidence.payload.schema_version
+                !== "intentdna.worker_already_stopped_evidence.v1"
+            || record.already_stopped_evidence.payload.run_id !== record.identity.run_id
+            || record.already_stopped_evidence.payload.step_id !== record.identity.step_id
+            || record.already_stopped_evidence.payload.activation_id !== record.identity.activation_id
+            || record.already_stopped_evidence.payload.attempt_id !== record.identity.attempt_id
+            || record.already_stopped_evidence.payload.claim_epoch !== record.identity.claim_epoch
+            || record.already_stopped_evidence.payload.worker_session_id !== record.identity.worker_session_id
+            || record.already_stopped_evidence.payload.execution_instance_id !== record.execution_instance_id
+            || record.already_stopped_evidence.payload.authority_instance_id !== record.authority_instance_id
+            || record.already_stopped_evidence.payload.authority_kind !== "local_process"
+            || record.already_stopped_evidence.payload.fencing_epoch !== record.fencing_epoch
+            || record.already_stopped_evidence.payload.started_at !== record.identity.started_at
+            || record.already_stopped_evidence.payload.completed_at !== record.raw_completion.completed_at
+            || canonicalizeJson(record.already_stopped_evidence.payload.observed_outcome)
+                !== canonicalizeJson(terminalOutcomeToCanonical(rawCompletionToOutcome(record.raw_completion)))
+            || record.already_stopped_evidence.payload.process_tree_drained !== true
+            || !isCanonicalDigest(record.already_stopped_evidence.payload.stop_idempotency_key)
+            || !isCanonicalTimestamp(record.already_stopped_evidence.payload.stop_requested_at)
+            || !["cancel", "execution_deadline", "peer_terminal"].includes(record.already_stopped_evidence.payload.stop_purpose)
+            || record.already_stopped_evidence.payload.source_evidence_digest
+                !== alreadyStoppedSourceEvidenceDigest(record)))
+        || (record.stop_receipt !== null && record.already_stopped_evidence !== null)
+        || (record.stop_receipt !== null && !isDurableStopReceipt(record.stop_receipt, record))
+        || (record.provider !== null && (record.backend.kind === "windows_job"
+            ? !isDurableWindowsProvider(record.provider)
+            : !isDurablePosixProvider(record.provider)))
+        || (record.backend.kind === "windows_job" && record.provider !== null
+            && (!isDurableWindowsProvider(record.provider)
+                || record.provider.containment_nonce !== record.backend.containment_nonce))
+        || (record.phase === "prepared" && record.provider !== null)
+        || (record.phase === "raw_completed" && record.raw_completion === null)
+        || (record.raw_completion !== null && record.raw_completion.process_tree_drained !== true)
+        || !windowsPhaseMatchesRecord(record)
+        || !windowsCompletionMatchesRecord(record)
+        || (record.phase === "normalized_completed" && (record.raw_completion === null || record.normalized_process_outcome === null))
+        || (record.phase === "receipted" && (record.raw_completion === null
+            || (record.stop_receipt === null && record.already_stopped_evidence === null)
+            || record.fencing_epoch === null))) {
+        throw new LocalExecutionAuthorityError("corrupt_state", "execution authority phase lacks required evidence");
+    }
+    return record;
+}
+function processIsAlive(pid) {
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch (error) {
+        return isErrno(error, "EPERM");
+    }
+}
+function processBirthIdentity(pid, platform) {
+    if (!Number.isSafeInteger(pid) || pid <= 0)
+        return null;
+    if (platform === "linux") {
+        try {
+            const stat = readFileSync(`/proc/${pid}/stat`, "utf8");
+            const fields = stat.slice(stat.lastIndexOf(")") + 2).trim().split(/\s+/);
+            const startTicks = fields[19];
+            return startTicks !== undefined && /^[0-9]+$/.test(startTicks)
+                ? `linux-start-ticks:${startTicks}`
+                : null;
+        }
+        catch {
+            return null;
+        }
+    }
+    if (platform !== "win32") {
+        const result = spawnSync("ps", ["-p", String(pid), "-o", "lstart="], {
+            encoding: "utf8",
+            timeout: 1_000,
+            windowsHide: true,
+        });
+        const started = result.status === 0 ? result.stdout.trim().replace(/\s+/g, " ") : "";
+        return started === "" ? null : `${platform}-lstart:${started}`;
+    }
+    return pid === process.pid ? `node-time-origin-ms:${Math.floor(performance.timeOrigin)}` : null;
+}
+function durableLockOwner(platform) {
+    const processBirthId = processBirthIdentity(process.pid, platform);
+    if (processBirthId === null) {
+        throw new LocalExecutionAuthorityError("unsupported", "cannot establish execution lock owner identity");
+    }
+    return {
+        schema_version: "intentdna.execution_lock_owner.v1",
+        pid: process.pid,
+        process_birth_id: processBirthId,
+        generation: randomUUID(),
+        acquired_at: Date.now(),
+    };
+}
+function readDurableLockOwner(path) {
+    try {
+        const value = JSON.parse(readFileSync(path, "utf8"));
+        if (!isRecord(value)
+            || !hasExactKeys(value, ["schema_version", "pid", "process_birth_id", "generation", "acquired_at"])
+            || value.schema_version !== "intentdna.execution_lock_owner.v1"
+            || !Number.isSafeInteger(value.pid)
+            || value.pid <= 0
+            || typeof value.process_birth_id !== "string"
+            || value.process_birth_id.length === 0
+            || typeof value.generation !== "string"
+            || value.generation.length === 0
+            || !Number.isSafeInteger(value.acquired_at)
+            || value.acquired_at < 0)
+            return null;
+        return value;
+    }
+    catch {
+        return null;
+    }
+}
+function publishDurableLock(lockPath, owner) {
+    const candidatePath = `${lockPath}.candidate.${process.pid}.${randomUUID()}`;
+    mkdirSync(candidatePath, { mode: DIRECTORY_MODE });
+    try {
+        const descriptor = openSync(join(candidatePath, "owner.json"), "wx", PRIVATE_FILE_MODE);
+        try {
+            writeFileSync(descriptor, `${canonicalizeJson(owner)}\n`, "utf8");
+            fsyncSync(descriptor);
+        }
+        finally {
+            closeSync(descriptor);
+        }
+        syncDirectory(candidatePath);
+        try {
+            renameSync(candidatePath, lockPath);
+        }
+        catch (error) {
+            if (isErrno(error, "EEXIST") || isErrno(error, "ENOTEMPTY")
+                || (isErrno(error, "EPERM") && existsSync(lockPath)))
+                return false;
+            throw error;
+        }
+        syncDirectory(dirname(lockPath));
+        return true;
+    }
+    finally {
+        rmSync(candidatePath, { recursive: true, force: true });
+    }
+}
+function releaseDurableLock(lockPath, owner) {
+    const ownerPath = join(lockPath, "owner.json");
+    if (!existsSync(ownerPath))
+        return;
+    const current = readDurableLockOwner(ownerPath);
+    if (current === null) {
+        throw new LocalExecutionAuthorityError("corrupt_state", "execution authority lock owner is invalid during release");
+    }
+    if (!durableLockOwnersEqual(current, owner))
+        return;
+    const releasedPath = `${lockPath}.released.${durableLockOwnerDigest(owner)}.${randomUUID()}`;
+    try {
+        renameSync(lockPath, releasedPath);
+    }
+    catch (error) {
+        if (isErrno(error, "ENOENT"))
+            return;
+        throw error;
+    }
+    syncDirectory(dirname(lockPath));
+    const releasedOwner = readDurableLockOwner(join(releasedPath, "owner.json"));
+    if (!durableLockOwnersEqual(releasedOwner, owner)) {
+        throw new LocalExecutionAuthorityError("corrupt_state", "execution authority lock ownership changed during release");
+    }
+    rmSync(releasedPath, { recursive: true, force: true });
+    syncDirectory(dirname(lockPath));
+}
+/**
+ * Retires one observed stale generation without exposing a later generation to
+ * delayed contenders. The non-empty, generation-specific tombstone is retained
+ * so a contender that observed the same owner can never rename a successor over it.
+ * This is exported only for lock-protocol regression tests, not from the runtime barrel.
+ */
+export function retireObservedStaleDurableLock(lockPath, observed) {
+    const quarantine = `${lockPath}.stale.${durableLockOwnerDigest(observed)}`;
+    try {
+        renameSync(lockPath, quarantine);
+    }
+    catch (error) {
+        if (isErrno(error, "ENOENT")
+            || isErrno(error, "EEXIST")
+            || isErrno(error, "ENOTEMPTY")
+            || ((isErrno(error, "EPERM") || isErrno(error, "EACCES")) && existsSync(quarantine)))
+            return false;
+        throw error;
+    }
+    syncDirectory(dirname(lockPath));
+    const retiredOwner = readDurableLockOwner(join(quarantine, "owner.json"));
+    if (!durableLockOwnersEqual(retiredOwner, observed)) {
+        throw new LocalExecutionAuthorityError("corrupt_state", "execution authority lock ownership changed during stale takeover");
+    }
+    return true;
+}
+function staleDurableLock(owner, platform) {
+    if (platform === "win32" || owner === null)
+        return false;
+    if (!processIsAlive(owner.pid))
+        return true;
+    const actualBirthId = processBirthIdentity(owner.pid, platform);
+    return actualBirthId !== null && actualBirthId !== owner.process_birth_id;
+}
+function providerProcessId(record) {
+    if (record.provider === null)
+        return null;
+    return record.backend.kind === "windows_job"
+        ? isDurableWindowsProvider(record.provider) ? record.provider.root_pid : null
+        : isDurablePosixProvider(record.provider) ? record.provider.process_group_id : null;
+}
+function providerMatchesProcessId(record, processId) {
+    return providerProcessId(record) === processId;
+}
+function windowsVerbatimCommandLine(executable, args) {
+    if (executable.includes("\0") || executable.includes('"')) {
+        throw new LocalExecutionAuthorityError("unsupported", "Windows executable path cannot be represented verbatim");
+    }
+    const executableToken = /\s/.test(executable) ? `"${executable}"` : executable;
+    const value = [executableToken, ...args].join(" ");
+    if (value.length === 0 || value.length > 32_766 || value.includes("\0")) {
+        throw new LocalExecutionAuthorityError("unsupported", "Windows verbatim command line exceeds the platform limit");
+    }
+    return value;
+}
+function sleep(milliseconds) {
+    return new Promise((resolvePromise) => setTimeout(resolvePromise, milliseconds));
+}
+function rawCompletionToOutcome(raw) {
+    if (raw.cancelled) {
+        return {
+            kind: "cancelled",
+            exit_code: raw.status,
+            signal: raw.signal,
+            reason: raw.cancellation_reason,
+        };
+    }
+    if (raw.timed_out) {
+        return {
+            kind: "timeout",
+            exit_code: raw.status,
+            signal: raw.signal,
+            timeout_ms: raw.timeout_ms,
+        };
+    }
+    if (raw.error !== null) {
+        return {
+            kind: "launch_error",
+            exit_code: null,
+            signal: null,
+            error: raw.error.message,
+        };
+    }
+    if (raw.output_limit_exceeded || raw.process_limit_exceeded) {
+        return {
+            kind: "malformed_result",
+            exit_code: raw.status,
+            signal: null,
+            error: raw.output_limit_exceeded
+                ? "provider output limit exceeded"
+                : "provider process limit exceeded",
+        };
+    }
+    if (raw.signal !== null) {
+        return { kind: "signal", exit_code: null, signal: raw.signal };
+    }
+    if (raw.status === 0)
+        return { kind: "success", exit_code: 0, signal: null };
+    return { kind: "non_zero_exit", exit_code: raw.status ?? -1, signal: null };
+}
+function rawCompletionToResult(raw, stdout, stderr) {
+    return {
+        stdout,
+        stderr,
+        status: raw.status,
+        signal: raw.signal,
+        timedOut: raw.timed_out,
+        cancelled: raw.cancelled,
+        cancellationReason: raw.cancellation_reason,
+        processLimitExceeded: raw.process_limit_exceeded,
+        outputLimitExceeded: raw.output_limit_exceeded,
+        terminationReason: raw.termination_reason,
+        processId: raw.process_id,
+        processTreeDrained: raw.process_tree_drained,
+        ...(raw.error === null
+            ? {}
+            : {
+                error: Object.assign(new Error(raw.error.message), { code: raw.error.code }),
+            }),
+    };
+}
+export class LocalAttemptExecutionAuthority {
+    rootDirectory;
+    preparationsDirectory;
+    transitionsDirectory;
+    recordsDirectory;
+    socketsDirectory;
+    streamsDirectory;
+    controlNamespace;
+    authorityInstanceId;
+    controlTimeoutMs;
+    pollIntervalMs;
+    platform;
+    architecture;
+    windowsResolverOptions;
+    registrations = new Map();
+    constructor(options = {}) {
+        this.platform = options.platform ?? process.platform;
+        this.architecture = options.architecture ?? process.arch;
+        this.windowsResolverOptions = {
+            platform: this.platform,
+            architecture: this.architecture,
+            ...(options.helper_path === undefined ? {} : { helper_path: options.helper_path }),
+            ...(options.expected_digest === undefined ? {} : { expected_digest: options.expected_digest }),
+        };
+        this.controlTimeoutMs = requirePositiveInteger(options.control_timeout_ms ?? DEFAULT_CONTROL_TIMEOUT_MS, "control_timeout_ms");
+        this.pollIntervalMs = requirePositiveInteger(options.poll_interval_ms ?? DEFAULT_POLL_INTERVAL_MS, "poll_interval_ms");
+        if (options.root_directory === undefined || options.root_directory.length === 0) {
+            throw new LocalExecutionAuthorityError("invalid_configuration", "root_directory is required for durable local execution authority");
+        }
+        this.rootDirectory = resolve(options.root_directory);
+        this.preparationsDirectory = join(this.rootDirectory, "preparations");
+        this.transitionsDirectory = join(this.rootDirectory, "attempt-transitions");
+        this.recordsDirectory = join(this.rootDirectory, "records");
+        this.controlNamespace = createHash("sha256")
+            .update(this.rootDirectory, "utf8")
+            .digest("hex")
+            .slice(0, 24);
+        this.socketsDirectory = this.platform === "win32"
+            ? ""
+            : join("/tmp", `intentdna-exec-${process.getuid?.() ?? "user"}-${this.controlNamespace}`);
+        this.streamsDirectory = join(this.rootDirectory, "streams");
+        for (const directory of [
+            this.rootDirectory,
+            this.preparationsDirectory,
+            this.transitionsDirectory,
+            this.recordsDirectory,
+            this.streamsDirectory,
+            ...(this.platform === "win32" ? [] : [this.socketsDirectory]),
+        ])
+            ensureRealPrivateDirectory(directory);
+        this.ensureSupervisorScript();
+        this.authorityInstanceId = this.loadOrCreateMetadata(options.authority_instance_id).authority_instance_id;
+    }
+    get authority_instance_id() {
+        return this.authorityInstanceId;
+    }
+    resolveWindowsArtifact() {
+        let artifact;
+        try {
+            artifact = resolveWindowsJobKeeperArtifact(this.windowsResolverOptions);
+        }
+        catch (error) {
+            if (error instanceof WindowsJobKeeperArtifactError) {
+                throw new LocalExecutionAuthorityError("unsupported", error.message, { cause: error });
+            }
+            throw error;
+        }
+        if (artifact === null) {
+            throw new LocalExecutionAuthorityError("unsupported", "Windows Job keeper is unavailable");
+        }
+        return artifact;
+    }
+    ensureSupported() {
+        if (this.platform === "win32")
+            this.resolveWindowsArtifact();
+    }
+    assertExecutionSupported() {
+        this.ensureSupported();
+    }
+    supervisorScriptPath() {
+        const digestValue = this.platform === "win32"
+            ? LOCAL_WINDOWS_EXECUTION_SUPERVISOR_DIGEST
+            : LOCAL_EXECUTION_SUPERVISOR_DIGEST;
+        const version = digestValue.slice("sha256:".length);
+        return join(this.rootDirectory, `supervisor.${this.platform === "win32" ? "windows." : ""}${version}.cjs`);
+    }
+    ensureSupervisorScript() {
+        const path = this.supervisorScriptPath();
+        const expectedSource = this.platform === "win32"
+            ? LOCAL_WINDOWS_EXECUTION_SUPERVISOR_SOURCE
+            : LOCAL_EXECUTION_SUPERVISOR_SOURCE;
+        const expectedDigest = this.platform === "win32"
+            ? LOCAL_WINDOWS_EXECUTION_SUPERVISOR_DIGEST
+            : LOCAL_EXECUTION_SUPERVISOR_DIGEST;
+        const validateExisting = () => {
+            const metadata = lstatSync(path);
+            if (!metadata.isFile() || metadata.isSymbolicLink()) {
+                throw new LocalExecutionAuthorityError("corrupt_state", "execution supervisor is not a regular file");
+            }
+            const source = readFileSync(path, "utf8");
+            if (textDigest(source) !== expectedDigest) {
+                throw new LocalExecutionAuthorityError("corrupt_state", "execution supervisor digest changed");
+            }
+            chmodSync(path, SCRIPT_FILE_MODE);
+        };
+        if (existsSync(path)) {
+            validateExisting();
+            return;
+        }
+        let descriptor;
+        try {
+            descriptor = openSync(path, "wx", PRIVATE_FILE_MODE);
+        }
+        catch (error) {
+            if (!isErrno(error, "EEXIST"))
+                throw error;
+            validateExisting();
+            return;
+        }
+        try {
+            writeFileSync(descriptor, expectedSource, "utf8");
+            fsyncSync(descriptor);
+        }
+        finally {
+            closeSync(descriptor);
+        }
+        chmodSync(path, SCRIPT_FILE_MODE);
+        syncDirectory(this.rootDirectory);
+    }
+    loadOrCreateMetadata(requested) {
+        const path = join(this.rootDirectory, "authority.json");
+        const load = () => {
+            const value = readJson(path);
+            if (!isRecord(value)
+                || value.schema_version !== AUTHORITY_SCHEMA_VERSION
+                || typeof value.authority_instance_id !== "string"
+                || value.authority_instance_id.length === 0) {
+                throw new LocalExecutionAuthorityError("corrupt_state", "local authority metadata is invalid");
+            }
+            const metadata = value;
+            if (requested !== undefined && requested !== metadata.authority_instance_id) {
+                throw new LocalExecutionAuthorityError("identity_conflict", "configured authority_instance_id conflicts with the durable authority root");
+            }
+            return metadata;
+        };
+        if (existsSync(path)) {
+            return load();
+        }
+        const metadata = {
+            schema_version: AUTHORITY_SCHEMA_VERSION,
+            authority_instance_id: requested ?? `local-execution-authority:${randomUUID()}`,
+            created_at: new Date().toISOString(),
+        };
+        try {
+            const descriptor = openSync(path, "wx", PRIVATE_FILE_MODE);
+            try {
+                writeFileSync(descriptor, `${canonicalizeJson(metadata)}\n`, "utf8");
+                fsyncSync(descriptor);
+            }
+            finally {
+                closeSync(descriptor);
+            }
+            syncDirectory(this.rootDirectory);
+            return metadata;
+        }
+        catch (error) {
+            if (!isErrno(error, "EEXIST"))
+                throw error;
+            return load();
+        }
+    }
+    recordPath(identity) {
+        return join(this.recordsDirectory, `${executionRecordDigest(identity).slice("sha256:".length)}.json`);
+    }
+    hasOtherAttemptRecord(identity) {
+        const expectedPath = this.recordPath(identity);
+        return readdirSync(this.recordsDirectory, { withFileTypes: true }).some((entry) => {
+            if (!entry.isFile() || entry.isSymbolicLink() || !entry.name.endsWith(".json"))
+                return false;
+            const path = join(this.recordsDirectory, entry.name);
+            if (path === expectedPath)
+                return false;
+            const record = this.readRecord(path);
+            return record.identity.run_id === identity.run_id
+                && record.identity.step_id === identity.step_id
+                && record.identity.attempt_id === identity.attempt_id;
+        });
+    }
+    preparationPath(identity) {
+        return join(this.preparationsDirectory, `${attemptDigest(identity).slice("sha256:".length)}.json`);
+    }
+    transitionPath(identity) {
+        return join(this.transitionsDirectory, attemptDigest(identity).slice("sha256:".length));
+    }
+    controlEndpoint(identity) {
+        const token = attemptDigest(identity).slice("sha256:".length, "sha256:".length + 24);
+        if (this.platform === "win32") {
+            return `\\\\.\\pipe\\intentdna-exec-${this.controlNamespace}-${token}`;
+        }
+        const socketPath = join(this.socketsDirectory, `${token}.sock`);
+        if (Buffer.byteLength(socketPath, "utf8") > 100) {
+            throw new LocalExecutionAuthorityError("unsupported", "execution control socket path is too long");
+        }
+        return socketPath;
+    }
+    backend() {
+        if (this.platform !== "win32")
+            return { kind: "posix_process_group" };
+        const artifact = this.resolveWindowsArtifact();
+        return {
+            kind: "windows_job",
+            architecture: artifact.architecture,
+            helper_path: artifact.path,
+            helper_digest: artifact.digest,
+            helper_source_digest: artifact.source_digest,
+            helper_protocol_version: artifact.protocol_version,
+            containment_nonce: randomUUID().replaceAll("-", "") + randomUUID().replaceAll("-", ""),
+        };
+    }
+    supervisor(endpoint) {
+        return {
+            kind: this.platform === "win32" ? "windows" : "posix",
+            socket_path: endpoint,
+            script_digest: this.platform === "win32"
+                ? LOCAL_WINDOWS_EXECUTION_SUPERVISOR_DIGEST
+                : LOCAL_EXECUTION_SUPERVISOR_DIGEST,
+            pid: null,
+            ready_at: null,
+        };
+    }
+    resolveAbsoluteWindowsExecutable(command, environment, cwd) {
+        const direct = win32Path.isAbsolute(command)
+            ? command
+            : (command.includes("\\") || command.includes("/"))
+                ? win32Path.resolve(cwd, command)
+                : null;
+        if (direct !== null && existsSync(direct))
+            return resolve(direct);
+        const resolved = resolveProcessCommand(command, [], "win32", environment, cwd).command;
+        if (win32Path.isAbsolute(resolved) && existsSync(resolved))
+            return resolve(resolved);
+        throw new LocalExecutionAuthorityError("unsupported", `Windows provider executable could not be resolved to an absolute path: ${command}`);
+    }
+    readRecord(path) {
+        return parseRecord(readJson(path));
+    }
+    readPreparation(path) {
+        const value = readJson(path);
+        if (!isRecord(value) || !hasExactKeys(value, [
+            "schema_version",
+            "identity",
+            "preparation_digest",
+            "execution_instance_id",
+            "challenge",
+            "authority_instance_id",
+            "backend",
+            "supervisor",
+            "created_at",
+        ]) || value.schema_version !== PREPARATION_SCHEMA_VERSION || !isRecord(value.identity)) {
+            throw new LocalExecutionAuthorityError("corrupt_state", "local execution preparation has an invalid schema");
+        }
+        const preparation = value;
+        requirePreparationRequest(preparation.identity);
+        if (preparation.identity.execution_instance_id !== preparation.execution_instance_id
+            || preparation.preparation_digest !== preparationDigest(preparation.identity)
+            || typeof preparation.challenge !== "string"
+            || preparation.challenge.length < 32
+            || typeof preparation.authority_instance_id !== "string"
+            || preparation.authority_instance_id.length === 0
+            || !isDurableBackend(preparation.backend)
+            || !isDurableSupervisor(preparation.supervisor, preparation.backend)
+            || preparation.supervisor.pid !== null
+            || preparation.supervisor.ready_at !== null
+            || !isCanonicalTimestamp(preparation.created_at)) {
+            throw new LocalExecutionAuthorityError("corrupt_state", "local execution preparation failed validation");
+        }
+        return preparation;
+    }
+    readVerifiedStream(evidence, expectedPath, maxOutputBytes) {
+        const expected = resolve(expectedPath);
+        const actual = resolve(evidence.path);
+        const relativePath = relative(this.streamsDirectory, actual);
+        if (actual !== expected
+            || relativePath === ""
+            || relativePath === ".."
+            || relativePath.startsWith(`..${process.platform === "win32" ? "\\" : "/"}`)) {
+            throw new LocalExecutionAuthorityError("corrupt_state", "durable stream path escapes its execution identity");
+        }
+        const pathMetadata = lstatSync(actual, { bigint: true });
+        if (!pathMetadata.isFile() || pathMetadata.isSymbolicLink()) {
+            throw new LocalExecutionAuthorityError("corrupt_state", "durable stream is not a regular file");
+        }
+        const descriptor = openSync(actual, fsConstants.O_RDONLY | (fsConstants.O_NOFOLLOW ?? 0));
+        try {
+            const before = fstatSync(descriptor, { bigint: true });
+            if (!before.isFile()
+                || before.dev.toString() !== evidence.device
+                || before.ino.toString() !== evidence.inode
+                || before.birthtimeNs.toString() !== evidence.birthtime_ns
+                || before.size !== BigInt(evidence.byte_count)
+                || before.size > BigInt(maxOutputBytes)) {
+                throw new LocalExecutionAuthorityError("corrupt_state", "durable stream identity does not match its evidence");
+            }
+            const bytes = readFileSync(descriptor);
+            const after = fstatSync(descriptor, { bigint: true });
+            const currentPath = lstatSync(actual, { bigint: true });
+            if (bytes.byteLength !== evidence.byte_count
+                || after.dev !== before.dev
+                || after.ino !== before.ino
+                || after.birthtimeNs !== before.birthtimeNs
+                || after.size !== before.size
+                || currentPath.dev !== before.dev
+                || currentPath.ino !== before.ino
+                || currentPath.birthtimeNs !== before.birthtimeNs
+                || digestBytes(bytes) !== evidence.sha256) {
+                throw new LocalExecutionAuthorityError("corrupt_state", "durable stream changed after completion");
+            }
+            return bytes.toString("utf8");
+        }
+        finally {
+            closeSync(descriptor);
+        }
+    }
+    rawCompletionResult(record) {
+        const raw = record.raw_completion;
+        if (raw === null) {
+            throw new LocalExecutionAuthorityError("corrupt_state", "durable raw completion is missing");
+        }
+        const streamToken = record.identity_digest.slice("sha256:".length, "sha256:".length + 24);
+        const stdout = this.readVerifiedStream(raw.stdout, join(this.streamsDirectory, `${streamToken}.stdout`), raw.max_output_bytes);
+        const stderr = this.readVerifiedStream(raw.stderr, join(this.streamsDirectory, `${streamToken}.stderr`), raw.max_output_bytes);
+        return {
+            ...rawCompletionToResult(raw, stdout, stderr),
+            startedAt: record.identity.started_at,
+            completedAt: raw.completed_at,
+            stdoutDigest: raw.stdout.sha256,
+            stdoutBytes: raw.stdout.byte_count,
+            stderrDigest: raw.stderr.sha256,
+            stderrBytes: raw.stderr.byte_count,
+        };
+    }
+    windowsArtifactMatchesBackend(artifact, backend) {
+        return artifact.architecture === backend.architecture
+            && artifact.path === backend.helper_path
+            && artifact.digest === backend.helper_digest
+            && artifact.source_digest === backend.helper_source_digest
+            && artifact.protocol_version === backend.helper_protocol_version;
+    }
+    async markUnsupported(path, message) {
+        return this.updateRecord(path, (current) => {
+            if (current.phase === "unsupported"
+                || current.phase === "never_launched"
+                || current.raw_completion !== null)
+                return current;
+            return {
+                ...current,
+                phase: "unsupported",
+                supervisor_error: message,
+                revision: current.revision + 1,
+                updated_at: new Date().toISOString(),
+            };
+        });
+    }
+    async failWindowsAuthentication(path, message, cause) {
+        const updated = await this.markUnsupported(path, message);
+        if (updated.raw_completion !== null) {
+            throw new LocalExecutionAuthorityError("identity_conflict", "Windows execution identity changed while completion was committed", { cause });
+        }
+        throw new LocalExecutionAuthorityError("identity_conflict", message, { cause });
+    }
+    async ensureWindowsBackendTrusted(record, path) {
+        if (record.backend.kind !== "windows_job")
+            return;
+        try {
+            const artifact = this.resolveWindowsArtifact();
+            if (!this.windowsArtifactMatchesBackend(artifact, record.backend)) {
+                throw new LocalExecutionAuthorityError("unsupported", "Windows Job keeper trust identity does not match the durable execution record");
+            }
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            const updated = await this.markUnsupported(path, message);
+            if (updated.raw_completion !== null)
+                return;
+            throw error instanceof LocalExecutionAuthorityError
+                ? error
+                : new LocalExecutionAuthorityError("unsupported", message, { cause: error });
+        }
+    }
+    async authenticateWindowsSupervisor(initial, path) {
+        if (initial.backend.kind !== "windows_job" || initial.raw_completion !== null)
+            return initial;
+        await this.ensureWindowsBackendTrusted(initial, path);
+        let lastError = null;
+        for (let attempt = 0; attempt < 3; attempt += 1) {
+            const before = this.readRecord(path);
+            if (before.raw_completion !== null || before.phase === "unsupported")
+                return before;
+            if (before.phase !== "running" || before.supervisor.pid === null || before.supervisor.ready_at === null) {
+                lastError = new Error("Windows execution supervisor is not durably ready");
+                break;
+            }
+            try {
+                const response = await this.sendControl(before, { action: "probe" });
+                const after = this.readRecord(path);
+                if (after.raw_completion !== null || after.phase === "unsupported")
+                    return after;
+                if (after.revision !== before.revision)
+                    continue;
+                const identity = response.identity;
+                const expected = {
+                    record_revision: after.revision,
+                    execution_instance_id: after.execution_instance_id,
+                    supervisor_pid: after.supervisor.pid,
+                    supervisor_ready_at: after.supervisor.ready_at,
+                    containment_nonce: after.backend.kind === "windows_job"
+                        ? after.backend.containment_nonce
+                        : "",
+                    backend: after.backend,
+                    provider: after.provider,
+                };
+                if (!isRecord(identity)
+                    || !hasExactKeys(identity, Object.keys(expected))
+                    || canonicalizeJson(identity) !== canonicalizeJson(expected)) {
+                    throw new Error("Windows execution supervisor identity does not match durable containment evidence");
+                }
+                return after;
+            }
+            catch (error) {
+                lastError = error;
+                break;
+            }
+        }
+        const message = lastError instanceof Error
+            ? lastError.message
+            : "Windows execution supervisor identity could not be authenticated";
+        return this.failWindowsAuthentication(path, message, lastError);
+    }
+    readRecoveryRecord(request) {
+        const identity = recoveryIdentity(request);
+        const path = this.recordPath(identity);
+        if (!existsSync(path)) {
+            if (this.hasOtherAttemptRecord(identity)) {
+                throw new LocalExecutionAuthorityError("identity_conflict", "recovery identity does not match the original execution authority claim");
+            }
+            return null;
+        }
+        const record = this.readRecord(path);
+        if (canonicalizeJson(coreIdentity(record.identity)) !== canonicalizeJson(coreIdentity(identity))) {
+            throw new LocalExecutionAuthorityError("identity_conflict", "recovery identity does not match the original execution authority");
+        }
+        return record;
+    }
+    requireRequestRecord(request) {
+        const identity = requestIdentity(request);
+        const record = this.readRecord(this.recordPath(identity));
+        if (canonicalizeJson(coreIdentity(record.identity)) !== canonicalizeJson(coreIdentity(identity))) {
+            throw new LocalExecutionAuthorityError("identity_conflict", "execution authority identity does not match");
+        }
+        const requestedExecutionInstance = request.execution_instance_id;
+        if (requestedExecutionInstance !== undefined
+            && requestedExecutionInstance !== record.execution_instance_id) {
+            throw new LocalExecutionAuthorityError("identity_conflict", "execution instance identity does not match");
+        }
+        return record;
+    }
+    async withLock(targetPath, operation) {
+        const lockPath = `${targetPath}.lock`;
+        const ownerPath = join(lockPath, "owner.json");
+        const owner = durableLockOwner(this.platform);
+        const deadline = Date.now() + this.controlTimeoutMs;
+        for (;;) {
+            if (publishDurableLock(lockPath, owner))
+                break;
+            const observed = readDurableLockOwner(ownerPath);
+            if (staleDurableLock(observed, this.platform)
+                && observed !== null
+                && retireObservedStaleDurableLock(lockPath, observed)) {
+                continue;
+            }
+            if (Date.now() >= deadline) {
+                throw new LocalExecutionAuthorityError("unsupported", `execution authority lock is unavailable for ${targetPath}`);
+            }
+            await sleep(this.pollIntervalMs);
+        }
+        try {
+            return await operation();
+        }
+        finally {
+            releaseDurableLock(lockPath, owner);
+        }
+    }
+    withLockSync(targetPath, operation) {
+        const lockPath = `${targetPath}.lock`;
+        const ownerPath = join(lockPath, "owner.json");
+        const owner = durableLockOwner(this.platform);
+        const deadline = Date.now() + this.controlTimeoutMs;
+        for (;;) {
+            if (publishDurableLock(lockPath, owner))
+                break;
+            const observed = readDurableLockOwner(ownerPath);
+            if (staleDurableLock(observed, this.platform)
+                && observed !== null
+                && retireObservedStaleDurableLock(lockPath, observed)) {
+                continue;
+            }
+            if (Date.now() >= deadline) {
+                throw new LocalExecutionAuthorityError("unsupported", `execution authority lock is unavailable for ${targetPath}`);
+            }
+            Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, this.pollIntervalMs);
+        }
+        try {
+            return operation();
+        }
+        finally {
+            releaseDurableLock(lockPath, owner);
+        }
+    }
+    async updateRecord(path, operation) {
+        return this.withLock(path, () => {
+            const current = this.readRecord(path);
+            const next = operation(current);
+            if (next === current)
+                return current;
+            if (next.execution_instance_id !== current.execution_instance_id
+                || next.challenge !== current.challenge
+                || next.revision !== current.revision + 1) {
+                throw new LocalExecutionAuthorityError("identity_conflict", "invalid execution record transition");
+            }
+            atomicWriteJson(path, next);
+            return next;
+        });
+    }
+    nextFencingEpoch() {
+        const path = join(this.rootDirectory, "fencing.epoch");
+        return this.withLock(path, () => {
+            let current = 0;
+            if (existsSync(path)) {
+                const metadata = lstatSync(path);
+                if (!metadata.isFile() || metadata.isSymbolicLink()) {
+                    throw new LocalExecutionAuthorityError("corrupt_state", "fencing epoch is not a regular file");
+                }
+                current = Number(readFileSync(path, "utf8"));
+                if (!Number.isSafeInteger(current) || current < 0) {
+                    throw new LocalExecutionAuthorityError("corrupt_state", "fencing epoch is invalid");
+                }
+            }
+            const next = current + 1;
+            if (!Number.isSafeInteger(next)) {
+                throw new LocalExecutionAuthorityError("unsupported", "fencing epoch is exhausted");
+            }
+            const temporary = `${path}.tmp.${process.pid}.${randomUUID()}`;
+            const descriptor = openSync(temporary, "wx", PRIVATE_FILE_MODE);
+            try {
+                writeFileSync(descriptor, String(next), "utf8");
+                fsyncSync(descriptor);
+            }
+            finally {
+                closeSync(descriptor);
+            }
+            renameSync(temporary, path);
+            syncDirectory(this.rootDirectory);
+            return next;
+        });
+    }
+    nextFencingEpochSync() {
+        const path = join(this.rootDirectory, "fencing.epoch");
+        return this.withLockSync(path, () => {
+            let current = 0;
+            if (existsSync(path)) {
+                const metadata = lstatSync(path);
+                if (!metadata.isFile() || metadata.isSymbolicLink()) {
+                    throw new LocalExecutionAuthorityError("corrupt_state", "fencing epoch is not a regular file");
+                }
+                current = Number(readFileSync(path, "utf8"));
+                if (!Number.isSafeInteger(current) || current < 0) {
+                    throw new LocalExecutionAuthorityError("corrupt_state", "fencing epoch is invalid");
+                }
+            }
+            const next = current + 1;
+            if (!Number.isSafeInteger(next)) {
+                throw new LocalExecutionAuthorityError("unsupported", "fencing epoch is exhausted");
+            }
+            atomicWriteJson(path, next);
+            return next;
+        });
+    }
+    createLaunchBinding(record) {
+        if (record.phase !== "prepared") {
+            throw new LocalExecutionAuthorityError("identity_conflict", "execution is no longer prepared for launch");
+        }
+        const recordPath = this.recordPath(record.identity);
+        const existing = this.registrations.get(record.identity_digest);
+        if (existing !== undefined) {
+            return this.bindingForRegistration(existing);
+        }
+        let resolveProcessStarted;
+        let rejectProcessStarted;
+        const processStarted = new Promise((resolvePromise, rejectPromise) => {
+            resolveProcessStarted = resolvePromise;
+            rejectProcessStarted = rejectPromise;
+        });
+        const registration = {
+            identity: record.identity,
+            recordPath,
+            abortController: new AbortController(),
+            processStarted,
+            resolveProcessStarted,
+            rejectProcessStarted,
+        };
+        this.registrations.set(record.identity_digest, registration);
+        return this.bindingForRegistration(registration);
+    }
+    bindingForRegistration(registration) {
+        return {
+            cancellation_signal: registration.abortController.signal,
+            process_started: registration.processStarted,
+            processStarted: (processId) => {
+                if (!Number.isSafeInteger(processId) || processId <= 0) {
+                    const error = new LocalExecutionAuthorityError("corrupt_state", "execution process id is invalid");
+                    registration.rejectProcessStarted(error);
+                    throw error;
+                }
+                const current = this.readRecord(registration.recordPath);
+                if (!providerMatchesProcessId(current, processId)) {
+                    const error = new LocalExecutionAuthorityError("identity_conflict", "execution process does not match the durable supervisor record");
+                    registration.rejectProcessStarted(error);
+                    throw error;
+                }
+                registration.resolveProcessStarted(processId);
+            },
+            processTreeCompleted: (observation) => this.recordNormalizedCompletion(registration.recordPath, observation),
+            executeProcessTree: (command, args, processOptions) => this.executeSupervised(registration, command, args, processOptions),
+        };
+    }
+    prepareExecution(request) {
+        requirePreparationRequest(request);
+        this.ensureSupported();
+        const path = this.preparationPath(request);
+        return this.withLockSync(this.transitionPath(request), () => {
+            const recordPath = this.recordPath({
+                ...request,
+                claim_epoch: request.execution_claim_epoch,
+                started_at: "1970-01-01T00:00:00.000Z",
+            });
+            const boundRecord = existsSync(recordPath) ? this.readRecord(recordPath) : null;
+            if (existsSync(path)) {
+                const current = this.readPreparation(path);
+                const sameAttempt = current.identity.run_id === request.run_id
+                    && current.identity.step_id === request.step_id
+                    && current.identity.activation_id === request.activation_id
+                    && current.identity.attempt_id === request.attempt_id;
+                if (!sameAttempt || request.execution_claim_epoch < current.identity.execution_claim_epoch) {
+                    throw new LocalExecutionAuthorityError("identity_conflict", "execution attempt already has a different durable preparation");
+                }
+                if (request.execution_claim_epoch > current.identity.execution_claim_epoch) {
+                    if (boundRecord !== null) {
+                        throw new LocalExecutionAuthorityError("identity_conflict", "a bound execution preparation cannot be superseded");
+                    }
+                    unlinkSync(path);
+                }
+                else if (canonicalizeJson(preparationCoreIdentity(current.identity))
+                    !== canonicalizeJson(preparationCoreIdentity(request))) {
+                    throw new LocalExecutionAuthorityError("identity_conflict", "same-epoch preparation has a different worker identity");
+                }
+                else {
+                    if (request.execution_instance_id !== undefined
+                        && request.execution_instance_id !== current.execution_instance_id) {
+                        throw new LocalExecutionAuthorityError("identity_conflict", "execution instance conflicts with the durable preparation");
+                    }
+                    return preparedHandle(current);
+                }
+            }
+            if (boundRecord !== null) {
+                throw new LocalExecutionAuthorityError("identity_conflict", "execution attempt is already bound and cannot be prepared again");
+            }
+            const executionInstanceId = request.execution_instance_id ?? `local-process:${randomUUID()}`;
+            const fullIdentity = {
+                ...request,
+                execution_instance_id: executionInstanceId,
+            };
+            const preparation = {
+                schema_version: PREPARATION_SCHEMA_VERSION,
+                identity: fullIdentity,
+                preparation_digest: preparationDigest(fullIdentity),
+                execution_instance_id: executionInstanceId,
+                challenge: randomUUID().replaceAll("-", "") + randomUUID().replaceAll("-", ""),
+                authority_instance_id: this.authorityInstanceId,
+                backend: this.backend(),
+                supervisor: this.supervisor(this.controlEndpoint({
+                    ...request,
+                    claim_epoch: request.execution_claim_epoch,
+                    started_at: "1970-01-01T00:00:00.000Z",
+                })),
+                created_at: new Date().toISOString(),
+            };
+            atomicWriteJson(path, preparation);
+            return preparedHandle(preparation);
+        });
+    }
+    recoverPreparedExecution(request) {
+        requirePreparationRequest(request);
+        this.ensureSupported();
+        const path = this.preparationPath(request);
+        if (!existsSync(path))
+            return null;
+        const preparation = this.readPreparation(path);
+        if (canonicalizeJson(preparationCoreIdentity(preparation.identity))
+            !== canonicalizeJson(preparationCoreIdentity(request))) {
+            throw new LocalExecutionAuthorityError("identity_conflict", "prepared execution recovery identity does not match");
+        }
+        return preparedHandle(preparation);
+    }
+    recoverExecutionForPreparation(request) {
+        requirePreparationRequest(request);
+        this.ensureSupported();
+        const recordPath = this.recordPath({
+            ...request,
+            claim_epoch: request.execution_claim_epoch,
+            started_at: "1970-01-01T00:00:00.000Z",
+        });
+        if (!existsSync(recordPath))
+            return null;
+        const record = this.readRecord(recordPath);
+        const recordedPreparationIdentity = {
+            run_id: record.identity.run_id,
+            step_id: record.identity.step_id,
+            activation_id: record.identity.activation_id,
+            attempt_id: record.identity.attempt_id,
+            execution_claim_epoch: record.identity.claim_epoch,
+            worker_session_id: record.identity.worker_session_id,
+            execution_instance_id: record.identity.execution_instance_id,
+        };
+        if (canonicalizeJson(preparationCoreIdentity(recordedPreparationIdentity))
+            !== canonicalizeJson(preparationCoreIdentity(request))) {
+            throw new LocalExecutionAuthorityError("identity_conflict", "durable execution identity does not match the verifier preparation");
+        }
+        return this.recoverExecution({
+            run_id: record.identity.run_id,
+            step_id: record.identity.step_id,
+            activation_id: record.identity.activation_id,
+            attempt_id: record.identity.attempt_id,
+            execution_claim_epoch: record.identity.claim_epoch,
+            executor: { kind: "worker", worker_session_id: record.identity.worker_session_id },
+            started_at: record.identity.started_at,
+        });
+    }
+    listPreparedExecutions() {
+        const entries = readdirSync(this.preparationsDirectory, { withFileTypes: true })
+            .filter((entry) => !/^\..+\.json\.tmp\.\d+\.[0-9a-f-]+$/u.test(entry.name))
+            .sort((left, right) => left.name.localeCompare(right.name));
+        return entries.map((entry) => {
+            if (!entry.isFile() || entry.isSymbolicLink() || !entry.name.endsWith(".json")) {
+                throw new LocalExecutionAuthorityError("corrupt_state", "local execution preparations directory contains an unexpected entry");
+            }
+            const preparation = this.readPreparation(join(this.preparationsDirectory, entry.name));
+            return {
+                handle: preparedHandle(preparation),
+                created_at: preparation.created_at,
+            };
+        });
+    }
+    abandonPreparedExecution(handle) {
+        requirePreparationRequest(handle);
+        if (handle.schema_version !== PREPARATION_HANDLE_SCHEMA_VERSION
+            || handle.preparation_digest !== preparationDigest(handle)) {
+            throw new TypeError("local execution preparation handle is invalid");
+        }
+        const path = this.preparationPath(handle);
+        this.withLockSync(this.transitionPath(handle), () => {
+            const recordPath = this.recordPath({
+                ...handle,
+                claim_epoch: handle.execution_claim_epoch,
+                started_at: "1970-01-01T00:00:00.000Z",
+            });
+            if (!existsSync(path)) {
+                if (existsSync(recordPath)) {
+                    throw new LocalExecutionAuthorityError("identity_conflict", "bound execution preparation cannot be abandoned");
+                }
+                return;
+            }
+            const preparation = this.readPreparation(path);
+            if (canonicalizeJson(preparedHandle(preparation)) !== canonicalizeJson(handle)) {
+                throw new LocalExecutionAuthorityError("identity_conflict", "prepared execution handle does not match durable authority state");
+            }
+            if (existsSync(recordPath)) {
+                throw new LocalExecutionAuthorityError("identity_conflict", "bound execution preparation cannot be abandoned");
+            }
+            unlinkSync(path);
+            syncDirectory(this.preparationsDirectory);
+        });
+    }
+    bindExecution(handle, request) {
+        if (handle.schema_version !== PREPARATION_HANDLE_SCHEMA_VERSION
+            || !isCanonicalTimestamp(request.started_at)) {
+            throw new TypeError("local execution bind request is invalid");
+        }
+        const path = this.preparationPath(handle);
+        return this.withLockSync(this.transitionPath(handle), () => {
+            const identity = {
+                run_id: handle.run_id,
+                step_id: handle.step_id,
+                activation_id: handle.activation_id,
+                attempt_id: handle.attempt_id,
+                claim_epoch: handle.execution_claim_epoch,
+                worker_session_id: handle.worker_session_id,
+                started_at: request.started_at,
+                execution_instance_id: handle.execution_instance_id,
+            };
+            const recordPath = this.recordPath(identity);
+            if (existsSync(recordPath)) {
+                const current = this.readRecord(recordPath);
+                if (canonicalizeJson(coreIdentity(current.identity)) !== canonicalizeJson(coreIdentity(identity))
+                    || current.execution_instance_id !== handle.execution_instance_id) {
+                    throw new LocalExecutionAuthorityError("identity_conflict", "bound execution record conflicts with the prepared handle");
+                }
+                if (existsSync(path)) {
+                    const lingering = this.readPreparation(path);
+                    if (canonicalizeJson(preparedHandle(lingering)) !== canonicalizeJson(handle)) {
+                        throw new LocalExecutionAuthorityError("identity_conflict", "lingering preparation conflicts with the bound execution record");
+                    }
+                    unlinkSync(path);
+                    syncDirectory(this.preparationsDirectory);
+                }
+                return this.createLaunchBinding(current);
+            }
+            const preparation = this.readPreparation(path);
+            if (canonicalizeJson(preparedHandle(preparation)) !== canonicalizeJson(handle)) {
+                throw new LocalExecutionAuthorityError("identity_conflict", "prepared execution handle does not match durable authority state");
+            }
+            const binding = this.registerExecution(identity, preparation);
+            unlinkSync(path);
+            syncDirectory(this.preparationsDirectory);
+            return binding;
+        });
+    }
+    registerExecution(identity, prepared) {
+        requireIdentity(identity);
+        this.ensureSupported();
+        if (prepared === undefined && this.hasOtherAttemptRecord(identity)) {
+            throw new LocalExecutionAuthorityError("identity_conflict", "execution attempt already has durable authority under a different claim");
+        }
+        if (prepared === undefined) {
+            const replay = () => {
+                const recordPath = this.recordPath(identity);
+                if (!existsSync(recordPath))
+                    return null;
+                const current = this.readRecord(recordPath);
+                if (canonicalizeJson(coreIdentity(current.identity)) !== canonicalizeJson(coreIdentity(identity))
+                    || (identity.execution_instance_id !== undefined
+                        && current.execution_instance_id !== identity.execution_instance_id)) {
+                    throw new LocalExecutionAuthorityError("identity_conflict", "execution attempt already has a different durable identity");
+                }
+                if (current.phase === "prepared")
+                    return this.createLaunchBinding(current);
+                if (current.phase === "never_launched") {
+                    throw new LocalExecutionAuthorityError("identity_conflict", "execution was durably attested as never launched");
+                }
+                if (current.phase === "unsupported") {
+                    throw new LocalExecutionAuthorityError("unsupported", current.supervisor_error ?? "execution supervisor evidence is unavailable");
+                }
+                return this.recoverExecution({
+                    run_id: identity.run_id,
+                    step_id: identity.step_id,
+                    activation_id: identity.activation_id,
+                    attempt_id: identity.attempt_id,
+                    execution_claim_epoch: identity.claim_epoch,
+                    executor: { kind: "worker", worker_session_id: identity.worker_session_id },
+                    started_at: identity.started_at,
+                }).binding;
+            };
+            const existing = replay();
+            if (existing !== null)
+                return existing;
+            try {
+                const handle = this.prepareExecution({
+                    run_id: identity.run_id,
+                    step_id: identity.step_id,
+                    activation_id: identity.activation_id,
+                    attempt_id: identity.attempt_id,
+                    execution_claim_epoch: identity.claim_epoch,
+                    worker_session_id: identity.worker_session_id,
+                    ...(identity.execution_instance_id === undefined
+                        ? {}
+                        : { execution_instance_id: identity.execution_instance_id }),
+                });
+                return this.bindExecution(handle, { started_at: identity.started_at });
+            }
+            catch (error) {
+                if (error instanceof LocalExecutionAuthorityError && error.code === "identity_conflict") {
+                    const raced = replay();
+                    if (raced !== null)
+                        return raced;
+                }
+                throw error;
+            }
+        }
+        const backend = prepared?.backend ?? this.backend();
+        const executionInstanceId = identity.execution_instance_id ?? `local-process:${randomUUID()}`;
+        const requiredIdentity = {
+            ...identity,
+            execution_instance_id: executionInstanceId,
+        };
+        const recordPath = this.recordPath(identity);
+        const controlEndpoint = this.controlEndpoint(identity);
+        const now = new Date().toISOString();
+        const record = {
+            schema_version: RECORD_SCHEMA_VERSION,
+            revision: 1,
+            phase: "prepared",
+            identity: requiredIdentity,
+            identity_digest: identityDigest(identity),
+            execution_instance_id: executionInstanceId,
+            challenge: prepared?.challenge
+                ?? randomUUID().replaceAll("-", "") + randomUUID().replaceAll("-", ""),
+            authority_instance_id: prepared?.authority_instance_id ?? this.authorityInstanceId,
+            backend,
+            supervisor: prepared?.supervisor ?? this.supervisor(controlEndpoint),
+            provider: null,
+            raw_completion: null,
+            normalized_process_outcome: null,
+            stop_fact: null,
+            stop_receipt: null,
+            already_stopped_evidence: null,
+            nonlaunch_attestation: null,
+            fencing_epoch: null,
+            supervisor_error: null,
+            created_at: now,
+            updated_at: now,
+        };
+        this.withLockSync(recordPath, () => {
+            if (existsSync(recordPath)) {
+                throw new LocalExecutionAuthorityError("identity_conflict", "execution identity is already registered");
+            }
+            const descriptor = openSync(recordPath, "wx", PRIVATE_FILE_MODE);
+            try {
+                writeFileSync(descriptor, `${canonicalizeJson(record)}\n`, "utf8");
+                fsyncSync(descriptor);
+            }
+            finally {
+                closeSync(descriptor);
+            }
+            syncDirectory(this.recordsDirectory);
+        });
+        return this.createLaunchBinding(record);
+    }
+    async probeRecovery(request) {
+        requireIdentity(recoveryIdentity(request));
+        let record = this.readRecoveryRecord(request);
+        if (record !== null
+            && record.backend.kind === "windows_job"
+            && record.raw_completion === null
+            && record.phase !== "never_launched"
+            && record.phase !== "unsupported") {
+            record = await this.authenticateWindowsSupervisor(record, this.recordPath(record.identity));
+        }
+        return { raw_completion_durable: record?.raw_completion !== null && record?.raw_completion !== undefined };
+    }
+    async attestNeverLaunched(request) {
+        const identity = recoveryIdentity(request);
+        requireIdentity(identity);
+        if (!isCanonicalDigest(request.failure_idempotency_key)) {
+            throw new TypeError("failure_idempotency_key must be a canonical SHA-256 digest");
+        }
+        if (!isCanonicalTimestamp(request.requested_at)) {
+            throw new TypeError("requested_at must be a canonical RFC 3339 timestamp");
+        }
+        const path = this.recordPath(identity);
+        const preparationPath = this.preparationPath(identity);
+        return this.withLockSync(this.transitionPath(identity), () => {
+            let current = null;
+            let preparation = null;
+            if (existsSync(preparationPath)) {
+                preparation = this.readPreparation(preparationPath);
+                if (canonicalizeJson(preparationCoreIdentity(preparation.identity))
+                    !== canonicalizeJson({
+                        run_id: identity.run_id,
+                        step_id: identity.step_id,
+                        activation_id: identity.activation_id,
+                        attempt_id: identity.attempt_id,
+                        execution_claim_epoch: identity.claim_epoch,
+                        worker_session_id: identity.worker_session_id,
+                    })) {
+                    throw new LocalExecutionAuthorityError("identity_conflict", "nonlaunch identity does not match the durable preparation");
+                }
+            }
+            if (existsSync(path)) {
+                current = this.readRecord(path);
+                if (canonicalizeJson(coreIdentity(current.identity)) !== canonicalizeJson(coreIdentity(identity))) {
+                    throw new LocalExecutionAuthorityError("identity_conflict", "nonlaunch identity does not match durable authority state");
+                }
+                if (current.phase === "never_launched") {
+                    const attestation = current.nonlaunch_attestation;
+                    if (attestation.payload.failure_idempotency_key !== request.failure_idempotency_key) {
+                        throw new LocalExecutionAuthorityError("identity_conflict", "execution already has a different nonlaunch failure");
+                    }
+                    if (preparation !== null) {
+                        if (preparation.execution_instance_id !== current.execution_instance_id) {
+                            throw new LocalExecutionAuthorityError("corrupt_state", "never-launched record conflicts with its lingering preparation");
+                        }
+                        unlinkSync(preparationPath);
+                        syncDirectory(this.preparationsDirectory);
+                    }
+                    return attestation;
+                }
+                if (current.phase !== "prepared" || current.supervisor.pid !== null || current.provider !== null) {
+                    throw new LocalExecutionAuthorityError("identity_conflict", "execution launch ownership has already begun");
+                }
+            }
+            if (current === null && preparation === null) {
+                if (this.hasOtherAttemptRecord(identity)) {
+                    throw new LocalExecutionAuthorityError("identity_conflict", "execution attempt already has durable authority under a different claim");
+                }
+                throw new LocalExecutionAuthorityError("unsupported", "never-launched state cannot be attested without durable preparation evidence");
+            }
+            const fencingEpoch = this.nextFencingEpochSync();
+            const now = new Date().toISOString();
+            const executionInstanceId = current?.execution_instance_id
+                ?? preparation?.execution_instance_id
+                ?? `local-process:${randomUUID()}`;
+            const authorityInstanceId = current?.authority_instance_id
+                ?? preparation?.authority_instance_id
+                ?? this.authorityInstanceId;
+            const requiredIdentity = {
+                ...identity,
+                execution_instance_id: executionInstanceId,
+            };
+            const backend = current?.backend ?? preparation?.backend ?? this.backend();
+            const controlEndpoint = this.controlEndpoint(identity);
+            const tombstone = current === null ? {
+                schema_version: RECORD_SCHEMA_VERSION,
+                revision: 1,
+                phase: "never_launched",
+                identity: requiredIdentity,
+                identity_digest: identityDigest(identity),
+                execution_instance_id: executionInstanceId,
+                challenge: preparation?.challenge
+                    ?? randomUUID().replaceAll("-", "") + randomUUID().replaceAll("-", ""),
+                authority_instance_id: authorityInstanceId,
+                backend,
+                supervisor: preparation?.supervisor ?? this.supervisor(controlEndpoint),
+                provider: null,
+                raw_completion: null,
+                normalized_process_outcome: null,
+                stop_fact: null,
+                stop_receipt: null,
+                already_stopped_evidence: null,
+                nonlaunch_attestation: null,
+                fencing_epoch: fencingEpoch,
+                supervisor_error: null,
+                created_at: now,
+                updated_at: now,
+            } : {
+                ...current,
+                phase: "never_launched",
+                nonlaunch_attestation: null,
+                fencing_epoch: fencingEpoch,
+                revision: current.revision + 1,
+                updated_at: now,
+            };
+            const payload = {
+                schema_version: "intentdna.worker_nonlaunch_attestation.v1",
+                run_id: identity.run_id,
+                step_id: identity.step_id,
+                activation_id: identity.activation_id,
+                attempt_id: identity.attempt_id,
+                claim_epoch: identity.claim_epoch,
+                worker_session_id: identity.worker_session_id,
+                execution_instance_id: executionInstanceId,
+                authority_kind: "local_process",
+                authority_instance_id: authorityInstanceId,
+                fencing_epoch: fencingEpoch,
+                started_at: identity.started_at,
+                attested_at: now,
+                failure_idempotency_key: request.failure_idempotency_key,
+                launch_state: "never_launched",
+                source_evidence_digest: nonlaunchSourceEvidenceDigest(tombstone),
+            };
+            const attestation = JSON.parse(canonicalizeJson({
+                attestation_digest: workerNonlaunchAttestationDigest(payload),
+                payload,
+            }));
+            const next = { ...tombstone, nonlaunch_attestation: attestation };
+            atomicWriteJson(path, next);
+            if (preparation !== null) {
+                unlinkSync(preparationPath);
+                syncDirectory(this.preparationsDirectory);
+            }
+            return attestation;
+        });
+    }
+    recoverExecution(request) {
+        const identity = recoveryIdentity(request);
+        requireIdentity(identity);
+        this.ensureSupported();
+        const record = this.readRecoveryRecord(request);
+        if (record === null) {
+            throw new LocalExecutionAuthorityError("unsupported", "durable execution authority record is unavailable");
+        }
+        if (record.phase === "prepared") {
+            return { kind: "launch", binding: this.createLaunchBinding(record) };
+        }
+        if (record.phase === "never_launched") {
+            throw new LocalExecutionAuthorityError("identity_conflict", "execution was durably attested as never launched");
+        }
+        if (record.phase === "unsupported") {
+            throw new LocalExecutionAuthorityError("unsupported", record.supervisor_error ?? "execution supervisor evidence is unavailable");
+        }
+        const recordPath = this.recordPath(identity);
+        const authentication = record.backend.kind === "windows_job" && record.raw_completion === null
+            ? this.authenticateWindowsSupervisor(record, recordPath)
+            : Promise.resolve(record);
+        const processStarted = (async () => {
+            await authentication;
+            for (;;) {
+                const current = this.readRecord(recordPath);
+                if (current.provider?.pid !== null && current.provider !== null)
+                    return current.provider.pid;
+                if (current.raw_completion !== null) {
+                    if (current.raw_completion.process_id !== null)
+                        return current.raw_completion.process_id;
+                    throw new LocalExecutionAuthorityError("unsupported", "durable execution completed without a provider identity");
+                }
+                if (current.phase === "unsupported") {
+                    throw new LocalExecutionAuthorityError("unsupported", current.supervisor_error ?? "execution supervisor evidence is unavailable");
+                }
+                await sleep(this.pollIntervalMs);
+            }
+        })();
+        const registration = {
+            identity: record.identity,
+            recordPath,
+            abortController: new AbortController(),
+            processStarted,
+            resolveProcessStarted: () => undefined,
+            rejectProcessStarted: () => undefined,
+        };
+        registration.processStarted.catch(() => undefined);
+        return { kind: "observe", binding: {
+                cancellation_signal: registration.abortController.signal,
+                process_started: registration.processStarted,
+                processStarted: (processId) => {
+                    const current = this.readRecord(registration.recordPath);
+                    if (!providerMatchesProcessId(current, processId)) {
+                        throw new LocalExecutionAuthorityError("identity_conflict", "recovered execution process does not match durable guardian identity");
+                    }
+                },
+                processTreeCompleted: (observation) => this.recordNormalizedCompletion(registration.recordPath, observation),
+                executeProcessTree: (_command, _args, options) => this.observeRecoveredExecution(registration, options),
+            } };
+    }
+    async executeSupervised(registration, command, args, options) {
+        if (options.spawnImpl !== undefined || options.platform !== undefined) {
+            throw new LocalExecutionAuthorityError("unsupported", "custom process launch adapters are unsupported");
+        }
+        if (options.maxProcessCount !== undefined) {
+            throw new LocalExecutionAuthorityError("unsupported", "durable supervisor process limits are not implemented");
+        }
+        if (options.killSignal === "SIGKILL" || options.killSignal === "SIGSTOP") {
+            throw new LocalExecutionAuthorityError("unsupported", `durable supervisor cannot preserve guardian identity with ${options.killSignal}`);
+        }
+        const record = await this.withLock(this.transitionPath(registration.identity), () => this.updateRecord(registration.recordPath, (current) => {
+            if (current.phase !== "prepared") {
+                throw new LocalExecutionAuthorityError("identity_conflict", "another execution binding already owns provider launch");
+            }
+            return {
+                ...current,
+                phase: "launching",
+                revision: current.revision + 1,
+                updated_at: new Date().toISOString(),
+            };
+        }));
+        const streamToken = record.identity_digest.slice("sha256:".length, "sha256:".length + 24);
+        const stdoutPath = join(this.streamsDirectory, `${streamToken}.stdout`);
+        const stderrPath = join(this.streamsDirectory, `${streamToken}.stderr`);
+        const gatePath = join(this.streamsDirectory, `${streamToken}.gate`);
+        const stdinPath = join(this.streamsDirectory, `${streamToken}.stdin`);
+        for (const path of [stdoutPath, stderrPath, gatePath, stdinPath]) {
+            try {
+                unlinkSync(path);
+            }
+            catch (error) {
+                if (!isErrno(error, "ENOENT"))
+                    throw error;
+            }
+        }
+        const environment = Object.fromEntries(Object.entries(options.env ?? process.env)
+            .filter((entry) => entry[1] !== undefined));
+        const cwd = resolve(options.cwd ?? process.cwd());
+        const timeoutMs = options.timeoutMs !== undefined
+            && Number.isFinite(options.timeoutMs)
+            && options.timeoutMs > 0
+            ? Math.floor(options.timeoutMs)
+            : null;
+        const maxOutputBytes = options.maxOutputBytes === undefined
+            ? DEFAULT_MAX_OUTPUT_BYTES
+            : requirePositiveInteger(Math.floor(options.maxOutputBytes), "maxOutputBytes");
+        const naturalDrainGraceMs = options.sigkillGraceMs !== undefined
+            && Number.isFinite(options.sigkillGraceMs)
+            && options.sigkillGraceMs >= 0
+            ? Math.floor(options.sigkillGraceMs)
+            : 1_000;
+        const forcedDrainGraceMs = options.cancellationGraceMs !== undefined
+            && Number.isFinite(options.cancellationGraceMs)
+            && options.cancellationGraceMs >= 0
+            ? Math.floor(options.cancellationGraceMs)
+            : 1_000;
+        let configuration;
+        if (record.backend.kind === "windows_job") {
+            const spec = resolveProcessCommand(command, args, "win32", environment, cwd);
+            const executable = this.resolveAbsoluteWindowsExecutable(spec.command, environment, cwd);
+            configuration = {
+                execution_instance_id: record.execution_instance_id,
+                challenge: record.challenge,
+                containment_nonce: record.backend.containment_nonce,
+                control_endpoint: record.supervisor.socket_path,
+                helper_path: record.backend.helper_path,
+                helper_digest: record.backend.helper_digest,
+                executable,
+                args: [...spec.args],
+                command_line: spec.windowsVerbatimArguments
+                    ? windowsVerbatimCommandLine(executable, spec.args)
+                    : null,
+                cwd,
+                env: environment,
+                stdin_path: options.stdin === undefined ? null : stdinPath,
+                stdin: options.stdin ?? "",
+                stdout_path: stdoutPath,
+                stderr_path: stderrPath,
+                max_output_bytes: maxOutputBytes,
+                timeout_ms: timeoutMs,
+                natural_drain_grace_ms: naturalDrainGraceMs,
+                forced_drain_grace_ms: forcedDrainGraceMs,
+            };
+        }
+        else {
+            configuration = {
+                execution_instance_id: record.execution_instance_id,
+                challenge: record.challenge,
+                socket_path: record.supervisor.socket_path,
+                stdout_path: stdoutPath,
+                stderr_path: stderrPath,
+                max_output_bytes: maxOutputBytes,
+                gate_path: gatePath,
+                command,
+                args: [...args],
+                cwd,
+                env: environment,
+                stdin: options.stdin ?? null,
+                timeout_ms: timeoutMs,
+                kill_signal: options.killSignal ?? "SIGTERM",
+                cancellation_grace_ms: options.cancellationGraceMs ?? 1_000,
+                timeout_grace_ms: options.sigkillGraceMs ?? 1_000,
+                windows_verbatim_arguments: false,
+                auto_release_gate: true,
+            };
+        }
+        const child = spawn(process.execPath, [this.supervisorScriptPath(), registration.recordPath], {
+            detached: true,
+            stdio: ["pipe", "ignore", "ignore"],
+            windowsHide: true,
+        });
+        child.unref();
+        child.stdin?.end(JSON.stringify(configuration));
+        let supervisorExit = null;
+        child.once("exit", (status, signal) => { supervisorExit = { status, signal }; });
+        let processObserved = false;
+        let cancellationSent = false;
+        const cancellationSignal = options.cancellationSignal;
+        const cancel = async () => {
+            if (cancellationSent)
+                return;
+            let current = this.readRecord(registration.recordPath);
+            if (current.raw_completion !== null)
+                return;
+            if (current.supervisor.ready_at === null)
+                return;
+            if (current.backend.kind === "windows_job") {
+                current = await this.authenticateWindowsSupervisor(current, registration.recordPath);
+                if (current.raw_completion !== null)
+                    return;
+            }
+            await this.sendControl(current, {
+                action: "stop",
+                reason: typeof cancellationSignal?.reason === "string"
+                    ? cancellationSignal.reason
+                    : options.cancellationReason ?? null,
+            });
+            cancellationSent = true;
+        };
+        const onAbort = () => { void cancel().catch(() => undefined); };
+        cancellationSignal?.addEventListener("abort", onAbort, { once: true });
+        if (cancellationSignal?.aborted)
+            onAbort();
+        try {
+            const deadline = timeoutMs === null
+                ? Number.POSITIVE_INFINITY
+                : Date.now()
+                    + Math.max(this.controlTimeoutMs, timeoutMs)
+                    + Math.max(forcedDrainGraceMs, naturalDrainGraceMs)
+                    + 5_000;
+            for (;;) {
+                const current = this.readRecord(registration.recordPath);
+                if (cancellationSignal?.aborted && !cancellationSent && current.supervisor.ready_at !== null) {
+                    await cancel();
+                    continue;
+                }
+                if (!processObserved && current.provider?.pid !== null && current.provider?.pid !== undefined) {
+                    processObserved = true;
+                    options.onProcessStart?.(current.provider.pid);
+                }
+                if (current.phase === "unsupported") {
+                    throw new LocalExecutionAuthorityError("unsupported", current.supervisor_error ?? "execution supervisor failed without trusted evidence");
+                }
+                if (["raw_completed", "normalized_completed", "receipted"].includes(current.phase)) {
+                    if (current.raw_completion === null) {
+                        throw new LocalExecutionAuthorityError("corrupt_state", "supervisor completed without raw evidence");
+                    }
+                    const result = this.rawCompletionResult(current);
+                    if (result.stdout !== "")
+                        options.onStdout?.(result.stdout);
+                    if (result.stderr !== "")
+                        options.onStderr?.(result.stderr);
+                    if (result.terminationReason !== null)
+                        options.onTerminationRequested?.(result.terminationReason);
+                    return result;
+                }
+                const supervisorPid = current.supervisor.pid ?? child.pid ?? null;
+                if (record.backend.kind === "windows_job" && supervisorExit !== null) {
+                    const detail = supervisorExit;
+                    const message = `Windows execution supervisor exited before trusted completion (status ${String(detail.status)}, signal ${String(detail.signal)})`;
+                    await this.markUnsupported(registration.recordPath, message);
+                    throw new LocalExecutionAuthorityError("unsupported", message);
+                }
+                if (record.backend.kind !== "windows_job" && supervisorPid !== null && !processIsAlive(supervisorPid)) {
+                    throw new LocalExecutionAuthorityError("unsupported", "execution supervisor exited before publishing trusted completion evidence");
+                }
+                if (Date.now() >= deadline) {
+                    throw new LocalExecutionAuthorityError("unsupported", "execution supervisor did not publish completion before the authority deadline");
+                }
+                await sleep(this.pollIntervalMs);
+            }
+        }
+        finally {
+            cancellationSignal?.removeEventListener("abort", onAbort);
+        }
+    }
+    async observeRecoveredExecution(registration, options) {
+        const initial = this.readRecord(registration.recordPath);
+        if (initial.backend.kind === "windows_job" && initial.raw_completion === null) {
+            await this.authenticateWindowsSupervisor(initial, registration.recordPath);
+        }
+        let cancellationSent = false;
+        const cancel = async () => {
+            if (cancellationSent)
+                return;
+            const current = this.readRecord(registration.recordPath);
+            if (current.raw_completion !== null)
+                return;
+            const authenticated = current.backend.kind === "windows_job"
+                ? await this.authenticateWindowsSupervisor(current, registration.recordPath)
+                : current;
+            if (authenticated.raw_completion !== null)
+                return;
+            await this.sendControl(authenticated, {
+                action: "stop",
+                reason: typeof options.cancellationSignal?.reason === "string"
+                    ? options.cancellationSignal.reason
+                    : options.cancellationReason ?? null,
+            });
+            cancellationSent = true;
+        };
+        const onAbort = () => { void cancel().catch(() => undefined); };
+        options.cancellationSignal?.addEventListener("abort", onAbort, { once: true });
+        if (options.cancellationSignal?.aborted)
+            onAbort();
+        let processObserved = false;
+        let nextWindowsProbeAt = 0;
+        try {
+            for (;;) {
+                const current = this.readRecord(registration.recordPath);
+                if (current.phase === "unsupported") {
+                    throw new LocalExecutionAuthorityError("unsupported", current.supervisor_error ?? "recovered execution supervisor failed");
+                }
+                if (current.raw_completion !== null) {
+                    const result = this.rawCompletionResult(current);
+                    if (result.stdout !== "")
+                        options.onStdout?.(result.stdout);
+                    if (result.stderr !== "")
+                        options.onStderr?.(result.stderr);
+                    if (result.terminationReason !== null)
+                        options.onTerminationRequested?.(result.terminationReason);
+                    return result;
+                }
+                if (!processObserved && current.provider?.pid !== null && current.provider !== null) {
+                    processObserved = true;
+                    options.onProcessStart?.(current.provider.pid);
+                }
+                if (current.backend.kind === "windows_job" && Date.now() >= nextWindowsProbeAt) {
+                    await this.authenticateWindowsSupervisor(current, registration.recordPath);
+                    nextWindowsProbeAt = Date.now() + 250;
+                }
+                if (current.backend.kind !== "windows_job"
+                    && (current.supervisor.pid === null || !processIsAlive(current.supervisor.pid))) {
+                    throw new LocalExecutionAuthorityError("unsupported", "recovered execution supervisor exited without durable completion");
+                }
+                await sleep(this.pollIntervalMs);
+            }
+        }
+        finally {
+            options.cancellationSignal?.removeEventListener("abort", onAbort);
+        }
+    }
+    async recordNormalizedCompletion(path, observation) {
+        await this.updateRecord(path, (current) => {
+            const matchesDurableEvidence = current.raw_completion !== null
+                && observation.process_tree_drained
+                && current.raw_completion.process_tree_drained
+                && observation.started_at === current.identity.started_at
+                && observation.completed_at >= current.raw_completion.completed_at
+                && observation.process_id === current.raw_completion.process_id;
+            if (current.phase === "receipted") {
+                if (!matchesDurableEvidence
+                    || (current.normalized_process_outcome !== null
+                        && canonicalizeJson(current.normalized_process_outcome) !== canonicalizeJson(observation.outcome))) {
+                    throw new LocalExecutionAuthorityError("identity_conflict", "execution completion conflicts with the durable receipt");
+                }
+                return current;
+            }
+            if (current.phase === "normalized_completed" && current.normalized_process_outcome !== null) {
+                if (!matchesDurableEvidence
+                    || canonicalizeJson(current.normalized_process_outcome) !== canonicalizeJson(observation.outcome)) {
+                    throw new LocalExecutionAuthorityError("identity_conflict", "execution completion was already normalized differently");
+                }
+                return current;
+            }
+            if (current.phase !== "raw_completed" || current.raw_completion === null) {
+                throw new LocalExecutionAuthorityError("unsupported", "raw supervisor completion is unavailable");
+            }
+            if (!matchesDurableEvidence) {
+                throw new LocalExecutionAuthorityError("identity_conflict", "normalized completion does not match durable supervisor evidence");
+            }
+            return {
+                ...current,
+                phase: "normalized_completed",
+                normalized_process_outcome: observation.outcome,
+                revision: current.revision + 1,
+                updated_at: new Date().toISOString(),
+            };
+        });
+    }
+    sendControl(record, request) {
+        const socketPath = record.supervisor.socket_path;
+        if (record.backend.kind !== "windows_job") {
+            let metadata;
+            try {
+                metadata = lstatSync(socketPath);
+            }
+            catch (error) {
+                throw new LocalExecutionAuthorityError("unsupported", "execution supervisor control socket is unavailable", { cause: error });
+            }
+            if (!metadata.isSocket() || metadata.isSymbolicLink() || (metadata.mode & 0o077) !== 0) {
+                throw new LocalExecutionAuthorityError("unsupported", "execution supervisor control socket is not trusted");
+            }
+        }
+        return new Promise((resolvePromise, rejectPromise) => {
+            const socket = connect(socketPath);
+            const framedControl = record.backend.kind === "windows_job";
+            let response = "";
+            const timer = setTimeout(() => {
+                socket.destroy();
+                rejectPromise(new LocalExecutionAuthorityError("unsupported", "execution supervisor control timed out"));
+            }, this.controlTimeoutMs);
+            timer.unref?.();
+            const fail = (error) => {
+                clearTimeout(timer);
+                rejectPromise(new LocalExecutionAuthorityError("unsupported", "execution supervisor control failed", { cause: error }));
+            };
+            socket.once("error", fail);
+            socket.setEncoding("utf8");
+            socket.on("data", (chunk) => {
+                response += chunk;
+                if (Buffer.byteLength(response, "utf8") > MAX_CONTROL_RESPONSE_BYTES) {
+                    socket.destroy(new Error("execution control response too large"));
+                }
+            });
+            socket.once("end", () => {
+                clearTimeout(timer);
+                try {
+                    if (response.trim().length === 0) {
+                        try {
+                            const durable = this.readRecord(this.recordPath(record.identity));
+                            const matchesStop = durable.raw_completion !== null
+                                && (request.stop_idempotency_key === undefined
+                                    || (durable.stop_fact?.kind === "canonical_stop"
+                                        && durable.stop_fact.stop_idempotency_key === request.stop_idempotency_key
+                                        && canonicalizeJson(durable.stop_fact.requested_outcome)
+                                            === canonicalizeJson(request.requested_outcome)));
+                            if (matchesStop) {
+                                resolvePromise({ ok: true, raw_completion: durable.raw_completion });
+                                return;
+                            }
+                        }
+                        catch {
+                            // The control response remains authoritative unless durable completion proves the stop.
+                        }
+                        throw new LocalExecutionAuthorityError("unsupported", "execution supervisor control response was empty");
+                    }
+                    let responseText = response;
+                    if (framedControl) {
+                        const newline = response.indexOf("\n");
+                        if (newline < 0 || response.slice(newline + 1).length !== 0) {
+                            throw new LocalExecutionAuthorityError("unsupported", "execution supervisor control response was incomplete or invalid");
+                        }
+                        responseText = response.slice(0, newline);
+                    }
+                    let value;
+                    try {
+                        value = JSON.parse(responseText);
+                    }
+                    catch (error) {
+                        throw new LocalExecutionAuthorityError("unsupported", "execution supervisor control response was incomplete or invalid", { cause: error });
+                    }
+                    if (value === null || typeof value !== "object" || typeof value.ok !== "boolean") {
+                        throw new LocalExecutionAuthorityError("unsupported", "execution supervisor control response was incomplete or invalid");
+                    }
+                    if (!value.ok) {
+                        throw new LocalExecutionAuthorityError("identity_conflict", value.error ?? "execution supervisor rejected the control request");
+                    }
+                    resolvePromise(value);
+                }
+                catch (error) {
+                    rejectPromise(error);
+                }
+            });
+            socket.once("connect", () => {
+                const payload = JSON.stringify({
+                    schema_version: CONTROL_SCHEMA_VERSION,
+                    execution_instance_id: record.execution_instance_id,
+                    challenge: record.challenge,
+                    ...(record.backend.kind === "windows_job"
+                        ? { containment_nonce: record.backend.containment_nonce }
+                        : {}),
+                    ...request,
+                });
+                if (framedControl)
+                    socket.write(`${payload}\n`);
+                else
+                    socket.end(payload);
+            });
+        });
+    }
+    async issueReceipt(path, requestedOutcome, stoppedAt, expectedReceipt) {
+        return this.withLock(path, async () => {
+            const current = this.readRecord(path);
+            if (current.stop_receipt !== null) {
+                if (canonicalizeJson(current.stop_receipt.payload.terminal_outcome) !== canonicalizeJson(requestedOutcome)
+                    || current.stop_receipt.payload.stopped_at !== stoppedAt
+                    || (expectedReceipt !== null && canonicalizeJson(current.stop_receipt) !== canonicalizeJson(expectedReceipt))) {
+                    throw new LocalExecutionAuthorityError("identity_conflict", "durable stop receipt conflicts with the request");
+                }
+                return {
+                    stop_receipt: current.stop_receipt,
+                    authority_instance_id: current.authority_instance_id,
+                    fencing_epoch: current.fencing_epoch,
+                };
+            }
+            if (current.raw_completion === null) {
+                throw new LocalExecutionAuthorityError("unsupported", "trusted process completion evidence is unavailable");
+            }
+            if (current.raw_completion.process_tree_drained !== true) {
+                throw new LocalExecutionAuthorityError("corrupt_state", "trusted process-tree drain evidence is unavailable");
+            }
+            const fencingEpoch = await this.nextFencingEpoch();
+            const receipt = createWorkerStopReceipt({
+                schema_version: "intentdna.worker_stop_receipt.v1",
+                run_id: current.identity.run_id,
+                step_id: current.identity.step_id,
+                activation_id: current.identity.activation_id,
+                attempt_id: current.identity.attempt_id,
+                claim_epoch: current.identity.claim_epoch,
+                worker_session_id: current.identity.worker_session_id,
+                execution_instance_id: current.execution_instance_id,
+                authority_kind: "local_process",
+                authority_instance_id: current.authority_instance_id,
+                fencing_epoch: fencingEpoch,
+                started_at: current.identity.started_at,
+                stopped_at: stoppedAt,
+                terminal_outcome: requestedOutcome,
+                process_tree_drained: true,
+                source_evidence_digest: stopReceiptSourceEvidenceDigest(current),
+            });
+            if (expectedReceipt !== null && canonicalizeJson(receipt) !== canonicalizeJson(expectedReceipt)) {
+                throw new LocalExecutionAuthorityError("identity_conflict", "expected stop receipt does not match durable evidence");
+            }
+            const updated = {
+                ...current,
+                phase: "receipted",
+                stop_receipt: receipt,
+                fencing_epoch: fencingEpoch,
+                revision: current.revision + 1,
+                updated_at: new Date().toISOString(),
+            };
+            atomicWriteJson(path, updated);
+            return {
+                stop_receipt: receipt,
+                authority_instance_id: updated.authority_instance_id,
+                fencing_epoch: fencingEpoch,
+            };
+        });
+    }
+    async issueAlreadyStoppedEvidence(path, request) {
+        return this.withLock(path, async () => {
+            const current = this.readRecord(path);
+            if (current.already_stopped_evidence !== null) {
+                if (!workerAlreadyStoppedEvidenceMatchesStop(current.already_stopped_evidence, request)) {
+                    throw new LocalExecutionAuthorityError("identity_conflict", "durable already-stopped evidence conflicts with the request");
+                }
+                return current.already_stopped_evidence;
+            }
+            if (request.expected_receipt !== null) {
+                throw new LocalExecutionAuthorityError("identity_conflict", "expected stop receipt cannot match a naturally completed execution");
+            }
+            if (current.stop_receipt !== null || current.stop_fact?.kind === "canonical_stop") {
+                throw new LocalExecutionAuthorityError("identity_conflict", "canonical stop already owns the durable terminal transition");
+            }
+            if (current.raw_completion === null) {
+                throw new LocalExecutionAuthorityError("unsupported", "trusted natural completion evidence is unavailable");
+            }
+            const fencingEpoch = await this.nextFencingEpoch();
+            const evidence = createWorkerAlreadyStoppedEvidence({
+                schema_version: "intentdna.worker_already_stopped_evidence.v1",
+                run_id: current.identity.run_id,
+                step_id: current.identity.step_id,
+                activation_id: current.identity.activation_id,
+                attempt_id: current.identity.attempt_id,
+                claim_epoch: current.identity.claim_epoch,
+                worker_session_id: current.identity.worker_session_id,
+                execution_instance_id: current.execution_instance_id,
+                authority_kind: "local_process",
+                authority_instance_id: current.authority_instance_id,
+                fencing_epoch: fencingEpoch,
+                started_at: current.identity.started_at,
+                completed_at: current.raw_completion.completed_at,
+                observed_outcome: terminalOutcomeToCanonical(rawCompletionToOutcome(current.raw_completion)),
+                process_tree_drained: true,
+                stop_idempotency_key: request.stop_idempotency_key,
+                stop_requested_at: request.requested_at,
+                stop_purpose: request.purpose,
+                stop_requested_outcome: request.requested_outcome,
+                source_evidence_digest: alreadyStoppedSourceEvidenceDigest(current),
+            });
+            const updated = {
+                ...current,
+                phase: "receipted",
+                already_stopped_evidence: evidence,
+                fencing_epoch: fencingEpoch,
+                revision: current.revision + 1,
+                updated_at: new Date().toISOString(),
+            };
+            atomicWriteJson(path, updated);
+            return evidence;
+        });
+    }
+    async withStoppedExecution(request, operation) {
+        const record = this.requireRequestRecord(request);
+        if (record.phase === "unsupported" || record.raw_completion === null) {
+            throw new LocalExecutionAuthorityError("unsupported", "trusted execution completion is unavailable");
+        }
+        if (record.normalized_process_outcome === null
+            || !processMatchesCanonical(record.normalized_process_outcome, request.reported_execution.outcome)
+            || request.reported_execution.started_at !== record.identity.started_at
+            || request.reported_execution.completed_at < record.raw_completion.completed_at) {
+            throw new LocalExecutionAuthorityError("identity_conflict", "reported execution does not match durable evidence");
+        }
+        const authority = await this.issueReceipt(this.recordPath(requestIdentity(request)), request.reported_execution.outcome, request.reported_execution.completed_at, request.expected_receipt);
+        return operation(authority);
+    }
+    async requestStop(request) {
+        const identity = requestIdentity(request);
+        const path = this.recordPath(identity);
+        const nonlaunchRequest = {
+            run_id: request.run_id,
+            step_id: request.step_id,
+            activation_id: request.activation_id,
+            attempt_id: request.attempt_id,
+            execution_claim_epoch: request.claim_epoch,
+            executor: request.executor,
+            started_at: request.started_at,
+            failure_idempotency_key: request.stop_idempotency_key,
+            requested_at: request.requested_at,
+        };
+        if (!existsSync(path)) {
+            return {
+                kind: "never_launched",
+                nonlaunch_attestation: await this.attestNeverLaunched(nonlaunchRequest),
+            };
+        }
+        let record = this.requireRequestRecord(request);
+        if (record.phase === "never_launched" || (record.phase === "prepared"
+            && record.supervisor.pid === null
+            && record.provider === null
+            && record.raw_completion === null)) {
+            if (request.expected_receipt !== null) {
+                throw new LocalExecutionAuthorityError("identity_conflict", "expected stop receipt cannot match a never-launched execution");
+            }
+            return {
+                kind: "never_launched",
+                nonlaunch_attestation: await this.attestNeverLaunched(nonlaunchRequest),
+            };
+        }
+        if (record.already_stopped_evidence !== null) {
+            const evidence = await this.issueAlreadyStoppedEvidence(path, request);
+            return { kind: "already_stopped", drain_evidence: evidence };
+        }
+        if (record.stop_receipt !== null) {
+            const authority = await this.issueReceipt(path, request.requested_outcome, record.stop_receipt.payload.stopped_at, request.expected_receipt);
+            return { kind: "stopped_by_request", authority };
+        }
+        if (record.phase === "unsupported") {
+            throw new LocalExecutionAuthorityError("unsupported", "execution supervisor evidence is unavailable");
+        }
+        if (record.raw_completion !== null && record.stop_fact?.kind !== "canonical_stop") {
+            const evidence = await this.issueAlreadyStoppedEvidence(path, request);
+            return { kind: "already_stopped", drain_evidence: evidence };
+        }
+        if (record.raw_completion === null) {
+            if (record.backend.kind === "windows_job") {
+                record = await this.authenticateWindowsSupervisor(record, path);
+            }
+        }
+        if (record.raw_completion === null) {
+            await this.sendControl(record, {
+                action: "stop",
+                stop_idempotency_key: request.stop_idempotency_key,
+                requested_at: request.requested_at,
+                requested_outcome: request.requested_outcome,
+            });
+            record = this.readRecord(path);
+        }
+        if (record.raw_completion === null
+            || record.stop_fact?.kind !== "canonical_stop"
+            || record.stop_fact.stop_idempotency_key !== request.stop_idempotency_key
+            || canonicalizeJson(record.stop_fact.requested_outcome) !== canonicalizeJson(request.requested_outcome)) {
+            throw new LocalExecutionAuthorityError("unsupported", "canonical stop evidence was not durably published");
+        }
+        const authority = await this.issueReceipt(path, request.requested_outcome, record.raw_completion.completed_at < request.requested_at
+            ? request.requested_at
+            : record.raw_completion.completed_at, request.expected_receipt);
+        return { kind: "stopped_by_request", authority };
+    }
+}