intentdna 1.9.0 → 1.9.3

package/dist/runtime/execution-authority.d.ts

@@ -0,0 +1,83 @@
+import type { ActivationId, AttemptExecutor, AttemptId, CanonicalAttemptOutcome, CanonicalResultDigest, CanonicalWorkerStopReceipt, CanonicalWorkerStopReceiptPayload, CanonicalWorkerNonlaunchAttestation, CanonicalWorkerNonlaunchAttestationPayload, CanonicalWorkerAlreadyStoppedEvidence, CanonicalWorkerAlreadyStoppedEvidencePayload, RunId, StepId } from "./run-contracts.js";
+export interface AttemptExecutionAuthorityRequest {
+    readonly run_id: RunId;
+    readonly step_id: StepId;
+    readonly activation_id: ActivationId;
+    readonly attempt_id: AttemptId;
+    readonly claim_epoch: number;
+    readonly executor: Extract<AttemptExecutor, {
+        kind: "worker";
+    }>;
+    readonly purpose: "finalize_result" | "reconcile_published_result";
+    readonly reported_execution: {
+        readonly started_at: string;
+        readonly completed_at: string;
+        readonly outcome: CanonicalAttemptOutcome;
+    };
+    readonly expected_receipt: CanonicalWorkerStopReceipt | null;
+}
+export type StopExecutionPurpose = "cancel" | "execution_deadline" | "peer_terminal";
+export interface StopExecutionRequest {
+    readonly run_id: RunId;
+    readonly step_id: StepId;
+    readonly activation_id: ActivationId;
+    readonly attempt_id: AttemptId;
+    readonly claim_epoch: number;
+    readonly executor: Extract<AttemptExecutor, {
+        kind: "worker";
+    }>;
+    readonly purpose: StopExecutionPurpose;
+    readonly requested_at: string;
+    readonly started_at: string;
+    readonly requested_outcome: CanonicalAttemptOutcome;
+    readonly stop_idempotency_key: CanonicalResultDigest;
+    readonly expected_receipt: CanonicalWorkerStopReceipt | null;
+}
+export interface StoppedExecutionAuthority {
+    readonly stop_receipt: CanonicalWorkerStopReceipt;
+    readonly authority_instance_id: string;
+    readonly fencing_epoch: number;
+}
+export type StopExecutionResolution = {
+    readonly kind: "stopped_by_request";
+    readonly authority: StoppedExecutionAuthority;
+} | {
+    readonly kind: "already_stopped";
+    readonly drain_evidence: CanonicalWorkerAlreadyStoppedEvidence;
+} | {
+    readonly kind: "never_launched";
+    readonly nonlaunch_attestation: CanonicalWorkerNonlaunchAttestation;
+};
+export interface ExecutionRecoveryProbeRequest {
+    readonly run_id: RunId;
+    readonly step_id: StepId;
+    readonly activation_id: ActivationId;
+    readonly attempt_id: AttemptId;
+    readonly execution_claim_epoch: number;
+    readonly executor: Extract<AttemptExecutor, {
+        kind: "worker";
+    }>;
+    readonly started_at: string;
+}
+export interface ExecutionRecoveryState {
+    readonly raw_completion_durable: boolean;
+}
+export interface NeverLaunchedAttestationRequest extends ExecutionRecoveryProbeRequest {
+    readonly failure_idempotency_key: CanonicalResultDigest;
+    readonly requested_at: string;
+}
+export interface AttemptExecutionAuthorityPort {
+    withStoppedExecution<T>(request: AttemptExecutionAuthorityRequest, operation: (authority: StoppedExecutionAuthority) => Promise<T>): Promise<T>;
+    requestStop?(request: StopExecutionRequest): Promise<StopExecutionResolution>;
+    probeRecovery?(request: ExecutionRecoveryProbeRequest): Promise<ExecutionRecoveryState>;
+    attestNeverLaunched?(request: NeverLaunchedAttestationRequest): Promise<CanonicalWorkerNonlaunchAttestation>;
+}
+export declare function workerNonlaunchAttestationDigest(payload: CanonicalWorkerNonlaunchAttestationPayload): CanonicalWorkerNonlaunchAttestation["attestation_digest"];
+export declare function workerNonlaunchAttestationMatches(attestation: CanonicalWorkerNonlaunchAttestation, request: NeverLaunchedAttestationRequest): boolean;
+export declare function workerStopReceiptDigest(payload: CanonicalWorkerStopReceiptPayload): CanonicalWorkerStopReceipt["receipt_digest"];
+export declare function workerAlreadyStoppedEvidenceDigest(payload: CanonicalWorkerAlreadyStoppedEvidencePayload): CanonicalWorkerAlreadyStoppedEvidence["evidence_digest"];
+export declare function createWorkerAlreadyStoppedEvidence(payload: CanonicalWorkerAlreadyStoppedEvidencePayload): CanonicalWorkerAlreadyStoppedEvidence;
+export declare function workerAlreadyStoppedEvidenceMatchesStop(evidence: CanonicalWorkerAlreadyStoppedEvidence, request: StopExecutionRequest): boolean;
+export declare function createWorkerStopReceipt(payload: CanonicalWorkerStopReceiptPayload): CanonicalWorkerStopReceipt;
+export declare function workerStopReceiptMatchesExecution(receipt: CanonicalWorkerStopReceipt, request: AttemptExecutionAuthorityRequest): boolean;
+export declare function workerStopReceiptMatchesStop(receipt: CanonicalWorkerStopReceipt, request: StopExecutionRequest): boolean;

package/dist/runtime/execution-authority.js

@@ -0,0 +1,98 @@
+import { createHash } from "node:crypto";
+import { canonicalizeJson } from "./canonical-json.js";
+export function workerNonlaunchAttestationDigest(payload) {
+    return `sha256:${createHash("sha256")
+        .update(canonicalizeJson(payload), "utf8")
+        .digest("hex")}`;
+}
+export function workerNonlaunchAttestationMatches(attestation, request) {
+    const payload = attestation.payload;
+    return attestation.attestation_digest === workerNonlaunchAttestationDigest(payload)
+        && payload.run_id === request.run_id
+        && payload.step_id === request.step_id
+        && payload.activation_id === request.activation_id
+        && payload.attempt_id === request.attempt_id
+        && payload.claim_epoch === request.execution_claim_epoch
+        && payload.worker_session_id === request.executor.worker_session_id
+        && payload.started_at === request.started_at
+        && payload.failure_idempotency_key === request.failure_idempotency_key
+        && payload.launch_state === "never_launched"
+        && payload.fencing_epoch > 0;
+}
+export function workerStopReceiptDigest(payload) {
+    return `sha256:${createHash("sha256")
+        .update(canonicalizeJson(payload), "utf8")
+        .digest("hex")}`;
+}
+export function workerAlreadyStoppedEvidenceDigest(payload) {
+    return `sha256:${createHash("sha256")
+        .update(canonicalizeJson(payload), "utf8")
+        .digest("hex")}`;
+}
+export function createWorkerAlreadyStoppedEvidence(payload) {
+    return {
+        evidence_digest: workerAlreadyStoppedEvidenceDigest(payload),
+        payload,
+    };
+}
+export function workerAlreadyStoppedEvidenceMatchesStop(evidence, request) {
+    const payload = evidence.payload;
+    return evidence.evidence_digest === workerAlreadyStoppedEvidenceDigest(payload)
+        && payload.run_id === request.run_id
+        && payload.step_id === request.step_id
+        && payload.activation_id === request.activation_id
+        && payload.attempt_id === request.attempt_id
+        && payload.claim_epoch === request.claim_epoch
+        && payload.worker_session_id === request.executor.worker_session_id
+        && payload.started_at === request.started_at
+        && payload.completed_at >= payload.started_at
+        && payload.process_tree_drained === true
+        && payload.stop_idempotency_key === request.stop_idempotency_key
+        && payload.stop_requested_at === request.requested_at
+        && payload.stop_purpose === request.purpose
+        && canonicalizeJson(payload.stop_requested_outcome) === canonicalizeJson(request.requested_outcome)
+        && payload.execution_instance_id.length > 0
+        && (payload.authority_kind === "local_process" || payload.authority_kind === "host_attested")
+        && payload.authority_instance_id.length > 0
+        && Number.isSafeInteger(payload.fencing_epoch)
+        && payload.fencing_epoch > 0
+        && /^sha256:[0-9a-f]{64}$/.test(payload.source_evidence_digest);
+}
+export function createWorkerStopReceipt(payload) {
+    return {
+        receipt_digest: workerStopReceiptDigest(payload),
+        payload,
+    };
+}
+export function workerStopReceiptMatchesExecution(receipt, request) {
+    const payload = receipt.payload;
+    return receipt.receipt_digest === workerStopReceiptDigest(payload)
+        && payload.run_id === request.run_id
+        && payload.step_id === request.step_id
+        && payload.activation_id === request.activation_id
+        && payload.attempt_id === request.attempt_id
+        && payload.claim_epoch === request.claim_epoch
+        && payload.worker_session_id === request.executor.worker_session_id
+        && payload.started_at === request.reported_execution.started_at
+        && payload.stopped_at === request.reported_execution.completed_at
+        && canonicalizeJson(payload.terminal_outcome)
+            === canonicalizeJson(request.reported_execution.outcome)
+        && payload.process_tree_drained === true;
+}
+export function workerStopReceiptMatchesStop(receipt, request) {
+    const payload = receipt.payload;
+    return receipt.receipt_digest === workerStopReceiptDigest(payload)
+        && payload.run_id === request.run_id
+        && payload.step_id === request.step_id
+        && payload.activation_id === request.activation_id
+        && payload.attempt_id === request.attempt_id
+        && payload.claim_epoch === request.claim_epoch
+        && payload.worker_session_id === request.executor.worker_session_id
+        && payload.started_at === request.started_at
+        && payload.stopped_at >= request.requested_at
+        && canonicalizeJson(payload.terminal_outcome)
+            === canonicalizeJson(request.requested_outcome)
+        && (request.expected_receipt === null
+            || canonicalizeJson(receipt) === canonicalizeJson(request.expected_receipt))
+        && payload.process_tree_drained === true;
+}

package/dist/runtime/handoff-resolver.js

@@ -76,7 +76,10 @@ export class HandoffResolver {
                 description: request.description,
                 mode: "reference",
                 source: request.source,
-                reference: output.reference,
+                reference: {
+                    ...output.reference,
+                    artifact_id: null,
+                },
             };
         }
         if (request.mode === "quote") {

package/dist/runtime/harness-pull-adapter.d.ts

@@ -0,0 +1,146 @@
+import { CanonicalRunApplication, type CompiledCanonicalTarget, type StartCanonicalTargetRequest } from "./canonical-run-application.js";
+import { type AcquireAttemptResponse, type AttemptExecutionSubmission, type AttemptView, type HeartbeatRequest, type LeaseView, type RunView, type StartRunResponse, type SubmitResponse } from "./canonical-run-service.js";
+import type { DriverCapabilities, ExecutableRunPlanPayload } from "./executable-run-plan.js";
+import type { CompiledIRFile } from "./plugin-adapter.js";
+import type { CanonicalCallerAttestationPayload, CanonicalEvidenceRef, CanonicalAttemptRecord, CanonicalResultDigest, ClaimToken, JsonValue, RunId, WorkerSessionId } from "./run-contracts.js";
+export declare const HARNESS_RUN_METADATA_SCHEMA_VERSION = "intentdna.harness_run_metadata.v1";
+export declare const HARNESS_CALLER_ATTESTATION_SCHEMA_VERSION: "intentdna.harness_caller_attestation.v1";
+export declare const HARNESS_SUBMISSION_MODE_VALUES: readonly ["relayed_submit", "attested_independent_submit"];
+export type HarnessSubmissionMode = typeof HARNESS_SUBMISSION_MODE_VALUES[number];
+export type HarnessPullAdapterErrorCode = "invalid_configuration" | "invalid_request" | "invalid_service_response" | "unsupported";
+export declare class HarnessPullAdapterError extends Error {
+    readonly code: HarnessPullAdapterErrorCode;
+    constructor(code: HarnessPullAdapterErrorCode, message: string, options?: ErrorOptions);
+}
+export interface HarnessPullCapabilities {
+    readonly driver: Readonly<DriverCapabilities>;
+    readonly submission_modes: readonly HarnessSubmissionMode[];
+    readonly stopped_execution_authority: boolean;
+}
+export interface HarnessRunMetadata {
+    readonly schema_version: typeof HARNESS_RUN_METADATA_SCHEMA_VERSION;
+    readonly transport: "harness_pull";
+    readonly project_directory: string;
+    readonly target: StartCanonicalTargetRequest["target"];
+    readonly compiled_ir: CompiledIRFile | null;
+    readonly requested_metadata: JsonValue | null;
+}
+export type HarnessCallerAttestationPayload = CanonicalCallerAttestationPayload;
+export interface HarnessCallerAttestation {
+    readonly attestation_ref: string;
+    readonly attestation_digest: CanonicalResultDigest;
+    readonly payload: HarnessCallerAttestationPayload;
+}
+export interface HarnessCallerAttestationRequest {
+    readonly run: RunView;
+    readonly submission: {
+        readonly attempt: CanonicalAttemptRecord;
+        readonly claim_epoch: number;
+        readonly submission_key_digest: CanonicalResultDigest;
+        readonly execution_digest: CanonicalResultDigest;
+    };
+}
+/**
+ * This port is a composition-root trust anchor. It must derive the current
+ * caller from host-authenticated context. The adapter supplies only durable
+ * submission facts; tool arguments are never caller attestation.
+ */
+export interface HarnessCallerAttestationAuthority {
+    readonly authority_id: string;
+    attest(request: HarnessCallerAttestationRequest): Promise<HarnessCallerAttestation>;
+}
+export interface HarnessAttemptProjectionContext {
+    readonly run: RunView;
+    readonly attached: AttemptView;
+    readonly lease_token: ClaimToken;
+    readonly owner_id: string;
+    readonly worker_session_id: WorkerSessionId;
+    readonly submission_mode: HarnessSubmissionMode;
+    readonly metadata: HarnessRunMetadata | null;
+}
+export interface HarnessPullService {
+    start(request: {
+        readonly plan_payload: ExecutableRunPlanPayload;
+        readonly run_binding: CompiledCanonicalTarget["run_binding"];
+        readonly metadata?: JsonValue;
+        readonly run_id?: RunId;
+    }): Promise<StartRunResponse>;
+    inspect(runId: RunId): Promise<RunView>;
+    resume(runId: RunId): Promise<RunView>;
+    acquireAttempt(request: {
+        readonly run_id: RunId;
+        readonly driver_id: string;
+        readonly recover_running?: boolean;
+    }): Promise<AcquireAttemptResponse>;
+    attachAttempt(request: {
+        readonly lease_token: ClaimToken;
+        readonly owner_id: string;
+        readonly worker_identity: string;
+        readonly capabilities: Partial<DriverCapabilities>;
+    }): Promise<AttemptView>;
+    heartbeat(request: HeartbeatRequest): Promise<LeaseView>;
+    submitAttempt(request: {
+        readonly lease_token: ClaimToken;
+        readonly owner_id: string;
+        readonly submission_key: string;
+        readonly execution: AttemptExecutionSubmission;
+        readonly evidence_refs?: readonly CanonicalEvidenceRef[];
+    }): Promise<SubmitResponse>;
+    cancel(runId: RunId, reason?: string | null): Promise<RunView>;
+}
+export interface HarnessAttemptAttachRequest {
+    readonly run_id: RunId;
+    readonly attempt_id: string;
+    readonly lease_token: ClaimToken;
+    readonly owner_id: string;
+    readonly worker_session_id: WorkerSessionId;
+    readonly submission_mode: HarnessSubmissionMode;
+}
+export interface HarnessAttemptSubmitRequest {
+    readonly run_id: RunId;
+    readonly attempt_id: string;
+    readonly lease_token: ClaimToken;
+    readonly owner_id: string;
+    readonly submission_key: string;
+    readonly submission_mode: HarnessSubmissionMode;
+    readonly execution: AttemptExecutionSubmission;
+    readonly evidence_refs?: readonly CanonicalEvidenceRef[];
+}
+export interface HarnessPullAdapterOptions {
+    readonly service: HarnessPullService;
+    readonly application?: CanonicalRunApplication<StartRunResponse>;
+    readonly capabilities: HarnessPullCapabilities;
+    readonly caller_attestation_authority?: HarnessCallerAttestationAuthority;
+    readonly attempt_projection_sink?: (context: HarnessAttemptProjectionContext) => Promise<void> | void;
+    readonly validate_worker_session_id?: (workerSessionId: WorkerSessionId) => void;
+    readonly driver_id?: string;
+}
+export declare function parseHarnessRunMetadata(value: JsonValue): HarnessRunMetadata | null;
+export declare function harnessCallerAttestationDigest(payload: HarnessCallerAttestationPayload): CanonicalResultDigest;
+export declare class HarnessPullAdapter {
+    readonly capabilities: HarnessPullCapabilities;
+    private readonly service;
+    private readonly application;
+    private readonly callerAttestationAuthority;
+    private readonly attemptProjectionSink;
+    private readonly validateWorkerSessionId;
+    private readonly driverId;
+    constructor(options: HarnessPullAdapterOptions);
+    start(request: StartCanonicalTargetRequest): Promise<StartRunResponse>;
+    startCompiled(request: {
+        readonly compiled: CompiledCanonicalTarget;
+        readonly project_directory: string;
+        readonly target: StartCanonicalTargetRequest["target"];
+        readonly metadata?: JsonValue;
+        readonly run_id?: RunId;
+    }): Promise<StartRunResponse>;
+    next(runId: RunId): Promise<AcquireAttemptResponse>;
+    attach(request: HarnessAttemptAttachRequest): Promise<AttemptView>;
+    heartbeat(request: HeartbeatRequest): Promise<LeaseView>;
+    submit(request: HarnessAttemptSubmitRequest): Promise<SubmitResponse>;
+    status(runId: RunId): Promise<RunView>;
+    cancel(runId: RunId, reason?: string | null): Promise<RunView>;
+    private requireAttempt;
+    private assertSubmissionMode;
+    private attestSubmission;
+}

package/dist/runtime/harness-pull-adapter.js

@@ -0,0 +1,315 @@
+import { createHash, randomUUID } from "node:crypto";
+import { CanonicalRunApplication, } from "./canonical-run-application.js";
+import { canonicalizeJson } from "./canonical-json.js";
+import { durableCanonicalRuntimeProjection } from "./canonical-runtime-projection.js";
+import { CALLER_ATTESTATION_SCHEMA_VERSION } from "./run-contracts.js";
+export const HARNESS_RUN_METADATA_SCHEMA_VERSION = "intentdna.harness_run_metadata.v1";
+export const HARNESS_CALLER_ATTESTATION_SCHEMA_VERSION = CALLER_ATTESTATION_SCHEMA_VERSION;
+export const HARNESS_SUBMISSION_MODE_VALUES = [
+    "relayed_submit",
+    "attested_independent_submit",
+];
+export class HarnessPullAdapterError extends Error {
+    code;
+    constructor(code, message, options) {
+        super(message, options);
+        this.name = "HarnessPullAdapterError";
+        this.code = code;
+    }
+}
+function digest(value) {
+    return `sha256:${createHash("sha256")
+        .update(canonicalizeJson(value), "utf8")
+        .digest("hex")}`;
+}
+function requireText(value, label) {
+    if (!value.trim()) {
+        throw new HarnessPullAdapterError("invalid_request", `${label} must be non-empty`);
+    }
+}
+function canonicalMetadata(compiled, request) {
+    const metadata = {
+        schema_version: HARNESS_RUN_METADATA_SCHEMA_VERSION,
+        transport: "harness_pull",
+        project_directory: request.environment.project_root,
+        target: request.target,
+        compiled_ir: compiled.projection === null
+            ? null
+            : durableCanonicalRuntimeProjection(compiled.projection),
+        requested_metadata: request.metadata ?? null,
+    };
+    return JSON.parse(canonicalizeJson(metadata));
+}
+export function parseHarnessRunMetadata(value) {
+    if (value === null || typeof value !== "object" || Array.isArray(value))
+        return null;
+    const record = value;
+    if (record.schema_version !== HARNESS_RUN_METADATA_SCHEMA_VERSION
+        || record.transport !== "harness_pull"
+        || typeof record.project_directory !== "string"
+        || record.target === null
+        || typeof record.target !== "object") {
+        return null;
+    }
+    return value;
+}
+export function harnessCallerAttestationDigest(payload) {
+    return digest(payload);
+}
+function validateCapabilities(capabilities, authority, projectionSink) {
+    const modes = new Set(capabilities.submission_modes);
+    if (capabilities.submission_modes.length !== modes.size
+        || capabilities.submission_modes.some((mode) => !HARNESS_SUBMISSION_MODE_VALUES.includes(mode))) {
+        throw new HarnessPullAdapterError("invalid_configuration", "harness submission modes are invalid");
+    }
+    if (modes.has("relayed_submit")
+        && capabilities.driver.direct_structured_submission !== true) {
+        throw new HarnessPullAdapterError("invalid_configuration", "relayed_submit requires direct_structured_submission");
+    }
+    if (modes.has("attested_independent_submit")
+        !== (capabilities.driver.caller_attestation === true)
+        || capabilities.driver.caller_attestation === true && authority === undefined) {
+        throw new HarnessPullAdapterError("invalid_configuration", "attested_independent_submit requires a trusted caller attestation authority");
+    }
+    if (capabilities.driver.hook_identity === true && projectionSink === undefined) {
+        throw new HarnessPullAdapterError("invalid_configuration", "hook_identity requires an attempt projection sink");
+    }
+    if (capabilities.driver.cancellation === true
+        && capabilities.stopped_execution_authority !== true) {
+        throw new HarnessPullAdapterError("invalid_configuration", "cancellation requires stopped-execution authority");
+    }
+}
+function assertRequiredCapabilities(plan, capabilities) {
+    for (const [name, required] of Object.entries(plan.required_capabilities)) {
+        if (required && capabilities[name] !== true) {
+            throw new HarnessPullAdapterError("unsupported", `harness capability ${name} is required`);
+        }
+    }
+}
+function sameJson(left, right) {
+    try {
+        return canonicalizeJson(left) === canonicalizeJson(right);
+    }
+    catch {
+        return false;
+    }
+}
+export class HarnessPullAdapter {
+    capabilities;
+    service;
+    application;
+    callerAttestationAuthority;
+    attemptProjectionSink;
+    validateWorkerSessionId;
+    driverId;
+    constructor(options) {
+        validateCapabilities(options.capabilities, options.caller_attestation_authority, options.attempt_projection_sink);
+        this.service = options.service;
+        this.application = options.application
+            ?? new CanonicalRunApplication({ starter: options.service });
+        this.capabilities = Object.freeze({
+            driver: Object.freeze({ ...options.capabilities.driver }),
+            submission_modes: Object.freeze([...options.capabilities.submission_modes]),
+            stopped_execution_authority: options.capabilities.stopped_execution_authority,
+        });
+        this.callerAttestationAuthority = options.caller_attestation_authority;
+        this.attemptProjectionSink = options.attempt_projection_sink;
+        this.validateWorkerSessionId = options.validate_worker_session_id;
+        this.driverId = options.driver_id ?? `harness-pull:${process.pid}:${randomUUID()}`;
+        requireText(this.driverId, "driver_id");
+    }
+    async start(request) {
+        const compiled = await this.application.compileTarget(request);
+        assertRequiredCapabilities(compiled.plan_payload, this.capabilities.driver);
+        return this.application.startCompiledTarget({
+            compiled,
+            metadata: canonicalMetadata(compiled, request),
+            ...(request.run_id === undefined ? {} : { run_id: request.run_id }),
+        });
+    }
+    async startCompiled(request) {
+        assertRequiredCapabilities(request.compiled.plan_payload, this.capabilities.driver);
+        const metadata = {
+            schema_version: HARNESS_RUN_METADATA_SCHEMA_VERSION,
+            transport: "harness_pull",
+            project_directory: request.project_directory,
+            target: request.target,
+            compiled_ir: request.compiled.projection === null
+                ? null
+                : durableCanonicalRuntimeProjection(request.compiled.projection),
+            requested_metadata: request.metadata ?? null,
+        };
+        return this.application.startCompiledTarget({
+            compiled: request.compiled,
+            metadata: JSON.parse(canonicalizeJson(metadata)),
+            ...(request.run_id === undefined ? {} : { run_id: request.run_id }),
+        });
+    }
+    async next(runId) {
+        requireText(runId, "run_id");
+        const resumed = await this.service.resume(runId);
+        assertRequiredCapabilities(resumed.plan.plan, this.capabilities.driver);
+        return this.service.acquireAttempt({
+            run_id: runId,
+            driver_id: this.driverId,
+            recover_running: false,
+        });
+    }
+    async attach(request) {
+        const run = await this.requireAttempt(request.run_id, request.attempt_id);
+        this.assertSubmissionMode(run, request.submission_mode);
+        try {
+            this.validateWorkerSessionId?.(request.worker_session_id);
+        }
+        catch (error) {
+            throw new HarnessPullAdapterError("invalid_request", "worker_session_id is invalid for this harness host", { cause: error });
+        }
+        const attached = await this.service.attachAttempt({
+            lease_token: request.lease_token,
+            owner_id: request.owner_id,
+            worker_identity: request.worker_session_id,
+            capabilities: this.capabilities.driver,
+        });
+        if (attached.lease.run_id !== request.run_id
+            || attached.lease.attempt_id !== request.attempt_id
+            || attached.attempt.executor?.kind !== "worker"
+            || attached.attempt.executor.worker_session_id !== request.worker_session_id) {
+            throw new HarnessPullAdapterError("invalid_service_response", "attached attempt identity does not match the requested harness lease");
+        }
+        if (this.capabilities.driver.hook_identity === true) {
+            const current = await this.service.inspect(request.run_id);
+            await this.attemptProjectionSink?.({
+                run: current,
+                attached,
+                lease_token: request.lease_token,
+                owner_id: request.owner_id,
+                worker_session_id: request.worker_session_id,
+                submission_mode: request.submission_mode,
+                metadata: parseHarnessRunMetadata(current.run.metadata),
+            });
+        }
+        return attached;
+    }
+    async heartbeat(request) {
+        return this.service.heartbeat(request);
+    }
+    async submit(request) {
+        const run = await this.requireAttempt(request.run_id, request.attempt_id);
+        this.assertSubmissionMode(run, request.submission_mode);
+        if (request.evidence_refs?.some((evidence) => evidence.kind === "caller_attestation")) {
+            throw new HarnessPullAdapterError("invalid_request", "caller attestation cannot be supplied through harness tool arguments");
+        }
+        const attempt = run.attempts.find((candidate) => candidate.attempt_id === request.attempt_id);
+        if (attempt.executor?.kind !== "worker"
+            || request.execution.executor.kind !== "worker"
+            || !sameJson(attempt.executor, request.execution.executor)) {
+            throw new HarnessPullAdapterError("invalid_request", "submission executor does not match the attached worker attempt");
+        }
+        const evidence = [...(request.evidence_refs ?? [])];
+        if (request.submission_mode === "attested_independent_submit") {
+            evidence.push(await this.attestSubmission(run, request));
+        }
+        return this.service.submitAttempt({
+            lease_token: request.lease_token,
+            owner_id: request.owner_id,
+            submission_key: request.submission_key,
+            execution: request.execution,
+            evidence_refs: evidence,
+        });
+    }
+    async status(runId) {
+        requireText(runId, "run_id");
+        return this.service.inspect(runId);
+    }
+    async cancel(runId, reason) {
+        requireText(runId, "run_id");
+        if (this.capabilities.driver.cancellation !== true) {
+            throw new HarnessPullAdapterError("unsupported", "harness cancellation requires trusted stopped-execution authority");
+        }
+        return this.service.cancel(runId, reason);
+    }
+    async requireAttempt(runId, attemptId) {
+        requireText(runId, "run_id");
+        requireText(attemptId, "attempt_id");
+        const run = await this.service.inspect(runId);
+        assertRequiredCapabilities(run.plan.plan, this.capabilities.driver);
+        if (!run.attempts.some((attempt) => attempt.attempt_id === attemptId)) {
+            throw new HarnessPullAdapterError("invalid_request", `attempt ${attemptId} does not belong to run ${runId}`);
+        }
+        return run;
+    }
+    assertSubmissionMode(run, mode) {
+        if (!this.capabilities.submission_modes.includes(mode)) {
+            throw new HarnessPullAdapterError("unsupported", `harness submission mode ${mode} is unavailable`);
+        }
+        if (run.plan.plan.required_capabilities.caller_attestation
+            && mode !== "attested_independent_submit") {
+            throw new HarnessPullAdapterError("unsupported", "this run requires attested_independent_submit");
+        }
+    }
+    async attestSubmission(run, request) {
+        const authority = this.callerAttestationAuthority;
+        if (authority === undefined) {
+            throw new HarnessPullAdapterError("unsupported", "trusted caller attestation is unavailable");
+        }
+        const attempt = run.attempts.find((candidate) => candidate.attempt_id === request.attempt_id);
+        const claim = [...run.claims]
+            .reverse()
+            .find((candidate) => candidate.attempt_id === request.attempt_id);
+        if (!claim || claim.owner_id !== request.owner_id) {
+            throw new HarnessPullAdapterError("invalid_request", "submission owner does not match the durable attempt claim");
+        }
+        if (request.execution.executor.kind !== "worker") {
+            throw new HarnessPullAdapterError("unsupported", "independent submission currently supports worker attempts only");
+        }
+        if (attempt.executor?.kind !== "worker"
+            || attempt.executor.worker_session_id !== request.execution.executor.worker_session_id) {
+            throw new HarnessPullAdapterError("invalid_request", "submission executor does not match the attached worker attempt");
+        }
+        const expected = {
+            run_id: request.run_id,
+            step_id: attempt.step_id,
+            activation_id: attempt.activation_id,
+            attempt_id: request.attempt_id,
+            claim_epoch: claim.claim_epoch,
+            worker_session_id: attempt.executor.worker_session_id,
+            submission_key_digest: digest({ submission_key: request.submission_key }),
+            execution_digest: digest(request.execution),
+        };
+        const attestation = await authority.attest({
+            run,
+            submission: {
+                attempt,
+                claim_epoch: claim.claim_epoch,
+                submission_key_digest: expected.submission_key_digest,
+                execution_digest: expected.execution_digest,
+            },
+        });
+        const payload = attestation.payload;
+        if (authority.authority_id.length === 0
+            || payload.schema_version !== HARNESS_CALLER_ATTESTATION_SCHEMA_VERSION
+            || payload.authority_id !== authority.authority_id
+            || !payload.agent_id
+            || !payload.session_id
+            || !sameJson({
+                run_id: payload.run_id,
+                step_id: payload.step_id,
+                activation_id: payload.activation_id,
+                attempt_id: payload.attempt_id,
+                claim_epoch: payload.claim_epoch,
+                worker_session_id: payload.worker_session_id,
+                submission_key_digest: payload.submission_key_digest,
+                execution_digest: payload.execution_digest,
+            }, expected)
+            || !attestation.attestation_ref
+            || attestation.attestation_digest !== harnessCallerAttestationDigest(payload)) {
+            throw new HarnessPullAdapterError("invalid_request", "caller attestation does not match the durable attempt submission");
+        }
+        return {
+            kind: "caller_attestation",
+            attestation_ref: attestation.attestation_ref,
+            attestation_digest: attestation.attestation_digest,
+            payload,
+        };
+    }
+}