intentdna 1.9.0 → 1.9.3

package/dist/runtime/canonical-run-service.js

@@ -0,0 +1,4760 @@
+import { createHash, randomUUID } from "node:crypto";
+import { resolve } from "node:path";
+import { canonicalizeJson } from "./canonical-json.js";
+import { CANONICAL_RESULT_SCHEMA_VERSION, CANONICAL_VERIFIER_EXECUTION_RECEIPT_SCHEMA_VERSION, CANONICAL_WORKSPACE_OBSERVATION_SCHEMA_VERSION, } from "./run-contracts.js";
+import { canonicalAttemptOutcomeStatus, validateCanonicalAttemptOutcome, } from "./canonical-attempt-outcome.js";
+import { parseStoredRunBinding } from "./run-binding.js";
+import { RunStoreError, } from "./run-store.js";
+import { ResultStoreError, } from "./result-store.js";
+import { ArtifactMaterializer, } from "./artifact-store.js";
+import { parseEvaluatorResult } from "./evaluator.js";
+import { assertVerifierCommandExecutionResult, execVerifierCommand, MAX_VERIFIER_DIAGNOSTIC_BYTES, MAX_VERIFIER_EVIDENCE_BYTES, verifierCommandExecutionPassed, } from "./verifier.js";
+import { workerNonlaunchAttestationMatches, workerStopReceiptMatchesExecution, workerStopReceiptMatchesStop, workerAlreadyStoppedEvidenceMatchesStop, } from "./execution-authority.js";
+import { observeWorkspace, workspaceObservationPolicy, WorkspaceObservationError, } from "./workspace-observation.js";
+import { DEFAULT_STRUCTURED_OUTPUT_SCHEMA_REGISTRY, validatePinnedStructuredOutput, } from "./structured-output-validator.js";
+import { bindVerifierCommand, TRUSTED_FULL_VERIFIER_COMMAND_SCHEMA_VERSION, } from "./verifier-command-binding.js";
+import { canonicalWorkspaceDirectory, WorkspaceIsolationError, } from "./workspace-isolation.js";
+export class CanonicalRunServiceError extends Error {
+    code;
+    constructor(code, message, options) {
+        super(message, options);
+        this.name = "CanonicalRunServiceError";
+        this.code = code;
+    }
+}
+export function canonicalVerifierEnvironment(supplied, platform = process.platform, hostEnvironment = process.env) {
+    const base = platform === "win32"
+        ? {
+            PATH: hostEnvironment.PATH ?? "",
+            PATHEXT: hostEnvironment.PATHEXT ?? ".COM;.EXE;.BAT;.CMD",
+            SystemRoot: hostEnvironment.SystemRoot ?? hostEnvironment.SYSTEMROOT ?? "C:\\Windows",
+            ComSpec: hostEnvironment.ComSpec ?? hostEnvironment.COMSPEC ?? "C:\\Windows\\System32\\cmd.exe",
+        }
+        : { PATH: "/opt/homebrew/bin:/usr/local/bin:/usr/bin:/bin:/usr/sbin:/sbin" };
+    return { ...base, ...supplied };
+}
+function isExecutionDeadlineTimeout(execution) {
+    return execution.outcome.kind === "worker_process"
+        && execution.outcome.status === "failed"
+        && execution.outcome.reason_code === "timeout"
+        && execution.outcome.process.kind === "timeout";
+}
+const TERMINAL_ACTIVATION_STATES = new Set(["succeeded", "failed", "skipped", "cancelled"]);
+const ATTEMPT_NODE_KINDS = new Set(["worker", "system", "interaction"]);
+const DEFAULT_LEASE_DURATION_MS = 30_000;
+const DEFAULT_EXECUTION_TIMEOUT_MS = 30 * 60_000;
+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")}`;
+}
+const SHA256_DIGEST_PATTERN = /^sha256:[a-f0-9]{64}$/u;
+function snapshotVerifierAuthorityDescriptor(value) {
+    let snapshot;
+    try {
+        snapshot = JSON.parse(canonicalizeJson(value));
+    }
+    catch (error) {
+        throw new CanonicalRunServiceError("invalid_request", "verifier execution authority descriptor must be canonical JSON data", { cause: error });
+    }
+    if (typeof snapshot !== "object" || snapshot === null || Array.isArray(snapshot)) {
+        throw new CanonicalRunServiceError("invalid_request", "verifier execution authority descriptor must be an object");
+    }
+    const descriptor = snapshot;
+    const expectedKeys = [
+        "schema_version",
+        "authority_instance_id",
+        "adapter_kind",
+        "adapter_version",
+        "configuration_digest",
+        "process_tree_containment",
+        "network_policies",
+    ].sort();
+    const actualKeys = Object.keys(descriptor).sort();
+    const fieldsMatch = actualKeys.length === expectedKeys.length
+        && actualKeys.every((key, index) => key === expectedKeys[index]);
+    const policies = descriptor.network_policies;
+    if (!fieldsMatch
+        || descriptor.schema_version !== "intentdna.verifier_execution_authority.v1"
+        || typeof descriptor.authority_instance_id !== "string"
+        || descriptor.authority_instance_id.trim().length === 0
+        || typeof descriptor.adapter_kind !== "string"
+        || descriptor.adapter_kind.trim().length === 0
+        || typeof descriptor.adapter_version !== "string"
+        || descriptor.adapter_version.trim().length === 0
+        || typeof descriptor.configuration_digest !== "string"
+        || !SHA256_DIGEST_PATTERN.test(descriptor.configuration_digest)
+        || typeof descriptor.process_tree_containment !== "boolean"
+        || !Array.isArray(policies)
+        || policies.length === 0
+        || policies.some((policy) => policy !== "allow" && policy !== "deny_all")
+        || new Set(policies).size !== policies.length) {
+        throw new CanonicalRunServiceError("invalid_request", "verifier execution authority descriptor is invalid");
+    }
+    Object.freeze(policies);
+    return Object.freeze(snapshot);
+}
+async function observeAttemptWorkspace(workspaceRoot, workspaceId) {
+    try {
+        const observation = await observeWorkspace({ workspace_root: workspaceRoot });
+        return {
+            schema_version: CANONICAL_WORKSPACE_OBSERVATION_SCHEMA_VERSION,
+            workspace_id: workspaceId,
+            scope: {
+                kind: "attempt_workspace",
+                relative_root: ".",
+                excluded_relative_paths: observation.excluded_relative_paths,
+            },
+            observed_digest: observation.observed_digest,
+            entry_count: observation.entry_count,
+            byte_count: observation.byte_count,
+            git: observation.git,
+        };
+    }
+    catch (error) {
+        if (!(error instanceof WorkspaceObservationError))
+            throw error;
+        throw new CanonicalRunServiceError(error.code, error.message, { cause: error });
+    }
+}
+function addMilliseconds(iso, milliseconds) {
+    return new Date(Date.parse(iso) + milliseconds).toISOString();
+}
+function defaultIdentity(kind, seed) {
+    const hex = createHash("sha256").update(`${kind}\0${seed}`, "utf8").digest("hex");
+    return `${kind}:${hex}`;
+}
+function publicAuditEvent(event) {
+    if (event.type !== "attempt_heartbeat")
+        return event;
+    const key = `claim:${event.attempt_id ?? "unknown"}`
+        + `:epoch:${event.payload.claim_epoch}:heartbeat:${event.payload.heartbeat_at}`;
+    return {
+        ...event,
+        event_id: defaultIdentity("event", key),
+        idempotency_key: key,
+    };
+}
+function requireNonEmpty(value, label) {
+    if (!value.trim()) {
+        throw new CanonicalRunServiceError("invalid_request", `${label} must not be empty`);
+    }
+}
+function resultIdFor(identities, attemptId) {
+    return identities.create("result", attemptId);
+}
+function runtimeTemplateValue(value) {
+    return typeof value === "string"
+        ? value
+        : canonicalizeJson(value);
+}
+function renderPacketPrompt(template, values) {
+    const malformed = template.replace(/\{\{[^{}]*\}\}/gu, "");
+    if (malformed.includes("{{")) {
+        throw new CanonicalRunServiceError("invalid_request", "packet prompt contains a malformed runtime placeholder");
+    }
+    return template.replace(/\{\{([^{}]+)\}\}|(^|[^\\])\$ARGUMENTS/gu, (_match, name, prefix) => {
+        if (name !== undefined) {
+            const value = values.get(name);
+            if (value === undefined) {
+                throw new CanonicalRunServiceError("invalid_request", `packet prompt contains unresolved runtime placeholder {{${name}}}`);
+            }
+            return value;
+        }
+        const value = values.get("ARGUMENTS");
+        if (value === undefined) {
+            throw new CanonicalRunServiceError("invalid_request", "packet prompt contains unresolved runtime placeholder $ARGUMENTS");
+        }
+        return `${prefix ?? ""}${value}`;
+    });
+}
+function resolveVerifierCommand(command, bindings, runtimeInputs, inputDefinitions) {
+    let context = "unquoted";
+    let backtickReturn = "unquoted";
+    let resolved = "";
+    const environment = new Map();
+    const environmentNames = new Map();
+    const renderPlaceholder = (name) => {
+        const handoff = /^handoff\.(.+)\.(materialized_path|commit_oid|artifact_id)$/u.exec(name);
+        if (handoff === null) {
+            if (name.startsWith("handoff.")) {
+                throw new CanonicalRunServiceError("verification_failed", `verifier command contains unsupported handoff placeholder {{${name}}}`);
+            }
+            return `{{${name}}}`;
+        }
+        if (context === "single" || context === "backtick") {
+            throw new CanonicalRunServiceError("verification_failed", `verifier handoff placeholder {{${name}}} is not allowed in ${context} quotes`);
+        }
+        const binding = bindings.find((candidate) => candidate.binding_id === handoff[1]);
+        if (binding?.mode !== "reference") {
+            throw new CanonicalRunServiceError("verification_failed", `verifier handoff ${handoff[1]} has no immutable reference`);
+        }
+        const field = handoff[2];
+        if ((field === "materialized_path" && binding.reference.kind === "artifact")
+            || (field === "commit_oid" && binding.reference.kind !== "artifact")) {
+            throw new CanonicalRunServiceError("verification_failed", `verifier handoff ${handoff[1]} does not provide ${field}`);
+        }
+        const value = field === "artifact_id"
+            ? binding.reference.artifact_id
+            : binding.reference.value;
+        if (value === null) {
+            throw new CanonicalRunServiceError("verification_failed", `verifier handoff ${handoff[1]} has no immutable artifact identity`);
+        }
+        const environmentKey = `${binding.binding_id}:${field}`;
+        let environmentName = environmentNames.get(environmentKey);
+        if (environmentName === undefined) {
+            environmentName = `INTENTDNA_HANDOFF_${environmentNames.size + 1}`;
+            environmentNames.set(environmentKey, environmentName);
+            environment.set(environmentName, value);
+        }
+        return context === "double"
+            ? `\${${environmentName}}`
+            : `"\${${environmentName}}"`;
+    };
+    for (let index = 0; index < command.length;) {
+        if (command.startsWith("{{", index)) {
+            const end = command.indexOf("}}", index + 2);
+            if (end < 0) {
+                throw new CanonicalRunServiceError("verification_failed", "verifier command contains a malformed runtime placeholder");
+            }
+            resolved += renderPlaceholder(command.slice(index + 2, end));
+            index = end + 2;
+            continue;
+        }
+        if (command.startsWith("$ARGUMENTS", index)) {
+            resolved += "$ARGUMENTS";
+            index += "$ARGUMENTS".length;
+            continue;
+        }
+        const character = command[index];
+        resolved += character;
+        if (character === "\\" && context !== "single" && index + 1 < command.length) {
+            resolved += command[index + 1];
+            index += 2;
+            continue;
+        }
+        if (context === "unquoted") {
+            if (character === "'")
+                context = "single";
+            else if (character === "\"")
+                context = "double";
+            else if (character === "`") {
+                backtickReturn = "unquoted";
+                context = "backtick";
+            }
+        }
+        else if (context === "single") {
+            if (character === "'")
+                context = "unquoted";
+        }
+        else if (context === "double") {
+            if (character === "\"")
+                context = "unquoted";
+            else if (character === "`") {
+                backtickReturn = "double";
+                context = "backtick";
+            }
+        }
+        else if (character === "`") {
+            context = backtickReturn;
+        }
+        index += 1;
+    }
+    const runtimeValues = Object.fromEntries(Object.entries(runtimeInputs).map(([name, value]) => [name, runtimeTemplateValue(value)]));
+    const trimmed = command.trim();
+    const namedWholeCommand = /^\{\{([A-Za-z_][A-Za-z0-9_]*)\}\}$/u.exec(trimmed)?.[1];
+    const wholeCommandInput = namedWholeCommand ?? (trimmed === "$ARGUMENTS" ? "ARGUMENTS" : null);
+    const wholeCommandDefinition = wholeCommandInput === null
+        ? undefined
+        : inputDefinitions.find((definition) => definition.name === wholeCommandInput);
+    const trustedWholeCommand = wholeCommandDefinition?.type === "trusted_verifier_command"
+        && typeof wholeCommandDefinition.default_value === "string"
+        && runtimeInputs[wholeCommandDefinition.name] === wholeCommandDefinition.default_value;
+    const bound = bindVerifierCommand({
+        command_template: resolved,
+        runtime_values: runtimeValues,
+        full_command_trust: trustedWholeCommand
+            ? {
+                schema_version: TRUSTED_FULL_VERIFIER_COMMAND_SCHEMA_VERSION,
+                source: "compiled_plan",
+            }
+            : undefined,
+    });
+    if (!bound.bound) {
+        throw new CanonicalRunServiceError("verification_failed", bound.message);
+    }
+    if (/\{\{[^{}]+\}\}/u.test(bound.command)) {
+        throw new CanonicalRunServiceError("verification_failed", "verifier command contains an unresolved runtime placeholder");
+    }
+    return {
+        command: bound.command,
+        environment: { ...Object.fromEntries(environment), ...bound.env },
+    };
+}
+function nodeById(plan, nodeId) {
+    const node = plan.nodes.find((candidate) => candidate.node_id === nodeId);
+    if (!node) {
+        throw new CanonicalRunServiceError("invalid_request", `plan node ${nodeId} was not found`);
+    }
+    return node;
+}
+class ArtifactOutputCapture {
+    store;
+    constructor(store) {
+        this.store = store;
+    }
+    async capture(request) {
+        const captured = [];
+        const captures = [];
+        for (const output of request.execution.outputs) {
+            if (output.kind === "text") {
+                captured.push({ name: output.name, kind: "text", text: output.text });
+                continue;
+            }
+            if (output.kind === "structured") {
+                canonicalizeJson(output.value);
+                captured.push({
+                    name: output.name,
+                    kind: "structured",
+                    value: output.value,
+                    schema_ref: output.schema_ref,
+                });
+                continue;
+            }
+            const response = await this.store.capture({
+                kind: output.artifact_kind,
+                workspace_root: request.execution.workspace.root,
+                source_path: output.source_path,
+                run_id: request.run_id,
+                activation_id: request.activation_id,
+                attempt_id: request.attempt_id,
+                output_name: output.name,
+                source_workspace_id: request.execution.workspace.workspace_id,
+            });
+            captures.push(response.capture);
+            captured.push({ name: output.name, kind: "artifact", capture: response.capture });
+        }
+        return {
+            outputs: captured,
+            captures,
+            revalidate: async () => {
+                for (const output of request.execution.outputs) {
+                    if (output.kind !== "reference")
+                        continue;
+                    const original = captures.find((capture) => capture.output_name === output.name);
+                    const response = await this.store.capture({
+                        kind: output.artifact_kind,
+                        workspace_root: request.execution.workspace.root,
+                        source_path: output.source_path,
+                        run_id: request.run_id,
+                        activation_id: request.activation_id,
+                        attempt_id: request.attempt_id,
+                        output_name: output.name,
+                        source_workspace_id: request.execution.workspace.workspace_id,
+                    });
+                    if (!original || response.capture.artifact_id !== original.artifact_id) {
+                        throw new CanonicalRunServiceError("source_drift", `output ${output.name} changed after verification`);
+                    }
+                }
+            },
+        };
+    }
+}
+export class LocalVerifierExecutionPort {
+    clock;
+    authority_descriptor;
+    constructor(clock, authorityInstanceId = "local-verifier-execution") {
+        this.clock = clock;
+        this.authority_descriptor = {
+            schema_version: "intentdna.verifier_execution_authority.v1",
+            authority_instance_id: authorityInstanceId,
+            adapter_kind: "local_process",
+            adapter_version: "v1",
+            configuration_digest: digest({ shell: "bash", arguments: ["--noprofile", "--norc", "-c"], network: "allow" }),
+            process_tree_containment: false,
+            network_policies: ["allow"],
+        };
+    }
+    async execute(request) {
+        if (request.network_policy !== "allow") {
+            throw new CanonicalRunServiceError("unsupported", "local verifier execution cannot enforce deny_all network policy");
+        }
+        const execution = await execVerifierCommand(request.cwd, request.resolved_command, request.timeout_ms, request.environment, () => this.clock.now());
+        if (!execution.processTreeDrained) {
+            throw new CanonicalRunServiceError("verification_failed", "local verifier process tree could not be drained");
+        }
+        return {
+            execution,
+            authority: {
+                authority_instance_id: this.authority_descriptor.authority_instance_id,
+                request_digest: request.request_digest,
+                authority_descriptor_digest: digest(this.authority_descriptor),
+                launch_descriptor_digest: request.request_digest,
+                process_tree_drained: true,
+                network_enforced: false,
+                enforcement_kind: "not_required",
+                enforcement_digest: null,
+                enforcement_descriptor: null,
+            },
+        };
+    }
+}
+class ContractVerifier {
+    artifactStore;
+    serviceInstanceId;
+    clock;
+    structuredOutputSchemaRegistry;
+    executionPort;
+    authorityDescriptor;
+    authorityDescriptorDigest;
+    constructor(artifactStore, serviceInstanceId, clock, structuredOutputSchemaRegistry, executionPort, authorityDescriptor, authorityDescriptorDigest) {
+        this.artifactStore = artifactStore;
+        this.serviceInstanceId = serviceInstanceId;
+        this.clock = clock;
+        this.structuredOutputSchemaRegistry = structuredOutputSchemaRegistry;
+        this.executionPort = executionPort;
+        this.authorityDescriptor = authorityDescriptor;
+        this.authorityDescriptorDigest = authorityDescriptorDigest;
+    }
+    async verify(request) {
+        const node = nodeById(request.plan.plan, request.activation.step_id);
+        if (node.kind !== "worker")
+            return [];
+        const byName = new Map(request.captured_outputs.map((output) => [output.name, output]));
+        const contractResults = node.packet_template.output_contract.map((contract) => ({
+            verifier_id: `output_contract:${contract.name}`,
+            passed: !contract.required || byName.has(contract.name),
+            reason_code: !contract.required || byName.has(contract.name)
+                ? "output_contract_satisfied"
+                : "required_output_missing",
+        }));
+        const gitCommitContracts = node.packet_template.output_contract.filter((contract) => contract.artifact_kind === "git_commit");
+        if (gitCommitContracts.length > 0) {
+            const presentOutputs = gitCommitContracts
+                .map((contract) => byName.get(contract.name))
+                .filter((output) => (output?.kind === "artifact" && output.capture.artifact_kind === "git_commit"));
+            const observation = presentOutputs.length === 0
+                ? null
+                : await observeAttemptWorkspace(request.execution.workspace.root, request.execution.workspace.workspace_id);
+            for (const contract of gitCommitContracts) {
+                const verifierId = `output_contract:${contract.name}:git_commit_provenance`;
+                const output = byName.get(contract.name);
+                if (output?.kind !== "artifact" || output.capture.artifact_kind !== "git_commit") {
+                    contractResults.push({
+                        verifier_id: verifierId,
+                        passed: !contract.required && output === undefined,
+                        reason_code: !contract.required && output === undefined
+                            ? "optional_git_commit_absent"
+                            : "git_commit_provenance_invalid",
+                    });
+                    continue;
+                }
+                if (observation === null) {
+                    throw new CanonicalRunServiceError("verification_failed", `git_commit output ${output.name} has no stopped workspace observation`);
+                }
+                let passed = false;
+                if (observation.git !== null
+                    && request.workspace_allocation.observed_head !== null
+                    && observation.git.head === output.capture.source_path) {
+                    try {
+                        await this.artifactStore.verifyGitCommitProducedByAttempt({
+                            artifact_id: output.capture.artifact_id,
+                            artifact_kind: "git_commit",
+                        }, request.execution.workspace.root, request.workspace_allocation.observed_head, request.workspace_allocation.observed_branch_ref);
+                        passed = true;
+                    }
+                    catch {
+                        passed = false;
+                    }
+                }
+                const evidence = {
+                    kind: "verifier_evidence",
+                    verifier_id: verifierId,
+                    evidence_digest: digest({
+                        artifact_capture: output.capture,
+                        workspace_observation: observation,
+                    }),
+                    artifact_capture: output.capture,
+                    workspace_observation: observation,
+                    execution_receipt: null,
+                };
+                contractResults.push({
+                    verifier_id: verifierId,
+                    passed,
+                    reason_code: passed
+                        ? "git_commit_produced_by_attempt"
+                        : "git_commit_provenance_invalid",
+                    evidence_refs: [evidence],
+                });
+            }
+        }
+        const planResults = [];
+        const workspaceVerifierIds = new Set();
+        const commandExecutions = new Map();
+        for (const verifier of request.plan.plan.verifier_plan.filter((item) => item.subject_node_id === node.node_id)) {
+            if (verifier.kind === "structured_output") {
+                const output = byName.get(verifier.output_name);
+                const validation = output?.kind === "structured"
+                    ? validatePinnedStructuredOutput({
+                        plan: request.plan.plan,
+                        node_id: verifier.node_id,
+                        output_name: verifier.output_name,
+                        schema_ref: output.schema_ref,
+                        value: output.value,
+                    }, this.structuredOutputSchemaRegistry)
+                    : null;
+                const passed = output?.kind === "structured"
+                    && output.schema_ref === verifier.schema_ref
+                    && validation?.valid === true;
+                planResults.push({
+                    verifier_id: verifier.verifier_id,
+                    passed,
+                    reason_code: passed
+                        ? "structured_output_present"
+                        : "structured_output_invalid",
+                });
+                continue;
+            }
+            if (verifier.kind === "artifact_exists"
+                || verifier.kind === "artifact_non_empty"
+                || verifier.kind === "artifact_contains"
+                || verifier.kind === "evaluator_result") {
+                const path = verifier.relative_path_template;
+                const output = request.captured_outputs.find((candidate) => (candidate.kind === "artifact" && candidate.capture.source_path === path));
+                let passed = output?.kind === "artifact";
+                if (passed && output?.kind === "artifact" && verifier.kind !== "artifact_exists") {
+                    const object = await this.artifactStore.require({
+                        artifact_id: output.capture.artifact_id,
+                        artifact_kind: output.capture.artifact_kind,
+                    });
+                    passed = object.size_bytes > 0;
+                    if (passed && verifier.kind === "artifact_contains") {
+                        if (output.capture.artifact_kind !== "file") {
+                            passed = false;
+                        }
+                        else {
+                            try {
+                                passed = new RegExp(verifier.pattern, "u").test((await this.artifactStore.readFileBytes(output.capture.artifact_id)).toString("utf8"));
+                            }
+                            catch {
+                                passed = false;
+                            }
+                        }
+                    }
+                    if (passed && verifier.kind === "evaluator_result") {
+                        if (output.capture.artifact_kind !== "file") {
+                            passed = false;
+                        }
+                        else {
+                            try {
+                                passed = parseEvaluatorResult((await this.artifactStore.readFileBytes(output.capture.artifact_id)).toString("utf8"), { require_score: verifier.require_score }).pass;
+                            }
+                            catch {
+                                passed = false;
+                            }
+                        }
+                    }
+                }
+                planResults.push({
+                    verifier_id: verifier.verifier_id,
+                    passed,
+                    reason_code: passed ? "immutable_artifact_verified" : "immutable_artifact_verification_failed",
+                });
+                continue;
+            }
+            if (verifier.kind === "command" || verifier.kind === "checkpoint") {
+                if (verifier.observation_policy === "current_provenance") {
+                    throw new CanonicalRunServiceError("unsupported", `verifier ${verifier.verifier_id} requires current provenance without typed immutable observations`);
+                }
+                const command = verifier.command;
+                if (command === null) {
+                    planResults.push({
+                        verifier_id: verifier.verifier_id,
+                        passed: false,
+                        reason_code: "checkpoint_command_required",
+                    });
+                    continue;
+                }
+                const relativeWorkingDirectory = verifier.kind === "command"
+                    ? verifier.relative_working_directory
+                    : ".";
+                let workingDirectory;
+                try {
+                    workingDirectory = await canonicalWorkspaceDirectory(request.execution.workspace.root, relativeWorkingDirectory, `verifier ${verifier.verifier_id} working_directory`);
+                }
+                catch (error) {
+                    if (!(error instanceof WorkspaceIsolationError))
+                        throw error;
+                    throw new CanonicalRunServiceError("verification_failed", error.message, { cause: error });
+                }
+                const resolvedCommand = resolveVerifierCommand(command, request.handoff_bindings, request.run.run_binding.binding.validated_inputs, request.plan.plan.input_contract.inputs);
+                const environment = canonicalVerifierEnvironment(resolvedCommand.environment);
+                const authorityDescriptorDigest = this.authorityDescriptorDigest;
+                const cwdIdentity = {
+                    workspace_id: request.execution.workspace.workspace_id,
+                    workspace_allocation_digest: digest(request.workspace_allocation),
+                    relative_working_directory: relativeWorkingDirectory,
+                    absolute_path_digest: textDigest(workingDirectory),
+                };
+                const environmentBindingDigest = digest(Object.fromEntries(Object.entries(environment)
+                    .sort(([left], [right]) => left.localeCompare(right))
+                    .map(([name, value]) => [name, textDigest(value)])));
+                const requestDescriptor = {
+                    schema_version: "intentdna.verifier_execution_request.v1",
+                    plan_id: request.plan.plan_id,
+                    verifier_id: verifier.verifier_id,
+                    verifier_definition_digest: digest(verifier),
+                    raw_command_digest: textDigest(resolvedCommand.command),
+                    cwd: cwdIdentity,
+                    supplied_environment: {
+                        binding_digest: environmentBindingDigest,
+                        variable_names: Object.keys(environment).sort(),
+                        inherit_parent: false,
+                        startup_files: false,
+                    },
+                    shell: { executable: "bash", arguments: ["--noprofile", "--norc", "-c"] },
+                    timeout_ms: 30_000,
+                    requested_at: request.execution.completed_at,
+                    network_mode: request.plan.plan.workspace_policy.allow_network ? "allow" : "deny_all",
+                    expected_authority_descriptor_digest: authorityDescriptorDigest,
+                };
+                const executionRequest = {
+                    request_digest: digest(requestDescriptor),
+                    descriptor: requestDescriptor,
+                    plan_id: requestDescriptor.plan_id,
+                    verifier_id: requestDescriptor.verifier_id,
+                    verifier_definition_digest: requestDescriptor.verifier_definition_digest,
+                    resolved_command_digest: requestDescriptor.raw_command_digest,
+                    resolved_command: resolvedCommand.command,
+                    cwd: workingDirectory,
+                    cwd_identity: cwdIdentity,
+                    environment,
+                    environment_binding_digest: environmentBindingDigest,
+                    timeout_ms: requestDescriptor.timeout_ms,
+                    requested_at: requestDescriptor.requested_at,
+                    network_policy: requestDescriptor.network_mode,
+                    inherit_parent_environment: false,
+                    load_startup_files: false,
+                };
+                const executed = await this.executionPort.execute(executionRequest);
+                try {
+                    assertVerifierCommandExecutionResult(executed.execution);
+                }
+                catch (error) {
+                    throw new CanonicalRunServiceError("verification_failed", "verifier execution returned an invalid process outcome", { cause: error });
+                }
+                if (executed.execution.processTreeDrained !== true) {
+                    throw new CanonicalRunServiceError("verification_failed", "verifier execution did not prove a drained process tree");
+                }
+                this.assertExecutionAuthority(executionRequest, executed.authority);
+                const authoritativePassed = verifierCommandExecutionPassed(executed.execution);
+                workspaceVerifierIds.add(verifier.verifier_id);
+                commandExecutions.set(verifier.verifier_id, {
+                    verifier,
+                    resolved: resolvedCommand,
+                    execution: executed.execution,
+                    relative_working_directory: relativeWorkingDirectory,
+                    request: executionRequest,
+                    authority: executed.authority,
+                });
+                planResults.push({
+                    verifier_id: verifier.verifier_id,
+                    passed: authoritativePassed,
+                    reason_code: authoritativePassed
+                        ? "verifier_command_passed"
+                        : executed.execution.outcome.kind === "timed_out"
+                            ? "verifier_command_timeout"
+                            : executed.execution.outcome.kind === "launch_error"
+                                ? "verifier_command_launch_error"
+                                : "verifier_command_failed",
+                });
+                continue;
+            }
+            planResults.push({
+                verifier_id: verifier.verifier_id,
+                passed: false,
+                reason_code: "verifier_kind_requires_injected_runtime",
+            });
+        }
+        if (workspaceVerifierIds.size > 0) {
+            const observation = await observeAttemptWorkspace(request.execution.workspace.root, request.execution.workspace.workspace_id);
+            for (let index = 0; index < planResults.length; index += 1) {
+                const result = planResults[index];
+                if (!workspaceVerifierIds.has(result.verifier_id))
+                    continue;
+                const commandExecution = commandExecutions.get(result.verifier_id);
+                if (commandExecution === undefined) {
+                    throw new CanonicalRunServiceError("verification_failed", `verifier ${result.verifier_id} has no historical execution record`);
+                }
+                const receipt = {
+                    schema_version: CANONICAL_VERIFIER_EXECUTION_RECEIPT_SCHEMA_VERSION,
+                    evidence_mode: "historical_execution",
+                    plan_id: request.plan.plan_id,
+                    verifier_id: result.verifier_id,
+                    verifier_definition_digest: digest(commandExecution.verifier),
+                    resolved_command_digest: textDigest(commandExecution.resolved.command),
+                    environment_binding_digest: commandExecution.request.environment_binding_digest,
+                    cwd_identity: {
+                        workspace_id: request.execution.workspace.workspace_id,
+                        workspace_allocation_digest: digest(request.workspace_allocation),
+                        relative_working_directory: commandExecution.relative_working_directory,
+                        absolute_path_digest: commandExecution.request.cwd_identity.absolute_path_digest,
+                    },
+                    started_at: commandExecution.execution.startedAt,
+                    requested_at: commandExecution.request.requested_at,
+                    completed_at: commandExecution.execution.completedAt,
+                    process_outcome: {
+                        kind: commandExecution.execution.outcome.kind,
+                        exit_code: commandExecution.execution.outcome.exitCode,
+                        signal: commandExecution.execution.outcome.signal,
+                        timed_out: commandExecution.execution.outcome.timedOut,
+                        launch_error: commandExecution.execution.outcome.launchError === null
+                            ? null
+                            : {
+                                code: commandExecution.execution.outcome.launchError.code,
+                                message_digest: commandExecution.execution.outcome.launchError.messageDigest,
+                            },
+                    },
+                    stdout: {
+                        digest: commandExecution.execution.stdoutDigest,
+                        byte_length: commandExecution.execution.stdoutBytes,
+                        truncated: commandExecution.execution.stdoutBytes > 0,
+                    },
+                    stderr: {
+                        digest: commandExecution.execution.stderrDigest,
+                        byte_length: commandExecution.execution.stderrBytes,
+                        truncated: commandExecution.execution.stderrBytes > 0,
+                    },
+                    truncation_policy: {
+                        kind: "digest_full_stream_diagnostics_only",
+                        raw_output_retained_bytes: 0,
+                        diagnostic_summary_max_bytes: MAX_VERIFIER_EVIDENCE_BYTES,
+                        diagnostic_line_max_bytes: MAX_VERIFIER_DIAGNOSTIC_BYTES,
+                    },
+                    observation_policy_digest: digest(workspaceObservationPolicy()),
+                    workspace_observation_digest: observation.observed_digest,
+                    service_invocation: {
+                        service_instance_id: this.serviceInstanceId,
+                        invocation_id: `verifier-invocation:${randomUUID()}`,
+                    },
+                    request_identity: {
+                        request_digest: commandExecution.request.request_digest,
+                        command_digest: commandExecution.request.resolved_command_digest,
+                        environment_digest: commandExecution.request.environment_binding_digest,
+                        authority_descriptor_digest: commandExecution.authority.authority_descriptor_digest,
+                        launch_descriptor_digest: commandExecution.authority.launch_descriptor_digest,
+                    },
+                    supplied_environment: {
+                        inherit_parent: false,
+                        startup_files: false,
+                        variable_names: Object.keys(commandExecution.request.environment).sort(),
+                    },
+                    shell_policy: {
+                        executable: "bash",
+                        arguments: ["--noprofile", "--norc", "-c"],
+                    },
+                    network_policy: {
+                        mode: commandExecution.request.network_policy,
+                        enforced: commandExecution.authority.network_enforced,
+                        enforcement_kind: commandExecution.authority.enforcement_kind,
+                        enforcement_digest: commandExecution.authority.enforcement_digest,
+                        enforcement_descriptor: commandExecution.authority.enforcement_descriptor,
+                    },
+                    execution_authority: {
+                        authority_instance_id: commandExecution.authority.authority_instance_id,
+                        authority_descriptor_digest: commandExecution.authority.authority_descriptor_digest,
+                        adapter_kind: this.authorityDescriptor.adapter_kind,
+                        adapter_version: this.authorityDescriptor.adapter_version,
+                        configuration_digest: this.authorityDescriptor.configuration_digest,
+                        process_tree_drained: commandExecution.authority.process_tree_drained,
+                    },
+                };
+                const evidence = {
+                    kind: "verifier_evidence",
+                    verifier_id: result.verifier_id,
+                    evidence_digest: digest({
+                        execution_receipt: receipt,
+                        workspace_observation: observation,
+                    }),
+                    artifact_capture: null,
+                    workspace_observation: observation,
+                    execution_receipt: receipt,
+                };
+                planResults[index] = { ...result, evidence_refs: [evidence] };
+            }
+        }
+        return [...contractResults, ...planResults];
+    }
+    assertExecutionAuthority(request, authority) {
+        if (!authority.authority_instance_id
+            || authority.request_digest !== request.request_digest
+            || authority.authority_descriptor_digest !== this.authorityDescriptorDigest
+            || authority.authority_descriptor_digest !== request.descriptor.expected_authority_descriptor_digest
+            || authority.launch_descriptor_digest !== request.request_digest
+            || authority.process_tree_drained !== true
+            || authority.authority_instance_id !== this.authorityDescriptor.authority_instance_id
+            || (request.network_policy === "deny_all" && (authority.network_enforced !== true
+                || authority.enforcement_kind !== "configured_adapter"
+                || authority.enforcement_digest === null
+                || authority.enforcement_descriptor === null
+                || authority.enforcement_digest !== digest(authority.enforcement_descriptor)
+                || authority.enforcement_descriptor.mode !== "deny_all"
+                || authority.enforcement_descriptor.adapter_kind !== this.authorityDescriptor.adapter_kind
+                || authority.enforcement_descriptor.adapter_version !== this.authorityDescriptor.adapter_version
+                || authority.enforcement_descriptor.configuration_digest !== this.authorityDescriptor.configuration_digest
+                || authority.enforcement_descriptor.authority_descriptor_digest !== authority.authority_descriptor_digest
+                || authority.enforcement_descriptor.request_digest !== request.request_digest))
+            || (request.network_policy === "allow" && (authority.network_enforced !== false
+                || authority.enforcement_kind !== "not_required"
+                || authority.enforcement_digest !== null
+                || authority.enforcement_descriptor !== null))) {
+            throw new CanonicalRunServiceError("verification_failed", "verifier execution authority does not match its request");
+        }
+    }
+}
+export class CanonicalRunService {
+    planStore;
+    runStore;
+    resultStore;
+    artifactStore;
+    artifactMaterializer;
+    clock;
+    identities;
+    outputCapture;
+    verifier;
+    additionalVerifier;
+    verifierExecutionPort;
+    verifierAuthorityDescriptor;
+    verifierAuthorityDescriptorDigest;
+    workspaceAuthority;
+    executionAuthority;
+    handoffRootDirectory;
+    hooks;
+    leaseDurationMs;
+    defaultExecutionTimeoutMs;
+    serviceInstanceId;
+    structuredOutputSchemaRegistry;
+    constructor(options) {
+        this.planStore = options.plan_store;
+        this.runStore = options.run_store;
+        this.resultStore = options.result_store;
+        this.artifactStore = options.artifact_store;
+        this.artifactMaterializer = new ArtifactMaterializer(options.artifact_store);
+        this.clock = options.clock ?? { now: () => new Date() };
+        this.identities = options.identities ?? { create: defaultIdentity };
+        this.serviceInstanceId = options.service_instance_id ?? `service:${randomUUID()}`;
+        this.structuredOutputSchemaRegistry = options.structured_output_schema_registry
+            ?? DEFAULT_STRUCTURED_OUTPUT_SCHEMA_REGISTRY;
+        this.outputCapture = options.output_capture
+            ?? new ArtifactOutputCapture(options.artifact_store);
+        this.verifierExecutionPort = options.verifier_execution_port ?? new LocalVerifierExecutionPort(this.clock);
+        this.verifierAuthorityDescriptor = snapshotVerifierAuthorityDescriptor(this.verifierExecutionPort.authority_descriptor);
+        this.verifierAuthorityDescriptorDigest = digest(this.verifierAuthorityDescriptor);
+        this.verifier = new ContractVerifier(options.artifact_store, this.serviceInstanceId, this.clock, this.structuredOutputSchemaRegistry, this.verifierExecutionPort, this.verifierAuthorityDescriptor, this.verifierAuthorityDescriptorDigest);
+        this.additionalVerifier = options.verifier ?? null;
+        this.workspaceAuthority = options.workspace_authority ?? null;
+        this.executionAuthority = options.execution_authority ?? null;
+        this.handoffRootDirectory = resolve(options.handoff_root_directory ?? this.runStore.serviceOwnedRuntimeDirectory("handoffs"));
+        this.hooks = options.hooks ?? {};
+        this.leaseDurationMs = options.lease_duration_ms ?? DEFAULT_LEASE_DURATION_MS;
+        this.defaultExecutionTimeoutMs = options.default_execution_timeout_ms
+            ?? DEFAULT_EXECUTION_TIMEOUT_MS;
+        if (!Number.isSafeInteger(this.leaseDurationMs) || this.leaseDurationMs <= 0) {
+            throw new CanonicalRunServiceError("invalid_request", "lease_duration_ms must be positive");
+        }
+        if (!Number.isSafeInteger(this.defaultExecutionTimeoutMs) || this.defaultExecutionTimeoutMs <= 0) {
+            throw new CanonicalRunServiceError("invalid_request", "default_execution_timeout_ms must be positive");
+        }
+    }
+    async start(request) {
+        this.assertVerifierExecutionSupported(request.plan_payload);
+        const storedPlan = await this.planStore.commitPlan(request.plan_payload);
+        const binding = parseStoredRunBinding(request.run_binding);
+        if (binding.binding.plan_id !== storedPlan.plan_id) {
+            throw new CanonicalRunServiceError("invalid_request", "run binding does not reference the committed plan");
+        }
+        const now = this.now();
+        const runId = request.run_id ?? this.identities.create("run", `${storedPlan.plan_id}\0${binding.binding_id}\0${now}\0${randomUUID()}`);
+        requireNonEmpty(runId, "run_id");
+        const incomingRouteTargets = new Set(storedPlan.plan.routes.map((route) => route.to_node_id));
+        const activations = storedPlan.plan.nodes
+            .filter((node) => ATTEMPT_NODE_KINDS.has(node.kind))
+            .map((node) => ({
+            run_id: runId,
+            step_id: node.node_id,
+            activation_id: this.activationId(runId, node.node_id),
+            workflow_round: 1,
+            state: incomingRouteTargets.has(node.node_id)
+                ? "dormant"
+                : node.depends_on.length === 0 ? "ready" : "dependency_blocked",
+            attempt_count: 0,
+            current_attempt_id: null,
+            committed_result_id: null,
+            created_at: now,
+            updated_at: now,
+        }));
+        const run = {
+            run_id: runId,
+            target: storedPlan.plan.target,
+            plan_id: storedPlan.plan_id,
+            plan_digest: storedPlan.plan_digest,
+            run_binding: binding,
+            status: "active",
+            cancellation: null,
+            terminal: null,
+            metadata: request.metadata ?? {},
+            created_at: now,
+            updated_at: now,
+        };
+        const requireSameStartIdentity = (existing) => {
+            const sameIdentity = existing.run.plan_id === run.plan_id
+                && existing.run.run_binding.binding_id === run.run_binding.binding_id
+                && canonicalizeJson(existing.run.metadata) === canonicalizeJson(run.metadata)
+                && existing.run.target.kind === run.target.kind
+                && existing.run.target.key === run.target.key;
+            if (!sameIdentity) {
+                throw new CanonicalRunServiceError("submission_conflict", `run ${runId} already exists with different start identity`);
+            }
+            return existing;
+        };
+        if (request.run_id !== undefined) {
+            const existing = await this.runStore.loadCanonicalRun(runId);
+            if (existing) {
+                const drained = await this.drainReadySystemNodes(requireSameStartIdentity(existing), storedPlan);
+                return {
+                    run_id: runId,
+                    plan_id: storedPlan.plan_id,
+                    view: this.toView(drained, storedPlan),
+                };
+            }
+        }
+        let snapshot;
+        try {
+            snapshot = await this.runStore.createCanonicalRun({ run, activations });
+        }
+        catch (error) {
+            if (request.run_id === undefined
+                || !(error instanceof RunStoreError)
+                || error.code !== "run_exists") {
+                throw error;
+            }
+            const existing = await this.runStore.loadCanonicalRun(runId);
+            if (!existing)
+                throw error;
+            snapshot = requireSameStartIdentity(existing);
+        }
+        snapshot = await this.reduceWithoutResult(snapshot, storedPlan);
+        snapshot = await this.drainReadySystemNodes(snapshot, storedPlan);
+        return {
+            run_id: runId,
+            plan_id: storedPlan.plan_id,
+            view: this.toView(snapshot, storedPlan),
+        };
+    }
+    async acquireAttempt(request) {
+        requireNonEmpty(request.driver_id, "driver_id");
+        for (;;) {
+            let snapshot = await this.requireSnapshot(request.run_id);
+            const plan = await this.requirePinnedPlan(snapshot);
+            this.assertVerifierExecutionSupported(plan.plan);
+            if (snapshot.events.some((event) => event.type === "attempt_stop_requested" && snapshot.attempts.find((attempt) => attempt.attempt_id === event.attempt_id)?.phase !== "terminal")) {
+                snapshot = await this.continueDurableStops(snapshot);
+            }
+            snapshot = await this.drainReadySystemNodes(snapshot, plan);
+            if (snapshot.run.terminal !== null) {
+                return { kind: "terminal", run: this.toView(snapshot, plan) };
+            }
+            if (snapshot.run.status === "cancelling") {
+                return {
+                    kind: "wait",
+                    reason_code: "run_cancelling",
+                    run: this.toView(snapshot, plan),
+                };
+            }
+            snapshot = await this.reduceWithoutResult(snapshot, plan);
+            if (snapshot.run.terminal !== null) {
+                return { kind: "terminal", run: this.toView(snapshot, plan) };
+            }
+            const now = this.now();
+            const activeAttempts = snapshot.attempts.filter((attempt) => attempt.phase !== "terminal");
+            let recoveredExpiredAttempt = false;
+            for (const activeAttempt of activeAttempts) {
+                const claims = this.claimsFor(snapshot, activeAttempt.attempt_id);
+                const latest = claims.at(-1);
+                if (Date.parse(latest.execution_deadline_at) <= Date.parse(now)) {
+                    await this.recoverExpiredAttempt(snapshot, plan, activeAttempt, now);
+                    recoveredExpiredAttempt = true;
+                    break;
+                }
+            }
+            if (recoveredExpiredAttempt)
+                continue;
+            const maxConcurrency = snapshot.run.run_binding.binding.max_concurrency ?? 1;
+            const activation = activeAttempts.length < maxConcurrency
+                && (activeAttempts.length === 0 || plan.plan.required_capabilities.parallelism)
+                ? snapshot.activations.find((item) => item.state === "ready")
+                : undefined;
+            if (!activation && activeAttempts.length > 0) {
+                let reclaimableAttempt;
+                for (const attempt of activeAttempts) {
+                    const latest = this.claimsFor(snapshot, attempt.attempt_id).at(-1);
+                    if (Date.parse(latest.execution_deadline_at) <= Date.parse(now))
+                        continue;
+                    if (attempt.phase === "claimed"
+                        && Date.parse(latest.driver_claim_lease.expires_at) <= Date.parse(now)) {
+                        reclaimableAttempt = attempt;
+                        break;
+                    }
+                    if (attempt.phase === "running"
+                        && request.recover_running === true
+                        && await this.runningAttemptIsRecoverable(snapshot, attempt, latest, now, request.driver_id)) {
+                        reclaimableAttempt = attempt;
+                        break;
+                    }
+                }
+                if (reclaimableAttempt) {
+                    const latest = this.claimsFor(snapshot, reclaimableAttempt.attempt_id).at(-1);
+                    const claim = this.createClaim(snapshot, plan, reclaimableAttempt, request.driver_id, now, latest.claim_epoch + 1);
+                    const event = this.event(snapshot, 0, {
+                        type: "attempt_claimed",
+                        step_id: reclaimableAttempt.step_id,
+                        activation_id: reclaimableAttempt.activation_id,
+                        attempt_id: reclaimableAttempt.attempt_id,
+                        result_id: null,
+                        key: `attempt:${reclaimableAttempt.attempt_id}:claim:${claim.claim_epoch}`,
+                        at: now,
+                        payload: {
+                            claim_epoch: claim.claim_epoch,
+                            owner_id: claim.owner_id,
+                            claim_expires_at: claim.driver_claim_lease.expires_at,
+                            execution_deadline_at: claim.execution_deadline_at,
+                        },
+                    });
+                    try {
+                        snapshot = (await this.runStore.updateCanonicalRun({
+                            run_id: snapshot.run.run_id,
+                            expected_record_version: snapshot.record_version,
+                            claims: [claim],
+                            events: [event],
+                        })).snapshot;
+                        return {
+                            kind: "attempt",
+                            lease: this.toLease(snapshot, reclaimableAttempt, claim),
+                            recovery: reclaimableAttempt.phase === "running"
+                                ? this.attemptRecovery(snapshot, reclaimableAttempt)
+                                : null,
+                        };
+                    }
+                    catch (error) {
+                        if (this.isVersionConflict(error))
+                            continue;
+                        throw error;
+                    }
+                }
+                return {
+                    kind: "wait",
+                    reason_code: "attempt_active",
+                    run: this.toView(snapshot, plan),
+                };
+            }
+            if (!activation) {
+                return { kind: "wait", reason_code: "dependencies_pending", run: this.toView(snapshot, plan) };
+            }
+            const retrySegmentEvent = [...snapshot.events].reverse().find((event) => (event.type === "retry_segment_scheduled"
+                && event.payload.retry_from_activation_id === activation.activation_id));
+            if (retrySegmentEvent
+                && Date.parse(now) < Date.parse(retrySegmentEvent.payload.ready_at)) {
+                return { kind: "wait", reason_code: "retry_backoff", run: this.toView(snapshot, plan) };
+            }
+            const attemptNumber = activation.attempt_count + 1;
+            if (attemptNumber > 1) {
+                const priorAttempt = snapshot.attempts.find((candidate) => (candidate.activation_id === activation.activation_id
+                    && candidate.attempt_number === attemptNumber - 1));
+                const retryNode = nodeById(plan.plan, activation.step_id);
+                if (priorAttempt?.completed_at && retryNode.kind === "worker") {
+                    const eligibleAt = Date.parse(priorAttempt.completed_at)
+                        + this.retryDelay(retryNode, priorAttempt.attempt_number);
+                    if (Date.parse(now) < eligibleAt) {
+                        return {
+                            kind: "wait",
+                            reason_code: "retry_backoff",
+                            run: this.toView(snapshot, plan),
+                        };
+                    }
+                }
+            }
+            const attemptId = this.identities.create("attempt", `${activation.activation_id}\0${attemptNumber}`);
+            const attempt = {
+                run_id: snapshot.run.run_id,
+                step_id: activation.step_id,
+                activation_id: activation.activation_id,
+                attempt_id: attemptId,
+                attempt_number: attemptNumber,
+                phase: "claimed",
+                executor: null,
+                started_at: null,
+                completed_at: null,
+                terminal_outcome: null,
+            };
+            const claim = this.createClaim(snapshot, plan, attempt, request.driver_id, now, 1);
+            const claimedActivation = {
+                ...activation,
+                state: "claimed",
+                attempt_count: attemptNumber,
+                current_attempt_id: attemptId,
+                updated_at: now,
+            };
+            const events = [
+                this.activationEvent(snapshot, 0, activation, claimedActivation, "driver_claimed", now),
+                this.event(snapshot, 1, {
+                    type: "attempt_claimed",
+                    step_id: attempt.step_id,
+                    activation_id: attempt.activation_id,
+                    attempt_id: attempt.attempt_id,
+                    result_id: null,
+                    key: `attempt:${attempt.attempt_id}:claim:1`,
+                    at: now,
+                    payload: {
+                        claim_epoch: 1,
+                        owner_id: request.driver_id,
+                        claim_expires_at: claim.driver_claim_lease.expires_at,
+                        execution_deadline_at: claim.execution_deadline_at,
+                    },
+                }),
+            ];
+            if (attemptNumber > 1) {
+                const priorAttempt = snapshot.attempts.find((candidate) => (candidate.activation_id === activation.activation_id
+                    && candidate.attempt_number === attemptNumber - 1));
+                if (priorAttempt) {
+                    events.push(this.event(snapshot, events.length, {
+                        type: "retry_scheduled",
+                        step_id: attempt.step_id,
+                        activation_id: attempt.activation_id,
+                        attempt_id: priorAttempt.attempt_id,
+                        result_id: null,
+                        key: `attempt:${priorAttempt.attempt_id}:retry:${attempt.attempt_id}`,
+                        at: now,
+                        payload: {
+                            prior_attempt_id: priorAttempt.attempt_id,
+                            replacement_attempt_id: attempt.attempt_id,
+                            next_attempt_number: attemptNumber,
+                            delay_ms: nodeById(plan.plan, attempt.step_id).kind === "worker"
+                                ? this.retryDelay(nodeById(plan.plan, attempt.step_id), priorAttempt.attempt_number)
+                                : 0,
+                            reason_code: "retry_claimed",
+                        },
+                    }));
+                }
+            }
+            try {
+                snapshot = (await this.runStore.updateCanonicalRun({
+                    run_id: snapshot.run.run_id,
+                    expected_record_version: snapshot.record_version,
+                    activations: [claimedActivation],
+                    attempts: [attempt],
+                    claims: [claim],
+                    events,
+                })).snapshot;
+                return {
+                    kind: "attempt",
+                    lease: this.toLease(snapshot, attempt, claim),
+                    recovery: null,
+                };
+            }
+            catch (error) {
+                if (this.isVersionConflict(error))
+                    continue;
+                throw error;
+            }
+        }
+    }
+    async attachAttempt(request) {
+        const located = await this.locateLease(request.lease_token, request.owner_id, false);
+        this.assertRunAttachable(located.snapshot);
+        const { activation, plan } = located;
+        this.assertVerifierExecutionSupported(plan.plan);
+        this.assertCapabilities(plan.plan.required_capabilities, request.capabilities);
+        const executor = typeof request.worker_identity === "string"
+            ? { kind: "worker", worker_session_id: request.worker_identity }
+            : request.worker_identity;
+        const node = nodeById(plan.plan, activation.step_id);
+        const expectedExecutorKind = node.kind === "worker"
+            ? "worker"
+            : node.kind === "system" ? "system" : node.kind === "interaction" ? "human" : null;
+        if (expectedExecutorKind === null || executor.kind !== expectedExecutorKind) {
+            throw new CanonicalRunServiceError(executor.kind === "worker" ? "attempt_state_conflict" : "unsupported", executor.kind === "worker"
+                ? `${node.kind} node requires ${expectedExecutorKind ?? "no"} executor`
+                : `external ${executor.kind} attach is unsupported in the canonical service`);
+        }
+        if (node.kind === "worker" && executor.kind === "worker") {
+            return this.attachWorkerAttempt(request, executor);
+        }
+        const { snapshot, claim, attempt } = located;
+        if (attempt.phase === "running") {
+            if (attempt.executor === null || canonicalizeJson(attempt.executor) !== canonicalizeJson(executor)) {
+                throw new CanonicalRunServiceError("attempt_state_conflict", "attempt is attached to a different executor");
+            }
+            return { lease: this.toLeaseView(snapshot, attempt, claim), attempt, activation, packet: null };
+        }
+        if (attempt.phase !== "claimed" || activation.state !== "claimed") {
+            throw new CanonicalRunServiceError("attempt_state_conflict", `attempt ${attempt.attempt_id} is not claimable`);
+        }
+        const now = this.now();
+        const runningAttempt = {
+            ...attempt,
+            phase: "running",
+            executor,
+            started_at: now,
+        };
+        const runningActivation = {
+            ...activation,
+            state: activation.state === "claimed" && nodeById(plan.plan, activation.step_id).kind === "interaction"
+                ? "waiting_for_human"
+                : "running",
+            updated_at: now,
+        };
+        const packet = null;
+        const events = [
+            this.activationEvent(snapshot, 0, activation, runningActivation, "attempt_attached", now),
+            this.event(snapshot, 1, {
+                type: "attempt_attached",
+                step_id: attempt.step_id,
+                activation_id: attempt.activation_id,
+                attempt_id: attempt.attempt_id,
+                result_id: null,
+                key: `attempt:${attempt.attempt_id}:attached`,
+                at: now,
+                payload: { claim_epoch: claim.claim_epoch, executor },
+            }),
+            this.event(snapshot, 2, {
+                type: "attempt_started",
+                step_id: attempt.step_id,
+                activation_id: attempt.activation_id,
+                attempt_id: attempt.attempt_id,
+                result_id: null,
+                key: `attempt:${attempt.attempt_id}:started`,
+                at: now,
+                payload: { executor },
+            }),
+        ];
+        events.push(...this.handoffResolutionEvents(snapshot, runningAttempt, packet, events.length, now));
+        if (node.kind === "interaction" && executor.kind === "human") {
+            events.push(this.event(snapshot, events.length, {
+                type: "interaction_requested",
+                step_id: attempt.step_id,
+                activation_id: attempt.activation_id,
+                attempt_id: attempt.attempt_id,
+                result_id: null,
+                key: `interaction:${node.interaction_id}:requested:${attempt.attempt_id}`,
+                at: now,
+                payload: {
+                    interaction_id: node.interaction_id,
+                    expected_principal_ref: executor.principal_ref,
+                },
+            }));
+        }
+        try {
+            const updated = (await this.runStore.updateCanonicalRun({
+                run_id: snapshot.run.run_id,
+                expected_record_version: snapshot.record_version,
+                activations: [runningActivation],
+                attempts: [runningAttempt],
+                events,
+            })).snapshot;
+            return {
+                lease: this.toLeaseView(updated, runningAttempt, claim),
+                attempt: runningAttempt,
+                activation: runningActivation,
+                packet,
+            };
+        }
+        catch (error) {
+            if (this.isVersionConflict(error)) {
+                const current = await this.locateLease(request.lease_token, request.owner_id, false);
+                this.assertRunAttachable(current.snapshot);
+                throw new CanonicalRunServiceError("stale_lease", "attempt changed while attaching", { cause: error });
+            }
+            throw error;
+        }
+    }
+    async attachWorkerAttempt(request, executor) {
+        if (this.workspaceAuthority === null) {
+            throw new CanonicalRunServiceError("unsupported", "attempt workspace authority is unavailable");
+        }
+        for (;;) {
+            const located = await this.locateLease(request.lease_token, request.owner_id, false);
+            let { snapshot, claim, attempt, activation, plan } = located;
+            this.assertRunAttachable(snapshot);
+            const node = nodeById(plan.plan, activation.step_id);
+            if (node.kind !== "worker")
+                throw new CanonicalRunServiceError("attempt_state_conflict", "attempt is not a worker node");
+            if (attempt.executor !== null && canonicalizeJson(attempt.executor) !== canonicalizeJson(executor)) {
+                throw new CanonicalRunServiceError("attempt_state_conflict", "attempt is attached to a different executor");
+            }
+            if (attempt.phase === "running") {
+                const allocation = this.requireCommittedWorkspace(snapshot, attempt, node);
+                return this.withWorkspaceAuthority(allocation, "prepare_inputs", false, async () => ({
+                    lease: this.toLeaseView(snapshot, attempt, claim),
+                    attempt,
+                    activation,
+                    packet: await this.materializePacket(snapshot, plan, activation, attempt, executor, allocation),
+                }));
+            }
+            if (attempt.phase !== "claimed" || activation.state !== "claimed") {
+                throw new CanonicalRunServiceError("attempt_state_conflict", `attempt ${attempt.attempt_id} is not claimable`);
+            }
+            let workspacePlan = this.workspacePlan(snapshot, attempt.attempt_id);
+            if (workspacePlan === null) {
+                workspacePlan = await this.planWorkspace(plan, snapshot.run, activation, attempt);
+                const now = this.now();
+                const events = [
+                    this.event(snapshot, 0, {
+                        type: "workspace_planned", step_id: attempt.step_id, activation_id: attempt.activation_id,
+                        attempt_id: attempt.attempt_id, result_id: null, key: `attempt:${attempt.attempt_id}:workspace:planned`, at: now,
+                        payload: { workspace_plan_id: workspacePlan.workspace_plan_id, plan: workspacePlan },
+                    }),
+                ];
+                try {
+                    snapshot = (await this.runStore.updateCanonicalRun({
+                        run_id: snapshot.run.run_id, expected_record_version: snapshot.record_version,
+                        events,
+                    })).snapshot;
+                }
+                catch (error) {
+                    if (this.isVersionConflict(error))
+                        continue;
+                    throw error;
+                }
+            }
+            let allocation = this.workspaceAllocation(snapshot, attempt.attempt_id);
+            if (allocation === null) {
+                try {
+                    snapshot = await this.workspaceAuthority.ensureWithExclusiveAuthority(workspacePlan, async (ensured) => {
+                        this.validateWorkspaceAllocation(ensured, attempt, node);
+                        const now = this.now();
+                        return (await this.runStore.updateCanonicalRun({
+                            run_id: snapshot.run.run_id,
+                            expected_record_version: snapshot.record_version,
+                            events: [this.event(snapshot, 0, {
+                                    type: "workspace_allocated", step_id: attempt.step_id, activation_id: attempt.activation_id,
+                                    attempt_id: attempt.attempt_id, result_id: null, key: `attempt:${attempt.attempt_id}:workspace:allocated`, at: now,
+                                    payload: { workspace_plan_id: workspacePlan.workspace_plan_id, allocation: ensured },
+                                })],
+                        })).snapshot;
+                    });
+                    allocation = this.requireCommittedWorkspace(snapshot, attempt, node);
+                }
+                catch (error) {
+                    if (this.isVersionConflict(error))
+                        continue;
+                    throw this.workspaceError(error, "attempt workspace ensure failed");
+                }
+            }
+            try {
+                return await this.withWorkspaceAuthority(allocation, "prepare_inputs", true, async () => {
+                    const now = this.now();
+                    const runningAttempt = { ...attempt, phase: "running", executor, started_at: now };
+                    const runningActivation = { ...activation, state: "running", updated_at: now };
+                    const packet = await this.materializePacket(snapshot, plan, runningActivation, runningAttempt, executor, allocation);
+                    const events = [
+                        this.activationEvent(snapshot, 0, activation, runningActivation, "attempt_attached", now),
+                        this.event(snapshot, 1, {
+                            type: "attempt_attached", step_id: attempt.step_id, activation_id: attempt.activation_id,
+                            attempt_id: attempt.attempt_id, result_id: null, key: `attempt:${attempt.attempt_id}:attached`, at: now,
+                            payload: { claim_epoch: claim.claim_epoch, executor },
+                        }),
+                        this.event(snapshot, 2, {
+                            type: "attempt_started", step_id: attempt.step_id, activation_id: attempt.activation_id,
+                            attempt_id: attempt.attempt_id, result_id: null, key: `attempt:${attempt.attempt_id}:started`, at: now,
+                            payload: { executor },
+                        }),
+                        ...this.handoffResolutionEvents(snapshot, runningAttempt, packet, 3, now),
+                    ];
+                    const updated = (await this.runStore.updateCanonicalRun({
+                        run_id: snapshot.run.run_id, expected_record_version: snapshot.record_version,
+                        activations: [runningActivation], attempts: [runningAttempt], events,
+                    })).snapshot;
+                    return { lease: this.toLeaseView(updated, runningAttempt, claim), attempt: runningAttempt, activation: runningActivation, packet };
+                });
+            }
+            catch (error) {
+                if (this.isVersionConflict(error))
+                    continue;
+                throw error;
+            }
+        }
+    }
+    async heartbeat(request) {
+        for (;;) {
+            const { snapshot, claim, attempt } = await this.locateLease(request.lease_token, request.owner_id, false);
+            if (this.stopIntentFor(snapshot, attempt.attempt_id) !== null) {
+                throw new CanonicalRunServiceError("stale_lease", "attempt stop has been requested");
+            }
+            if (attempt.phase === "terminal") {
+                throw new CanonicalRunServiceError("attempt_state_conflict", "terminal attempt cannot heartbeat");
+            }
+            const now = this.now();
+            if (Date.parse(now) < Date.parse(claim.driver_claim_lease.heartbeat_at)) {
+                throw new CanonicalRunServiceError("invalid_request", "heartbeat clock moved backward");
+            }
+            if (now === claim.driver_claim_lease.heartbeat_at) {
+                return { ...this.toLeaseView(snapshot, attempt, claim), heartbeat_at: now };
+            }
+            const expiresAt = new Date(Math.min(Date.parse(claim.execution_deadline_at), Date.parse(now) + this.leaseDurationMs)).toISOString();
+            const renewed = {
+                ...claim,
+                driver_claim_lease: {
+                    ...claim.driver_claim_lease,
+                    heartbeat_at: now,
+                    expires_at: expiresAt,
+                },
+            };
+            const event = this.event(snapshot, 0, {
+                type: "attempt_heartbeat",
+                step_id: attempt.step_id,
+                activation_id: attempt.activation_id,
+                attempt_id: attempt.attempt_id,
+                result_id: null,
+                key: `claim:${attempt.attempt_id}:epoch:${claim.claim_epoch}:heartbeat:${now}`,
+                at: now,
+                payload: {
+                    claim_epoch: claim.claim_epoch,
+                    heartbeat_at: now,
+                    claim_expires_at: expiresAt,
+                },
+            });
+            try {
+                const updated = (await this.runStore.updateCanonicalRun({
+                    run_id: snapshot.run.run_id,
+                    expected_record_version: snapshot.record_version,
+                    claims: [renewed],
+                    events: [event],
+                })).snapshot;
+                return { ...this.toLeaseView(updated, attempt, renewed), heartbeat_at: now };
+            }
+            catch (error) {
+                if (this.isVersionConflict(error))
+                    continue;
+                throw error;
+            }
+        }
+    }
+    async submitAttempt(request) {
+        requireNonEmpty(request.submission_key, "submission_key");
+        if (request.execution.stdout_reference != null
+            || request.execution.stderr_reference != null) {
+            throw new CanonicalRunServiceError("invalid_request", "caller cannot submit service-owned stdout or stderr evidence");
+        }
+        for (const evidence of request.evidence_refs ?? []) {
+            if (["submission", "verifier_evidence", "artifact_capture", "worker_stopped"].includes(evidence.kind)) {
+                throw new CanonicalRunServiceError("invalid_request", `caller cannot submit service-owned ${evidence.kind} evidence`);
+            }
+        }
+        const submissionKeyDigest = digest({ submission_key: request.submission_key });
+        const submissionDigest = digest({
+            execution: request.execution,
+            evidence_refs: request.evidence_refs ?? [],
+        });
+        const initial = await this.locateLease(request.lease_token, request.owner_id, true, true);
+        this.assertVerifierExecutionSupported(initial.plan.plan);
+        const resultId = resultIdFor(this.identities, initial.attempt.attempt_id);
+        const replay = await this.findReplay(initial.snapshot, initial.plan, initial.attempt.attempt_id, resultId, submissionKeyDigest, submissionDigest);
+        if (replay) {
+            const drained = await this.drainReadySystemNodes(initial.snapshot, initial.plan);
+            return { ...replay, run: this.toView(drained, initial.plan) };
+        }
+        if (initial.snapshot.run.terminal !== null || initial.snapshot.run.status === "cancelling") {
+            throw new CanonicalRunServiceError("run_terminal", initial.snapshot.run.status === "cancelling" ? "run cancellation has been requested" : "run is terminal");
+        }
+        const orphan = await this.resultStore.loadPublished(resultId);
+        if (orphan) {
+            const submission = this.submissionEvidence(orphan.result);
+            if (submission.submission_key_digest !== submissionKeyDigest
+                || submission.submission_digest !== submissionDigest) {
+                throw new CanonicalRunServiceError("submission_conflict", "attempt has a different published submission");
+            }
+            const reconciled = await this.reconcilePublishedResult(initial.snapshot, initial.plan, orphan.result);
+            const drained = await this.drainReadySystemNodes(reconciled, initial.plan);
+            return {
+                result: orphan.result,
+                replayed: true,
+                run: this.toView(drained, initial.plan),
+            };
+        }
+        if (initial.attempt.phase !== "running" || initial.attempt.executor === null) {
+            throw new CanonicalRunServiceError("attempt_state_conflict", "attempt must be attached before submit");
+        }
+        if (canonicalizeJson(initial.attempt.executor) !== canonicalizeJson(request.execution.executor)) {
+            throw new CanonicalRunServiceError("stale_lease", "submission executor does not match attached executor");
+        }
+        if (request.execution.started_at !== initial.attempt.started_at) {
+            throw new CanonicalRunServiceError("submission_conflict", "execution.started_at does not match the durable attempt");
+        }
+        const submittedAt = this.clock.now().getTime();
+        const completedAt = Date.parse(request.execution.completed_at);
+        if (!Number.isFinite(completedAt)
+            || completedAt < Date.parse(request.execution.started_at)
+            || completedAt > submittedAt) {
+            throw new CanonicalRunServiceError("invalid_request", "execution completion time is invalid");
+        }
+        const executionDeadline = Date.parse(initial.claim.execution_deadline_at);
+        if (submittedAt >= executionDeadline) {
+            const node = nodeById(initial.plan.plan, initial.attempt.step_id);
+            const finalizationDeadline = executionDeadline + (node.kind === "worker" ? node.attempt_policy.cancellation_grace_ms : 0);
+            if (!isExecutionDeadlineTimeout(request.execution)
+                || submittedAt > finalizationDeadline
+                || completedAt > finalizationDeadline) {
+                throw new CanonicalRunServiceError("stale_lease", "attempt execution deadline has elapsed");
+            }
+        }
+        await this.validateCallerAttestationIndependence(initial.snapshot, initial.plan, initial.activation, request.evidence_refs ?? []);
+        const allocation = this.requireCommittedWorkspace(initial.snapshot, initial.attempt, nodeById(initial.plan.plan, initial.activation.step_id));
+        const authoritativeWorkspace = allocation.working_directory;
+        if (resolve(request.execution.workspace.root) !== resolve(authoritativeWorkspace)
+            || request.execution.workspace.workspace_id !== initial.attempt.attempt_id) {
+            throw new CanonicalRunServiceError("submission_conflict", "execution workspace does not match the attempt allocation");
+        }
+        const finalized = await this.withStoppedExecution(initial.snapshot, initial.claim, initial.attempt, request.execution, "finalize_result", null, async (executionAuthority) => this.withWorkspaceAuthority(allocation, "finalize_result", false, async (workspaceAuthority) => {
+            validateCanonicalAttemptOutcome(request.execution.executor, request.execution.outcome);
+            this.validateSubmittedOutputs(initial.snapshot, initial.plan, initial.activation, request.execution);
+            const captureRequest = {
+                run_id: initial.snapshot.run.run_id,
+                activation_id: initial.activation.activation_id,
+                attempt_id: initial.attempt.attempt_id,
+                execution: request.execution,
+            };
+            const captured = await this.outputCapture.capture(captureRequest);
+            await this.hooks.after_output_capture?.(captureRequest);
+            const verifierBindings = await this.verifierHandoffBindings(initial.snapshot, initial.plan, initial.activation, initial.attempt, allocation);
+            const verifyRequest = {
+                plan: initial.plan,
+                run: initial.snapshot.run,
+                activation: initial.activation,
+                attempt: initial.attempt,
+                execution: request.execution,
+                workspace_allocation: allocation,
+                captured_outputs: captured.outputs,
+                handoff_bindings: verifierBindings,
+            };
+            const mandatoryVerification = await this.verifier.verify(verifyRequest);
+            const additionalVerification = await this.additionalVerifier?.verify(verifyRequest) ?? [];
+            this.validateVerificationLanes(verifyRequest, mandatoryVerification, additionalVerification);
+            const invalidGitCommit = mandatoryVerification.find((result) => (result.verifier_id.endsWith(":git_commit_provenance") && !result.passed));
+            if (invalidGitCommit) {
+                throw new CanonicalRunServiceError("verification_failed", `git_commit output failed attempt provenance verification: ${invalidGitCommit.verifier_id}`);
+            }
+            const verification = [...mandatoryVerification, ...additionalVerification];
+            await this.validateCommandVerifierReceipts(verifyRequest, mandatoryVerification);
+            await this.hooks.after_verification?.(verifyRequest);
+            await captured.revalidate();
+            this.validateDecisionOutputs(initial.plan.plan, initial.activation.step_id, captured.outputs);
+            const verifierEvidence = verification.flatMap((item) => item.evidence_refs ?? []);
+            if (verification.some((item) => ((item.evidence_refs ?? []).some((evidence) => evidence.verifier_id !== item.verifier_id)))) {
+                throw new CanonicalRunServiceError("verification_failed", "verifier evidence identity does not match its parent result");
+            }
+            const verificationResults = [
+                ...mandatoryVerification.map((item) => ({
+                    verifier_id: item.verifier_id,
+                    authority: "service",
+                    passed: item.passed,
+                    reason_code: item.reason_code,
+                    evidence_refs: item.evidence_refs ?? [],
+                    domain_value: item.domain_value ?? null,
+                })),
+                ...additionalVerification.map((item) => ({
+                    verifier_id: item.verifier_id,
+                    authority: "additional",
+                    passed: item.passed,
+                    reason_code: item.reason_code,
+                    evidence_refs: item.evidence_refs ?? [],
+                    domain_value: item.domain_value ?? null,
+                })),
+            ];
+            const now = this.now();
+            const result = {
+                schema_version: CANONICAL_RESULT_SCHEMA_VERSION,
+                run_id: initial.snapshot.run.run_id,
+                step_id: initial.attempt.step_id,
+                activation_id: initial.attempt.activation_id,
+                attempt_id: initial.attempt.attempt_id,
+                result_id: resultId,
+                executor: request.execution.executor,
+                terminal_outcome: request.execution.outcome,
+                outputs: captured.outputs,
+                verification_results: verificationResults,
+                started_at: request.execution.started_at,
+                completed_at: request.execution.completed_at,
+                committed_at: now,
+                stdout_reference: request.execution.stdout_reference ?? null,
+                stderr_reference: request.execution.stderr_reference ?? null,
+                evidence_refs: [
+                    ...(request.evidence_refs ?? []),
+                    ...captured.captures.map((capture) => ({
+                        kind: "artifact_capture",
+                        capture,
+                    })),
+                    ...verifierEvidence,
+                    ...(executionAuthority === null ? [] : [{
+                            kind: "worker_stopped",
+                            receipt: executionAuthority.stop_receipt,
+                        }]),
+                    { kind: "submission", submission_key_digest: submissionKeyDigest, submission_digest: submissionDigest },
+                ],
+            };
+            let published;
+            try {
+                published = await this.resultStore.publish(result);
+            }
+            catch (error) {
+                if (error instanceof ResultStoreError && error.code === "immutable_conflict") {
+                    const winner = await this.resultStore.loadPublished(resultId);
+                    if (winner) {
+                        const submission = this.submissionEvidence(winner.result);
+                        if (submission.submission_key_digest === submissionKeyDigest
+                            && submission.submission_digest === submissionDigest) {
+                            return {
+                                kind: "reconcile_published_winner",
+                                result: winner.result,
+                            };
+                        }
+                    }
+                    throw new CanonicalRunServiceError("submission_conflict", `attempt ${initial.attempt.attempt_id} already has a conflicting published result`, { cause: error });
+                }
+                throw error;
+            }
+            await this.hooks.after_result_publish?.(published.result);
+            for (;;) {
+                const located = await this.locateLease(request.lease_token, request.owner_id, true, true);
+                const replayAfterPublish = await this.findReplay(located.snapshot, located.plan, located.attempt.attempt_id, resultId, submissionKeyDigest, submissionDigest);
+                if (replayAfterPublish) {
+                    const drained = await this.drainReadySystemNodes(located.snapshot, located.plan);
+                    return {
+                        kind: "response",
+                        response: { ...replayAfterPublish, run: this.toView(drained, located.plan) },
+                    };
+                }
+                if (located.snapshot.run.status === "cancelling") {
+                    throw new CanonicalRunServiceError("run_terminal", "run cancellation has been requested");
+                }
+                if (located.attempt.phase !== "running" || located.attempt.executor === null) {
+                    throw new CanonicalRunServiceError("stale_lease", "attempt is no longer authoritative");
+                }
+                await captured.revalidate();
+                await this.revalidateWorkspaceObservations(published.result, allocation);
+                const committedAt = this.now();
+                const drained = await this.prepareFailurePeerStops(located.snapshot, located.plan, located.attempt, published.result.terminal_outcome, committedAt);
+                if (drained.record_version !== located.snapshot.record_version)
+                    continue;
+                const decisionOutputs = await this.loadDecisionOutputs(located.snapshot, located.plan, published.result);
+                const update = await this.buildSubmissionUpdate(located.snapshot, located.plan, located.activation, located.attempt, published.result, published.reference, captured.captures, verification, submissionKeyDigest, submissionDigest, committedAt, decisionOutputs, {
+                    worker_stop_receipt_digest: executionAuthority?.stop_receipt.receipt_digest ?? null,
+                    worker_stop_receipt: executionAuthority?.stop_receipt ?? null,
+                    workspace_authority: workspaceAuthority,
+                    purpose: "finalize_result",
+                });
+                if (update.run?.terminal !== null) {
+                    const peerDrained = await this.prepareTerminalPeerStops(located.snapshot, located.attempt, committedAt);
+                    if (peerDrained.record_version !== located.snapshot.record_version)
+                        continue;
+                }
+                try {
+                    const snapshot = (await this.runStore.updateCanonicalRun(update)).snapshot;
+                    const drained = await this.drainReadySystemNodes(snapshot, located.plan);
+                    return {
+                        kind: "response",
+                        response: {
+                            result: published.result,
+                            replayed: !published.published,
+                            run: this.toView(drained, located.plan),
+                        },
+                    };
+                }
+                catch (error) {
+                    if (this.isVersionConflict(error))
+                        continue;
+                    throw error;
+                }
+            }
+        }));
+        if (finalized.kind === "response")
+            return finalized.response;
+        const current = await this.requireSnapshot(initial.snapshot.run.run_id);
+        const replayAfterAuthorityRelease = await this.findReplay(current, initial.plan, initial.attempt.attempt_id, resultId, submissionKeyDigest, submissionDigest);
+        if (replayAfterAuthorityRelease) {
+            const drained = await this.drainReadySystemNodes(current, initial.plan);
+            return { ...replayAfterAuthorityRelease, run: this.toView(drained, initial.plan) };
+        }
+        const reconciled = await this.reconcilePublishedResult(current, initial.plan, finalized.result);
+        const drained = await this.drainReadySystemNodes(reconciled, initial.plan);
+        return {
+            result: finalized.result,
+            replayed: true,
+            run: this.toView(drained, initial.plan),
+        };
+    }
+    async failAttempt(request) {
+        const located = await this.locateLease(request.lease_token, request.owner_id, true);
+        if (located.attempt.executor === null || located.attempt.started_at === null) {
+            throw new CanonicalRunServiceError("attempt_state_conflict", "attempt must be attached before failure");
+        }
+        const allocation = this.requireCommittedWorkspace(located.snapshot, located.attempt, nodeById(located.plan.plan, located.activation.step_id));
+        const completedAt = request.completed_at ?? this.now();
+        return this.submitAttempt({
+            lease_token: request.lease_token,
+            owner_id: request.owner_id,
+            submission_key: request.submission_key,
+            execution: {
+                executor: located.attempt.executor,
+                started_at: located.attempt.started_at,
+                completed_at: completedAt,
+                outcome: request.outcome,
+                outputs: [],
+                workspace: {
+                    root: allocation.working_directory,
+                    workspace_id: allocation.workspace_id,
+                },
+            },
+            evidence_refs: request.evidence_refs,
+        });
+    }
+    async settleDriverFailure(request) {
+        requireNonEmpty(request.failure_key, "failure_key");
+        requireNonEmpty(request.reason_code, "reason_code");
+        const located = await this.locateLease(request.lease_token, request.owner_id, true);
+        if (located.attempt.executor?.kind !== "worker" || located.attempt.started_at === null) {
+            throw new CanonicalRunServiceError("attempt_state_conflict", "driver failure settlement requires an attached worker attempt");
+        }
+        const failureDigest = digest({
+            failure_key: request.failure_key,
+            reason_code: request.reason_code,
+            message: request.message,
+        });
+        if (located.attempt.phase === "terminal") {
+            this.assertDriverFailureReplay(located.snapshot, located.attempt, failureDigest, request);
+            return this.toView(located.snapshot, located.plan);
+        }
+        if (this.executionAuthority?.attestNeverLaunched === undefined) {
+            throw new CanonicalRunServiceError("unsupported", "nonlaunch execution authority is unavailable");
+        }
+        const recovery = this.attemptRecovery(located.snapshot, located.attempt);
+        const now = this.now();
+        const authorityRequest = {
+            run_id: located.attempt.run_id,
+            step_id: located.attempt.step_id,
+            activation_id: located.attempt.activation_id,
+            attempt_id: located.attempt.attempt_id,
+            execution_claim_epoch: recovery.execution_claim_epoch,
+            executor: located.attempt.executor,
+            started_at: located.attempt.started_at,
+            failure_idempotency_key: failureDigest,
+            requested_at: now,
+        };
+        let attestation;
+        try {
+            attestation = await this.executionAuthority.attestNeverLaunched(authorityRequest);
+        }
+        catch (error) {
+            const authorityCode = typeof error === "object"
+                && error !== null
+                && "code" in error
+                ? String(error.code)
+                : null;
+            if (authorityCode === "identity_conflict") {
+                throw new CanonicalRunServiceError("submission_conflict", "execution authority has already recorded a different launch or nonlaunch fact", { cause: error });
+            }
+            throw new CanonicalRunServiceError("unsupported", "execution authority cannot attest that the worker was never launched", { cause: error });
+        }
+        if (!workerNonlaunchAttestationMatches(attestation, authorityRequest)) {
+            throw new CanonicalRunServiceError("submission_conflict", "nonlaunch attestation does not match the driver failure");
+        }
+        const outcome = {
+            kind: "worker_process",
+            status: "failed",
+            reason_code: request.reason_code,
+            message: request.message,
+            process: { kind: "launch_error", exit_code: null, signal: null, error: request.message ?? request.reason_code },
+        };
+        for (;;) {
+            const snapshot = await this.requireSnapshot(located.snapshot.run.run_id);
+            this.assertCurrentClaim(snapshot, located.attempt, located.claim, request);
+            const attempt = snapshot.attempts.find((candidate) => candidate.attempt_id === located.attempt.attempt_id);
+            const activation = snapshot.activations.find((candidate) => candidate.activation_id === located.activation.activation_id);
+            if (!attempt || !activation)
+                throw new CanonicalRunServiceError("attempt_state_conflict", "driver failure attempt disappeared");
+            if (attempt.phase === "terminal") {
+                this.assertDriverFailureReplay(snapshot, attempt, failureDigest, request);
+                return this.toView(snapshot, located.plan);
+            }
+            const drained = await this.prepareFailurePeerStops(snapshot, located.plan, attempt, outcome, attestation.payload.attested_at);
+            if (drained.record_version !== snapshot.record_version)
+                continue;
+            const update = await this.buildNonlaunchFailureUpdate(snapshot, located.plan, activation, attempt, outcome, failureDigest, attestation);
+            try {
+                const updated = (await this.runStore.updateCanonicalRun(update)).snapshot;
+                return this.toView(updated, located.plan);
+            }
+            catch (error) {
+                if (this.isVersionConflict(error))
+                    continue;
+                throw error;
+            }
+        }
+    }
+    assertDriverFailureReplay(snapshot, attempt, failureDigest, request) {
+        const event = snapshot.events.find((candidate) => candidate.type === "attempt_terminal" && candidate.attempt_id === attempt.attempt_id);
+        const attestation = event?.payload.worker_nonlaunch_attestation ?? null;
+        if (attestation?.payload.failure_idempotency_key === failureDigest
+            && attempt.terminal_outcome?.kind === "worker_process"
+            && attempt.terminal_outcome.reason_code === request.reason_code
+            && attempt.terminal_outcome.message === request.message)
+            return;
+        throw new CanonicalRunServiceError("submission_conflict", "attempt has a different committed driver failure");
+    }
+    async inspect(runId) {
+        const snapshot = await this.requireSnapshot(runId);
+        return this.toView(snapshot, await this.requirePinnedPlan(snapshot));
+    }
+    async inspectAudit(runId) {
+        const snapshot = await this.requireSnapshot(runId);
+        const view = this.toView(snapshot, await this.requirePinnedPlan(snapshot));
+        return {
+            ...view,
+            events: snapshot.events.map(publicAuditEvent),
+            ledger: {
+                created_at: snapshot.created_at,
+                updated_at: snapshot.updated_at,
+                record_version: snapshot.record_version,
+            },
+        };
+    }
+    async resume(runId) {
+        let snapshot = await this.requireSnapshot(runId);
+        const plan = await this.requirePinnedPlan(snapshot);
+        this.assertVerifierExecutionSupported(plan.plan);
+        snapshot = await this.continueDurableStops(snapshot);
+        snapshot = await this.drainReadySystemNodes(snapshot, plan);
+        return this.toView(snapshot, plan);
+    }
+    async cancel(runIdOrRequest, reason) {
+        const request = typeof runIdOrRequest === "string"
+            ? { run_id: runIdOrRequest, reason: reason ?? null }
+            : { run_id: runIdOrRequest.run_id, reason: runIdOrRequest.reason ?? null };
+        let snapshot;
+        let plan;
+        for (;;) {
+            snapshot = await this.requireSnapshot(request.run_id);
+            plan = await this.requirePinnedPlan(snapshot);
+            if (snapshot.run.terminal !== null)
+                return this.toView(snapshot, plan);
+            if (snapshot.run.status === "cancelling")
+                break;
+            const now = this.now();
+            const cancellation = { requested_at: now, reason: request.reason };
+            const cancellingRun = {
+                ...snapshot.run,
+                status: "cancelling",
+                cancellation,
+                updated_at: now,
+            };
+            const event = this.event(snapshot, 0, {
+                type: "run_cancel_requested", step_id: null, activation_id: null,
+                attempt_id: null, result_id: null, key: `run:${request.run_id}:cancel-requested`, at: now,
+                payload: { reason: request.reason },
+            });
+            try {
+                snapshot = (await this.runStore.updateCanonicalRun({
+                    run_id: request.run_id,
+                    expected_record_version: snapshot.record_version,
+                    run: cancellingRun,
+                    events: [event],
+                })).snapshot;
+                break;
+            }
+            catch (error) {
+                if (this.isVersionConflict(error))
+                    continue;
+                throw error;
+            }
+        }
+        snapshot = await this.persistStopIntents(snapshot, this.cancellationStopSpecifications(snapshot));
+        snapshot = await this.continueDurableStops(snapshot);
+        plan = await this.requirePinnedPlan(snapshot);
+        return this.toView(snapshot, plan);
+    }
+    systemInput(snapshot, name) {
+        const value = snapshot.run.run_binding.binding.validated_inputs[name];
+        if (typeof value !== "string" || value.trim() === "") {
+            throw new CanonicalRunServiceError("invalid_request", `system input ${name} must be a non-empty string`);
+        }
+        return value;
+    }
+    async requireOriginResult(current, planId, resultId) {
+        if (!SHA256_DIGEST_PATTERN.test(planId)) {
+            throw new CanonicalRunServiceError("invalid_request", "origin plan id must be a lowercase sha256 digest");
+        }
+        const published = await this.resultStore.loadPublished(resultId);
+        if (!published) {
+            throw new CanonicalRunServiceError("invalid_request", `origin result ${resultId} was not found`);
+        }
+        if (published.result.run_id === current.run.run_id) {
+            throw new CanonicalRunServiceError("invalid_request", "canonical import must reference a previous run");
+        }
+        const snapshot = await this.runStore.loadCanonicalRun(published.result.run_id);
+        if (!snapshot || snapshot.run.plan_id !== planId) {
+            throw new CanonicalRunServiceError("submission_conflict", "origin result does not belong to the declared plan");
+        }
+        const reference = snapshot.result_refs.find((candidate) => candidate.result_id === resultId);
+        if (!reference) {
+            throw new CanonicalRunServiceError("submission_conflict", "origin result is not committed in its run ledger");
+        }
+        const result = await this.resultStore.require(reference);
+        if (canonicalizeJson(result) !== canonicalizeJson(published.result)
+            || canonicalAttemptOutcomeStatus(result.terminal_outcome) !== "succeeded") {
+            throw new CanonicalRunServiceError("submission_conflict", "origin result is not an immutable successful result");
+        }
+        return { snapshot, result, reference };
+    }
+    async captureImportedOutput(snapshot, activation, attempt, source, sourceOutput, outputName) {
+        if (sourceOutput.kind === "text") {
+            return { output: { ...sourceOutput, name: outputName }, capture: null };
+        }
+        if (sourceOutput.kind === "structured") {
+            return { output: { ...sourceOutput, name: outputName }, capture: null };
+        }
+        const captured = await this.artifactStore.captureExisting({
+            artifact_id: sourceOutput.capture.artifact_id,
+            artifact_kind: sourceOutput.capture.artifact_kind,
+            run_id: snapshot.run.run_id,
+            activation_id: activation.activation_id,
+            attempt_id: attempt.attempt_id,
+            output_name: outputName,
+            source_workspace_id: `canonical:${source.run_id}`,
+            source_path: sourceOutput.capture.source_path,
+        });
+        return {
+            output: { name: outputName, kind: "artifact", capture: captured.capture },
+            capture: captured.capture,
+        };
+    }
+    validateSystemOutputs(plan, node, outputs) {
+        const contracts = new Map((node.output_contract ?? []).map((contract) => [contract.name, contract]));
+        const seen = new Set();
+        for (const output of outputs) {
+            if (seen.has(output.name)) {
+                throw new CanonicalRunServiceError("verification_failed", `system output ${output.name} is duplicated`);
+            }
+            seen.add(output.name);
+            const contract = contracts.get(output.name);
+            if (!contract) {
+                throw new CanonicalRunServiceError("verification_failed", `system output ${output.name} is undeclared`);
+            }
+            const kind = output.kind === "artifact" ? "reference" : output.kind;
+            if (contract.kind !== kind) {
+                throw new CanonicalRunServiceError("verification_failed", `system output ${output.name} kind does not match its contract`);
+            }
+            if (output.kind === "artifact" && contract.artifact_kind !== output.capture.artifact_kind) {
+                throw new CanonicalRunServiceError("verification_failed", `system output ${output.name} artifact kind does not match its contract`);
+            }
+            if (output.kind === "structured") {
+                const validation = validatePinnedStructuredOutput({
+                    plan: plan.plan,
+                    node_id: node.node_id,
+                    output_name: output.name,
+                    schema_ref: output.schema_ref,
+                    value: output.value,
+                }, this.structuredOutputSchemaRegistry);
+                if (!validation.valid) {
+                    throw new CanonicalRunServiceError("verification_failed", `system output ${output.name} failed structured validation at ${validation.path}: ${validation.message}`);
+                }
+            }
+        }
+        for (const contract of contracts.values()) {
+            if (contract.required && !seen.has(contract.name)) {
+                throw new CanonicalRunServiceError("verification_failed", `required system output ${contract.name} is missing`);
+            }
+        }
+    }
+    currentRunResult(snapshot, nodeId) {
+        const activation = this.latestActivationForStep(snapshot.activations, nodeId);
+        if (!activation?.committed_result_id || activation.state !== "succeeded") {
+            throw new CanonicalRunServiceError("attempt_state_conflict", `system source node ${nodeId} has no successful committed result`);
+        }
+        const reference = snapshot.result_refs.find((candidate) => candidate.result_id === activation.committed_result_id);
+        if (!reference) {
+            throw new CanonicalRunServiceError("submission_conflict", `system source result ${activation.committed_result_id} is missing from the run ledger`);
+        }
+        return { resultId: activation.committed_result_id, reference };
+    }
+    systemRequirementSatisfied(snapshot, plan, nodeId) {
+        const node = nodeById(plan.plan, nodeId);
+        if (node.kind === "gate") {
+            return snapshot.events.some((event) => (event.type === "gate_evaluated"
+                && event.payload.gate_id === nodeId
+                && event.payload.passed));
+        }
+        if (ATTEMPT_NODE_KINDS.has(node.kind)) {
+            const activation = this.latestActivationForStep(snapshot.activations, nodeId);
+            return activation?.state === "succeeded" && activation.committed_result_id !== null;
+        }
+        return snapshot.events.some((event) => ((event.type === "decision_evaluated" && event.payload.decision_id === nodeId)
+            || (event.type === "run_terminal" && node.kind === "terminal")));
+    }
+    async executeSystemOperation(snapshot, plan, activation, attempt, node) {
+        const operation = node.operation;
+        if (operation.kind === "resolve_diagnosis_source") {
+            const mode = this.systemInput(snapshot, operation.mode_input);
+            if (!new Set(["fresh", "legacy", "canonical"]).has(mode)) {
+                throw new CanonicalRunServiceError("invalid_request", `unsupported diagnosis source mode ${mode}`);
+            }
+            return {
+                outputs: [{
+                        name: operation.output_name,
+                        kind: "structured",
+                        value: { mode },
+                        schema_ref: node.output_contract?.find((output) => output.name === operation.output_name)?.schema_ref ?? null,
+                    }],
+                captures: [],
+                evidence_refs: [],
+                system_origin: { kind: "run_input", input_names: [operation.mode_input] },
+            };
+        }
+        if (operation.kind === "adopt_artifact" || operation.kind === "adopt_artifact_bundle") {
+            const artifacts = operation.kind === "adopt_artifact"
+                ? [{
+                        source_reference_input: operation.source_reference_input,
+                        expected_digest_input: operation.expected_digest_input,
+                        output_name: operation.output_name,
+                        artifact_kind: "file",
+                    }]
+                : operation.artifacts;
+            const outputs = [];
+            const captures = [];
+            const sources = [];
+            for (const artifact of artifacts) {
+                const sourcePath = this.systemInput(snapshot, artifact.source_reference_input);
+                const expectedDigest = this.systemInput(snapshot, artifact.expected_digest_input);
+                if (!SHA256_DIGEST_PATTERN.test(expectedDigest)) {
+                    throw new CanonicalRunServiceError("invalid_request", `system input ${artifact.expected_digest_input} must be a lowercase sha256 digest`);
+                }
+                const captured = await this.artifactStore.capture({
+                    kind: artifact.artifact_kind,
+                    workspace_root: snapshot.run.run_binding.binding.project_root,
+                    source_path: sourcePath,
+                    run_id: snapshot.run.run_id,
+                    activation_id: activation.activation_id,
+                    attempt_id: attempt.attempt_id,
+                    output_name: artifact.output_name,
+                    source_workspace_id: `project:${textDigest(snapshot.run.run_binding.binding.project_root)}`,
+                });
+                if (captured.object.artifact_id !== expectedDigest) {
+                    throw new CanonicalRunServiceError("source_drift", `legacy artifact ${sourcePath} does not match its expected digest`);
+                }
+                outputs.push({ name: artifact.output_name, kind: "artifact", capture: captured.capture });
+                captures.push(captured.capture);
+                sources.push({ source_path: sourcePath, expected_digest: expectedDigest, artifact_id: captured.object.artifact_id });
+            }
+            return {
+                outputs,
+                captures,
+                evidence_refs: [],
+                system_origin: { kind: "legacy_external", sources },
+            };
+        }
+        if (operation.kind === "import_result" || operation.kind === "import_result_bundle") {
+            const origin = await this.requireOriginResult(snapshot, this.systemInput(snapshot, operation.source_plan_input), this.systemInput(snapshot, operation.source_result_input));
+            const mappings = operation.kind === "import_result"
+                ? [{ source_output_name: operation.output_name, output_name: operation.output_name }]
+                : operation.required_outputs;
+            const outputs = [];
+            const captures = [];
+            for (const mapping of mappings) {
+                const sourceOutput = origin.result.outputs.find((output) => output.name === mapping.source_output_name);
+                if (!sourceOutput) {
+                    throw new CanonicalRunServiceError("submission_conflict", `origin result lacks output ${mapping.source_output_name}`);
+                }
+                const copied = await this.captureImportedOutput(snapshot, activation, attempt, origin.result, sourceOutput, mapping.output_name);
+                outputs.push(copied.output);
+                if (copied.capture)
+                    captures.push(copied.capture);
+            }
+            return {
+                outputs,
+                captures,
+                evidence_refs: [{ kind: "result", result: origin.reference }],
+                system_origin: {
+                    kind: "canonical_import",
+                    origin_plan_id: origin.snapshot.run.plan_id,
+                    origin_run_ids: [origin.result.run_id],
+                    origin_result_ids: [origin.result.result_id],
+                    origin_artifact_ids: origin.result.outputs.flatMap((output) => output.kind === "artifact" ? [output.capture.artifact_id] : []),
+                    policy_id: null,
+                },
+            };
+        }
+        if (operation.kind === "import_review") {
+            const sourcePlanId = this.systemInput(snapshot, operation.source_plan_input);
+            const diagnosis = await this.requireOriginResult(snapshot, sourcePlanId, this.systemInput(snapshot, operation.source_diagnosis_result_input));
+            const review = await this.requireOriginResult(snapshot, sourcePlanId, this.systemInput(snapshot, operation.source_review_result_input));
+            const diagnosisArtifactNames = diagnosis.result.outputs.flatMap((output) => (output.kind === "artifact" ? [output.name] : []));
+            const boundOutputNames = new Set(review.snapshot.events.flatMap((event) => (event.type === "handoff_resolved"
+                && event.activation_id === review.result.activation_id
+                && event.payload.source_result_id === diagnosis.result.result_id
+                ? [event.payload.output_name]
+                : [])));
+            if (diagnosisArtifactNames.length === 0
+                || diagnosisArtifactNames.some((name) => !boundOutputNames.has(name))) {
+                throw new CanonicalRunServiceError("submission_conflict", "origin review is not bound to the declared diagnosis result artifacts");
+            }
+            const verdictMapping = operation.required_outputs.find((mapping) => (node.output_contract?.find((contract) => contract.name === mapping.output_name)?.kind === "structured"));
+            const verdict = review.result.outputs.find((output) => (output.kind === "structured" && output.name === verdictMapping?.source_output_name));
+            const verdictValue = verdict?.kind === "structured" ? verdict.value : null;
+            const verdictRecord = verdictValue !== null
+                && typeof verdictValue === "object"
+                && !Array.isArray(verdictValue)
+                ? verdictValue
+                : null;
+            if (verdict?.kind !== "structured"
+                || verdictRecord === null
+                || verdictRecord.verdict !== "APPROVE"
+                || verdictRecord.contract_valid !== true) {
+                throw new CanonicalRunServiceError("submission_conflict", "origin diagnosis review is not an approved typed verdict");
+            }
+            const outputs = [];
+            const captures = [];
+            for (const mapping of operation.required_outputs) {
+                const sourceOutput = review.result.outputs.find((output) => output.name === mapping.source_output_name);
+                if (!sourceOutput) {
+                    throw new CanonicalRunServiceError("submission_conflict", `origin review lacks output ${mapping.source_output_name}`);
+                }
+                const copied = await this.captureImportedOutput(snapshot, activation, attempt, review.result, sourceOutput, mapping.output_name);
+                outputs.push(copied.output);
+                if (copied.capture)
+                    captures.push(copied.capture);
+            }
+            const artifactIds = [...diagnosis.result.outputs, ...review.result.outputs].flatMap((output) => (output.kind === "artifact" ? [output.capture.artifact_id] : []));
+            return {
+                outputs,
+                captures,
+                evidence_refs: [
+                    { kind: "result", result: diagnosis.reference },
+                    { kind: "result", result: review.reference },
+                ],
+                system_origin: {
+                    kind: "canonical_import",
+                    origin_plan_id: diagnosis.snapshot.run.plan_id,
+                    origin_run_ids: [...new Set([diagnosis.result.run_id, review.result.run_id])],
+                    origin_result_ids: [diagnosis.result.result_id, review.result.result_id],
+                    origin_artifact_ids: [...new Set(artifactIds)],
+                    policy_id: operation.policy_id,
+                },
+            };
+        }
+        if (operation.kind === "seal_result_bundle") {
+            const candidates = operation.candidates.filter((candidate) => (candidate.required_node_ids.every((nodeId) => this.systemRequirementSatisfied(snapshot, plan, nodeId))));
+            if (candidates.length !== 1) {
+                throw new CanonicalRunServiceError("attempt_state_conflict", `system seal requires exactly one satisfied candidate, found ${candidates.length}`);
+            }
+            const selected = candidates[0];
+            const sourceByNode = new Map();
+            for (const mapping of selected.outputs) {
+                if (sourceByNode.has(mapping.source_node_id))
+                    continue;
+                const current = this.currentRunResult(snapshot, mapping.source_node_id);
+                sourceByNode.set(mapping.source_node_id, {
+                    result: await this.resultStore.require(current.reference),
+                    reference: current.reference,
+                });
+            }
+            const outputs = [];
+            const captures = [];
+            for (const mapping of selected.outputs) {
+                const source = sourceByNode.get(mapping.source_node_id);
+                const sourceOutput = source.result.outputs.find((output) => output.name === mapping.source_output_name);
+                if (!sourceOutput) {
+                    throw new CanonicalRunServiceError("submission_conflict", `seal source ${mapping.source_node_id} lacks output ${mapping.source_output_name}`);
+                }
+                const copied = await this.captureImportedOutput(snapshot, activation, attempt, source.result, sourceOutput, mapping.output_name);
+                outputs.push(copied.output);
+                if (copied.capture)
+                    captures.push(copied.capture);
+            }
+            const sourceResults = [...sourceByNode.values()];
+            if (operation.origin_output_name !== undefined) {
+                const primary = sourceResults[0]?.result;
+                const mode = primary?.executor.kind === "worker"
+                    ? "fresh"
+                    : primary?.system_origin?.kind === "legacy_external"
+                        ? "legacy"
+                        : primary?.system_origin?.kind === "canonical_import"
+                            ? "canonical"
+                            : null;
+                if (!primary || mode === null) {
+                    throw new CanonicalRunServiceError("submission_conflict", "diagnosis seal cannot determine its typed origin");
+                }
+                outputs.push({
+                    name: operation.origin_output_name,
+                    kind: "structured",
+                    value: { mode, source_node_id: primary.step_id, source_result_id: primary.result_id },
+                    schema_ref: node.output_contract?.find((output) => output.name === operation.origin_output_name)?.schema_ref ?? null,
+                });
+            }
+            return {
+                outputs,
+                captures,
+                evidence_refs: sourceResults.map((source) => ({ kind: "result", result: source.reference })),
+                system_origin: {
+                    kind: "current_run_results",
+                    source_result_ids: sourceResults.map((source) => source.result.result_id),
+                },
+            };
+        }
+        if (operation.kind === "materialize_handoff") {
+            const handoff = plan.plan.handoff_plan.find((candidate) => candidate.handoff_id === operation.handoff_id);
+            if (!handoff) {
+                throw new CanonicalRunServiceError("invalid_request", `handoff ${operation.handoff_id} is unavailable`);
+            }
+            const source = this.currentRunResult(snapshot, handoff.from_node_id);
+            return {
+                outputs: [],
+                captures: [],
+                evidence_refs: [{ kind: "result", result: source.reference }],
+                system_origin: { kind: "current_run_results", source_result_ids: [source.resultId] },
+            };
+        }
+        const exhaustive = operation;
+        throw new CanonicalRunServiceError("unsupported", `unsupported system operation ${exhaustive.kind}`);
+    }
+    async beginSystemAttempt(snapshot, plan, activation) {
+        const node = nodeById(plan.plan, activation.step_id);
+        if (node.kind !== "system" || activation.state !== "ready")
+            return snapshot;
+        const now = this.now();
+        const attemptNumber = activation.attempt_count + 1;
+        const attemptId = this.identities.create("attempt", `${activation.activation_id}\0${attemptNumber}`);
+        const attempt = {
+            run_id: snapshot.run.run_id,
+            step_id: activation.step_id,
+            activation_id: activation.activation_id,
+            attempt_id: attemptId,
+            attempt_number: attemptNumber,
+            phase: "claimed",
+            executor: null,
+            started_at: null,
+            completed_at: null,
+            terminal_outcome: null,
+        };
+        const claim = this.createClaim(snapshot, plan, attempt, `system:${this.serviceInstanceId}`, now, 1);
+        const claimedActivation = {
+            ...activation,
+            state: "claimed",
+            attempt_count: attemptNumber,
+            current_attempt_id: attemptId,
+            updated_at: now,
+        };
+        const events = [
+            this.activationEvent(snapshot, 0, activation, claimedActivation, "system_claimed", now),
+            this.event(snapshot, 1, {
+                type: "attempt_claimed",
+                step_id: attempt.step_id,
+                activation_id: attempt.activation_id,
+                attempt_id: attempt.attempt_id,
+                result_id: null,
+                key: `attempt:${attempt.attempt_id}:claim:1`,
+                at: now,
+                payload: {
+                    claim_epoch: 1,
+                    owner_id: claim.owner_id,
+                    claim_expires_at: claim.driver_claim_lease.expires_at,
+                    execution_deadline_at: claim.execution_deadline_at,
+                },
+            }),
+        ];
+        try {
+            return (await this.runStore.updateCanonicalRun({
+                run_id: snapshot.run.run_id,
+                expected_record_version: snapshot.record_version,
+                activations: [claimedActivation],
+                attempts: [attempt],
+                claims: [claim],
+                events,
+            })).snapshot;
+        }
+        catch (error) {
+            if (this.isVersionConflict(error))
+                return this.requireSnapshot(snapshot.run.run_id);
+            throw error;
+        }
+    }
+    async attachSystemAttempt(snapshot, plan, attempt) {
+        if (attempt.phase !== "claimed")
+            return snapshot;
+        const activation = snapshot.activations.find((candidate) => candidate.activation_id === attempt.activation_id);
+        const node = activation ? nodeById(plan.plan, activation.step_id) : null;
+        if (!activation || activation.state !== "claimed" || node?.kind !== "system")
+            return snapshot;
+        const now = this.now();
+        const executor = {
+            kind: "system",
+            service_instance_id: this.serviceInstanceId,
+            operation: node.operation.kind,
+        };
+        const runningAttempt = {
+            ...attempt,
+            phase: "running",
+            executor,
+            started_at: now,
+        };
+        const runningActivation = { ...activation, state: "running", updated_at: now };
+        const claim = this.claimsFor(snapshot, attempt.attempt_id).at(-1);
+        if (!claim) {
+            throw new CanonicalRunServiceError("submission_conflict", "claimed system attempt has no durable claim");
+        }
+        try {
+            return (await this.runStore.updateCanonicalRun({
+                run_id: snapshot.run.run_id,
+                expected_record_version: snapshot.record_version,
+                activations: [runningActivation],
+                attempts: [runningAttempt],
+                events: [
+                    this.activationEvent(snapshot, 0, activation, runningActivation, "system_started", now),
+                    this.event(snapshot, 1, {
+                        type: "attempt_attached",
+                        step_id: attempt.step_id,
+                        activation_id: attempt.activation_id,
+                        attempt_id: attempt.attempt_id,
+                        result_id: null,
+                        key: `attempt:${attempt.attempt_id}:attached`,
+                        at: now,
+                        payload: { claim_epoch: claim.claim_epoch, executor },
+                    }),
+                    this.event(snapshot, 2, {
+                        type: "attempt_started",
+                        step_id: attempt.step_id,
+                        activation_id: attempt.activation_id,
+                        attempt_id: attempt.attempt_id,
+                        result_id: null,
+                        key: `attempt:${attempt.attempt_id}:started`,
+                        at: now,
+                        payload: { executor },
+                    }),
+                ],
+            })).snapshot;
+        }
+        catch (error) {
+            if (this.isVersionConflict(error))
+                return this.requireSnapshot(snapshot.run.run_id);
+            throw error;
+        }
+    }
+    async reconcilePublishedSystemResult(initial, plan, result) {
+        for (;;) {
+            const snapshot = await this.requireSnapshot(initial.run.run_id);
+            if (snapshot.result_refs.some((reference) => reference.result_id === result.result_id))
+                return snapshot;
+            const attempt = snapshot.attempts.find((candidate) => candidate.attempt_id === result.attempt_id);
+            const activation = snapshot.activations.find((candidate) => candidate.activation_id === result.activation_id);
+            const node = activation ? nodeById(plan.plan, activation.step_id) : null;
+            if (!attempt
+                || !activation
+                || node?.kind !== "system"
+                || attempt.phase !== "running"
+                || attempt.executor?.kind !== "system"
+                || result.executor.kind !== "system"
+                || canonicalizeJson(attempt.executor) !== canonicalizeJson(result.executor)) {
+                throw new CanonicalRunServiceError("submission_conflict", `published system result ${result.result_id} cannot reconcile to its attempt`);
+            }
+            const published = await this.resultStore.loadPublished(result.result_id);
+            if (!published || canonicalizeJson(published.result) !== canonicalizeJson(result)) {
+                throw new CanonicalRunServiceError("submission_conflict", "published system result changed during reconciliation");
+            }
+            if (canonicalAttemptOutcomeStatus(result.terminal_outcome) === "succeeded") {
+                this.validateSystemOutputs(plan, node, result.outputs);
+                this.validateDecisionOutputs(plan.plan, node.node_id, result.outputs);
+            }
+            const submission = this.submissionEvidence(result);
+            const decisionOutputs = await this.loadDecisionOutputs(snapshot, plan, result);
+            const update = await this.buildSubmissionUpdate(snapshot, plan, activation, attempt, result, published.reference, result.outputs.flatMap((output) => output.kind === "artifact" ? [output.capture] : []), [], submission.submission_key_digest, submission.submission_digest, this.now(), decisionOutputs, {
+                worker_stop_receipt_digest: null,
+                worker_stop_receipt: null,
+                workspace_authority: null,
+                purpose: "system_operation",
+            });
+            try {
+                return (await this.runStore.updateCanonicalRun(update)).snapshot;
+            }
+            catch (error) {
+                if (this.isVersionConflict(error))
+                    continue;
+                throw error;
+            }
+        }
+    }
+    async completeSystemAttempt(snapshot, plan, attempt) {
+        const activation = snapshot.activations.find((candidate) => candidate.activation_id === attempt.activation_id);
+        const node = activation ? nodeById(plan.plan, activation.step_id) : null;
+        if (!activation || node?.kind !== "system" || attempt.phase !== "running" || attempt.executor?.kind !== "system") {
+            return snapshot;
+        }
+        const resultId = resultIdFor(this.identities, attempt.attempt_id);
+        const existing = await this.resultStore.loadPublished(resultId);
+        if (existing)
+            return this.reconcilePublishedSystemResult(snapshot, plan, existing.result);
+        let executed = null;
+        let outcome = { kind: "succeeded" };
+        try {
+            executed = await this.executeSystemOperation(snapshot, plan, activation, attempt, node);
+            this.validateSystemOutputs(plan, node, executed.outputs);
+            this.validateDecisionOutputs(plan.plan, node.node_id, executed.outputs);
+        }
+        catch (error) {
+            const code = error instanceof CanonicalRunServiceError ? error.code : "system_operation_failed";
+            outcome = {
+                kind: "failed",
+                reason_code: `system_${code}`,
+                message: error instanceof Error ? error.message : String(error),
+            };
+        }
+        const completedAt = this.now();
+        const submissionKeyDigest = digest({
+            kind: "system_operation",
+            run_id: snapshot.run.run_id,
+            attempt_id: attempt.attempt_id,
+            operation: node.operation.kind,
+        });
+        const submissionDigest = digest({
+            operation: node.operation,
+            outcome,
+            outputs: executed?.outputs ?? [],
+            system_origin: executed?.system_origin ?? null,
+        });
+        const result = {
+            schema_version: CANONICAL_RESULT_SCHEMA_VERSION,
+            run_id: snapshot.run.run_id,
+            step_id: attempt.step_id,
+            activation_id: attempt.activation_id,
+            attempt_id: attempt.attempt_id,
+            result_id: resultId,
+            executor: attempt.executor,
+            terminal_outcome: outcome,
+            outputs: executed?.outputs ?? [],
+            verification_results: [],
+            started_at: attempt.started_at,
+            completed_at: completedAt,
+            committed_at: completedAt,
+            stdout_reference: null,
+            stderr_reference: null,
+            evidence_refs: [
+                ...(executed?.evidence_refs ?? []),
+                ...(executed?.captures ?? []).map((capture) => ({ kind: "artifact_capture", capture })),
+                { kind: "submission", submission_key_digest: submissionKeyDigest, submission_digest: submissionDigest },
+            ],
+            system_origin: executed?.system_origin ?? null,
+        };
+        try {
+            const published = await this.resultStore.publish(result);
+            if (published.published)
+                await this.hooks.after_result_publish?.(published.result);
+            return this.reconcilePublishedSystemResult(snapshot, plan, published.result);
+        }
+        catch (error) {
+            if (error instanceof ResultStoreError && error.code === "immutable_conflict") {
+                const winner = await this.resultStore.loadPublished(resultId);
+                if (winner)
+                    return this.reconcilePublishedSystemResult(snapshot, plan, winner.result);
+            }
+            throw error;
+        }
+    }
+    async drainReadySystemNodes(initial, plan) {
+        let snapshot = initial;
+        for (;;) {
+            snapshot = await this.reconcilePublishedResults(snapshot, plan);
+            snapshot = await this.reduceWithoutResult(snapshot, plan);
+            if (snapshot.run.terminal !== null || snapshot.run.status === "cancelling")
+                return snapshot;
+            const running = snapshot.attempts.find((attempt) => (attempt.phase !== "terminal"
+                && nodeById(plan.plan, attempt.step_id).kind === "system"));
+            if (running) {
+                snapshot = running.phase === "claimed"
+                    ? await this.attachSystemAttempt(snapshot, plan, running)
+                    : await this.completeSystemAttempt(snapshot, plan, running);
+                continue;
+            }
+            const ready = snapshot.activations.find((activation) => (activation.state === "ready"
+                && nodeById(plan.plan, activation.step_id).kind === "system"));
+            if (!ready)
+                return snapshot;
+            snapshot = await this.beginSystemAttempt(snapshot, plan, ready);
+        }
+    }
+    now() {
+        return this.clock.now().toISOString();
+    }
+    activationId(runId, nodeId) {
+        return this.identities.create("activation", `${runId}\0${nodeId}\0${0}`);
+    }
+    activationRoundId(runId, nodeId, round) {
+        return this.identities.create("activation", `${runId}\0${nodeId}\0${round - 1}`);
+    }
+    async requireSnapshot(runId) {
+        try {
+            return await this.runStore.requireCanonicalRun(runId);
+        }
+        catch (error) {
+            if (error instanceof RunStoreError && error.code === "run_not_found") {
+                throw new CanonicalRunServiceError("run_not_found", `run ${runId} was not found`, { cause: error });
+            }
+            throw error;
+        }
+    }
+    async requirePinnedPlan(snapshot) {
+        const plan = await this.planStore.requirePlan(snapshot.run.plan_id);
+        if (plan.plan_digest !== snapshot.run.plan_digest) {
+            throw new CanonicalRunServiceError("invalid_request", "pinned plan digest disagrees with run ledger");
+        }
+        return plan;
+    }
+    toView(snapshot, plan) {
+        return {
+            run: snapshot.run,
+            plan,
+            activations: snapshot.activations,
+            attempts: snapshot.attempts,
+            claims: snapshot.claims.map(({ claim_token: _claimToken, ...claim }) => claim),
+            results: snapshot.result_refs,
+            record_version: snapshot.record_version,
+        };
+    }
+    claimsFor(snapshot, attemptId) {
+        return snapshot.claims
+            .filter((claim) => claim.attempt_id === attemptId)
+            .sort((left, right) => left.claim_epoch - right.claim_epoch);
+    }
+    assertCurrentClaim(snapshot, attempt, claim, request) {
+        const activation = snapshot.activations.find((candidate) => candidate.activation_id === attempt.activation_id);
+        const latest = this.claimsFor(snapshot, attempt.attempt_id).at(-1);
+        if (activation?.current_attempt_id !== attempt.attempt_id
+            || latest === undefined
+            || latest.claim_token !== request.lease_token
+            || latest.owner_id !== request.owner_id
+            || latest.claim_epoch !== claim.claim_epoch) {
+            throw new CanonicalRunServiceError("stale_lease", "lease epoch changed while obtaining execution authority");
+        }
+    }
+    attemptRecovery(snapshot, attempt) {
+        if (attempt.executor?.kind !== "worker" || attempt.started_at === null) {
+            throw new CanonicalRunServiceError("attempt_state_conflict", `running attempt ${attempt.attempt_id} lacks a durable worker execution identity`);
+        }
+        const attached = snapshot.events.find((event) => event.type === "attempt_attached" && event.attempt_id === attempt.attempt_id);
+        if (!attached) {
+            throw new CanonicalRunServiceError("attempt_state_conflict", `running attempt ${attempt.attempt_id} lacks a durable attach event`);
+        }
+        return {
+            worker_session_id: attempt.executor.worker_session_id,
+            execution_claim_epoch: attached.payload.claim_epoch,
+        };
+    }
+    async runningAttemptIsRecoverable(snapshot, attempt, latestClaim, now, requestingDriverId) {
+        if (Date.parse(latestClaim.driver_claim_lease.expires_at) <= Date.parse(now))
+            return true;
+        if (latestClaim.owner_id === requestingDriverId)
+            return false;
+        if (this.executionAuthority?.probeRecovery === undefined)
+            return false;
+        const recovery = this.attemptRecovery(snapshot, attempt);
+        try {
+            const state = await this.executionAuthority.probeRecovery({
+                run_id: attempt.run_id,
+                step_id: attempt.step_id,
+                activation_id: attempt.activation_id,
+                attempt_id: attempt.attempt_id,
+                execution_claim_epoch: recovery.execution_claim_epoch,
+                executor: { kind: "worker", worker_session_id: recovery.worker_session_id },
+                started_at: attempt.started_at,
+            });
+            return state.raw_completion_durable;
+        }
+        catch (error) {
+            throw new CanonicalRunServiceError("unsupported", `running attempt ${attempt.attempt_id} recovery authority is unavailable`, { cause: error });
+        }
+    }
+    createClaim(snapshot, plan, attempt, ownerId, now, epoch) {
+        const node = attempt.step_id;
+        const definition = nodeById(plan.plan, node);
+        const planTimeout = definition.kind === "worker"
+            ? definition.attempt_policy.timeout_ms ?? this.defaultExecutionTimeoutMs
+            : this.defaultExecutionTimeoutMs;
+        const deadline = epoch === 1
+            ? addMilliseconds(now, planTimeout)
+            : this.claimsFor(snapshot, attempt.attempt_id)[0].execution_deadline_at;
+        const expires = new Date(Math.min(Date.parse(deadline), Date.parse(now) + this.leaseDurationMs)).toISOString();
+        return {
+            run_id: snapshot.run.run_id,
+            step_id: node,
+            activation_id: attempt.activation_id,
+            attempt_id: attempt.attempt_id,
+            claim_token: randomUUID(),
+            claim_epoch: epoch,
+            owner_id: ownerId,
+            claimed_record_version: snapshot.record_version,
+            driver_claim_lease: { acquired_at: now, heartbeat_at: now, expires_at: expires },
+            execution_deadline_at: deadline,
+        };
+    }
+    toLease(_snapshot, attempt, claim) {
+        return {
+            run_id: attempt.run_id,
+            step_id: attempt.step_id,
+            activation_id: attempt.activation_id,
+            attempt_id: attempt.attempt_id,
+            attempt_number: attempt.attempt_number,
+            claim_token: claim.claim_token,
+            claim_epoch: claim.claim_epoch,
+            owner_id: claim.owner_id,
+            claim_expires_at: claim.driver_claim_lease.expires_at,
+            execution_deadline_at: claim.execution_deadline_at,
+        };
+    }
+    toLeaseView(snapshot, attempt, claim) {
+        const { claim_token: _claimToken, ...lease } = this.toLease(snapshot, attempt, claim);
+        return lease;
+    }
+    async recoverExpiredAttempt(snapshot, plan, attempt, now) {
+        const activation = snapshot.activations.find((candidate) => candidate.activation_id === attempt.activation_id);
+        const node = nodeById(plan.plan, attempt.step_id);
+        const retryable = node.kind === "worker"
+            && attempt.attempt_number < node.attempt_policy.max_attempts
+            && node.attempt_policy.retryable_outcomes.includes("timeout");
+        const executor = attempt.executor ?? {
+            kind: "system",
+            service_instance_id: this.serviceInstanceId,
+            operation: "expire_unattached_attempt",
+        };
+        const timeoutMs = Math.max(1, Date.parse(this.claimsFor(snapshot, attempt.attempt_id).at(-1).execution_deadline_at)
+            - Date.parse(attempt.started_at ?? this.claimsFor(snapshot, attempt.attempt_id).at(-1).driver_claim_lease.acquired_at));
+        const outcome = executor.kind === "worker"
+            ? {
+                kind: "worker_process",
+                status: "failed",
+                reason_code: "execution_deadline_elapsed",
+                message: "worker execution deadline elapsed",
+                process: {
+                    kind: "timeout",
+                    exit_code: null,
+                    signal: null,
+                    timeout_ms: timeoutMs,
+                },
+            }
+            : retryable
+                ? { kind: "failed", reason_code: "execution_deadline_elapsed", message: null }
+                : { kind: "cancelled", reason: "execution deadline elapsed before attach" };
+        if (executor.kind === "worker") {
+            const specifications = snapshot.attempts.flatMap((candidate) => {
+                if (candidate.phase === "terminal" || candidate.executor?.kind !== "worker")
+                    return [];
+                const source = candidate.attempt_id === attempt.attempt_id;
+                const peerOutcome = source ? outcome : {
+                    kind: "worker_process",
+                    status: "cancelled",
+                    reason_code: "execution_deadline_elapsed",
+                    message: null,
+                    process: {
+                        kind: "cancelled",
+                        exit_code: null,
+                        signal: null,
+                        reason: "execution_deadline_elapsed",
+                    },
+                };
+                return [{
+                        attempt: candidate,
+                        purpose: source ? "execution_deadline" : "peer_terminal",
+                        requestedAt: now,
+                        outcome: peerOutcome,
+                    }];
+            });
+            snapshot = await this.persistStopIntents(snapshot, specifications);
+            return this.continueDurableStops(snapshot);
+        }
+        const terminalAttempt = {
+            ...attempt,
+            phase: "terminal",
+            executor,
+            started_at: attempt.started_at ?? now,
+            completed_at: now,
+            terminal_outcome: outcome,
+        };
+        const nextState = retryable
+            ? "ready"
+            : attempt.phase === "running" ? "failed" : "cancelled";
+        const nextActivation = {
+            ...activation,
+            state: nextState,
+            updated_at: now,
+        };
+        const events = [];
+        let offset = 0;
+        if (attempt.started_at === null) {
+            events.push(this.event(snapshot, offset++, {
+                type: "attempt_started", step_id: attempt.step_id,
+                activation_id: attempt.activation_id, attempt_id: attempt.attempt_id,
+                result_id: null, key: `attempt:${attempt.attempt_id}:deadline-started`, at: now,
+                payload: { executor },
+            }));
+        }
+        events.push(this.event(snapshot, offset++, {
+            type: "attempt_terminal", step_id: attempt.step_id,
+            activation_id: attempt.activation_id, attempt_id: attempt.attempt_id,
+            result_id: null, key: `attempt:${attempt.attempt_id}:deadline-terminal`, at: now,
+            payload: { executor, outcome, worker_stop_receipt: null, worker_nonlaunch_attestation: null },
+        }));
+        events.push(this.activationEvent(snapshot, offset++, activation, nextActivation, retryable ? "execution_deadline_retry" : "execution_deadline_exhausted", now));
+        let run = snapshot.run;
+        const activations = [nextActivation];
+        const attempts = [terminalAttempt];
+        if (!retryable) {
+            run = this.terminalRun(snapshot.run, "failed", "execution_deadline_elapsed", now);
+            const cancelledAttempts = await this.cancelConcurrentAttempts(snapshot, activation.activation_id, now, "execution_deadline_elapsed", events.length);
+            attempts.push(...cancelledAttempts.attempts);
+            events.push(...cancelledAttempts.events);
+            offset = events.length;
+            for (const other of snapshot.activations) {
+                if (other.activation_id === activation.activation_id || TERMINAL_ACTIVATION_STATES.has(other.state))
+                    continue;
+                const cancelled = { ...other, state: "cancelled", updated_at: now };
+                activations.push(cancelled);
+                events.push(this.activationEvent(snapshot, offset++, other, cancelled, "run_failed", now));
+            }
+            events.push(this.runTerminalEvent(snapshot, offset, run, now));
+        }
+        try {
+            return (await this.runStore.updateCanonicalRun({
+                run_id: snapshot.run.run_id,
+                expected_record_version: snapshot.record_version,
+                run,
+                activations,
+                attempts,
+                events,
+            })).snapshot;
+        }
+        catch (error) {
+            if (this.isVersionConflict(error))
+                return this.requireSnapshot(snapshot.run.run_id);
+            throw error;
+        }
+    }
+    async locateLease(token, ownerId, allowExpired, allowTerminal = false) {
+        requireNonEmpty(token, "lease_token");
+        const snapshots = await this.runStore.loadAllAnyRuns();
+        const snapshot = snapshots.find((candidate) => (candidate.schema_version === 2 && candidate.claims.some((claim) => claim.claim_token === token)));
+        if (!snapshot)
+            throw new CanonicalRunServiceError("lease_not_found", "lease token was not found");
+        const claim = snapshot.claims.find((candidate) => candidate.claim_token === token);
+        requireNonEmpty(ownerId, "owner_id");
+        if (claim.owner_id !== ownerId) {
+            throw new CanonicalRunServiceError("stale_lease", "lease is owned by a different driver");
+        }
+        const attempt = snapshot.attempts.find((candidate) => candidate.attempt_id === claim.attempt_id);
+        const activation = snapshot.activations.find((candidate) => candidate.activation_id === claim.activation_id);
+        if (!attempt || !activation) {
+            throw new CanonicalRunServiceError("lease_not_found", "lease target no longer exists");
+        }
+        if (activation.current_attempt_id !== attempt.attempt_id) {
+            throw new CanonicalRunServiceError("stale_lease", "attempt has been replaced");
+        }
+        const latest = this.claimsFor(snapshot, attempt.attempt_id).at(-1);
+        if (latest.claim_token !== token) {
+            throw new CanonicalRunServiceError("stale_lease", "lease epoch has been replaced");
+        }
+        if (snapshot.run.terminal !== null && !allowTerminal) {
+            throw new CanonicalRunServiceError("run_terminal", "run is terminal");
+        }
+        if (snapshot.run.terminal === null
+            && snapshot.run.status !== "cancelling"
+            && this.stopIntentFor(snapshot, attempt.attempt_id) !== null) {
+            throw new CanonicalRunServiceError("stale_lease", "attempt stop has been requested");
+        }
+        if (!allowExpired && Date.parse(claim.driver_claim_lease.expires_at) <= this.clock.now().getTime()) {
+            throw new CanonicalRunServiceError("lease_expired", "driver claim lease has expired");
+        }
+        return { snapshot, plan: await this.requirePinnedPlan(snapshot), claim, attempt, activation };
+    }
+    assertRunAttachable(snapshot) {
+        if (snapshot.run.terminal !== null || snapshot.run.status === "cancelling") {
+            throw new CanonicalRunServiceError("run_terminal", snapshot.run.status === "cancelling"
+                ? "run cancellation has been requested"
+                : "run is terminal");
+        }
+    }
+    assertCapabilities(required, provided) {
+        for (const [name, needed] of Object.entries(required)) {
+            if (needed && provided[name] !== true) {
+                throw new CanonicalRunServiceError("unsupported", `driver capability ${name} is required`);
+            }
+        }
+    }
+    commandVerifiers(plan) {
+        return plan.verifier_plan.filter((verifier) => ((verifier.kind === "command" || verifier.kind === "checkpoint") && verifier.command !== null));
+    }
+    assertVerifierExecutionSupported(plan) {
+        const commandVerifiers = this.commandVerifiers(plan);
+        if (commandVerifiers.length > 0
+            && !this.verifierAuthorityDescriptor.process_tree_containment) {
+            throw new CanonicalRunServiceError("unsupported", "command verifiers require a configured process-tree containment authority");
+        }
+        if (!plan.workspace_policy.allow_network
+            && commandVerifiers.length > 0
+            && !this.verifierAuthorityDescriptor.network_policies.includes("deny_all")) {
+            throw new CanonicalRunServiceError("unsupported", "command verifiers require a configured deny_all execution port");
+        }
+    }
+    async validateCommandVerifierReceipts(request, results) {
+        for (const verifier of this.commandVerifiers(request.plan.plan).filter((item) => (item.subject_node_id === request.activation.step_id))) {
+            const matchingResults = results.filter((result) => result.verifier_id === verifier.verifier_id);
+            const receipts = matchingResults.flatMap((result) => ((result.evidence_refs ?? []).flatMap((evidence) => (evidence.kind === "verifier_evidence" && evidence.execution_receipt !== null
+                ? [evidence.execution_receipt]
+                : []))));
+            if (matchingResults.length !== 1 || receipts.length !== 1) {
+                throw new CanonicalRunServiceError("verification_failed", `verifier ${verifier.verifier_id} requires exactly one service-owned execution receipt`);
+            }
+            const receipt = receipts[0];
+            const relativeWorkingDirectory = verifier.kind === "command" ? verifier.relative_working_directory : ".";
+            const resolved = resolveVerifierCommand(verifier.command, request.handoff_bindings, request.run.run_binding.binding.validated_inputs, request.plan.plan.input_contract.inputs);
+            const environment = canonicalVerifierEnvironment(resolved.environment);
+            const environmentBindingDigest = digest(Object.fromEntries(Object.entries(environment)
+                .sort(([left], [right]) => left.localeCompare(right))
+                .map(([name, value]) => [name, textDigest(value)])));
+            const networkPolicy = request.plan.plan.workspace_policy.allow_network ? "allow" : "deny_all";
+            const workingDirectory = await canonicalWorkspaceDirectory(request.execution.workspace.root, relativeWorkingDirectory, `verifier ${verifier.verifier_id} working_directory`);
+            const authorityDescriptorDigest = this.verifierAuthorityDescriptorDigest;
+            const cwdIdentity = {
+                workspace_id: request.execution.workspace.workspace_id,
+                workspace_allocation_digest: digest(request.workspace_allocation),
+                relative_working_directory: relativeWorkingDirectory,
+                absolute_path_digest: textDigest(workingDirectory),
+            };
+            const requestDescriptor = {
+                schema_version: "intentdna.verifier_execution_request.v1",
+                plan_id: request.plan.plan_id,
+                verifier_id: verifier.verifier_id,
+                verifier_definition_digest: digest(verifier),
+                raw_command_digest: textDigest(resolved.command),
+                cwd: cwdIdentity,
+                supplied_environment: {
+                    binding_digest: environmentBindingDigest,
+                    variable_names: Object.keys(environment).sort(),
+                    inherit_parent: false,
+                    startup_files: false,
+                },
+                shell: { executable: "bash", arguments: ["--noprofile", "--norc", "-c"] },
+                timeout_ms: 30_000,
+                requested_at: receipt.requested_at,
+                network_mode: networkPolicy,
+                expected_authority_descriptor_digest: authorityDescriptorDigest,
+            };
+            if (receipt.plan_id !== request.plan.plan_id
+                || receipt.verifier_id !== verifier.verifier_id
+                || receipt.verifier_definition_digest !== digest(verifier)
+                || receipt.resolved_command_digest !== textDigest(resolved.command)
+                || receipt.environment_binding_digest !== environmentBindingDigest
+                || canonicalizeJson(receipt.cwd_identity) !== canonicalizeJson(cwdIdentity)
+                || receipt.request_identity.request_digest !== digest(requestDescriptor)
+                || receipt.request_identity.command_digest !== receipt.resolved_command_digest
+                || receipt.request_identity.environment_digest !== receipt.environment_binding_digest
+                || receipt.request_identity.authority_descriptor_digest !== authorityDescriptorDigest
+                || receipt.request_identity.launch_descriptor_digest !== receipt.request_identity.request_digest
+                || receipt.supplied_environment.inherit_parent !== false
+                || receipt.supplied_environment.startup_files !== false
+                || canonicalizeJson(receipt.supplied_environment.variable_names) !== canonicalizeJson(Object.keys(environment).sort())
+                || receipt.shell_policy.executable !== "bash"
+                || canonicalizeJson(receipt.shell_policy.arguments) !== canonicalizeJson(["--noprofile", "--norc", "-c"])
+                || receipt.network_policy.mode !== networkPolicy
+                || (networkPolicy === "deny_all" && (receipt.network_policy.enforced !== true
+                    || receipt.network_policy.enforcement_kind !== "configured_adapter"
+                    || receipt.network_policy.enforcement_digest === null
+                    || receipt.network_policy.enforcement_descriptor === null
+                    || receipt.network_policy.enforcement_digest !== digest(receipt.network_policy.enforcement_descriptor)
+                    || receipt.network_policy.enforcement_descriptor.mode !== "deny_all"
+                    || receipt.network_policy.enforcement_descriptor.adapter_kind !== receipt.execution_authority.adapter_kind
+                    || receipt.network_policy.enforcement_descriptor.adapter_version !== receipt.execution_authority.adapter_version
+                    || receipt.network_policy.enforcement_descriptor.configuration_digest !== receipt.execution_authority.configuration_digest
+                    || receipt.network_policy.enforcement_descriptor.authority_descriptor_digest !== authorityDescriptorDigest
+                    || receipt.network_policy.enforcement_descriptor.request_digest !== receipt.request_identity.request_digest))
+                || (networkPolicy === "allow" && (receipt.network_policy.enforced !== false
+                    || receipt.network_policy.enforcement_kind !== "not_required"
+                    || receipt.network_policy.enforcement_digest !== null
+                    || receipt.network_policy.enforcement_descriptor !== null))
+                || receipt.execution_authority.authority_descriptor_digest !== authorityDescriptorDigest
+                || receipt.execution_authority.authority_instance_id !== this.verifierAuthorityDescriptor.authority_instance_id
+                || receipt.execution_authority.adapter_kind !== this.verifierAuthorityDescriptor.adapter_kind
+                || receipt.execution_authority.adapter_version !== this.verifierAuthorityDescriptor.adapter_version
+                || receipt.execution_authority.configuration_digest !== this.verifierAuthorityDescriptor.configuration_digest
+                || receipt.execution_authority.process_tree_drained !== true) {
+                const mismatch = {
+                    plan: receipt.plan_id !== request.plan.plan_id,
+                    verifier: receipt.verifier_definition_digest !== digest(verifier),
+                    command: receipt.resolved_command_digest !== textDigest(resolved.command),
+                    environment: receipt.environment_binding_digest !== environmentBindingDigest,
+                    cwd: canonicalizeJson(receipt.cwd_identity) !== canonicalizeJson(cwdIdentity),
+                    request: receipt.request_identity.request_digest !== digest(requestDescriptor),
+                    variables: canonicalizeJson(receipt.supplied_environment.variable_names) !== canonicalizeJson(Object.keys(environment).sort()),
+                    network: receipt.network_policy.mode !== networkPolicy,
+                };
+                throw new CanonicalRunServiceError("verification_failed", `verifier ${verifier.verifier_id} execution receipt does not match its pinned request: ${canonicalizeJson(mismatch)}`);
+            }
+        }
+    }
+    serviceVerifierIds(request) {
+        const node = nodeById(request.plan.plan, request.activation.step_id);
+        return new Set([
+            ...request.plan.plan.verifier_plan
+                .filter((verifier) => verifier.subject_node_id === request.activation.step_id)
+                .map((verifier) => verifier.verifier_id),
+            ...(node.kind === "worker"
+                ? node.packet_template.output_contract.flatMap((output) => [
+                    `output_contract:${output.name}`,
+                    ...(output.artifact_kind === "git_commit"
+                        ? [`output_contract:${output.name}:git_commit_provenance`]
+                        : []),
+                ])
+                : []),
+        ]);
+    }
+    validateVerificationLanes(request, serviceResults, additionalResults) {
+        const expected = this.serviceVerifierIds(request);
+        const actualServiceIds = new Set();
+        for (const result of serviceResults) {
+            requireNonEmpty(result.verifier_id, "service verifier_id");
+            if (!expected.has(result.verifier_id)) {
+                throw new CanonicalRunServiceError("verification_failed", `unexpected service verifier result ${result.verifier_id}`);
+            }
+            if (actualServiceIds.has(result.verifier_id)) {
+                throw new CanonicalRunServiceError("verification_failed", `mandatory verifier ${result.verifier_id} requires exactly one result`);
+            }
+            actualServiceIds.add(result.verifier_id);
+        }
+        for (const verifierId of expected) {
+            if (!actualServiceIds.has(verifierId)) {
+                throw new CanonicalRunServiceError("verification_failed", `mandatory verifier ${verifierId} requires exactly one result`);
+            }
+        }
+        const reserved = new Set([
+            ...request.plan.plan.verifier_plan.map((verifier) => verifier.verifier_id),
+            ...request.plan.plan.nodes.flatMap((node) => node.kind === "worker"
+                ? node.packet_template.output_contract.flatMap((output) => [
+                    `output_contract:${output.name}`,
+                    ...(output.artifact_kind === "git_commit"
+                        ? [`output_contract:${output.name}:git_commit_provenance`]
+                        : []),
+                ])
+                : []),
+        ]);
+        const additionalIds = new Set();
+        for (const result of additionalResults) {
+            requireNonEmpty(result.verifier_id, "additional verifier_id");
+            if (reserved.has(result.verifier_id)) {
+                throw new CanonicalRunServiceError("verification_failed", `additional verifier ${result.verifier_id} collides with service authority`);
+            }
+            if (additionalIds.has(result.verifier_id)) {
+                throw new CanonicalRunServiceError("verification_failed", `additional verifier ${result.verifier_id} requires exactly one result`);
+            }
+            additionalIds.add(result.verifier_id);
+        }
+    }
+    validateSubmittedOutputs(snapshot, plan, activation, execution) {
+        const node = nodeById(plan.plan, activation.step_id);
+        if (node.kind !== "worker") {
+            if (execution.outputs.length > 0) {
+                throw new CanonicalRunServiceError("invalid_request", `${node.kind} attempt cannot submit worker outputs`);
+            }
+            return;
+        }
+        const contracts = new Map(node.packet_template.output_contract.map((item) => [item.name, item]));
+        const seen = new Set();
+        for (const output of execution.outputs) {
+            if (seen.has(output.name)) {
+                throw new CanonicalRunServiceError("invalid_request", `duplicate output ${output.name}`);
+            }
+            seen.add(output.name);
+            const contract = contracts.get(output.name);
+            if (!contract) {
+                throw new CanonicalRunServiceError("invalid_request", `undeclared output ${output.name}`);
+            }
+            if (contract.kind !== output.kind) {
+                throw new CanonicalRunServiceError("invalid_request", `output ${output.name} kind does not match its contract`);
+            }
+            if (output.kind === "reference") {
+                if (contract.artifact_kind !== output.artifact_kind) {
+                    throw new CanonicalRunServiceError("invalid_request", `output ${output.name} artifact kind does not match its contract`);
+                }
+                const runtimeValues = new Map(Object.entries(snapshot.run.run_binding.binding.validated_inputs)
+                    .map(([name, value]) => [name, runtimeTemplateValue(value)]));
+                const expectedPath = contract.relative_path_template === null
+                    ? null
+                    : renderPacketPrompt(contract.relative_path_template, runtimeValues);
+                if (expectedPath !== null
+                    && resolve(execution.workspace.root, output.source_path)
+                        !== resolve(execution.workspace.root, expectedPath)) {
+                    throw new CanonicalRunServiceError("invalid_request", `output ${output.name} path does not match its contract`);
+                }
+            }
+            if (output.kind === "structured") {
+                const validation = validatePinnedStructuredOutput({
+                    plan: plan.plan,
+                    node_id: activation.step_id,
+                    output_name: output.name,
+                    schema_ref: output.schema_ref,
+                    value: output.value,
+                }, this.structuredOutputSchemaRegistry);
+                if (!validation.valid) {
+                    throw new CanonicalRunServiceError("verification_failed", `output ${output.name} failed structured validation at ${validation.path}: ${validation.message}`);
+                }
+            }
+        }
+        const succeeded = execution.outcome.kind === "worker_process"
+            && execution.outcome.status === "succeeded";
+        for (const contract of contracts.values()) {
+            if (succeeded && contract.required && !seen.has(contract.name)) {
+                throw new CanonicalRunServiceError("invalid_request", `required output ${contract.name} is missing`);
+            }
+        }
+    }
+    async validateCallerAttestationIndependence(snapshot, plan, activation, evidenceRefs) {
+        if (!plan.plan.required_capabilities.caller_attestation)
+            return;
+        const attestations = evidenceRefs.filter((evidence) => evidence.kind === "caller_attestation");
+        if (attestations.length !== 1 || attestations[0].payload === undefined) {
+            throw new CanonicalRunServiceError("unsupported", "run requires one trusted caller attestation identity payload");
+        }
+        const current = attestations[0].payload;
+        const sourceResultIds = new Set();
+        for (const handoff of plan.plan.handoff_plan.filter((item) => item.to_node_id === activation.step_id)) {
+            const sourceActivation = snapshot.activations
+                .filter((item) => item.step_id === handoff.from_node_id && item.committed_result_id !== null)
+                .at(-1);
+            if (sourceActivation?.committed_result_id !== null && sourceActivation?.committed_result_id !== undefined) {
+                sourceResultIds.add(sourceActivation.committed_result_id);
+            }
+        }
+        const visited = new Set();
+        const sourceIdentities = [];
+        const collectSourceIdentities = async (resultId) => {
+            if (visited.has(resultId))
+                return;
+            visited.add(resultId);
+            const published = await this.resultStore.loadPublished(resultId);
+            if (published === null) {
+                throw new CanonicalRunServiceError("submission_conflict", `source result ${resultId} is missing from immutable result storage`);
+            }
+            const sourceResult = published.result;
+            const sourceAttestations = sourceResult.evidence_refs.filter((evidence) => evidence.kind === "caller_attestation" && evidence.payload !== undefined);
+            if (sourceResult.executor.kind === "worker") {
+                if (sourceAttestations.length !== 1) {
+                    throw new CanonicalRunServiceError("submission_conflict", `source result ${resultId} lacks one trusted caller attestation identity`);
+                }
+                sourceIdentities.push(sourceAttestations[0].payload);
+                return;
+            }
+            const origin = sourceResult.system_origin;
+            if (sourceAttestations.length !== 0 || origin === null || origin === undefined) {
+                throw new CanonicalRunServiceError("submission_conflict", `system source result ${resultId} has invalid caller identity provenance`);
+            }
+            if (origin.kind === "current_run_results") {
+                for (const originResultId of origin.source_result_ids) {
+                    await collectSourceIdentities(originResultId);
+                }
+            }
+            else if (origin.kind === "canonical_import") {
+                for (const originResultId of origin.origin_result_ids) {
+                    await collectSourceIdentities(originResultId);
+                }
+            }
+        };
+        for (const resultId of sourceResultIds) {
+            await collectSourceIdentities(resultId);
+        }
+        for (const source of sourceIdentities) {
+            const sameAuthority = source.authority_id === current.authority_id;
+            if (source.worker_session_id === current.worker_session_id
+                || sameAuthority && (source.agent_id === current.agent_id
+                    || source.session_id === current.session_id)) {
+                throw new CanonicalRunServiceError("submission_conflict", "independent submission reuses the attested identity from its source result chain");
+            }
+        }
+    }
+    workspaceAllocation(snapshot, attemptId) {
+        const event = snapshot.events.find((candidate) => candidate.type === "workspace_allocated" && candidate.attempt_id === attemptId);
+        return event?.payload.allocation ?? null;
+    }
+    workspacePlan(snapshot, attemptId) {
+        const event = snapshot.events.find((candidate) => candidate.type === "workspace_planned" && candidate.attempt_id === attemptId);
+        return event?.payload.plan ?? null;
+    }
+    validateWorkspaceAllocation(allocation, attempt, node) {
+        if (allocation.workspace_id !== attempt.attempt_id) {
+            throw new CanonicalRunServiceError("unsupported", "workspace allocation identity does not match the attempt");
+        }
+        const expectedKind = node.kind === "worker" ? node.workspace.isolation : "none";
+        if (allocation.kind !== expectedKind) {
+            throw new CanonicalRunServiceError("unsupported", `workspace allocation kind ${allocation.kind} does not satisfy ${expectedKind}`);
+        }
+    }
+    requireCommittedWorkspace(snapshot, attempt, node) {
+        const allocation = this.workspaceAllocation(snapshot, attempt.attempt_id);
+        if (allocation === null) {
+            throw new CanonicalRunServiceError("unsupported", `attempt ${attempt.attempt_id} has no committed workspace allocation`);
+        }
+        this.validateWorkspaceAllocation(allocation, attempt, node);
+        return allocation;
+    }
+    async planWorkspace(plan, run, activation, attempt) {
+        if (this.workspaceAuthority === null) {
+            throw new CanonicalRunServiceError("unsupported", "attempt workspace authority is unavailable");
+        }
+        try {
+            return await this.workspaceAuthority.plan({ plan, run, activation, attempt });
+        }
+        catch (error) {
+            throw this.workspaceError(error, "attempt workspace planning is unavailable");
+        }
+    }
+    async withWorkspaceAuthority(allocation, purpose, requireCleanWorktree, operation) {
+        if (this.workspaceAuthority === null) {
+            throw new CanonicalRunServiceError("unsupported", "attempt workspace authority is unavailable");
+        }
+        let entered = false;
+        try {
+            return await this.workspaceAuthority.withExclusiveMutationAuthority({ allocation, purpose, require_clean_worktree: requireCleanWorktree }, async (authority) => {
+                entered = true;
+                if (authority.workspace_id !== allocation.workspace_id
+                    || authority.workspace_allocation_digest !== digest(allocation)
+                    || !authority.authority_instance_id
+                    || !Number.isSafeInteger(authority.fencing_epoch)
+                    || authority.fencing_epoch <= 0) {
+                    throw new CanonicalRunServiceError("workspace_conflict", "workspace mutation authority does not match the committed allocation");
+                }
+                return operation(authority);
+            });
+        }
+        catch (error) {
+            if (entered)
+                throw error;
+            throw this.workspaceError(error, "exclusive attempt workspace authority is unavailable");
+        }
+    }
+    workspaceError(error, message) {
+        if (error instanceof CanonicalRunServiceError)
+            return error;
+        const code = typeof error === "object" && error !== null && "code" in error
+            ? String(error.code)
+            : "";
+        return new CanonicalRunServiceError(["workspace_conflict", "workspace_mismatch", "path_conflict", "branch_conflict"].includes(code)
+            ? "workspace_conflict"
+            : "unsupported", message, { cause: error });
+    }
+    stopIntentFor(snapshot, attemptId) {
+        const event = snapshot.events.find((candidate) => (candidate.type === "attempt_stop_requested" && candidate.attempt_id === attemptId));
+        return event?.type === "attempt_stop_requested" ? event.payload.intent : null;
+    }
+    stopIdentity(attempt, executionClaimEpoch) {
+        return digest({
+            run_id: attempt.run_id,
+            step_id: attempt.step_id,
+            activation_id: attempt.activation_id,
+            attempt_id: attempt.attempt_id,
+            claim_epoch: executionClaimEpoch,
+            worker_session_id: attempt.executor?.kind === "worker"
+                ? attempt.executor.worker_session_id
+                : null,
+        });
+    }
+    async persistStopIntents(initial, specifications) {
+        let snapshot = initial;
+        for (;;) {
+            const events = [];
+            for (const specification of specifications) {
+                const attempt = snapshot.attempts.find((candidate) => candidate.attempt_id === specification.attempt.attempt_id);
+                if (!attempt || attempt.phase === "terminal" || this.stopIntentFor(snapshot, attempt.attempt_id))
+                    continue;
+                if (attempt.executor?.kind !== "worker" || attempt.started_at === null)
+                    continue;
+                const executionClaimEpoch = this.attemptRecovery(snapshot, attempt).execution_claim_epoch;
+                const intent = {
+                    schema_version: "intentdna.attempt_stop_intent.v1",
+                    run_id: attempt.run_id,
+                    step_id: attempt.step_id,
+                    activation_id: attempt.activation_id,
+                    attempt_id: attempt.attempt_id,
+                    claim_epoch: executionClaimEpoch,
+                    worker_session_id: attempt.executor.worker_session_id,
+                    stop_idempotency_key: this.stopIdentity(attempt, executionClaimEpoch),
+                    purpose: specification.purpose,
+                    requested_at: specification.requestedAt,
+                    started_at: attempt.started_at,
+                    requested_outcome: specification.outcome,
+                };
+                events.push(this.event(snapshot, events.length, {
+                    type: "attempt_stop_requested",
+                    step_id: attempt.step_id,
+                    activation_id: attempt.activation_id,
+                    attempt_id: attempt.attempt_id,
+                    result_id: null,
+                    key: `attempt:${attempt.attempt_id}:stop-requested`,
+                    at: specification.requestedAt,
+                    payload: { intent },
+                }));
+            }
+            if (events.length === 0)
+                return snapshot;
+            try {
+                return (await this.runStore.updateCanonicalRun({
+                    run_id: snapshot.run.run_id,
+                    expected_record_version: snapshot.record_version,
+                    events,
+                })).snapshot;
+            }
+            catch (error) {
+                if (!this.isVersionConflict(error))
+                    throw error;
+                snapshot = await this.requireSnapshot(snapshot.run.run_id);
+            }
+        }
+    }
+    async prepareFailurePeerStops(snapshot, plan, sourceAttempt, outcome, requestedAt) {
+        if (canonicalAttemptOutcomeStatus(outcome) === "succeeded")
+            return snapshot;
+        const node = nodeById(plan.plan, sourceAttempt.step_id);
+        const retryOutcome = outcome.kind === "worker_process" && outcome.process.kind !== "success"
+            ? outcome.process.kind
+            : canonicalAttemptOutcomeStatus(outcome) === "cancelled" ? "cancelled" : "malformed_result";
+        const retryable = node.kind === "worker"
+            && sourceAttempt.attempt_number < node.attempt_policy.max_attempts
+            && node.attempt_policy.retryable_outcomes.includes(retryOutcome);
+        if (retryable)
+            return snapshot;
+        const peers = snapshot.attempts.flatMap((attempt) => {
+            if (attempt.attempt_id === sourceAttempt.attempt_id || attempt.phase === "terminal" || attempt.executor?.kind !== "worker")
+                return [];
+            const peerOutcome = {
+                kind: "worker_process",
+                status: "cancelled",
+                reason_code: "peer_attempt_failed",
+                message: null,
+                process: { kind: "cancelled", exit_code: null, signal: null, reason: "peer_attempt_failed" },
+            };
+            return [{ attempt, purpose: "peer_terminal", requestedAt, outcome: peerOutcome }];
+        });
+        if (peers.length === 0)
+            return snapshot;
+        const withIntents = await this.persistStopIntents(snapshot, peers);
+        return this.continueDurableStops(withIntents);
+    }
+    async prepareTerminalPeerStops(snapshot, sourceAttempt, requestedAt) {
+        const peers = snapshot.attempts.flatMap((attempt) => {
+            if (attempt.attempt_id === sourceAttempt.attempt_id || attempt.phase === "terminal" || attempt.executor?.kind !== "worker")
+                return [];
+            const outcome = {
+                kind: "worker_process",
+                status: "cancelled",
+                reason_code: "run_terminal",
+                message: null,
+                process: { kind: "cancelled", exit_code: null, signal: null, reason: "run_terminal" },
+            };
+            return [{ attempt, purpose: "peer_terminal", requestedAt, outcome }];
+        });
+        if (peers.length === 0)
+            return snapshot;
+        const withIntents = await this.persistStopIntents(snapshot, peers);
+        return this.continueDurableStops(withIntents);
+    }
+    async continueDurableStops(initial) {
+        let snapshot = initial;
+        if (snapshot.run.status === "cancelling") {
+            snapshot = await this.persistStopIntents(snapshot, this.cancellationStopSpecifications(snapshot));
+        }
+        const pending = snapshot.events.filter((event) => event.type === "attempt_stop_requested");
+        for (const event of pending) {
+            if (event.type !== "attempt_stop_requested")
+                continue;
+            let expectedReceipt = null;
+            for (;;) {
+                const attempt = snapshot.attempts.find((candidate) => candidate.attempt_id === event.attempt_id);
+                if (!attempt || attempt.phase === "terminal")
+                    break;
+                const resolution = await this.requestWorkerStop(snapshot, attempt, event.payload.intent, expectedReceipt);
+                try {
+                    snapshot = resolution.kind === "stopped_by_request"
+                        ? await this.confirmDurableStop(snapshot, attempt, event.payload.intent, resolution.authority.stop_receipt)
+                        : resolution.kind === "already_stopped"
+                            ? await this.confirmAlreadyDurableStop(snapshot, attempt, event.payload.intent, resolution.drain_evidence)
+                            : await this.confirmNeverLaunchedStop(snapshot, attempt, event.payload.intent, resolution.nonlaunch_attestation);
+                    break;
+                }
+                catch (error) {
+                    if (!this.isVersionConflict(error))
+                        throw error;
+                    snapshot = await this.requireSnapshot(snapshot.run.run_id);
+                    const current = snapshot.attempts.find((candidate) => candidate.attempt_id === attempt.attempt_id);
+                    if (!current || current.phase === "terminal")
+                        break;
+                    expectedReceipt = resolution.kind === "stopped_by_request"
+                        ? resolution.authority.stop_receipt
+                        : null;
+                }
+            }
+        }
+        return this.aggregateDurableStops(snapshot);
+    }
+    cancellationStopSpecifications(snapshot) {
+        const cancellation = snapshot.run.cancellation;
+        if (snapshot.run.status !== "cancelling" || cancellation === null)
+            return [];
+        return snapshot.attempts.flatMap((attempt) => {
+            if (attempt.phase === "terminal" || attempt.executor?.kind !== "worker")
+                return [];
+            const outcome = {
+                kind: "worker_process",
+                status: "cancelled",
+                reason_code: "run_cancelled",
+                message: cancellation.reason,
+                process: {
+                    kind: "cancelled",
+                    exit_code: null,
+                    signal: null,
+                    reason: cancellation.reason,
+                },
+            };
+            return [{
+                    attempt,
+                    purpose: "cancel",
+                    requestedAt: cancellation.requested_at,
+                    outcome,
+                }];
+        });
+    }
+    async confirmDurableStop(snapshot, attempt, intent, receipt) {
+        const activation = snapshot.activations.find((candidate) => candidate.activation_id === attempt.activation_id);
+        const now = receipt.payload.stopped_at;
+        const terminalAttempt = {
+            ...attempt,
+            phase: "terminal",
+            completed_at: now,
+            terminal_outcome: receipt.payload.terminal_outcome,
+        };
+        const plan = await this.requirePinnedPlan(snapshot);
+        const node = nodeById(plan.plan, attempt.step_id);
+        const retryable = intent.purpose === "execution_deadline"
+            && node.kind === "worker"
+            && attempt.attempt_number < node.attempt_policy.max_attempts
+            && node.attempt_policy.retryable_outcomes.includes("timeout");
+        const state = retryable ? "ready"
+            : intent.purpose === "execution_deadline" ? "failed" : "cancelled";
+        const terminalActivation = { ...activation, state, updated_at: now };
+        const events = [
+            this.event(snapshot, 0, {
+                type: "attempt_terminal",
+                step_id: attempt.step_id,
+                activation_id: attempt.activation_id,
+                attempt_id: attempt.attempt_id,
+                result_id: null,
+                key: `attempt:${attempt.attempt_id}:stopped`,
+                at: now,
+                payload: { executor: attempt.executor, outcome: receipt.payload.terminal_outcome, worker_stop_receipt: receipt, worker_nonlaunch_attestation: null },
+            }),
+            this.activationEvent(snapshot, 1, activation, terminalActivation, intent.purpose, now),
+        ];
+        return (await this.runStore.updateCanonicalRun({
+            run_id: snapshot.run.run_id,
+            expected_record_version: snapshot.record_version,
+            attempts: [terminalAttempt],
+            activations: [terminalActivation],
+            events,
+        })).snapshot;
+    }
+    async confirmAlreadyDurableStop(snapshot, attempt, intent, evidence) {
+        const activation = snapshot.activations.find((candidate) => candidate.activation_id === attempt.activation_id);
+        const now = evidence.payload.completed_at;
+        const terminalAttempt = {
+            ...attempt,
+            phase: "terminal",
+            completed_at: now,
+            terminal_outcome: intent.requested_outcome,
+        };
+        const plan = await this.requirePinnedPlan(snapshot);
+        const node = nodeById(plan.plan, attempt.step_id);
+        const retryable = intent.purpose === "execution_deadline"
+            && node.kind === "worker"
+            && attempt.attempt_number < node.attempt_policy.max_attempts
+            && node.attempt_policy.retryable_outcomes.includes("timeout");
+        const terminalActivation = {
+            ...activation,
+            state: retryable ? "ready" : intent.purpose === "execution_deadline" ? "failed" : "cancelled",
+            updated_at: now,
+        };
+        const events = [
+            this.event(snapshot, 0, {
+                type: "attempt_terminal",
+                step_id: attempt.step_id,
+                activation_id: attempt.activation_id,
+                attempt_id: attempt.attempt_id,
+                result_id: null,
+                key: `attempt:${attempt.attempt_id}:already-stopped`,
+                at: now,
+                payload: {
+                    executor: attempt.executor,
+                    outcome: intent.requested_outcome,
+                    worker_stop_receipt: null,
+                    worker_nonlaunch_attestation: null,
+                    worker_already_stopped_evidence: evidence,
+                },
+            }),
+            this.activationEvent(snapshot, 1, activation, terminalActivation, intent.purpose, now),
+        ];
+        return (await this.runStore.updateCanonicalRun({
+            run_id: snapshot.run.run_id,
+            expected_record_version: snapshot.record_version,
+            attempts: [terminalAttempt],
+            activations: [terminalActivation],
+            events,
+        })).snapshot;
+    }
+    async confirmNeverLaunchedStop(snapshot, attempt, intent, attestation) {
+        const activation = snapshot.activations.find((candidate) => candidate.activation_id === attempt.activation_id);
+        const now = attestation.payload.attested_at;
+        const terminalAttempt = {
+            ...attempt,
+            phase: "terminal",
+            completed_at: now,
+            terminal_outcome: intent.requested_outcome,
+        };
+        const plan = await this.requirePinnedPlan(snapshot);
+        const node = nodeById(plan.plan, attempt.step_id);
+        const retryable = intent.purpose === "execution_deadline"
+            && node.kind === "worker"
+            && attempt.attempt_number < node.attempt_policy.max_attempts
+            && node.attempt_policy.retryable_outcomes.includes("timeout");
+        const terminalActivation = {
+            ...activation,
+            state: retryable ? "ready" : intent.purpose === "execution_deadline" ? "failed" : "cancelled",
+            updated_at: now,
+        };
+        const events = [
+            this.event(snapshot, 0, {
+                type: "attempt_terminal",
+                step_id: attempt.step_id,
+                activation_id: attempt.activation_id,
+                attempt_id: attempt.attempt_id,
+                result_id: null,
+                key: `attempt:${attempt.attempt_id}:never-launched`,
+                at: now,
+                payload: {
+                    executor: attempt.executor,
+                    outcome: intent.requested_outcome,
+                    worker_stop_receipt: null,
+                    worker_nonlaunch_attestation: attestation,
+                },
+            }),
+            this.activationEvent(snapshot, 1, activation, terminalActivation, intent.purpose, now),
+        ];
+        return (await this.runStore.updateCanonicalRun({
+            run_id: snapshot.run.run_id,
+            expected_record_version: snapshot.record_version,
+            attempts: [terminalAttempt],
+            activations: [terminalActivation],
+            events,
+        })).snapshot;
+    }
+    async aggregateDurableStops(initial) {
+        let snapshot = initial;
+        for (;;) {
+            if (snapshot.run.terminal !== null)
+                return snapshot;
+            const intents = snapshot.events.filter((event) => event.type === "attempt_stop_requested");
+            const cancelling = snapshot.run.status === "cancelling";
+            const currentDeadlineIntents = intents.filter((event) => {
+                if (event.type !== "attempt_stop_requested" || event.payload.intent.purpose !== "execution_deadline")
+                    return false;
+                const attempt = snapshot.attempts.find((candidate) => candidate.attempt_id === event.attempt_id);
+                const activation = attempt === undefined ? undefined : snapshot.activations.find((candidate) => candidate.activation_id === attempt.activation_id);
+                return activation?.current_attempt_id === event.attempt_id;
+            });
+            const drainIntents = cancelling ? intents : currentDeadlineIntents;
+            const activeWorkerExecution = snapshot.attempts.some((attempt) => (attempt.phase !== "terminal"
+                && attempt.executor?.kind === "worker"
+                && attempt.started_at !== null));
+            if ((cancelling && activeWorkerExecution)
+                || (!cancelling && drainIntents.length === 0)
+                || drainIntents.some((event) => snapshot.attempts.find((attempt) => attempt.attempt_id === event.attempt_id)?.phase !== "terminal")) {
+                return snapshot;
+            }
+            const now = this.now();
+            const deadline = currentDeadlineIntents.length > 0;
+            if (deadline && snapshot.activations.some((activation) => activation.state === "ready"))
+                return snapshot;
+            if (!cancelling && !deadline)
+                return snapshot;
+            const attempts = [];
+            const activations = [];
+            const events = [];
+            for (const activation of snapshot.activations) {
+                if (TERMINAL_ACTIVATION_STATES.has(activation.state))
+                    continue;
+                const attempt = activation.current_attempt_id === null ? null : snapshot.attempts.find((candidate) => candidate.attempt_id === activation.current_attempt_id) ?? null;
+                if (attempt && attempt.phase !== "terminal") {
+                    const executor = attempt.started_at === null
+                        ? { kind: "system", service_instance_id: this.serviceInstanceId, operation: "aggregate_stop" }
+                        : attempt.executor ?? { kind: "system", service_instance_id: this.serviceInstanceId, operation: "aggregate_stop" };
+                    const outcome = { kind: "cancelled", reason: cancelling ? snapshot.run.cancellation?.reason ?? null : "execution_deadline_elapsed" };
+                    attempts.push({ ...attempt, phase: "terminal", executor, started_at: attempt.started_at ?? now, completed_at: now, terminal_outcome: outcome });
+                    if (attempt.started_at === null)
+                        events.push(this.event(snapshot, events.length, { type: "attempt_started", step_id: attempt.step_id, activation_id: attempt.activation_id, attempt_id: attempt.attempt_id, result_id: null, key: `attempt:${attempt.attempt_id}:aggregate-started`, at: now, payload: { executor } }));
+                    events.push(this.event(snapshot, events.length, { type: "attempt_terminal", step_id: attempt.step_id, activation_id: attempt.activation_id, attempt_id: attempt.attempt_id, result_id: null, key: `attempt:${attempt.attempt_id}:aggregate-terminal`, at: now, payload: { executor, outcome, worker_stop_receipt: null, worker_nonlaunch_attestation: null } }));
+                }
+                const terminal = { ...activation, state: "cancelled", updated_at: now };
+                activations.push(terminal);
+                events.push(this.activationEvent(snapshot, events.length, activation, terminal, cancelling ? "run_cancelled" : "run_failed", now));
+            }
+            const run = cancelling
+                ? this.terminalRun(snapshot.run, "cancelled", "run_cancelled", now)
+                : this.terminalRun(snapshot.run, "failed", "execution_deadline_elapsed", now);
+            events.push(this.runTerminalEvent(snapshot, events.length, run, now));
+            try {
+                return (await this.runStore.updateCanonicalRun({ run_id: snapshot.run.run_id, expected_record_version: snapshot.record_version, run, attempts, activations, events })).snapshot;
+            }
+            catch (error) {
+                if (!this.isVersionConflict(error))
+                    throw error;
+                snapshot = await this.requireSnapshot(snapshot.run.run_id);
+            }
+        }
+    }
+    async requestWorkerStop(snapshot, attempt, intent, expectedReceipt) {
+        if (attempt.executor?.kind !== "worker" || attempt.started_at === null) {
+            throw new CanonicalRunServiceError("attempt_state_conflict", "worker stop requires a running worker attempt");
+        }
+        if (this.executionAuthority?.requestStop === undefined) {
+            throw new CanonicalRunServiceError("unsupported", "worker stop authority is unavailable");
+        }
+        const executionClaimEpoch = this.attemptRecovery(snapshot, attempt).execution_claim_epoch;
+        const stopRequest = {
+            run_id: attempt.run_id,
+            step_id: attempt.step_id,
+            activation_id: attempt.activation_id,
+            attempt_id: attempt.attempt_id,
+            claim_epoch: executionClaimEpoch,
+            executor: attempt.executor,
+            purpose: intent.purpose,
+            requested_at: intent.requested_at,
+            started_at: intent.started_at,
+            requested_outcome: intent.requested_outcome,
+            stop_idempotency_key: intent.stop_idempotency_key,
+            expected_receipt: expectedReceipt,
+        };
+        let resolution;
+        try {
+            resolution = await this.executionAuthority.requestStop(stopRequest);
+        }
+        catch (error) {
+            throw new CanonicalRunServiceError("unsupported", "worker stop authority is unavailable", { cause: error });
+        }
+        const matches = resolution?.kind === "stopped_by_request"
+            ? resolution.authority !== undefined
+                && workerStopReceiptMatchesStop(resolution.authority.stop_receipt, stopRequest)
+                && resolution.authority.authority_instance_id === resolution.authority.stop_receipt.payload.authority_instance_id
+                && resolution.authority.fencing_epoch === resolution.authority.stop_receipt.payload.fencing_epoch
+                && resolution.authority.fencing_epoch > 0
+            : resolution?.kind === "already_stopped"
+                && resolution.drain_evidence !== undefined
+                && workerAlreadyStoppedEvidenceMatchesStop(resolution.drain_evidence, stopRequest)
+                || resolution?.kind === "never_launched"
+                    && resolution.nonlaunch_attestation !== undefined
+                    && workerNonlaunchAttestationMatches(resolution.nonlaunch_attestation, {
+                        run_id: stopRequest.run_id,
+                        step_id: stopRequest.step_id,
+                        activation_id: stopRequest.activation_id,
+                        attempt_id: stopRequest.attempt_id,
+                        execution_claim_epoch: stopRequest.claim_epoch,
+                        executor: stopRequest.executor,
+                        started_at: stopRequest.started_at,
+                        failure_idempotency_key: stopRequest.stop_idempotency_key,
+                        requested_at: stopRequest.requested_at,
+                    });
+        if (!matches) {
+            throw new CanonicalRunServiceError("submission_conflict", "worker stop authority does not match the durable attempt");
+        }
+        return resolution;
+    }
+    async withStoppedExecution(snapshot, _claim, attempt, execution, purpose, expectedReceipt, operation) {
+        if (attempt.executor?.kind !== "worker")
+            return operation(null);
+        if (this.executionAuthority === null) {
+            throw new CanonicalRunServiceError("unsupported", "worker finalization requires stopped-execution authority");
+        }
+        const authorityRequest = {
+            run_id: attempt.run_id,
+            step_id: attempt.step_id,
+            activation_id: attempt.activation_id,
+            attempt_id: attempt.attempt_id,
+            claim_epoch: this.attemptRecovery(snapshot, attempt).execution_claim_epoch,
+            executor: attempt.executor,
+            purpose,
+            reported_execution: {
+                started_at: execution.started_at,
+                completed_at: execution.completed_at,
+                outcome: execution.outcome,
+            },
+            expected_receipt: expectedReceipt,
+        };
+        let entered = false;
+        try {
+            return await this.executionAuthority.withStoppedExecution(authorityRequest, async (authority) => {
+                entered = true;
+                if (!workerStopReceiptMatchesExecution(authority.stop_receipt, authorityRequest)
+                    || authority.authority_instance_id
+                        !== authority.stop_receipt.payload.authority_instance_id
+                    || authority.fencing_epoch !== authority.stop_receipt.payload.fencing_epoch
+                    || authority.fencing_epoch <= 0
+                    || (expectedReceipt !== null
+                        && canonicalizeJson(authority.stop_receipt) !== canonicalizeJson(expectedReceipt))) {
+                    throw new CanonicalRunServiceError("submission_conflict", "stopped-execution authority does not match the durable attempt");
+                }
+                return operation(authority);
+            });
+        }
+        catch (error) {
+            if (entered)
+                throw error;
+            throw new CanonicalRunServiceError("unsupported", "stopped-execution authority is unavailable", { cause: error });
+        }
+    }
+    async materializePacket(snapshot, plan, activation, attempt, executor, allocation) {
+        const node = nodeById(plan.plan, activation.step_id);
+        if (node.kind !== "worker" || executor.kind !== "worker")
+            return null;
+        if (allocation === null) {
+            throw new CanonicalRunServiceError("unsupported", "worker attempt has no workspace allocation");
+        }
+        const handoffs = plan.plan.handoff_plan.filter((item) => item.to_node_id === node.node_id);
+        const bindings = [];
+        for (const handoff of handoffs) {
+            const sourceActivation = snapshot.activations
+                .filter((item) => item.step_id === handoff.from_node_id && item.committed_result_id !== null)
+                .at(-1);
+            if (!sourceActivation?.committed_result_id) {
+                if (handoff.required) {
+                    throw new CanonicalRunServiceError("attempt_state_conflict", `required handoff ${handoff.handoff_id} is unavailable`);
+                }
+                bindings.push({
+                    binding_id: handoff.handoff_id, input_name: handoff.input_name,
+                    required: false, description: handoff.handoff_id, mode: "none", reason: "source_unavailable",
+                });
+                continue;
+            }
+            const reference = snapshot.result_refs.find((item) => item.result_id === sourceActivation.committed_result_id);
+            const result = await this.resultStore.require(reference);
+            const output = result.outputs.find((item) => item.name === handoff.output_name);
+            if (!output) {
+                if (handoff.required) {
+                    throw new CanonicalRunServiceError("attempt_state_conflict", `handoff output ${handoff.output_name} is unavailable`);
+                }
+                bindings.push({
+                    binding_id: handoff.handoff_id, input_name: handoff.input_name,
+                    required: false, description: handoff.handoff_id, mode: "none", reason: "output_unavailable",
+                });
+                continue;
+            }
+            const source = { result_id: result.result_id, step_id: result.step_id, output_name: output.name };
+            if (handoff.mode === "reference") {
+                if (output.kind !== "artifact") {
+                    throw new CanonicalRunServiceError("attempt_state_conflict", `handoff output ${handoff.output_name} is not a captured artifact`);
+                }
+                let deliveredReference;
+                if (output.capture.artifact_kind === "git_commit") {
+                    const commit = await this.artifactStore.verifyGitCommitInWorkspace({
+                        artifact_id: output.capture.artifact_id,
+                        artifact_kind: "git_commit",
+                    }, allocation.working_directory);
+                    deliveredReference = {
+                        kind: "artifact",
+                        value: commit.commit_oid,
+                        artifact_id: output.capture.artifact_id,
+                    };
+                }
+                else {
+                    const materialized = await this.artifactMaterializer.materializeReplaySafe({
+                        artifact_id: output.capture.artifact_id,
+                        artifact_kind: output.capture.artifact_kind,
+                        destination_root: resolve(this.handoffRootDirectory, createHash("sha256").update(snapshot.run.run_id).digest("hex"), createHash("sha256").update(attempt.attempt_id).digest("hex")),
+                        binding_id: handoff.handoff_id,
+                    });
+                    deliveredReference = {
+                        kind: output.capture.artifact_kind === "file" ? "file" : "directory",
+                        value: materialized.materialized_path,
+                        artifact_id: output.capture.artifact_id,
+                    };
+                }
+                bindings.push({
+                    binding_id: handoff.handoff_id, input_name: handoff.input_name,
+                    required: handoff.required, description: handoff.handoff_id, mode: "reference", source,
+                    reference: deliveredReference,
+                });
+            }
+            else if (handoff.mode === "quote") {
+                if (output.kind !== "text") {
+                    throw new CanonicalRunServiceError("attempt_state_conflict", `handoff output ${handoff.output_name} is not exact text`);
+                }
+                bindings.push({
+                    binding_id: handoff.handoff_id, input_name: handoff.input_name,
+                    required: handoff.required, description: handoff.handoff_id, mode: "quote", source,
+                    exact_text: output.text, selection: { start: null, end: null, selector: null },
+                });
+            }
+            else {
+                if (output.kind !== "structured" || output.schema_ref !== handoff.schema_ref) {
+                    throw new CanonicalRunServiceError("attempt_state_conflict", `handoff output ${handoff.output_name} does not match its structured contract`);
+                }
+                bindings.push({
+                    binding_id: handoff.handoff_id, input_name: handoff.input_name,
+                    required: handoff.required, description: handoff.handoff_id, mode: "structured", source,
+                    value: output.value, schema_ref: output.schema_ref,
+                });
+            }
+        }
+        const workerNode = node;
+        const promptValues = new Map();
+        for (const inputName of workerNode.packet_template.runtime_input_names) {
+            const value = snapshot.run.run_binding.binding.validated_inputs[inputName];
+            if (value === undefined) {
+                throw new CanonicalRunServiceError("invalid_request", `runtime input ${inputName} is missing from the pinned run binding`);
+            }
+            promptValues.set(inputName, runtimeTemplateValue(value));
+        }
+        const bindingById = new Map(bindings.map((binding) => [binding.binding_id, binding]));
+        for (const handoff of handoffs) {
+            const binding = bindingById.get(handoff.handoff_id);
+            if (binding === undefined) {
+                throw new CanonicalRunServiceError("attempt_state_conflict", `handoff ${handoff.handoff_id} was not resolved`);
+            }
+            if (binding.mode === "none") {
+                const suffixes = handoff.mode === "reference"
+                    ? handoff.artifact_kind === "git_commit"
+                        ? ["commit_oid", "artifact_id"]
+                        : ["materialized_path", "artifact_id"]
+                    : handoff.mode === "quote" ? ["exact_text"] : ["json"];
+                for (const suffix of suffixes) {
+                    promptValues.set(`handoff.${binding.binding_id}.${suffix}`, "null");
+                }
+            }
+            else if (binding.mode === "reference" && handoff.mode === "reference") {
+                promptValues.set(`handoff.${binding.binding_id}.${handoff.artifact_kind === "git_commit" ? "commit_oid" : "materialized_path"}`, binding.reference.value);
+                if (binding.reference.artifact_id === null) {
+                    throw new CanonicalRunServiceError("attempt_state_conflict", `handoff ${binding.binding_id} has no immutable artifact identity`);
+                }
+                promptValues.set(`handoff.${binding.binding_id}.artifact_id`, binding.reference.artifact_id);
+            }
+            else if (binding.mode === "quote" && handoff.mode === "quote") {
+                promptValues.set(`handoff.${binding.binding_id}.exact_text`, binding.exact_text);
+            }
+            else if (binding.mode === "structured" && handoff.mode === "structured") {
+                promptValues.set(`handoff.${binding.binding_id}.json`, canonicalizeJson(binding.value));
+            }
+            else {
+                throw new CanonicalRunServiceError("attempt_state_conflict", `handoff ${binding.binding_id} resolved with the wrong delivery mode`);
+            }
+        }
+        const standalonePrompt = renderPacketPrompt(workerNode.packet_template.standalone_prompt, promptValues);
+        return {
+            packet_version: 1,
+            run_id: snapshot.run.run_id,
+            step_id: activation.step_id,
+            attempt_id: attempt.attempt_id,
+            worker_session_id: executor.worker_session_id,
+            attempt_number: attempt.attempt_number,
+            workflow_round: activation.workflow_round,
+            role: workerNode.role,
+            constraints: workerNode.packet_template.constraints,
+            standalone_prompt: standalonePrompt,
+            input_bindings: bindings,
+            output_contract: workerNode.packet_template.output_contract.map((output) => ({
+                name: output.name, kind: output.kind, required: output.required,
+                description: output.description, schema_ref: output.schema_ref,
+            })),
+            workspace: {
+                isolation: workerNode.workspace.isolation,
+                working_directory: allocation.working_directory,
+            },
+            execution: {
+                timeout_ms: workerNode.attempt_policy.timeout_ms,
+                cancellation_grace_ms: workerNode.attempt_policy.cancellation_grace_ms,
+                retry: {
+                    max_attempts: workerNode.attempt_policy.max_attempts,
+                    backoff: workerNode.attempt_policy.backoff,
+                    initial_delay_ms: workerNode.attempt_policy.initial_delay_ms,
+                    max_delay_ms: workerNode.attempt_policy.max_delay_ms,
+                    retryable_outcomes: workerNode.attempt_policy.retryable_outcomes,
+                },
+            },
+            created_at: attempt.started_at ?? this.now(),
+        };
+    }
+    async verifierHandoffBindings(snapshot, plan, activation, attempt, allocation) {
+        if (attempt.executor?.kind !== "worker")
+            return [];
+        const packet = await this.materializePacket(snapshot, plan, activation, attempt, attempt.executor, allocation);
+        const bindings = packet?.input_bindings ?? [];
+        for (const binding of bindings) {
+            if (binding.mode === "none")
+                continue;
+            const resolved = snapshot.events.some((event) => (event.type === "handoff_resolved"
+                && event.attempt_id === attempt.attempt_id
+                && event.payload.binding_id === binding.binding_id
+                && event.payload.source_result_id === binding.source.result_id
+                && event.payload.output_name === binding.source.output_name));
+            if (!resolved) {
+                throw new CanonicalRunServiceError("attempt_state_conflict", `handoff ${binding.binding_id} was not committed for attempt ${attempt.attempt_id}`);
+            }
+        }
+        return bindings;
+    }
+    handoffResolutionEvents(snapshot, attempt, packet, initialOffset, at) {
+        const bindings = packet?.input_bindings.filter((binding) => binding.mode !== "none") ?? [];
+        return bindings.map((binding, offset) => this.event(snapshot, initialOffset + offset, {
+            type: "handoff_resolved",
+            step_id: attempt.step_id,
+            activation_id: attempt.activation_id,
+            attempt_id: attempt.attempt_id,
+            result_id: null,
+            key: `attempt:${attempt.attempt_id}:handoff:${binding.binding_id}`,
+            at,
+            payload: {
+                binding_id: binding.binding_id,
+                source_result_id: binding.source.result_id,
+                output_name: binding.source.output_name,
+            },
+        }));
+    }
+    async findReplay(snapshot, plan, attemptId, resultId, keyDigest, submissionDigest) {
+        const event = snapshot.events.find((candidate) => (candidate.type === "result_committed" && candidate.attempt_id === attemptId));
+        if (!event)
+            return null;
+        if (event.payload.submission_key_digest !== keyDigest
+            || event.payload.submission_digest !== submissionDigest
+            || event.result_id !== resultId) {
+            throw new CanonicalRunServiceError("submission_conflict", "attempt already has a different committed submission");
+        }
+        const reference = snapshot.result_refs.find((item) => item.result_id === resultId);
+        if (!reference)
+            throw new CanonicalRunServiceError("submission_conflict", "committed result reference is missing");
+        return { result: await this.resultStore.require(reference), replayed: true, run: this.toView(snapshot, plan) };
+    }
+    submissionEvidence(result) {
+        const evidence = result.evidence_refs.filter((item) => item.kind === "submission");
+        if (evidence.length !== 1) {
+            throw new CanonicalRunServiceError("submission_conflict", `published result ${result.result_id} lacks unique submission evidence`);
+        }
+        return evidence[0];
+    }
+    workerStopReceipt(result) {
+        const evidence = result.evidence_refs.filter((item) => item.kind === "worker_stopped");
+        if (result.executor.kind !== "worker") {
+            if (evidence.length !== 0) {
+                throw new CanonicalRunServiceError("submission_conflict", `non-worker result ${result.result_id} carries worker stop evidence`);
+            }
+            return null;
+        }
+        if (evidence.length !== 1) {
+            throw new CanonicalRunServiceError("submission_conflict", `worker result ${result.result_id} lacks unique stop evidence`);
+        }
+        return evidence[0].receipt;
+    }
+    outputsPreserveAuthority(expected, actual) {
+        if (expected.length !== actual.length)
+            return false;
+        const byName = new Map(actual.map((output) => [output.name, output]));
+        return expected.every((output) => {
+            const candidate = byName.get(output.name);
+            if (!candidate || candidate.kind !== output.kind)
+                return false;
+            if (output.kind === "artifact" && candidate.kind === "artifact") {
+                return output.capture.artifact_id === candidate.capture.artifact_id
+                    && output.capture.artifact_kind === candidate.capture.artifact_kind;
+            }
+            return canonicalizeJson(output) === canonicalizeJson(candidate);
+        });
+    }
+    async revalidateWorkspaceObservations(result, allocation) {
+        const observations = result.verification_results.flatMap((verification) => (verification.evidence_refs.flatMap((evidence) => (evidence.workspace_observation === null ? [] : [evidence.workspace_observation]))));
+        if (observations.length === 0)
+            return;
+        for (const expected of observations) {
+            if (expected.workspace_id !== allocation.workspace_id) {
+                throw new CanonicalRunServiceError("submission_conflict", `published result ${result.result_id} observes a different workspace allocation`);
+            }
+            const actual = await observeAttemptWorkspace(allocation.working_directory, allocation.workspace_id);
+            if (canonicalizeJson(actual) !== canonicalizeJson(expected)) {
+                throw new CanonicalRunServiceError("source_drift", `published result ${result.result_id} workspace changed after verification`);
+            }
+        }
+    }
+    async reconcilePublishedResults(initial, plan) {
+        let snapshot = initial;
+        for (;;) {
+            const activeAttempts = snapshot.attempts.filter((candidate) => candidate.phase !== "terminal");
+            let reconciled = false;
+            for (const attempt of activeAttempts) {
+                const published = await this.resultStore.loadPublished(resultIdFor(this.identities, attempt.attempt_id));
+                if (!published)
+                    continue;
+                snapshot = await this.reconcilePublishedResult(snapshot, plan, published.result);
+                reconciled = true;
+                break;
+            }
+            if (!reconciled)
+                return snapshot;
+        }
+    }
+    async reconcilePublishedResult(initial, plan, result) {
+        if (result.executor.kind === "system") {
+            return this.reconcilePublishedSystemResult(initial, plan, result);
+        }
+        const initialAttempt = initial.attempts.find((candidate) => candidate.attempt_id === result.attempt_id);
+        const initialActivation = initial.activations.find((candidate) => candidate.activation_id === result.activation_id);
+        if (!initialAttempt || !initialActivation) {
+            throw new CanonicalRunServiceError("submission_conflict", `published result ${result.result_id} has no durable attempt allocation`);
+        }
+        const allocation = this.requireCommittedWorkspace(initial, initialAttempt, nodeById(plan.plan, initialActivation.step_id));
+        const claim = this.claimsFor(initial, initialAttempt.attempt_id).at(-1);
+        if (!claim) {
+            throw new CanonicalRunServiceError("submission_conflict", `published result ${result.result_id} has no durable claim`);
+        }
+        const execution = {
+            executor: result.executor,
+            started_at: result.started_at,
+            completed_at: result.completed_at,
+            outcome: result.terminal_outcome,
+            outputs: result.outputs.map((output) => {
+                if (output.kind === "text")
+                    return output;
+                if (output.kind === "structured")
+                    return output;
+                return {
+                    name: output.name,
+                    kind: "reference",
+                    artifact_kind: output.capture.artifact_kind,
+                    source_path: output.capture.source_path,
+                };
+            }),
+            workspace: {
+                root: allocation.working_directory,
+                workspace_id: allocation.workspace_id,
+            },
+            stdout_reference: result.stdout_reference,
+            stderr_reference: result.stderr_reference,
+        };
+        const expectedReceipt = this.workerStopReceipt(result);
+        const handoffBindings = await this.verifierHandoffBindings(initial, plan, initialActivation, initialAttempt, allocation);
+        const replayVerificationRequest = {
+            plan,
+            run: initial.run,
+            activation: initialActivation,
+            attempt: initialAttempt,
+            execution,
+            workspace_allocation: allocation,
+            captured_outputs: result.outputs,
+            handoff_bindings: handoffBindings,
+        };
+        const serviceVerification = result.verification_results.filter((item) => item.authority === "service");
+        const additionalVerification = result.verification_results.filter((item) => item.authority === "additional");
+        this.validateVerificationLanes(replayVerificationRequest, serviceVerification, additionalVerification);
+        await this.validateCommandVerifierReceipts(replayVerificationRequest, serviceVerification);
+        return this.withStoppedExecution(initial, claim, initialAttempt, execution, "reconcile_published_result", expectedReceipt, async (executionAuthority) => this.withWorkspaceAuthority(allocation, "reconcile_published_result", false, async (workspaceAuthority) => {
+            for (;;) {
+                const snapshot = await this.requireSnapshot(initial.run.run_id);
+                const existing = snapshot.result_refs.find((item) => item.result_id === result.result_id);
+                if (existing)
+                    return snapshot;
+                if (snapshot.run.status === "cancelling") {
+                    throw new CanonicalRunServiceError("run_terminal", "run cancellation has been requested");
+                }
+                const attempt = snapshot.attempts.find((candidate) => candidate.attempt_id === result.attempt_id);
+                const activation = snapshot.activations.find((candidate) => candidate.activation_id === result.activation_id);
+                if (!attempt
+                    || !activation
+                    || attempt.phase !== "running"
+                    || attempt.executor === null
+                    || result.run_id !== snapshot.run.run_id
+                    || result.step_id !== attempt.step_id
+                    || canonicalizeJson(result.executor) !== canonicalizeJson(attempt.executor)) {
+                    throw new CanonicalRunServiceError("submission_conflict", `published result ${result.result_id} cannot reconcile to its attempt`);
+                }
+                const published = await this.resultStore.loadPublished(result.result_id);
+                if (!published || canonicalizeJson(published.result) !== canonicalizeJson(result)) {
+                    throw new CanonicalRunServiceError("submission_conflict", "published result changed during reconciliation");
+                }
+                const submission = this.submissionEvidence(result);
+                const recaptured = await this.outputCapture.capture({
+                    run_id: snapshot.run.run_id,
+                    activation_id: activation.activation_id,
+                    attempt_id: attempt.attempt_id,
+                    execution,
+                });
+                await recaptured.revalidate();
+                if (!this.outputsPreserveAuthority(result.outputs, recaptured.outputs)) {
+                    throw new CanonicalRunServiceError("source_drift", `published result ${result.result_id} source no longer matches its immutable capture`);
+                }
+                await this.revalidateWorkspaceObservations(result, allocation);
+                const drained = await this.prepareFailurePeerStops(snapshot, plan, attempt, result.terminal_outcome, this.now());
+                if (drained.record_version !== snapshot.record_version)
+                    continue;
+                const verification = result.verification_results;
+                const captures = result.outputs.flatMap((output) => output.kind === "artifact" ? [output.capture] : []);
+                const decisionOutputs = await this.loadDecisionOutputs(snapshot, plan, result);
+                const update = await this.buildSubmissionUpdate(snapshot, plan, activation, attempt, result, published.reference, captures, verification, submission.submission_key_digest, submission.submission_digest, this.now(), decisionOutputs, {
+                    worker_stop_receipt_digest: executionAuthority?.stop_receipt.receipt_digest ?? null,
+                    worker_stop_receipt: executionAuthority?.stop_receipt ?? null,
+                    workspace_authority: workspaceAuthority,
+                    purpose: "reconcile_published_result",
+                });
+                if (update.run?.terminal !== null) {
+                    const peerDrained = await this.prepareTerminalPeerStops(snapshot, attempt, this.now());
+                    if (peerDrained.record_version !== snapshot.record_version)
+                        continue;
+                }
+                try {
+                    return (await this.runStore.updateCanonicalRun(update)).snapshot;
+                }
+                catch (error) {
+                    if (this.isVersionConflict(error))
+                        continue;
+                    throw error;
+                }
+            }
+        }));
+    }
+    async loadDecisionOutputs(snapshot, plan, currentResult) {
+        const outputs = new Map();
+        for (const decision of plan.plan.nodes) {
+            if (decision.kind !== "decision")
+                continue;
+            if (decision.source.node_id === currentResult.step_id) {
+                outputs.set(decision.node_id, currentResult.outputs);
+                continue;
+            }
+            const activation = this.latestActivationForStep(snapshot.activations, decision.source.node_id);
+            if (!activation?.committed_result_id)
+                continue;
+            const reference = snapshot.result_refs.find((candidate) => candidate.result_id === activation.committed_result_id);
+            if (!reference)
+                continue;
+            outputs.set(decision.node_id, (await this.resultStore.require(reference)).outputs);
+        }
+        return outputs;
+    }
+    async buildSubmissionUpdate(snapshot, plan, activation, attempt, result, reference, captures, verification, keyDigest, submissionDigest, now, decisionOutputs, finalizationAuthority) {
+        const outcomeStatus = canonicalAttemptOutcomeStatus(result.terminal_outcome);
+        const node = nodeById(plan.plan, activation.step_id);
+        const retryOutcome = result.terminal_outcome.kind === "worker_process"
+            && result.terminal_outcome.process.kind !== "success"
+            ? result.terminal_outcome.process.kind
+            : outcomeStatus === "cancelled" ? "cancelled" : "malformed_result";
+        const retryable = node.kind === "worker"
+            && outcomeStatus !== "succeeded"
+            && attempt.attempt_number < node.attempt_policy.max_attempts
+            && node.attempt_policy.retryable_outcomes.includes(retryOutcome);
+        const retrySegment = node.kind === "worker" && node.attempt_policy.retry_segment_id !== null
+            ? plan.plan.retry_segments.find((segment) => (segment.retry_segment_id === node.attempt_policy.retry_segment_id)) ?? null
+            : null;
+        const fromRound = retrySegment === null ? 0 : activation.workflow_round;
+        const segmentRetryable = !retryable
+            && outcomeStatus !== "succeeded"
+            && retrySegment !== null
+            && retrySegment.retryable_outcomes.includes(retryOutcome)
+            && fromRound < retrySegment.max_rounds;
+        const retrySegmentExhausted = !retryable
+            && outcomeStatus !== "succeeded"
+            && retrySegment !== null
+            && retrySegment.retryable_outcomes.includes(retryOutcome)
+            && fromRound >= retrySegment.max_rounds;
+        const terminalAttempt = {
+            ...attempt,
+            phase: "terminal",
+            completed_at: result.completed_at,
+            terminal_outcome: result.terminal_outcome,
+        };
+        const completedActivation = {
+            ...activation,
+            state: retryable ? "ready" : outcomeStatus,
+            committed_result_id: outcomeStatus === "succeeded" ? result.result_id : activation.committed_result_id,
+            updated_at: now,
+        };
+        const activations = [completedActivation];
+        const attempts = [terminalAttempt];
+        const events = [];
+        let offset = 0;
+        events.push(this.activationEvent(snapshot, offset++, activation, completedActivation, retryable ? "retryable_attempt_failed" : "attempt_completed", now));
+        events.push(this.event(snapshot, offset++, {
+            type: "attempt_terminal", step_id: attempt.step_id, activation_id: attempt.activation_id,
+            attempt_id: attempt.attempt_id, result_id: null, key: `attempt:${attempt.attempt_id}:terminal`, at: now,
+            payload: {
+                executor: terminalAttempt.executor,
+                outcome: terminalAttempt.terminal_outcome,
+                worker_stop_receipt: finalizationAuthority.worker_stop_receipt,
+                worker_nonlaunch_attestation: null,
+            },
+        }));
+        for (const capture of captures) {
+            events.push(this.event(snapshot, offset++, {
+                type: "artifact_captured", step_id: attempt.step_id, activation_id: attempt.activation_id,
+                attempt_id: attempt.attempt_id, result_id: null,
+                key: `capture:${capture.capture_id}`, at: now, payload: { capture },
+            }));
+        }
+        events.push(this.event(snapshot, offset++, {
+            type: "result_committed", step_id: attempt.step_id, activation_id: attempt.activation_id,
+            attempt_id: attempt.attempt_id, result_id: result.result_id,
+            key: `result:${result.result_id}:committed`, at: now,
+            payload: {
+                result_digest: reference.result_digest,
+                submission_key_digest: keyDigest,
+                submission_digest: submissionDigest,
+                worker_stop_receipt_digest: finalizationAuthority.worker_stop_receipt_digest,
+                workspace_allocation_digest: finalizationAuthority.workspace_authority?.workspace_allocation_digest ?? null,
+                mutation_authority_instance_id: finalizationAuthority.workspace_authority?.authority_instance_id ?? null,
+                mutation_fencing_epoch: finalizationAuthority.workspace_authority?.fencing_epoch ?? null,
+                finalization_purpose: finalizationAuthority.purpose,
+            },
+        }));
+        if (segmentRetryable && retrySegment !== null) {
+            const toRound = fromRound + 1;
+            const priorActivations = retrySegment.node_ids.map((stepId) => (stepId === activation.step_id
+                ? completedActivation
+                : snapshot.activations.filter((candidate) => candidate.step_id === stepId).at(-1)));
+            if (priorActivations.some((candidate) => (candidate === undefined || !TERMINAL_ACTIVATION_STATES.has(candidate.state)))) {
+                throw new CanonicalRunServiceError("attempt_state_conflict", `retry segment ${retrySegment.retry_segment_id} has non-terminal prior activations`);
+            }
+            const replacements = retrySegment.node_ids.map((stepId) => ({
+                run_id: snapshot.run.run_id,
+                step_id: stepId,
+                activation_id: this.activationRoundId(snapshot.run.run_id, stepId, toRound),
+                workflow_round: toRound,
+                state: stepId === retrySegment.retry_from_node_id ? "ready" : "dependency_blocked",
+                attempt_count: 0,
+                current_attempt_id: null,
+                committed_result_id: null,
+                created_at: now,
+                updated_at: now,
+            }));
+            const delayMs = this.retrySegmentDelay(retrySegment, fromRound);
+            activations.push(...replacements);
+            events.push(this.event(snapshot, offset++, {
+                type: "retry_segment_scheduled",
+                step_id: activation.step_id,
+                activation_id: activation.activation_id,
+                attempt_id: null,
+                result_id: result.result_id,
+                key: `retry-segment:${retrySegment.retry_segment_id}:round:${toRound}`,
+                at: now,
+                payload: {
+                    retry_segment_id: retrySegment.retry_segment_id,
+                    from_round: fromRound,
+                    to_round: toRound,
+                    prior_activation_ids: priorActivations.map((candidate) => candidate.activation_id),
+                    replacement_activation_ids: replacements.map((candidate) => candidate.activation_id),
+                    retry_from_activation_id: replacements.find((candidate) => (candidate.step_id === retrySegment.retry_from_node_id)).activation_id,
+                    triggering_result_id: result.result_id,
+                    delay_ms: delayMs,
+                    ready_at: addMilliseconds(now, delayMs),
+                    reason_code: retryOutcome,
+                },
+            }));
+        }
+        if (node.kind === "interaction" && terminalAttempt.executor?.kind === "human") {
+            events.push(this.event(snapshot, offset++, {
+                type: "interaction_submitted",
+                step_id: attempt.step_id,
+                activation_id: attempt.activation_id,
+                attempt_id: attempt.attempt_id,
+                result_id: null,
+                key: `interaction:${node.interaction_id}:submitted:${attempt.attempt_id}`,
+                at: now,
+                payload: {
+                    interaction_id: node.interaction_id,
+                    principal_ref: terminalAttempt.executor.principal_ref,
+                    attestation_ref: terminalAttempt.executor.attestation_ref,
+                },
+            }));
+        }
+        let run = snapshot.run;
+        if (!retryable && !segmentRetryable && outcomeStatus === "succeeded") {
+            const reduction = this.reduceAfterSuccess(snapshot, plan, completedActivation, reference.result_id, verification, now, offset, decisionOutputs);
+            activations.push(...reduction.activations);
+            events.push(...reduction.events);
+            run = reduction.run;
+            if (run.terminal !== null) {
+                const cancelledAttempts = await this.cancelConcurrentAttempts(snapshot, activation.activation_id, now, "run_terminal", events.length);
+                attempts.push(...cancelledAttempts.attempts);
+                events.push(...cancelledAttempts.events);
+            }
+        }
+        else if (!retryable && !segmentRetryable) {
+            run = this.terminalRun(snapshot.run, "failed", retrySegmentExhausted
+                ? "retry_segment_max_rounds_exhausted"
+                : "attempt_failed", now);
+            const cancelledAttempts = await this.cancelConcurrentAttempts(snapshot, activation.activation_id, now, "peer_attempt_failed", events.length);
+            attempts.push(...cancelledAttempts.attempts);
+            events.push(...cancelledAttempts.events);
+            for (const other of snapshot.activations) {
+                if (other.activation_id === activation.activation_id || TERMINAL_ACTIVATION_STATES.has(other.state))
+                    continue;
+                const cancelled = { ...other, state: "cancelled", updated_at: now };
+                activations.push(cancelled);
+                events.push(this.activationEvent(snapshot, events.length, other, cancelled, "run_failed", now));
+            }
+            events.push(this.runTerminalEvent(snapshot, events.length, run, now));
+        }
+        return {
+            run_id: snapshot.run.run_id,
+            expected_record_version: snapshot.record_version,
+            run,
+            activations,
+            attempts,
+            events,
+            result_refs: [reference],
+        };
+    }
+    async buildNonlaunchFailureUpdate(snapshot, plan, activation, attempt, outcome, failureDigest, attestation) {
+        const now = attestation.payload.attested_at;
+        const node = nodeById(plan.plan, activation.step_id);
+        const retryable = node.kind === "worker"
+            && attempt.attempt_number < node.attempt_policy.max_attempts
+            && node.attempt_policy.retryable_outcomes.includes("launch_error");
+        const retrySegment = node.kind === "worker" && node.attempt_policy.retry_segment_id !== null
+            ? plan.plan.retry_segments.find((segment) => segment.retry_segment_id === node.attempt_policy.retry_segment_id) ?? null
+            : null;
+        const fromRound = retrySegment === null ? 0 : activation.workflow_round;
+        const segmentRetryable = !retryable
+            && retrySegment !== null
+            && retrySegment.retryable_outcomes.includes("launch_error")
+            && fromRound < retrySegment.max_rounds;
+        const retrySegmentExhausted = !retryable
+            && retrySegment !== null
+            && retrySegment.retryable_outcomes.includes("launch_error")
+            && fromRound >= retrySegment.max_rounds;
+        const terminalAttempt = {
+            ...attempt,
+            phase: "terminal",
+            completed_at: now,
+            terminal_outcome: outcome,
+        };
+        const completedActivation = {
+            ...activation,
+            state: retryable ? "ready" : "failed",
+            updated_at: now,
+        };
+        const activations = [completedActivation];
+        const attempts = [terminalAttempt];
+        const events = [
+            this.activationEvent(snapshot, 0, activation, completedActivation, retryable ? "retryable_attempt_failed" : "attempt_completed", now),
+            this.event(snapshot, 1, {
+                type: "attempt_terminal", step_id: attempt.step_id, activation_id: attempt.activation_id,
+                attempt_id: attempt.attempt_id, result_id: null,
+                key: `attempt:${attempt.attempt_id}:driver-failure:${failureDigest}`, at: now,
+                payload: {
+                    executor: terminalAttempt.executor, outcome,
+                    worker_stop_receipt: null, worker_nonlaunch_attestation: attestation,
+                },
+            }),
+        ];
+        if (segmentRetryable && retrySegment !== null) {
+            const toRound = fromRound + 1;
+            const priorActivations = retrySegment.node_ids.map((stepId) => (stepId === activation.step_id
+                ? completedActivation
+                : snapshot.activations.filter((candidate) => candidate.step_id === stepId).at(-1)));
+            if (priorActivations.some((candidate) => candidate === undefined || !TERMINAL_ACTIVATION_STATES.has(candidate.state))) {
+                throw new CanonicalRunServiceError("attempt_state_conflict", `retry segment ${retrySegment.retry_segment_id} has non-terminal prior activations`);
+            }
+            const replacements = retrySegment.node_ids.map((stepId) => ({
+                run_id: snapshot.run.run_id,
+                step_id: stepId,
+                activation_id: this.activationRoundId(snapshot.run.run_id, stepId, toRound),
+                workflow_round: toRound,
+                state: stepId === retrySegment.retry_from_node_id ? "ready" : "dependency_blocked",
+                attempt_count: 0,
+                current_attempt_id: null,
+                committed_result_id: null,
+                created_at: now,
+                updated_at: now,
+            }));
+            const delayMs = this.retrySegmentDelay(retrySegment, fromRound);
+            activations.push(...replacements);
+            events.push(this.event(snapshot, events.length, {
+                type: "retry_segment_scheduled", step_id: activation.step_id,
+                activation_id: activation.activation_id, attempt_id: null, result_id: null,
+                key: `retry-segment:${retrySegment.retry_segment_id}:round:${toRound}`, at: now,
+                payload: {
+                    retry_segment_id: retrySegment.retry_segment_id,
+                    from_round: fromRound,
+                    to_round: toRound,
+                    prior_activation_ids: priorActivations.map((candidate) => candidate.activation_id),
+                    replacement_activation_ids: replacements.map((candidate) => candidate.activation_id),
+                    retry_from_activation_id: replacements.find((candidate) => candidate.step_id === retrySegment.retry_from_node_id).activation_id,
+                    triggering_result_id: null,
+                    delay_ms: delayMs,
+                    ready_at: addMilliseconds(now, delayMs),
+                    reason_code: "launch_error",
+                },
+            }));
+        }
+        let run = snapshot.run;
+        if (!retryable && !segmentRetryable) {
+            run = this.terminalRun(snapshot.run, "failed", retrySegmentExhausted ? "retry_segment_max_rounds_exhausted" : "attempt_failed", now);
+            const cancelledAttempts = await this.cancelConcurrentAttempts(snapshot, activation.activation_id, now, "peer_attempt_failed", events.length);
+            attempts.push(...cancelledAttempts.attempts);
+            events.push(...cancelledAttempts.events);
+            for (const other of snapshot.activations) {
+                if (other.activation_id === activation.activation_id || TERMINAL_ACTIVATION_STATES.has(other.state))
+                    continue;
+                const cancelled = { ...other, state: "cancelled", updated_at: now };
+                activations.push(cancelled);
+                events.push(this.activationEvent(snapshot, events.length, other, cancelled, "run_failed", now));
+            }
+            events.push(this.runTerminalEvent(snapshot, events.length, run, now));
+        }
+        return {
+            run_id: snapshot.run.run_id,
+            expected_record_version: snapshot.record_version,
+            run,
+            activations,
+            attempts,
+            events,
+        };
+    }
+    reduceAfterSuccess(snapshot, stored, source, sourceResultId, verification, now, initialOffset, decisionOutputs) {
+        const plan = stored.plan;
+        const changed = new Map();
+        const created = [];
+        const events = [];
+        let run = snapshot.run;
+        const completedDeterministicNodes = new Map();
+        const markDeterministicNodeCompleted = (nodeId, round) => {
+            const rounds = completedDeterministicNodes.get(nodeId) ?? new Set();
+            rounds.add(round);
+            completedDeterministicNodes.set(nodeId, rounds);
+        };
+        const effectiveActivation = (stepId, round) => {
+            const activation = this.latestActivationForStep(snapshot.activations, stepId, round);
+            if (!activation)
+                return null;
+            if (activation.activation_id === source.activation_id)
+                return source;
+            return changed.get(activation.activation_id) ?? activation;
+        };
+        const dependencyCompleted = (nodeId, round) => {
+            const node = nodeById(plan, nodeId);
+            if (!ATTEMPT_NODE_KINDS.has(node.kind)) {
+                if (completedDeterministicNodes.get(nodeId)?.has(round))
+                    return true;
+                return snapshot.events.some((event) => {
+                    const sourceActivation = event.activation_id === null
+                        ? null
+                        : snapshot.activations.find((candidate) => candidate.activation_id === event.activation_id) ?? null;
+                    if (sourceActivation?.workflow_round !== round)
+                        return false;
+                    if (node.kind === "gate") {
+                        return event.type === "gate_evaluated"
+                            && event.payload.gate_id === nodeId
+                            && event.payload.passed;
+                    }
+                    if (node.kind === "decision") {
+                        return event.type === "decision_evaluated"
+                            && event.payload.decision_id === nodeId;
+                    }
+                    return false;
+                });
+            }
+            return effectiveActivation(nodeId, round)?.state === "succeeded";
+        };
+        const visited = new Set();
+        const visit = (fromNodeId) => {
+            if (visited.has(fromNodeId))
+                return;
+            visited.add(fromNodeId);
+            const from = nodeById(plan, fromNodeId);
+            let selected = [];
+            if (from.kind === "gate") {
+                const relevant = verification.filter((item) => from.verifier_ids.includes(item.verifier_id));
+                const passed = from.verifier_ids.every((id) => relevant.some((item) => item.verifier_id === id && item.passed));
+                events.push(this.event(snapshot, initialOffset + events.length, {
+                    type: "gate_evaluated", step_id: source.step_id, activation_id: source.activation_id,
+                    attempt_id: null, result_id: sourceResultId,
+                    key: `gate:${source.activation_id}:${from.node_id}`, at: now,
+                    payload: { gate_id: from.node_id, predicate: { verifier_ids: from.verifier_ids }, source_result_id: sourceResultId, passed, reason_code: passed ? "all_verifiers_passed" : "verifier_failed" },
+                }));
+                selected = plan.routes.filter((route) => route.from_node_id === from.node_id && route.condition.kind === "gate" && route.condition.outcome === (passed ? "pass" : "fail"));
+                markDeterministicNodeCompleted(from.node_id, source.workflow_round);
+            }
+            else if (from.kind === "decision") {
+                const output = decisionOutputs.get(from.node_id)?.find((item) => item.name === from.source.output_name);
+                const value = output?.kind === "structured" ? this.jsonPointer(output.value, from.source.json_pointer) : null;
+                if (typeof value !== "string" || !from.allowed_values.includes(value)) {
+                    throw new CanonicalRunServiceError("verification_failed", `decision ${from.node_id} produced an undeclared string value`);
+                }
+                events.push(this.event(snapshot, initialOffset + events.length, {
+                    type: "decision_evaluated", step_id: source.step_id, activation_id: source.activation_id,
+                    attempt_id: null, result_id: sourceResultId,
+                    key: `decision:${source.activation_id}:${from.node_id}`, at: now,
+                    payload: { decision_id: from.node_id, value: value, source_result_id: sourceResultId, reason_code: "typed_decision_evaluated" },
+                }));
+                selected = plan.routes.filter((route) => route.from_node_id === from.node_id && route.condition.kind === "decision" && route.condition.value === value);
+                markDeterministicNodeCompleted(from.node_id, source.workflow_round);
+            }
+            else if (from.kind === "terminal") {
+                const terminal = plan.terminals.find((item) => item.terminal_id === from.terminal_id);
+                run = this.terminalRun(snapshot.run, terminal.status === "unsupported" ? "failed" : terminal.status, terminal.reason_code, now);
+                return;
+            }
+            else if (from.kind === "interaction") {
+                selected = plan.routes.filter((route) => (route.from_node_id === from.node_id
+                    && route.condition.kind === "interaction"
+                    && route.condition.outcome === "submitted"));
+            }
+            else {
+                selected = plan.routes.filter((route) => route.from_node_id === from.node_id && route.condition.kind === "always");
+            }
+            for (const route of selected) {
+                const decisionRetry = plan.retry_segments.find((segment) => (segment.continue_route_id === route.route_id));
+                if (decisionRetry !== undefined && source.workflow_round < decisionRetry.max_rounds) {
+                    const toRound = source.workflow_round + 1;
+                    const priorActivations = decisionRetry.node_ids.map((stepId) => (effectiveActivation(stepId, source.workflow_round)));
+                    if (priorActivations.some((candidate) => (candidate === null || !TERMINAL_ACTIVATION_STATES.has(candidate.state)))) {
+                        throw new CanonicalRunServiceError("attempt_state_conflict", `retry segment ${decisionRetry.retry_segment_id} has non-terminal prior activations`);
+                    }
+                    const replacements = decisionRetry.node_ids.map((stepId) => ({
+                        run_id: snapshot.run.run_id,
+                        step_id: stepId,
+                        activation_id: this.activationRoundId(snapshot.run.run_id, stepId, toRound),
+                        workflow_round: toRound,
+                        state: stepId === decisionRetry.retry_from_node_id ? "ready" : "dependency_blocked",
+                        attempt_count: 0,
+                        current_attempt_id: null,
+                        committed_result_id: null,
+                        created_at: now,
+                        updated_at: now,
+                    }));
+                    created.push(...replacements);
+                    const delayMs = this.retrySegmentDelay(decisionRetry, source.workflow_round);
+                    events.push(this.event(snapshot, initialOffset + events.length, {
+                        type: "retry_segment_scheduled",
+                        step_id: source.step_id,
+                        activation_id: source.activation_id,
+                        attempt_id: null,
+                        result_id: sourceResultId,
+                        key: `retry-segment:${decisionRetry.retry_segment_id}:round:${toRound}`,
+                        at: now,
+                        payload: {
+                            retry_segment_id: decisionRetry.retry_segment_id,
+                            from_round: source.workflow_round,
+                            to_round: toRound,
+                            prior_activation_ids: priorActivations.map((candidate) => candidate.activation_id),
+                            replacement_activation_ids: replacements.map((candidate) => candidate.activation_id),
+                            retry_from_activation_id: replacements.find((candidate) => (candidate.step_id === decisionRetry.retry_from_node_id)).activation_id,
+                            triggering_result_id: sourceResultId,
+                            delay_ms: delayMs,
+                            ready_at: addMilliseconds(now, delayMs),
+                            reason_code: "typed_continue",
+                        },
+                    }));
+                    events.push(this.event(snapshot, initialOffset + events.length, {
+                        type: "route_selected",
+                        step_id: source.step_id,
+                        activation_id: source.activation_id,
+                        attempt_id: null,
+                        result_id: sourceResultId,
+                        key: `route:${source.activation_id}:${route.route_id}`,
+                        at: now,
+                        payload: {
+                            route_id: route.route_id,
+                            source_activation_id: source.activation_id,
+                            source_result_id: sourceResultId,
+                            successor_activation_ids: [],
+                            reason_code: "typed_continue",
+                        },
+                    }));
+                    continue;
+                }
+                const target = nodeById(plan, route.to_node_id);
+                const successorIds = [];
+                if (ATTEMPT_NODE_KINDS.has(target.kind)) {
+                    const current = this.latestActivationForStep(snapshot.activations.map((item) => changed.get(item.activation_id) ?? item), target.node_id);
+                    if (current && current.state === "dormant") {
+                        const ready = target.depends_on.every((dependency) => (dependencyCompleted(dependency, current.workflow_round)));
+                        const next = { ...current, state: ready ? "ready" : "dependency_blocked", updated_at: now };
+                        changed.set(next.activation_id, next);
+                        successorIds.push(next.activation_id);
+                    }
+                }
+                events.push(this.event(snapshot, initialOffset + events.length, {
+                    type: "route_selected", step_id: source.step_id, activation_id: source.activation_id,
+                    attempt_id: null, result_id: sourceResultId,
+                    key: `route:${source.activation_id}:${route.route_id}`, at: now,
+                    payload: { route_id: route.route_id, source_activation_id: source.activation_id, source_result_id: sourceResultId, successor_activation_ids: successorIds, reason_code: "typed_route_selected" },
+                }));
+                if (!ATTEMPT_NODE_KINDS.has(target.kind)) {
+                    visit(target.node_id);
+                }
+            }
+            const routedTargetIds = new Set(plan.routes.map((route) => route.to_node_id));
+            for (const dependent of plan.nodes) {
+                if (ATTEMPT_NODE_KINDS.has(dependent.kind)
+                    || routedTargetIds.has(dependent.node_id)
+                    || dependent.depends_on.length === 0
+                    || !dependent.depends_on.includes(fromNodeId)
+                    || !dependent.depends_on.every((dependency) => (dependencyCompleted(dependency, source.workflow_round))))
+                    continue;
+                markDeterministicNodeCompleted(dependent.node_id, source.workflow_round);
+                visit(dependent.node_id);
+            }
+        };
+        visit(source.step_id);
+        for (const activation of snapshot.activations) {
+            if (activation.state !== "dependency_blocked" || changed.has(activation.activation_id))
+                continue;
+            const latest = this.latestActivationForStep(snapshot.activations, activation.step_id);
+            if (latest?.activation_id !== activation.activation_id)
+                continue;
+            const node = nodeById(plan, activation.step_id);
+            if (node.depends_on.every((dependency) => (dependencyCompleted(dependency, activation.workflow_round)))) {
+                changed.set(activation.activation_id, { ...activation, state: "ready", updated_at: now });
+            }
+        }
+        for (const next of changed.values()) {
+            const prior = snapshot.activations.find((item) => item.activation_id === next.activation_id);
+            events.push(this.activationEvent(snapshot, initialOffset + events.length, prior, next, "dependencies_satisfied", now));
+        }
+        if (run.terminal !== null) {
+            for (const activation of snapshot.activations) {
+                const current = changed.get(activation.activation_id) ?? activation;
+                if (current.activation_id === source.activation_id || TERMINAL_ACTIVATION_STATES.has(current.state))
+                    continue;
+                const currentAttempt = current.current_attempt_id === null
+                    ? null
+                    : snapshot.attempts.find((attempt) => (attempt.attempt_id === current.current_attempt_id
+                        && attempt.phase !== "terminal")) ?? null;
+                const skipped = {
+                    ...current,
+                    state: currentAttempt ? "cancelled" : "skipped",
+                    updated_at: now,
+                };
+                changed.set(skipped.activation_id, skipped);
+                events.push(this.activationEvent(snapshot, initialOffset + events.length, current, skipped, currentAttempt ? "run_terminal" : "terminal_route_selected", now));
+            }
+            events.push(this.runTerminalEvent(snapshot, initialOffset + events.length, run, now));
+        }
+        return { activations: [...changed.values(), ...created], events, run };
+    }
+    latestActivationForStep(activations, stepId, maxRound = Number.POSITIVE_INFINITY) {
+        let latest = null;
+        for (const activation of activations) {
+            if (activation.step_id !== stepId || activation.workflow_round > maxRound)
+                continue;
+            if (latest === null || activation.workflow_round > latest.workflow_round) {
+                latest = activation;
+            }
+        }
+        return latest;
+    }
+    async cancelConcurrentAttempts(snapshot, excludedActivationId, now, reasonCode, initialOffset) {
+        const attempts = [];
+        const events = [];
+        for (const attempt of snapshot.attempts) {
+            if (attempt.activation_id === excludedActivationId || attempt.phase === "terminal")
+                continue;
+            const executor = attempt.executor ?? {
+                kind: "system",
+                service_instance_id: this.serviceInstanceId,
+                operation: "cancel_concurrent_attempt",
+            };
+            const outcome = executor.kind === "worker"
+                ? {
+                    kind: "worker_process",
+                    status: "cancelled",
+                    reason_code: reasonCode,
+                    message: null,
+                    process: {
+                        kind: "cancelled",
+                        exit_code: null,
+                        signal: null,
+                        reason: reasonCode,
+                    },
+                }
+                : { kind: "cancelled", reason: reasonCode };
+            if (executor.kind === "worker")
+                continue;
+            const terminalAttempt = {
+                ...attempt,
+                phase: "terminal",
+                executor,
+                started_at: attempt.started_at ?? now,
+                completed_at: now,
+                terminal_outcome: outcome,
+            };
+            attempts.push(terminalAttempt);
+            if (attempt.started_at === null) {
+                events.push(this.event(snapshot, initialOffset + events.length, {
+                    type: "attempt_started",
+                    step_id: attempt.step_id,
+                    activation_id: attempt.activation_id,
+                    attempt_id: attempt.attempt_id,
+                    result_id: null,
+                    key: `attempt:${attempt.attempt_id}:terminal-started`,
+                    at: now,
+                    payload: { executor },
+                }));
+            }
+            events.push(this.event(snapshot, initialOffset + events.length, {
+                type: "attempt_terminal",
+                step_id: attempt.step_id,
+                activation_id: attempt.activation_id,
+                attempt_id: attempt.attempt_id,
+                result_id: null,
+                key: `attempt:${attempt.attempt_id}:terminal-cancelled`,
+                at: now,
+                payload: { executor, outcome, worker_stop_receipt: null, worker_nonlaunch_attestation: null },
+            }));
+        }
+        return { attempts, events };
+    }
+    async reduceWithoutResult(snapshot, plan) {
+        if (snapshot.run.terminal !== null || snapshot.activations.length > 0)
+            return snapshot;
+        const routedTargets = new Set(plan.plan.routes.map((route) => route.to_node_id));
+        const rootTerminal = plan.plan.nodes.find((node) => (node.kind === "terminal"
+            && node.depends_on.length === 0
+            && !routedTargets.has(node.node_id)));
+        if (!rootTerminal || rootTerminal.kind !== "terminal")
+            return snapshot;
+        const terminal = plan.plan.terminals.find((item) => item.terminal_id === rootTerminal.terminal_id);
+        const now = this.now();
+        const run = this.terminalRun(snapshot.run, terminal.status === "unsupported" ? "failed" : terminal.status, terminal.reason_code, now);
+        const event = this.runTerminalEvent(snapshot, 0, run, now);
+        try {
+            return (await this.runStore.updateCanonicalRun({
+                run_id: snapshot.run.run_id,
+                expected_record_version: snapshot.record_version,
+                run,
+                events: [event],
+            })).snapshot;
+        }
+        catch (error) {
+            if (this.isVersionConflict(error))
+                return this.requireSnapshot(snapshot.run.run_id);
+            throw error;
+        }
+    }
+    terminalRun(run, status, reasonCode, now) {
+        return {
+            ...run,
+            status,
+            terminal: { status, reason_code: reasonCode, reason: null, completed_at: now },
+            updated_at: now,
+        };
+    }
+    retryDelay(node, priorAttemptNumber) {
+        if (node.attempt_policy.backoff === "none")
+            return 0;
+        const multiplier = node.attempt_policy.backoff === "linear"
+            ? priorAttemptNumber
+            : 2 ** Math.max(0, priorAttemptNumber - 1);
+        const delay = node.attempt_policy.initial_delay_ms * multiplier;
+        return node.attempt_policy.max_delay_ms === null
+            ? delay
+            : Math.min(delay, node.attempt_policy.max_delay_ms);
+    }
+    retrySegmentDelay(segment, priorRound) {
+        if (segment.backoff === "none")
+            return 0;
+        const multiplier = segment.backoff === "linear"
+            ? priorRound
+            : 2 ** Math.max(0, priorRound - 1);
+        const delay = segment.initial_delay_ms * multiplier;
+        return segment.max_delay_ms === null
+            ? delay
+            : Math.min(delay, segment.max_delay_ms);
+    }
+    jsonPointer(value, pointer) {
+        if (pointer === "")
+            return value;
+        let current = value;
+        for (const raw of pointer.split("/").slice(1)) {
+            const key = raw.replace(/~1/gu, "/").replace(/~0/gu, "~");
+            if (Array.isArray(current))
+                current = current[Number(key)];
+            else if (current !== null && typeof current === "object") {
+                current = current[key];
+            }
+            else
+                current = undefined;
+        }
+        if (current === undefined) {
+            throw new CanonicalRunServiceError("verification_failed", `decision JSON pointer ${pointer} was not found`);
+        }
+        return current;
+    }
+    validateDecisionOutputs(plan, sourceNodeId, outputs) {
+        for (const decision of plan.nodes) {
+            if (decision.kind !== "decision" || decision.source.node_id !== sourceNodeId)
+                continue;
+            const output = outputs.find((candidate) => candidate.name === decision.source.output_name);
+            const value = output?.kind === "structured"
+                ? this.jsonPointer(output.value, decision.source.json_pointer)
+                : null;
+            if (typeof value !== "string" || !decision.allowed_values.includes(value)) {
+                throw new CanonicalRunServiceError("verification_failed", `decision ${decision.node_id} produced an undeclared string value`);
+            }
+        }
+    }
+    activationEvent(snapshot, offset, before, after, reasonCode, at) {
+        return this.event(snapshot, offset, {
+            type: "activation_state_changed",
+            step_id: after.step_id,
+            activation_id: after.activation_id,
+            attempt_id: null,
+            result_id: null,
+            key: `activation:${after.activation_id}:${before.state}:${after.state}:${after.attempt_count}`,
+            at,
+            payload: { from: before.state, to: after.state, reason_code: reasonCode },
+        });
+    }
+    runTerminalEvent(snapshot, offset, run, at) {
+        return this.event(snapshot, offset, {
+            type: "run_terminal", step_id: null, activation_id: null,
+            attempt_id: null, result_id: null,
+            key: `run:${run.run_id}:terminal:${run.status}`, at,
+            payload: {
+                status: run.terminal.status,
+                reason_code: run.terminal.reason_code,
+                reason: run.terminal.reason,
+            },
+        });
+    }
+    event(snapshot, offset, input) {
+        return {
+            event_id: this.identities.create("event", input.key),
+            run_id: snapshot.run.run_id,
+            step_id: input.step_id,
+            activation_id: input.activation_id,
+            attempt_id: input.attempt_id,
+            result_id: input.result_id,
+            sequence: snapshot.events.length + offset + 1,
+            idempotency_key: input.key,
+            type: input.type,
+            occurred_at: input.at,
+            payload: input.payload,
+        };
+    }
+    isVersionConflict(error) {
+        return error instanceof RunStoreError && error.code === "version_conflict";
+    }
+}