@astrosheep/keiyaku 4.5.29 → 4.6.2

package/build/src/protocol/deliver.js

@@ -1,15 +1,31 @@
+import { entryUlidSchema } from "./attempt.js";
+import { z } from "zod";
+import { snapshotIdSchema } from "./operations.js";
+import { conflictRecoverySchema, worktreeWorkspaceSchema } from "../git/workspace.js";
 import { materializeIntegrationSnapshot, materializeJudgedConflict, planIntegration, worktreeChangeId, } from "../git/integration.js";
 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 { contractStateWitness, privateStateSeatAttempt, sameWorktreeWitness, STALE_PRIVATE_STATE_PREPARATION, } from "./run.js";
+import { contractStateWitness, privateStateSeatAttempt, runBoundedAttempts, 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";
 import { admitDecidedOffer, mintAttempts } from "./attempt.js";
 import { appointmentFor, readPlaceRegister } from "../workspace-place.js";
 import { attemptDecisionWithSeatClose, timestamp } from "./operations.js";
-export { decodeMaterializedConflict } from "./result-codec.js";
+export const deliverLeadingSchema = z
+    .object({ kind: z.enum(["admitted-now", "already-admitted"]), fact: entryUlidSchema })
+    .strict();
+export const materializedConflictSchema = z
+    .object({
+    kind: z.literal("integration-conflict-materialized"),
+    targetHead: snapshotIdSchema,
+    conflictPaths: z.array(z.string().refine((value) => value.trim() !== "")).readonly(),
+    workspace: worktreeWorkspaceSchema,
+    handoffBase: snapshotIdSchema,
+    recovery: conflictRecoverySchema,
+})
+    .strict();
 const DELIVER_CONFLICT_RECOVERY = conflictRecovery;
 async function captureAuthorizedDeliveryTender(repository, stage, includeDirty) {
     const { contractId, coordinates } = stage;
@@ -299,13 +315,19 @@ function continuationDeliveryDecision(input, observation, assembled) {
     if (record === undefined || state === null || state.delivery === null || assembled.derivation === undefined) {
         return { kind: "redecide" };
     }
+    const delivery = record.entries.findLast((entry) => entry.kind === "deliver");
+    if (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,
+        value: {
+            ...state.delivery.data,
+            leading: { kind: "already-admitted", fact: delivery.entry },
+        },
     };
 }
 async function decideAndAdmitDelivery(input, attempt, seat, observation, assembled) {
@@ -343,9 +365,15 @@ async function decideAndAdmitDelivery(input, attempt, seat, observation, assembl
     });
     if (admission.kind !== "accepted")
         return admission;
+    const deliverFact = admission.facts.find((fact) => fact.contract === input.contractId && fact.kind === "deliver");
+    if (deliverFact?.kind !== "deliver")
+        throw new Error("confirmed delivery requires its own receipt");
     return {
         ...admission,
-        value: preparation.data,
+        value: {
+            ...preparation.data,
+            leading: { kind: "admitted-now", fact: deliverFact.entry },
+        },
     };
 }
 /**
@@ -476,25 +504,11 @@ async function finishDeliverRefusal(input, refusal) {
     return await materializeDeliverConflict(input, refusal);
 }
 export async function admitDeliveryOperation(input) {
-    const attempts = mintAttempts({ entryCount: 2 });
-    let first = null;
-    for (let index = 0; index < attempts.length; index += 1) {
-        const result = await deliverAttempt(input, attempts[index]);
-        if (result.kind === "accepted") {
-            first = result;
-            break;
-        }
-        if (result.kind === "refused")
-            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 };
-    }
-    if (first === null)
-        return { kind: "retry", reason: { kind: "exhausted" } };
-    input.progress?.recordResidue(input.contractId, first);
-    return first;
+    const result = await runBoundedAttempts(mintAttempts({ entryCount: 2 }), (attempt) => deliverAttempt(input, attempt));
+    if (result.kind === "refused")
+        return await finishDeliverRefusal(input, result.refusal);
+    if (result.kind !== "accepted")
+        return { kind: "retry", reason: result };
+    input.progress?.recordResidue(input.contractId, result);
+    return result;
 }

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

@@ -1,14 +1,14 @@
 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>>;
+    contractId: z.ZodPipe<z.ZodString, z.ZodTransform<import("../index.js").ContractId, string>>;
     fact: z.ZodPipe<z.ZodUnknown, z.ZodTransform<Readonly<{
         v: 1;
         kind: "bind";
-        contract: import("../core/facts/types.js").ContractId;
+        contract: import("../index.js").ContractId;
         entry: import("../core/facts/types.js").EntryUlid;
         at: string;
-        actor?: import("../core/facts/types.js").ActorId;
+        actor?: import("../index.js").ActorId;
         data: Readonly<{
             coordinates: import("../core/facts/types.js").ContractCoordinates;
             terms: import("../core/facts/types.js").ContractTerms;
@@ -16,10 +16,10 @@ declare const observationSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
     }> | Readonly<{
         v: 1;
         kind: "amend";
-        contract: import("../core/facts/types.js").ContractId;
+        contract: import("../index.js").ContractId;
         entry: import("../core/facts/types.js").EntryUlid;
         at: string;
-        actor?: import("../core/facts/types.js").ActorId;
+        actor?: import("../index.js").ActorId;
         data: Readonly<{
             document: Readonly<{
                 bytes: string;
@@ -27,29 +27,29 @@ declare const observationSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
             }>;
             segments: readonly import("../core/facts/types.js").DocumentSegmentKey[];
             gates: readonly import("../core/facts/types.js").Gate[];
-            after: readonly import("../core/facts/types.js").ContractId[];
+            after: readonly import("../index.js").ContractId[];
         }>;
     }> | Readonly<{
         v: 1;
         kind: "bound";
-        contract: import("../core/facts/types.js").ContractId;
+        contract: import("../index.js").ContractId;
         entry: import("../core/facts/types.js").EntryUlid;
         at: string;
-        actor?: import("../core/facts/types.js").ActorId;
+        actor?: import("../index.js").ActorId;
         data: Readonly<Record<string, never>>;
     }> | Readonly<{
         v: 1;
         kind: "deliver";
-        contract: import("../core/facts/types.js").ContractId;
+        contract: import("../index.js").ContractId;
         entry: import("../core/facts/types.js").EntryUlid;
         at: string;
-        actor?: import("../core/facts/types.js").ActorId;
+        actor?: import("../index.js").ActorId;
         data: Readonly<{
-            tenderSnapshot: import("../core/facts/types.js").SnapshotId;
+            tenderSnapshot: import("../index.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;
+                predecessor: import("../index.js").SnapshotId;
+                snapshot: import("../index.js").SnapshotId;
+                changeId: import("../index.js").ChangeId;
             }>;
             method: "squash";
             policy: Readonly<{
@@ -59,21 +59,21 @@ declare const observationSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
     }> | Readonly<{
         v: 1;
         kind: "reintegrated";
-        contract: import("../core/facts/types.js").ContractId;
+        contract: import("../index.js").ContractId;
         entry: import("../core/facts/types.js").EntryUlid;
         at: string;
-        actor?: import("../core/facts/types.js").ActorId;
+        actor?: import("../index.js").ActorId;
         data: Readonly<{
-            predecessor: import("../core/facts/types.js").SnapshotId;
-            snapshot: import("../core/facts/types.js").SnapshotId;
+            predecessor: import("../index.js").SnapshotId;
+            snapshot: import("../index.js").SnapshotId;
         }>;
     }> | Readonly<{
         v: 1;
         kind: "attestation";
-        contract: import("../core/facts/types.js").ContractId;
+        contract: import("../index.js").ContractId;
         entry: import("../core/facts/types.js").EntryUlid;
         at: string;
-        actor?: import("../core/facts/types.js").ActorId;
+        actor?: import("../index.js").ActorId;
         data: Readonly<{
             gate: import("../core/facts/types.js").Gate;
             subject: import("../core/facts/types.js").DependencyKeySet;
@@ -83,45 +83,44 @@ declare const observationSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
     }> | Readonly<{
         v: 1;
         kind: "claimed";
-        contract: import("../core/facts/types.js").ContractId;
+        contract: import("../index.js").ContractId;
         entry: import("../core/facts/types.js").EntryUlid;
         at: string;
-        actor?: import("../core/facts/types.js").ActorId;
+        actor?: import("../index.js").ActorId;
         data: Readonly<{
             delivery: import("../core/facts/types.js").EntryUlid;
         }>;
     }> | Readonly<{
         v: 1;
         kind: "arc";
-        contract: import("../core/facts/types.js").ContractId;
+        contract: import("../index.js").ContractId;
         entry: import("../core/facts/types.js").EntryUlid;
         at: string;
-        actor?: import("../core/facts/types.js").ActorId;
+        actor?: import("../index.js").ActorId;
         data: Readonly<{
             seq: number;
             title: string;
-            objective: string;
-            brief: string;
+            body: string;
         }>;
     }> | Readonly<{
         v: 1;
         kind: "abandoned";
-        contract: import("../core/facts/types.js").ContractId;
+        contract: import("../index.js").ContractId;
         entry: import("../core/facts/types.js").EntryUlid;
         at: string;
-        actor?: import("../core/facts/types.js").ActorId;
+        actor?: import("../index.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>>;
+    contractId: z.ZodPipe<z.ZodString, z.ZodTransform<import("../index.js").ContractId, string>>;
+    snapshot: z.ZodPipe<z.ZodString, z.ZodTransform<import("../index.js").SnapshotId, string>>;
     observation: z.ZodDiscriminatedUnion<[z.ZodObject<{
         state: z.ZodEnum<{
-            finished: "finished";
             started: "started";
+            finished: "finished";
         }>;
         outcome: z.ZodOptional<z.ZodString>;
         elapsedMs: z.ZodOptional<z.ZodNumber>;
@@ -158,24 +157,24 @@ declare const observationSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
     }, 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>>;
+    contractId: z.ZodPipe<z.ZodString, z.ZodTransform<import("../index.js").ContractId, string>>;
     stage: z.ZodEnum<{
         placement: "placement";
         continuation: "continuation";
         reconciliation: "reconciliation";
     }>;
     state: z.ZodEnum<{
-        finished: "finished";
         started: "started";
+        finished: "finished";
     }>;
 }, 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;
+export type ExecutionObservation = z.infer<typeof observationSchema>;
+export type ExecutionObserver = (event: ExecutionObservation) => void | PromiseLike<void>;
 /** One owner decoder for local and transported ephemeral observations. */
-export declare function decodeExecutionEvent(value: unknown): ExecutionEvent;
+export declare function decodeExecutionObservation(value: unknown): ExecutionObservation;
 /** Observation failure cannot change execution, admission, or process custody. */
-export declare function observeExecution(observer: ExecutionObserver | undefined, event: ExecutionEvent): void;
+export declare function observeExecution(observer: ExecutionObserver | undefined, event: ExecutionObservation): void;
 export {};

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

@@ -1,29 +1,27 @@
 import { z } from "zod";
 import { decodeJournalEntry } from "../core/facts/codec.js";
-import { contractId, snapshotId } from "../core/facts/types.js";
+import { contractIdSchema, snapshotIdSchema } from "../git/identity.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,
+        contractId: contractIdSchema,
         fact: z.unknown().transform(decodeJournalEntry),
     })
         .strict(),
     z
         .object({
         kind: z.literal("verification"),
-        contractId: contract,
-        snapshot,
+        contractId: contractIdSchema,
+        snapshot: snapshotIdSchema,
         observation: verificationObservationSchema,
     })
         .strict(),
     z
         .object({
         kind: z.literal("stage"),
-        contractId: contract,
+        contractId: contractIdSchema,
         stage: z.enum(["placement", "continuation", "reconciliation"]),
         state: z.enum(["started", "finished"]),
     })
@@ -31,13 +29,13 @@ const observationSchema = z.discriminatedUnion("kind", [
     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) {
+export function decodeExecutionObservation(value) {
     return observationSchema.parse(value);
 }
 /** Observation failure cannot change execution, admission, or process custody. */
 export function observeExecution(observer, event) {
     try {
-        observer?.(event);
+        void Promise.resolve(observer?.(event)).catch(() => undefined);
     }
     catch {
         // A consumer controls observation only, not the operation being observed.

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

@@ -1,17 +1,16 @@
-import type { ExecutionProgress } from "./progress.js";
+import { z } from "zod";
+import type { ProtocolProgress } 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 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 ActiveContractRefusal } from "../core/facts/observation.js";
+import type { ActorId, AttestationEntry, ContractId, ContractState, DependencyKeySet, SnapshotId } from "../core/facts/types.js";
 import { type VerificationDefinition } from "../verification/declaration.js";
 import { type CompanionDecorator, type ProtocolPreparation, type ProtocolResult } from "./run.js";
 type CommonIntentAdmissionOptions<Refusal> = Readonly<{
-    progress?: ExecutionProgress;
+    progress?: ProtocolProgress;
     observedContracts?: readonly ContractId[];
     observe?: (repository: GitRepository, channel: GitDecodeChannel, contracts: readonly ContractId[]) => Promise<GitDecisionObservation>;
     decorateOffer?: CompanionDecorator;
@@ -45,29 +44,96 @@ type VerifyDeliveryInput = Readonly<{
     snapshot?: SnapshotId;
     signal?: AbortSignal;
     verification?: VerificationDefinition;
-    progress?: ExecutionProgress;
+    progress?: ProtocolProgress;
 }>;
-export type VerificationRuntimeStop = CapturedOutput & (Readonly<{
-    failure: "unknown-exit" | "cancelled";
-}> | Readonly<{
-    failure: "candidate-unavailable" | "spawn-error";
-    diagnostic: string;
-}> | Readonly<{
-    failure: "environment-failure";
-    diagnostic: string;
-}> | Readonly<{
-    failure: "environment-failure";
-    name: string;
-    detail: HookFailure;
-}>);
-export type VerificationCleanupFailure = Readonly<{
-    phase: "destroy";
-    name: string;
-    detail: HookFailure;
+export declare const verificationRuntimeStopSchema: z.ZodUnion<readonly [z.ZodObject<{
+    stdout: z.ZodOptional<z.ZodString>;
+    stderr: z.ZodOptional<z.ZodString>;
+    truncated: z.ZodOptional<z.ZodLiteral<true>>;
+    failure: z.ZodEnum<{
+        cancelled: "cancelled";
+        "unknown-exit": "unknown-exit";
+    }>;
+}, z.core.$strict>, z.ZodObject<{
+    stdout: z.ZodOptional<z.ZodString>;
+    stderr: z.ZodOptional<z.ZodString>;
+    truncated: z.ZodOptional<z.ZodLiteral<true>>;
+    failure: z.ZodEnum<{
+        "spawn-error": "spawn-error";
+        "candidate-unavailable": "candidate-unavailable";
+    }>;
+    diagnostic: z.ZodString;
+}, z.core.$strict>, z.ZodObject<{
+    stdout: z.ZodOptional<z.ZodString>;
+    stderr: z.ZodOptional<z.ZodString>;
+    truncated: z.ZodOptional<z.ZodLiteral<true>>;
+    failure: z.ZodLiteral<"environment-failure">;
+    diagnostic: z.ZodString;
+}, z.core.$strict>, z.ZodObject<{
+    stdout: z.ZodOptional<z.ZodString>;
+    stderr: z.ZodOptional<z.ZodString>;
+    truncated: z.ZodOptional<z.ZodLiteral<true>>;
+    failure: z.ZodLiteral<"environment-failure">;
+    name: z.ZodString;
+    detail: z.ZodUnion<readonly [z.ZodObject<{
+        kind: z.ZodLiteral<"exit">;
+        code: z.ZodNumber;
+        stdout: z.ZodString;
+        stderr: z.ZodString;
+        truncated: z.ZodBoolean;
+    }, z.core.$strict>, z.ZodObject<{
+        stdout: z.ZodOptional<z.ZodString>;
+        stderr: z.ZodOptional<z.ZodString>;
+        truncated: z.ZodOptional<z.ZodBoolean>;
+        kind: z.ZodLiteral<"timeout">;
+    }, z.core.$strict>, z.ZodObject<{
+        stdout: z.ZodOptional<z.ZodString>;
+        stderr: z.ZodOptional<z.ZodString>;
+        truncated: z.ZodOptional<z.ZodBoolean>;
+        kind: z.ZodLiteral<"unknown-exit">;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"spawn-error">;
+        diagnostic: z.ZodString;
+    }, z.core.$strict>]>;
+}, z.core.$strict>]>;
+type VerificationRuntimeStop = z.infer<typeof verificationRuntimeStopSchema>;
+export declare const verificationCleanupFailureSchema: z.ZodObject<{
+    phase: z.ZodLiteral<"destroy">;
+    name: z.ZodString;
+    detail: z.ZodUnion<readonly [z.ZodObject<{
+        kind: z.ZodLiteral<"exit">;
+        code: z.ZodNumber;
+        stdout: z.ZodString;
+        stderr: z.ZodString;
+        truncated: z.ZodBoolean;
+    }, z.core.$strict>, z.ZodObject<{
+        stdout: z.ZodOptional<z.ZodString>;
+        stderr: z.ZodOptional<z.ZodString>;
+        truncated: z.ZodOptional<z.ZodBoolean>;
+        kind: z.ZodLiteral<"timeout">;
+    }, z.core.$strict>, z.ZodObject<{
+        stdout: z.ZodOptional<z.ZodString>;
+        stderr: z.ZodOptional<z.ZodString>;
+        truncated: z.ZodOptional<z.ZodBoolean>;
+        kind: z.ZodLiteral<"unknown-exit">;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"spawn-error">;
+        diagnostic: z.ZodString;
+    }, z.core.$strict>]>;
+}, z.core.$strict>;
+export type VerificationCleanupFailure = z.infer<typeof verificationCleanupFailureSchema>;
+type VerificationReuseRefusal = Readonly<{
+    kind: "verification-reuse";
+    reuse: CurrentVerifiedAttestation;
+}>;
+export type VerificationReuseStep = Readonly<{
+    kind: "reused";
+    reuse: CurrentVerifiedAttestation;
 }>;
-export type VerificationStep = ProtocolResult<AttestationRefusal> | VerificationRuntimeStop;
+export type VerificationStep = ProtocolResult<ActiveContractRefusal | VerificationReuseRefusal> | VerificationRuntimeStop | VerificationReuseStep;
 export type VerificationResult = Readonly<{
     step: VerificationStep;
+    reuse?: CurrentVerifiedAttestation;
     counts?: Readonly<{
         passed: number;
         total: number;
@@ -77,11 +143,16 @@ export type VerificationResult = Readonly<{
     cleanup?: VerificationCleanupFailure;
     leak?: WorktreeLeak;
 }>;
-export type CurrentVerifiedAttestation = Readonly<{
-    entry: EntryUlid;
-    verdict: "satisfied" | "unsatisfied";
-    summary?: string;
-}>;
+export declare const verificationReuseSchema: z.ZodObject<{
+    entry: z.ZodPipe<z.ZodString, z.ZodTransform<import("../core/facts/types.js").EntryUlid, string>>;
+    verdict: z.ZodEnum<{
+        satisfied: "satisfied";
+        unsatisfied: "unsatisfied";
+    }>;
+    summary: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+export type CurrentVerifiedAttestation = z.infer<typeof verificationReuseSchema>;
+export declare function reusableVerificationAttestation(current: AttestationEntry | undefined, subject: DependencyKeySet, verdict: "satisfied" | "unsatisfied"): CurrentVerifiedAttestation | undefined;
 /** Read the latest current verified attestation through the generic currentness judge. */
 export declare function currentVerifiedAttestation(state: ContractState): CurrentVerifiedAttestation | undefined;
 /** Run Verification against an explicit or admitted integration snapshot. */

package/build/src/protocol/intent.js

@@ -1,5 +1,9 @@
+import { entryUlidSchema } from "./attempt.js";
+import { z } from "zod";
+import { hookFailureSchema } from "../git/hooks.js";
 import { materializeScratchCandidate } from "../git/scratch.js";
 import { projectSettings } from "../settings.js";
+import { activeContract } from "../core/facts/observation.js";
 import { dependencyKeySet } from "../core/subject.js";
 import { latestCurrentAttestations } from "../core/facts/gate.js";
 import { decideAttestation } from "../core/verbs/attestation.js";
@@ -47,6 +51,43 @@ export function admitPreparedIntent(channel, repository, input, decide, options)
         decide,
     });
 }
+const verificationCapturedOutputFields = {
+    stdout: z.string().min(1).optional(),
+    stderr: z.string().min(1).optional(),
+    truncated: z.literal(true).optional(),
+};
+export const verificationRuntimeStopSchema = z.union([
+    z.object({ failure: z.enum(["unknown-exit", "cancelled"]), ...verificationCapturedOutputFields }).strict(),
+    z
+        .object({
+        failure: z.enum(["candidate-unavailable", "spawn-error"]),
+        diagnostic: z.string().refine((value) => value.trim() !== ""),
+        ...verificationCapturedOutputFields,
+    })
+        .strict(),
+    z
+        .object({
+        failure: z.literal("environment-failure"),
+        diagnostic: z.string().refine((value) => value.trim() !== ""),
+        ...verificationCapturedOutputFields,
+    })
+        .strict(),
+    z
+        .object({
+        failure: z.literal("environment-failure"),
+        name: z.string().refine((value) => value.trim() !== ""),
+        detail: hookFailureSchema,
+        ...verificationCapturedOutputFields,
+    })
+        .strict(),
+]);
+export const verificationCleanupFailureSchema = z
+    .object({
+    phase: z.literal("destroy"),
+    name: z.string().refine((value) => value.trim() !== ""),
+    detail: hookFailureSchema,
+})
+    .strict();
 function runtimeStop(outcome) {
     return outcome.kind === "spawn-error"
         ? { failure: outcome.kind, diagnostic: outcome.diagnostic, ...capturedOutput(outcome) }
@@ -68,6 +109,22 @@ function verificationInput(outcome, input, subject) {
         },
     };
 }
+export const verificationReuseSchema = z
+    .object({
+    entry: entryUlidSchema,
+    verdict: z.enum(["satisfied", "unsatisfied"]),
+    summary: z.string().optional(),
+})
+    .strict();
+export function reusableVerificationAttestation(current, subject, verdict) {
+    if (current === undefined || current.data.subject !== subject || current.data.verdict !== verdict)
+        return undefined;
+    return {
+        entry: current.entry,
+        verdict: current.data.verdict,
+        ...(current.data.summary === undefined ? {} : { summary: current.data.summary }),
+    };
+}
 /** Read the latest current verified attestation through the generic currentness judge. */
 export function currentVerifiedAttestation(state) {
     const current = latestCurrentAttestations(state, new Set([VERIFIED])).get(VERIFIED);
@@ -85,7 +142,22 @@ function retainVerificationReceipt(input, step) {
 }
 async function verificationStep(input, execution, subject) {
     if (execution.outcome.kind === "terminal") {
-        return await admitIntent(input.channel, input.repository, verificationInput(execution.outcome, input, subject), decideAttestation, input.progress === undefined ? {} : { progress: input.progress });
+        const verdict = execution.outcome.verdict;
+        const admission = await admitIntent(input.channel, input.repository, verificationInput(execution.outcome, input, subject), decideAttestation, {
+            ...(input.progress === undefined ? {} : { progress: input.progress }),
+            validateAdmission: (observation) => {
+                const state = activeContract(observation.decision, input.contractId);
+                if ("kind" in state)
+                    return undefined;
+                const current = [...state.attestations].reverse().find((attestation) => attestation.data.gate === VERIFIED);
+                const reuse = reusableVerificationAttestation(current, subject, verdict);
+                return reuse === undefined ? undefined : { kind: "verification-reuse", reuse };
+            },
+        });
+        if (admission.kind === "refused" && admission.refusal.kind === "verification-reuse") {
+            return { kind: "reused", reuse: admission.refusal.reuse };
+        }
+        return admission;
     }
     if (execution.outcome.kind === "candidate-unavailable")
         return { failure: "candidate-unavailable", diagnostic: execution.outcome.diagnostic };
@@ -134,6 +206,7 @@ export async function verifyDelivery(input) {
     retainVerificationReceipt(input, step);
     return {
         step,
+        ...("kind" in step && step.kind === "reused" ? { reuse: step.reuse } : {}),
         ...(counts === undefined ? {} : { counts }),
         ...(execution.cleanup === undefined ? {} : { cleanup: execution.cleanup }),
         ...(execution.leak === undefined ? {} : { leak: execution.leak }),