@astrosheep/keiyaku 4.5.19 → 4.5.21

package/build/src/protocol/deliver.js

@@ -2,7 +2,7 @@ import { materializeIntegrationSnapshot, materializeJudgedConflict, planIntegrat
 import { captureTender, dirtyTenderRefusal, materializeTenderSnapshot, prepareDeliveryCommitMetadata, } from "../git/tender.js";
 import { checkoutDetachedSnapshot, recordConflictHandoff, retireConflictHandoff, workspaceMergeStatePresent, worktreePath, conflictRecovery, } from "../git/workspace.js";
 import { observeContractsForAdmissionAt } from "../git/observe.js";
-import { matchingPrivateRootObservation, privateStateSeatAttempt, sameSpeculativeWorktreeInput, } from "./run.js";
+import { contractStateWitness, privateStateSeatAttempt, sameWorktreeWitness, STALE_PRIVATE_STATE_PREPARATION, } from "./run.js";
 import { contractState } from "../core/facts/observation.js";
 import { decideDeliver } from "../core/verbs/deliver.js";
 import { currentVerifiedAttestation } from "./intent.js";
@@ -134,52 +134,132 @@ function hasSupersedingVerification(state, journal) {
     const verificationIndex = journal.findIndex((entry) => entry.entry === current.entry);
     return deliveryIndex >= 0 && verificationIndex > deliveryIndex;
 }
-async function speculateDelivery(input) {
+/**
+ * Repeatable physical delivery work outside the publication seat: locate the appointed worktree from
+ * one non-authoritative private-state read, capture its bytes, and materialize the prepared artifacts.
+ */
+async function prepareExternalDelivery(input) {
     const observation = await observeContractsForAdmissionAt(input.scope, input.channel, [input.contractId]);
     const state = contractState(observation.decision, input.contractId);
-    const derivation = state === null ? undefined : input.deriveDocument(state);
-    if (state === null || derivation === undefined) {
-        return { observation, state, preparation: { kind: "unavailable" } };
+    if (state === null)
+        return { kind: "unavailable" };
+    return {
+        kind: "artifacts",
+        witness: contractStateWitness(state),
+        artifacts: await prepareDeliveryArtifacts(input, observation, state),
+    };
+}
+async function prepareDeliveryArtifacts(input, observation, state) {
+    const derivation = input.deriveDocument(state);
+    if (derivation.verification.kind === "refused")
+        return { kind: "defer" };
+    if (reusesCurrentCandidate(input, state, derivation))
+        return { kind: "defer" };
+    if (input.materializeConflict === true && state.terminal === null)
+        return { kind: "defer" };
+    const captured = await captureAuthorizedDeliveryTender(input.scope, { contractId: state.id, coordinates: state.coordinates }, input.includeDirty);
+    if (captured.kind === "refused")
+        return { kind: "refused", refusal: captured.refusal };
+    const worktree = await worktreeInput(input.scope, state, captured.data);
+    if (state.terminal === null &&
+        state.delivery !== null &&
+        worktree.changeId === state.delivery.data.integration.changeId &&
+        !hasSupersedingVerification(state, observation.journals.get(state.id)?.entries ?? [])) {
+        return {
+            kind: "continuation",
+            worktree,
+        };
     }
+    const prepared = await mechanicalDeliveryPreparation(input, state, derivation, captured.data);
+    return prepared.kind === "prepared"
+        ? { kind: "mechanical", data: prepared.data, worktree: prepared.worktree }
+        : { kind: "refused", refusal: prepared.refusal };
+}
+/**
+ * Assemble the in-custody decision input from the fresh Contract. State-derived choices are recomputed
+ * here; artifacts the fresh state cannot justify are spent, which restarts the whole preparation.
+ */
+async function assembleDeliveryAttempt(input, observation, external) {
+    const state = contractState(observation.decision, input.contractId);
+    if (external.kind === "unavailable") {
+        return state === null
+            ? { kind: "assembled", state: null, preparation: { kind: "unavailable" } }
+            : { kind: "stale" };
+    }
+    if (state === null)
+        return { kind: "stale" };
+    if (external.witness.head !== state.head)
+        return { kind: "stale" };
+    const derivation = input.deriveDocument(state);
     if (derivation.verification.kind === "refused") {
         return {
-            observation,
+            kind: "assembled",
             state,
             derivation,
             preparation: { kind: "refused", document: derivation.document, refusal: derivation.verification.refusal },
         };
     }
     if (reusesCurrentCandidate(input, state, derivation))
-        return { observation, state, derivation };
-    if (input.materializeConflict === true && state.terminal === null)
-        return { observation, state, derivation };
-    const captured = await captureAuthorizedDeliveryTender(input.scope, { contractId: state.id, coordinates: state.coordinates }, input.includeDirty);
-    if (captured.kind === "refused") {
+        return { kind: "assembled", state, derivation };
+    const artifacts = external.artifacts;
+    if (artifacts.kind === "defer")
+        return await completeDeferredDelivery(input, state, derivation);
+    if (artifacts.kind === "refused") {
         return {
-            observation,
+            kind: "assembled",
             state,
             derivation,
-            preparation: { kind: "refused", document: derivation.document, refusal: captured.refusal },
+            preparation: { kind: "refused", document: derivation.document, refusal: artifacts.refusal },
         };
     }
-    const capturedWorktree = await worktreeInput(input.scope, state, captured.data);
-    if (state.terminal === null &&
-        state.delivery !== null &&
-        capturedWorktree.changeId === state.delivery.data.integration.changeId &&
-        !hasSupersedingVerification(state, observation.journals.get(state.id)?.entries ?? [])) {
+    if (!sameWorktreeWitness(artifacts.worktree, await recaptureDeliveryWorktree(input, state))) {
+        return { kind: "stale" };
+    }
+    if (artifacts.kind === "continuation") {
+        const delivery = state.delivery;
+        if (delivery === null)
+            return { kind: "stale" };
         return {
-            observation,
+            kind: "assembled",
             state,
             derivation,
-            preparation: { kind: "prepared", document: derivation.document, data: state.delivery.data },
-            worktree: capturedWorktree,
+            preparation: { kind: "prepared", document: derivation.document, data: delivery.data },
             continuation: true,
         };
     }
-    const prepared = await mechanicalDeliveryPreparation(input, state, derivation, captured.data);
-    return prepared.kind === "prepared"
-        ? { observation, state, derivation, preparation: prepared, worktree: prepared.worktree }
-        : { observation, state, derivation, preparation: prepared };
+    return {
+        kind: "assembled",
+        state,
+        derivation,
+        preparation: { kind: "prepared", document: derivation.document, data: artifacts.data },
+    };
+}
+/**
+ * Complete a preparation the outside phase could not settle. A requested conflict materialization
+ * must retire its owned handoff and then capture the worktree that follows, so it only runs under
+ * this custody; every other deferred state is decided by reuse above or refuses on its own.
+ */
+async function completeDeferredDelivery(input, state, derivation) {
+    if (input.materializeConflict !== true || state.terminal !== null)
+        return { kind: "assembled", state, derivation };
+    const materialization = await materializationMergeStateRefusal(input);
+    if (materialization !== undefined) {
+        return {
+            kind: "assembled",
+            state,
+            derivation,
+            preparation: { kind: "refused", document: derivation.document, refusal: materialization },
+        };
+    }
+    const prepared = await mechanicalDeliveryPreparation(input, state, derivation);
+    return {
+        kind: "assembled",
+        state,
+        derivation,
+        preparation: prepared.kind === "prepared"
+            ? { kind: "prepared", document: derivation.document, data: prepared.data }
+            : prepared,
+    };
 }
 function reusesCurrentCandidate(input, state, derivation) {
     return (input.overwrite !== true &&
@@ -189,60 +269,54 @@ function reusesCurrentCandidate(input, state, derivation) {
         derivation.verification.data !== null &&
         currentVerifiedAttestation(state) === undefined);
 }
-async function resolveDeliveryPreparation(input, speculated) {
-    if (speculated.preparation !== undefined)
-        return speculated.preparation;
-    if (speculated.state === null || speculated.derivation === undefined)
-        return { kind: "unavailable" };
-    const materialization = await materializationMergeStateRefusal(input);
-    if (materialization !== undefined) {
-        return { kind: "refused", document: speculated.derivation.document, refusal: materialization };
-    }
-    const prepared = await mechanicalDeliveryPreparation(input, speculated.state, speculated.derivation);
-    return prepared.kind === "prepared"
-        ? { kind: "prepared", document: prepared.document, data: prepared.data }
-        : prepared;
+/** Accept a delivery whose current candidate is already admitted, without admitting it again. */
+function currentCandidateDeliveryDecision(input, observation, assembled) {
+    const state = assembled.state;
+    if (state === null || assembled.derivation === undefined)
+        return undefined;
+    if (!reusesCurrentCandidate(input, state, assembled.derivation))
+        return undefined;
+    const record = observation.journals.get(input.contractId);
+    const delivery = record?.entries.findLast((entry) => entry.kind === "deliver");
+    if (record === undefined || delivery === undefined)
+        throw new Error("current delivery is missing its journal fact");
+    input.progress?.recordAdmission({ kind: "accepted", facts: [], state, journal: record.entries });
+    return {
+        kind: "accepted",
+        facts: [],
+        state,
+        journal: record.entries,
+        value: {
+            ...state.delivery.data,
+            leading: { kind: "already-admitted", fact: delivery.entry },
+        },
+    };
 }
-async function decideAndAdmitDelivery(input, attempt, seat, observation, speculated) {
-    const currentState = speculated.state;
-    if (currentState !== null &&
-        speculated.derivation !== undefined &&
-        reusesCurrentCandidate(input, currentState, speculated.derivation)) {
-        const record = observation.journals.get(input.contractId);
-        const delivery = record?.entries.findLast((entry) => entry.kind === "deliver");
-        if (record === undefined || delivery === undefined)
-            throw new Error("current delivery is missing its journal fact");
-        input.progress?.recordAdmission({ kind: "accepted", facts: [], state: currentState, journal: record.entries });
-        return {
-            kind: "accepted",
-            facts: [],
-            state: currentState,
-            journal: record.entries,
-            value: {
-                ...currentState.delivery.data,
-                leading: { kind: "already-admitted", fact: delivery.entry },
-            },
-        };
-    }
-    if (speculated.continuation === true) {
-        const record = observation.journals.get(input.contractId);
-        if (record === undefined ||
-            record.state === null ||
-            record.state.delivery === null ||
-            speculated.derivation === undefined) {
-            return { kind: "redecide" };
-        }
-        const state = record.state;
-        input.progress?.recordAdmission({ kind: "accepted", facts: [], state, journal: record.entries });
-        return {
-            kind: "accepted",
-            facts: [],
-            state,
-            journal: record.entries,
-            value: record.state.delivery.data,
-        };
+/** Continue the admitted integration this worktree already carries, without a new offer. */
+function continuationDeliveryDecision(input, observation, assembled) {
+    const record = observation.journals.get(input.contractId);
+    const state = record?.state ?? null;
+    if (record === undefined || state === null || state.delivery === null || assembled.derivation === undefined) {
+        return { kind: "redecide" };
     }
-    const preparation = await resolveDeliveryPreparation(input, speculated);
+    input.progress?.recordAdmission({ kind: "accepted", facts: [], state, journal: record.entries });
+    return {
+        kind: "accepted",
+        facts: [],
+        state,
+        journal: record.entries,
+        value: state.delivery.data,
+    };
+}
+async function decideAndAdmitDelivery(input, attempt, seat, observation, assembled) {
+    const current = currentCandidateDeliveryDecision(input, observation, assembled);
+    if (current !== undefined)
+        return current;
+    if (assembled.continuation === true)
+        return continuationDeliveryDecision(input, observation, assembled);
+    const preparation = assembled.preparation ?? STALE_PRIVATE_STATE_PREPARATION;
+    if (preparation.kind === "stale")
+        return preparation;
     const decision = decideDeliver({
         input: {
             contractId: input.contractId,
@@ -274,22 +348,19 @@ async function decideAndAdmitDelivery(input, attempt, seat, observation, specula
         value: preparation.data,
     };
 }
-async function deliverAttemptInPrivateStateSeat(input, attempt, seat, speculated) {
-    const observation = await matchingPrivateRootObservation(input.scope, input.channel, input.contractId, speculated.observation, async (fresh) => {
-        if (speculated.worktree === undefined)
-            return true;
-        const state = contractState(fresh.decision, input.contractId);
-        if (state === null)
-            return false;
-        return sameSpeculativeWorktreeInput(speculated.worktree, await recaptureDeliveryWorktree(input, state));
-    });
-    return "kind" in observation
-        ? observation
-        : await decideAndAdmitDelivery(input, attempt, seat, observation, speculated);
-}
+/**
+ * One delivery attempt: the repeatable physical preparation happens outside custody, then a single
+ * in-custody observation, witness validation, assembly, decision, and atomic publication.
+ */
 async function deliverAttempt(input, attempt) {
-    const speculated = await speculateDelivery(input);
-    return await privateStateSeatAttempt(input.scope, async (seat) => await deliverAttemptInPrivateStateSeat(input, attempt, seat, speculated), attemptDecisionWithSeatClose);
+    const external = await prepareExternalDelivery(input);
+    return await privateStateSeatAttempt(input.scope, async (seat) => {
+        const observation = await observeContractsForAdmissionAt(input.scope, input.channel, [input.contractId]);
+        const assembled = await assembleDeliveryAttempt(input, observation, external);
+        if (assembled.kind === "stale")
+            return STALE_PRIVATE_STATE_PREPARATION;
+        return await decideAndAdmitDelivery(input, attempt, seat, observation, assembled);
+    }, attemptDecisionWithSeatClose);
 }
 function isIntegrationConflict(refusal) {
     return refusal.kind === "integration-failed" && refusal.reason === "conflict";
@@ -417,6 +488,8 @@ export async function admitDeliveryOperation(input) {
             return await finishDeliverRefusal(input, result.refusal);
         if (result.kind === "publication-failed")
             return { kind: "retry", reason: result };
+        if (result.kind === "stale" || result.kind === "redecide")
+            continue;
         if (result.kind === "collision" && index + 1 === attempts.length)
             return { kind: "retry", reason: result };
     }

package/build/src/protocol/execution-observation.d.ts

@@ -0,0 +1,181 @@
+import { z } from "zod";
+declare const observationSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    kind: z.ZodLiteral<"admitted">;
+    contractId: z.ZodPipe<z.ZodString, z.ZodTransform<import("../core/facts/types.js").ContractId, string>>;
+    fact: z.ZodPipe<z.ZodUnknown, z.ZodTransform<Readonly<{
+        v: 1;
+        kind: "bind";
+        contract: import("../core/facts/types.js").ContractId;
+        entry: import("../core/facts/types.js").EntryUlid;
+        at: string;
+        actor?: import("../core/facts/types.js").ActorId;
+        data: Readonly<{
+            coordinates: import("../core/facts/types.js").ContractCoordinates;
+            terms: import("../core/facts/types.js").ContractTerms;
+        }>;
+    }> | Readonly<{
+        v: 1;
+        kind: "amend";
+        contract: import("../core/facts/types.js").ContractId;
+        entry: import("../core/facts/types.js").EntryUlid;
+        at: string;
+        actor?: import("../core/facts/types.js").ActorId;
+        data: Readonly<{
+            document: Readonly<{
+                bytes: string;
+                key: import("../core/facts/types.js").DocumentKey;
+            }>;
+            segments: readonly import("../core/facts/types.js").DocumentSegmentKey[];
+            gates: readonly import("../core/facts/types.js").Gate[];
+            after: readonly import("../core/facts/types.js").ContractId[];
+        }>;
+    }> | Readonly<{
+        v: 1;
+        kind: "bound";
+        contract: import("../core/facts/types.js").ContractId;
+        entry: import("../core/facts/types.js").EntryUlid;
+        at: string;
+        actor?: import("../core/facts/types.js").ActorId;
+        data: Readonly<Record<string, never>>;
+    }> | Readonly<{
+        v: 1;
+        kind: "deliver";
+        contract: import("../core/facts/types.js").ContractId;
+        entry: import("../core/facts/types.js").EntryUlid;
+        at: string;
+        actor?: import("../core/facts/types.js").ActorId;
+        data: Readonly<{
+            tenderSnapshot: import("../core/facts/types.js").SnapshotId;
+            integration: Readonly<{
+                predecessor: import("../core/facts/types.js").SnapshotId;
+                snapshot: import("../core/facts/types.js").SnapshotId;
+                changeId: import("../core/facts/types.js").ChangeId;
+            }>;
+            method: "squash";
+            policy: Readonly<{
+                requireBranchesToBeUpToDate: boolean;
+            }>;
+        }>;
+    }> | Readonly<{
+        v: 1;
+        kind: "reintegrated";
+        contract: import("../core/facts/types.js").ContractId;
+        entry: import("../core/facts/types.js").EntryUlid;
+        at: string;
+        actor?: import("../core/facts/types.js").ActorId;
+        data: Readonly<{
+            predecessor: import("../core/facts/types.js").SnapshotId;
+            snapshot: import("../core/facts/types.js").SnapshotId;
+        }>;
+    }> | Readonly<{
+        v: 1;
+        kind: "attestation";
+        contract: import("../core/facts/types.js").ContractId;
+        entry: import("../core/facts/types.js").EntryUlid;
+        at: string;
+        actor?: import("../core/facts/types.js").ActorId;
+        data: Readonly<{
+            gate: import("../core/facts/types.js").Gate;
+            subject: import("../core/facts/types.js").DependencyKeySet;
+            verdict: "satisfied" | "unsatisfied";
+            summary?: string;
+        }>;
+    }> | Readonly<{
+        v: 1;
+        kind: "claimed";
+        contract: import("../core/facts/types.js").ContractId;
+        entry: import("../core/facts/types.js").EntryUlid;
+        at: string;
+        actor?: import("../core/facts/types.js").ActorId;
+        data: Readonly<{
+            delivery: import("../core/facts/types.js").EntryUlid;
+        }>;
+    }> | Readonly<{
+        v: 1;
+        kind: "arc";
+        contract: import("../core/facts/types.js").ContractId;
+        entry: import("../core/facts/types.js").EntryUlid;
+        at: string;
+        actor?: import("../core/facts/types.js").ActorId;
+        data: Readonly<{
+            seq: number;
+            title: string;
+            objective: string;
+            brief: string;
+        }>;
+    }> | Readonly<{
+        v: 1;
+        kind: "abandoned";
+        contract: import("../core/facts/types.js").ContractId;
+        entry: import("../core/facts/types.js").EntryUlid;
+        at: string;
+        actor?: import("../core/facts/types.js").ActorId;
+        data: Readonly<{
+            note?: string;
+        }>;
+    }>, unknown>>;
+}, z.core.$strict>, z.ZodObject<{
+    kind: z.ZodLiteral<"verification">;
+    contractId: z.ZodPipe<z.ZodString, z.ZodTransform<import("../core/facts/types.js").ContractId, string>>;
+    snapshot: z.ZodPipe<z.ZodString, z.ZodTransform<import("../core/facts/types.js").SnapshotId, string>>;
+    observation: z.ZodDiscriminatedUnion<[z.ZodObject<{
+        state: z.ZodEnum<{
+            finished: "finished";
+            started: "started";
+        }>;
+        outcome: z.ZodOptional<z.ZodString>;
+        elapsedMs: z.ZodOptional<z.ZodNumber>;
+        phase: z.ZodEnum<{
+            cleanup: "cleanup";
+            materialize: "materialize";
+            setup: "setup";
+            declaration: "declaration";
+        }>;
+        cwd: z.ZodOptional<z.ZodString>;
+        name: z.ZodOptional<z.ZodString>;
+        command: z.ZodOptional<z.ZodString>;
+        index: z.ZodOptional<z.ZodNumber>;
+        total: z.ZodOptional<z.ZodNumber>;
+        kind: z.ZodLiteral<"phase">;
+    }, z.core.$strict>, z.ZodObject<{
+        stream: z.ZodEnum<{
+            stdout: "stdout";
+            stderr: "stderr";
+        }>;
+        text: z.ZodString;
+        phase: z.ZodEnum<{
+            cleanup: "cleanup";
+            materialize: "materialize";
+            setup: "setup";
+            declaration: "declaration";
+        }>;
+        cwd: z.ZodOptional<z.ZodString>;
+        name: z.ZodOptional<z.ZodString>;
+        command: z.ZodOptional<z.ZodString>;
+        index: z.ZodOptional<z.ZodNumber>;
+        total: z.ZodOptional<z.ZodNumber>;
+        kind: z.ZodLiteral<"output">;
+    }, z.core.$strict>], "kind">;
+}, z.core.$strict>, z.ZodObject<{
+    kind: z.ZodLiteral<"stage">;
+    contractId: z.ZodPipe<z.ZodString, z.ZodTransform<import("../core/facts/types.js").ContractId, string>>;
+    stage: z.ZodEnum<{
+        placement: "placement";
+        continuation: "continuation";
+        reconciliation: "reconciliation";
+    }>;
+    state: z.ZodEnum<{
+        finished: "finished";
+        started: "started";
+    }>;
+}, z.core.$strict>, z.ZodObject<{
+    kind: z.ZodLiteral<"progress-dropped">;
+    count: z.ZodNumber;
+}, z.core.$strict>], "kind">;
+export type ExecutionEvent = z.infer<typeof observationSchema>;
+export type ExecutionObserver = (event: ExecutionEvent) => void;
+/** One owner decoder for local and transported ephemeral observations. */
+export declare function decodeExecutionEvent(value: unknown): ExecutionEvent;
+/** Observation failure cannot change execution, admission, or process custody. */
+export declare function observeExecution(observer: ExecutionObserver | undefined, event: ExecutionEvent): void;
+export {};

package/build/src/protocol/execution-observation.js

@@ -0,0 +1,45 @@
+import { z } from "zod";
+import { decodeJournalEntry } from "../core/facts/codec.js";
+import { contractId, snapshotId } from "../core/facts/types.js";
+import { verificationObservationSchema } from "../verification/observation.js";
+const contract = z.string().transform((value) => contractId(value));
+const snapshot = z.string().transform((value) => snapshotId(value));
+const observationSchema = z.discriminatedUnion("kind", [
+    z
+        .object({
+        kind: z.literal("admitted"),
+        contractId: contract,
+        fact: z.unknown().transform(decodeJournalEntry),
+    })
+        .strict(),
+    z
+        .object({
+        kind: z.literal("verification"),
+        contractId: contract,
+        snapshot,
+        observation: verificationObservationSchema,
+    })
+        .strict(),
+    z
+        .object({
+        kind: z.literal("stage"),
+        contractId: contract,
+        stage: z.enum(["placement", "continuation", "reconciliation"]),
+        state: z.enum(["started", "finished"]),
+    })
+        .strict(),
+    z.object({ kind: z.literal("progress-dropped"), count: z.number().int().positive() }).strict(),
+]);
+/** One owner decoder for local and transported ephemeral observations. */
+export function decodeExecutionEvent(value) {
+    return observationSchema.parse(value);
+}
+/** Observation failure cannot change execution, admission, or process custody. */
+export function observeExecution(observer, event) {
+    try {
+        observer?.(event);
+    }
+    catch {
+        // A consumer controls observation only, not the operation being observed.
+    }
+}

package/build/src/protocol/intent.d.ts

@@ -2,43 +2,39 @@ import type { ExecutionProgress } from "./progress.js";
 import type { GitDecisionObservation } from "../git/observe.js";
 import type { GitDecodeChannel, GitTreeSelection } from "../git/read-observation.js";
 import type { GitRepository } from "../git/process.js";
-import type { GitRefAssertion } from "../git/repository.js";
 import { type WorktreeLeak } from "../git/scratch.js";
 import type { HookFailure } from "../git/hooks.js";
 import type { DecideInput, OfferDecision } from "../core/decide.js";
 import type { ActorId, ContractId, ContractState, EntryUlid, SnapshotId } from "../core/facts/types.js";
 import { type AttestationRefusal } from "../core/verbs/attestation.js";
+import { type CapturedOutput } from "../verification/execution.js";
 import { type VerificationDefinition } from "../verification/declaration.js";
-import { type CompanionDecorator, type ProtocolResult } from "./run.js";
-type IntentAdmissionOptions<Input, Refusal, Seed> = Readonly<{
+import { type CompanionDecorator, type ProtocolPreparation, type ProtocolResult } from "./run.js";
+type CommonIntentAdmissionOptions<Refusal> = Readonly<{
     progress?: ExecutionProgress;
     observedContracts?: readonly ContractId[];
     observe?: (repository: GitRepository, channel: GitDecodeChannel, contracts: readonly ContractId[]) => Promise<GitDecisionObservation>;
     decorateOffer?: CompanionDecorator;
     validateAdmission?: (observation: GitDecisionObservation) => Refusal | undefined | Promise<Refusal | undefined>;
     observationSelection?: GitTreeSelection;
-    prepareInput?: (observation: GitDecisionObservation, input: Seed) => Readonly<{
-        kind: "prepared";
-        input: Input;
-        assertions?: readonly GitRefAssertion[];
-    }> | Readonly<{
-        kind: "refused";
-        refusal: Refusal;
-    }> | Promise<Readonly<{
-        kind: "prepared";
-        input: Input;
-        assertions?: readonly GitRefAssertion[];
-    }> | Readonly<{
-        kind: "refused";
-        refusal: Refusal;
-    }>>;
 }>;
-/** Observe, decide, and atomically admit one intent with bounded Git retries. */
+type IntentAdmissionOptions<Refusal = never> = CommonIntentAdmissionOptions<Refusal>;
+type PreparedIntentAdmissionOptions<Input, Refusal, Seed, Prepared> = CommonIntentAdmissionOptions<Refusal> & Readonly<{
+    preparation: ProtocolPreparation<Input, Refusal, Seed, Prepared>;
+}>;
+/** Observe, decide, and atomically admit one intent whose invocation already is its decision input. */
 export declare function admitIntent<Input extends Readonly<{
     contractId: ContractId;
+}>, Refusal>(channel: GitDecodeChannel, repository: GitRepository, input: Input, decide: (input: DecideInput<Input>) => OfferDecision<Refusal>, options?: IntentAdmissionOptions<Refusal>): Promise<ProtocolResult<Refusal>>;
+/**
+ * Observe, decide, and atomically admit one intent whose repeatable preparation happens outside
+ * the publication seat and whose decision input is assembled from the fresh in-custody observation.
+ */
+export declare function admitPreparedIntent<Input extends Readonly<{
+    contractId: ContractId;
 }>, Refusal, Seed extends Readonly<{
     contractId: ContractId;
-}> = Input>(channel: GitDecodeChannel, repository: GitRepository, input: Seed, decide: (input: DecideInput<Input>) => OfferDecision<Refusal>, options?: IntentAdmissionOptions<Input, Refusal, Seed>): Promise<ProtocolResult<Refusal>>;
+}>, Prepared>(channel: GitDecodeChannel, repository: GitRepository, input: Seed, decide: (input: DecideInput<Input>) => OfferDecision<Refusal>, options: PreparedIntentAdmissionOptions<Input, Refusal, Seed, Prepared>): Promise<ProtocolResult<Refusal>>;
 type VerifyDeliveryInput = Readonly<{
     channel: GitDecodeChannel;
     repository: GitRepository;
@@ -51,7 +47,7 @@ type VerifyDeliveryInput = Readonly<{
     verification?: VerificationDefinition;
     progress?: ExecutionProgress;
 }>;
-export type VerificationRuntimeStop = Readonly<{
+export type VerificationRuntimeStop = CapturedOutput & (Readonly<{
     failure: "unknown-exit" | "cancelled";
 }> | Readonly<{
     failure: "candidate-unavailable" | "spawn-error";
@@ -63,7 +59,7 @@ export type VerificationRuntimeStop = Readonly<{
     failure: "environment-failure";
     name: string;
     detail: HookFailure;
-}>;
+}>);
 export type VerificationCleanupFailure = Readonly<{
     phase: "destroy";
     name: string;