@astrosheep/keiyaku 4.6.4 → 4.6.6

package/build/src/library/contract-creation.js

@@ -12,7 +12,7 @@ import { captureLocalContractComposition, derivedGates, derivedHooks, gateNames,
 import { actorOption, normalizedList, requireInput, requireMarkdown, taskOption } from "./input.js";
 import { InvocationAccumulator } from "./invocation.js";
 import { project, validated } from "./outcome.js";
-import { completeReconcile } from "./reconcile.js";
+import { reconcileAffectedContracts } from "./reconcile.js";
 import { observeRegion } from "./region.js";
 import { scopeForRepo } from "./repo.js";
 function bindInput(input, composition) {
@@ -122,7 +122,7 @@ function bindValue(keiyaku, region, warnings, workspace, appointmentLag) {
 // eslint-disable-next-line max-params -- Keep this local operation's custody, admission, and policy witnesses explicit.
 async function bindComplete(accumulator, id, scope, channel, leading, hooks, value) {
     retainAdmission(accumulator, id, leading, false);
-    await reconcileAll(accumulator, id, scope, channel, hooks);
+    await reconcileAffectedContracts(accumulator, id, scope, channel, hooks);
     try {
         const appointment = await readManagedWorktreeAppointment(scope, id);
         if (appointment.kind === "appointed")
@@ -139,34 +139,6 @@ async function bindComplete(accumulator, id, scope, channel, leading, hooks, val
     accumulator.extendConclusions(id, conclusions(built));
     return built;
 }
-async function reconcileAll(accumulator, id, scope, channel, hooks) {
-    for (const contract of [...new Set([id, ...accumulator.snapshot().affected])]) {
-        try {
-            accumulator.observe({ kind: "stage", contractId: contract, stage: "reconciliation", state: "started" });
-            const report = await (async () => {
-                try {
-                    return await completeReconcile({
-                        scope,
-                        channel,
-                        contractId: contract,
-                        hooks,
-                        retryHooks: false,
-                        progress: accumulator,
-                    });
-                }
-                finally {
-                    accumulator.observe({ kind: "stage", contractId: contract, stage: "reconciliation", state: "finished" });
-                }
-            })();
-            void report;
-        }
-        catch (error) {
-            if (!isOperationalStop(error, scope.signal))
-                throw error;
-            accumulator.recordStop(executionStop(contract, "reconciliation", error, scope.signal));
-        }
-    }
-}
 // eslint-disable-next-line max-params -- Keep this local operation's custody, admission, and policy witnesses explicit.
 async function markdownBind(prepared, document, hooks, scope, channel, accumulator, handle, omittedMarkdownTarget) {
     const { task, target, actor, gates, after } = prepared;

package/build/src/library/contract-execution.d.ts

@@ -27,5 +27,4 @@ export declare class ContractExecution {
     /** One accumulator before the first admission-capable await, one projector after teardown. */
     private local;
     private conclude;
-    private reconcileContracts;
 }

package/build/src/library/contract-execution.js

@@ -25,7 +25,7 @@ import { deliveryForContract } from "./delivery.js";
 import { actorOption, contractTerms, documentDerivation, normalizedList, optionalBoolean, optionalNonblank, optionalSignal, requireInput, requireMarkdown, } from "./input.js";
 import { InvocationAccumulator } from "./invocation.js";
 import { KeiyakuError, errorCategory, project, validated, } from "./outcome.js";
-import { completeReconcile } from "./reconcile.js";
+import { reconcileAffectedContracts } from "./reconcile.js";
 import { observeChangedRegion } from "./region.js";
 export class ContractExecution {
     seat;
@@ -157,6 +157,7 @@ export class ContractExecution {
                 if (outcome.kind !== "accepted")
                     return expected(this.id, outcome);
                 leadingValue = outcome.value;
+                accumulator.extendConclusions(this.id, { leading: outcome.value.leading });
                 stage = "verification";
                 await advanceAndContinue(accumulator, scope, localChannel, this.id, this.composition, outcome, values.signal, "verification");
             }
@@ -168,12 +169,13 @@ export class ContractExecution {
             const retained = accumulator.conclusions(this.id) ?? {};
             const value = { ...base, ...leadingValue, ...retained };
             accumulator.recordConclusions(this.id, value);
-            await this.reconcileContracts(accumulator, scope, localChannel, hooks);
+            await reconcileAffectedContracts(accumulator, this.id, scope, localChannel, hooks);
             return acceptedOutcome("deliver", this.id, accumulator, deliveryForContract(this.scope, value));
         }, values.signal, observer);
     }
     async review(input, options) {
-        const values = validated(() => requireInput(input, "review input", ["verdict", "summary", "signal"]));
+        const values = validated(() => requireInput(input, "review input", ["verdict", "summary", "actor", "signal"]));
+        const actor = validated(() => actorOption(values.actor));
         const verdict = values.verdict;
         if (verdict !== "satisfied" && verdict !== "unsatisfied")
             throw new KeiyakuError("invalid-input", "verdict must be satisfied or unsatisfied", {
@@ -195,6 +197,7 @@ export class ContractExecution {
                     contractId: this.id,
                     verdict,
                     ...(summary === undefined ? {} : { summary }),
+                    ...actor,
                 },
             });
         const hooks = derivedHooks(this.composition);
@@ -209,6 +212,7 @@ export class ContractExecution {
                     contractId: this.id,
                     progress: accumulator,
                     ...(this.composition.actor === undefined ? {} : { actor: this.composition.actor }),
+                    ...actor,
                     ...(signal === undefined ? {} : { signal }),
                     verdict,
                     ...(summary === undefined ? {} : { summary }),
@@ -229,7 +233,7 @@ export class ContractExecution {
             }
             const retained = { ...value, ...accumulator.conclusions(this.id) };
             accumulator.extendConclusions(this.id, retained);
-            await this.reconcileContracts(accumulator, scope, localChannel, hooks);
+            await reconcileAffectedContracts(accumulator, this.id, scope, localChannel, hooks);
             return acceptedOutcome("review", this.id, accumulator, retained);
         }, signal, observer);
     }
@@ -379,38 +383,9 @@ export class ContractExecution {
         retainAdmission(accumulator, this.id, input.leading, input.verificationResidueRecorded);
         const value = input.value(input.leading.value);
         accumulator.extendConclusions(this.id, conclusions(value));
-        await this.reconcileContracts(accumulator, input.scope, input.channel, input.hooks);
+        await reconcileAffectedContracts(accumulator, this.id, input.scope, input.channel, input.hooks);
         return value;
     }
-    async reconcileContracts(accumulator, scope, channel, hooks) {
-        for (const contract of [...new Set([this.id, ...accumulator.snapshot().affected])]) {
-            try {
-                scope.signal?.throwIfAborted();
-                accumulator.observe({ kind: "stage", contractId: contract, stage: "reconciliation", state: "started" });
-                const report = await (async () => {
-                    try {
-                        return await completeReconcile({
-                            scope,
-                            channel,
-                            contractId: contract,
-                            hooks,
-                            retryHooks: false,
-                            progress: accumulator,
-                        });
-                    }
-                    finally {
-                        accumulator.observe({ kind: "stage", contractId: contract, stage: "reconciliation", state: "finished" });
-                    }
-                })();
-                void report;
-            }
-            catch (error) {
-                if (!isOperationalStop(error, scope.signal))
-                    throw error;
-                accumulator.recordStop(executionStop(contract, "reconciliation", error, scope.signal));
-            }
-        }
-    }
 }
 function changedAmendTerms(before, after) {
     return {

package/build/src/library/contract-operations.d.ts

@@ -55,17 +55,20 @@ declare const reviewRequestSchema: z.ZodPipe<z.ZodObject<{
         unsatisfied: "unsatisfied";
     }>;
     summary: z.ZodOptional<z.ZodString>;
+    actor: z.ZodOptional<z.ZodString>;
 }, z.core.$strict>, z.ZodTransform<{
     repoRoot: string;
     contractId: import("../core/facts/types.js").ContractId;
     verdict: "satisfied" | "unsatisfied";
     summary?: string | undefined;
+    actor?: string | undefined;
     action: "contract.review";
 }, {
     repoRoot: string;
     contractId: import("../core/facts/types.js").ContractId;
     verdict: "satisfied" | "unsatisfied";
     summary?: string | undefined;
+    actor?: string | undefined;
 }>>;
 export type ContractRequest = z.infer<typeof auditRequestSchema> | z.infer<typeof deliverRequestSchema> | z.infer<typeof reviewRequestSchema>;
 type DeliverRequest = Extract<ContractRequest, {
@@ -174,6 +177,7 @@ declare const contractServiceSchema: z.ZodUnion<readonly [z.ZodObject<{
                 path: z.ZodString;
             }, z.core.$strict>;
             identity: z.ZodObject<{
+                note: z.ZodOptional<z.ZodString>;
                 tenderSnapshot: z.ZodPipe<z.ZodString, z.ZodTransform<import("../core/facts/types.js").SnapshotId, string>>;
                 integration: z.ZodObject<{
                     predecessor: z.ZodPipe<z.ZodString, z.ZodTransform<import("../core/facts/types.js").SnapshotId, string>>;
@@ -376,7 +380,7 @@ declare const contractServiceSchema: z.ZodUnion<readonly [z.ZodObject<{
     contractId: z.ZodPipe<z.ZodString, z.ZodTransform<import("../core/facts/types.js").ContractId, string>>;
     reviewFactId: z.ZodString;
 }, z.core.$strict>]>;
-export type ContractService = z.infer<typeof contractServiceSchema>;
+type ContractService = z.infer<typeof contractServiceSchema>;
 type ContractReference = ContractService | z.infer<typeof materializedHandoffReferenceSchema>;
 export type ContractRequestPort = Readonly<{
     audit(input: AuditRequest & Readonly<{

package/build/src/library/contract-operations.js

@@ -4,7 +4,7 @@ import { AkumaBodyRequestError, requestBodyCommand } from "../akuma/request-rend
 import { eraseRequestCommand, } from "../akuma/request-wire.js";
 import { auditReportSchema } from "../protocol/audit.js";
 import { materializedConflictSchema } from "../protocol/deliver.js";
-import { decodeExecutionObservation, observeExecution, } from "../protocol/execution-observation.js";
+import { observationSchema, observeExecution } from "../protocol/execution-observation.js";
 import { contractIdSchema } from "../protocol/operations.js";
 import { deliveryValueSchema } from "./delivery.js";
 import { InvocationAccumulator } from "./invocation.js";
@@ -27,7 +27,11 @@ const deliverRequestSchema = contractRequestBaseSchema
 })
     .transform((request) => ({ action: "contract.deliver", ...request }));
 const reviewRequestSchema = contractRequestBaseSchema
-    .extend({ verdict: z.enum(["satisfied", "unsatisfied"]), summary: nonblankStringSchema.optional() })
+    .extend({
+    verdict: z.enum(["satisfied", "unsatisfied"]),
+    summary: nonblankStringSchema.optional(),
+    actor: z.string().optional(),
+})
     .transform((request) => ({ action: "contract.review", ...request }));
 const auditServiceSchema = z
     .object({
@@ -250,7 +254,7 @@ export async function requestForwardedContractLive(input) {
         value: input.request,
         onProgress: (value) => {
             try {
-                observeExecution(input.observe, decodeExecutionObservation(value));
+                observeExecution(input.observe, observationSchema.parse(value));
             }
             catch {
                 observeExecution(input.observe, { kind: "progress-dropped", count: 1 });

package/build/src/library/contract-types.d.ts

@@ -72,7 +72,7 @@ export type KeiyakuSelectInput = Readonly<{
     repo: Repo;
     id: ContractId;
 }>;
-export type ReviewInput = Readonly<{
+export type ReviewInput = ActorOptions & Readonly<{
     verdict: AttestationData["verdict"];
     summary?: string;
     signal?: AbortSignal;

package/build/src/library/delivery.d.ts

@@ -11,108 +11,99 @@ export declare const deliveryValueSchema: z.ZodObject<{
             filesChanged: z.ZodNumber;
             insertions: z.ZodNumber;
         }, z.core.$strict>>;
-        verification: z.ZodOptional<z.ZodObject<{
-            mode: z.ZodEnum<{
-                reused: "reused";
-                ran: "ran";
-            }>;
-            verdict: z.ZodEnum<{
-                satisfied: "satisfied";
-                unsatisfied: "unsatisfied";
-            }>;
-        }, z.core.$strict>>;
     }, z.core.$strict>>;
-    verification: z.ZodOptional<z.ZodUnion<readonly [z.ZodObject<{
-        refusal: z.ZodUnion<readonly [z.ZodObject<{
-            kind: z.ZodEnum<{
-                terminal: "terminal";
-                "contract-missing": "contract-missing";
-            }>;
-            contractId: z.ZodPipe<z.ZodString, z.ZodTransform<import("../core/facts/types.js").ContractId, string>>;
-        }, z.core.$strict>, z.ZodObject<{
-            kind: z.ZodLiteral<"verification-declaration-invalid">;
-            contractId: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<import("../core/facts/types.js").ContractId, string>>>;
-        }, z.core.$strict>]>;
-    }, z.core.$strict>, z.ZodObject<{
-        retry: z.ZodUnion<readonly [z.ZodObject<{
-            kind: z.ZodEnum<{
-                exhausted: "exhausted";
-                collision: "collision";
-            }>;
-        }, z.core.$strict>, z.ZodObject<{
-            kind: z.ZodLiteral<"publication-failed">;
-            diagnostic: z.ZodString;
-        }, z.core.$strict>]>;
-    }, z.core.$strict>, 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";
+    verification: z.ZodOptional<z.ZodDiscriminatedUnion<[z.ZodObject<{
+        snapshot: z.ZodPipe<z.ZodString, z.ZodTransform<SnapshotId, string>>;
+        verdict: z.ZodEnum<{
+            satisfied: "satisfied";
+            unsatisfied: "unsatisfied";
         }>;
+        summary: z.ZodOptional<z.ZodString>;
+        kind: z.ZodLiteral<"ran">;
+        entry: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<import("../core/facts/types.js").EntryUlid, string>>>;
     }, 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";
+        snapshot: z.ZodPipe<z.ZodString, z.ZodTransform<SnapshotId, string>>;
+        verdict: z.ZodEnum<{
+            satisfied: "satisfied";
+            unsatisfied: "unsatisfied";
         }>;
-        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;
+        entry: z.ZodPipe<z.ZodString, z.ZodTransform<import("../core/facts/types.js").EntryUlid, string>>;
+        summary: z.ZodOptional<z.ZodString>;
+        kind: z.ZodLiteral<"reused">;
     }, 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;
+        kind: z.ZodLiteral<"stopped">;
+        stop: z.ZodUnion<readonly [z.ZodObject<{
+            refusal: z.ZodUnion<readonly [z.ZodObject<{
+                kind: z.ZodEnum<{
+                    terminal: "terminal";
+                    "contract-missing": "contract-missing";
+                }>;
+                contractId: z.ZodPipe<z.ZodString, z.ZodTransform<import("../core/facts/types.js").ContractId, string>>;
+            }, z.core.$strict>, z.ZodObject<{
+                kind: z.ZodLiteral<"verification-declaration-invalid">;
+                contractId: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<import("../core/facts/types.js").ContractId, string>>>;
+            }, z.core.$strict>]>;
         }, z.core.$strict>, z.ZodObject<{
+            retry: z.ZodUnion<readonly [z.ZodObject<{
+                kind: z.ZodEnum<{
+                    exhausted: "exhausted";
+                    collision: "collision";
+                }>;
+            }, z.core.$strict>, z.ZodObject<{
+                kind: z.ZodLiteral<"publication-failed">;
+                diagnostic: z.ZodString;
+            }, z.core.$strict>]>;
+        }, z.core.$strict>, z.ZodUnion<readonly [z.ZodObject<{
             stdout: z.ZodOptional<z.ZodString>;
             stderr: z.ZodOptional<z.ZodString>;
-            truncated: z.ZodOptional<z.ZodBoolean>;
-            kind: z.ZodLiteral<"timeout">;
+            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.ZodBoolean>;
-            kind: z.ZodLiteral<"unknown-exit">;
+            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<{
-            kind: z.ZodLiteral<"spawn-error">;
+            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.core.$strict>]>]>>;
-    verificationReuse: z.ZodOptional<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>>;
-    verificationSubject: z.ZodOptional<z.ZodObject<{
-        mode: z.ZodEnum<{
-            reused: "reused";
-            ran: "ran";
-        }>;
-        verdict: z.ZodEnum<{
-            satisfied: "satisfied";
-            unsatisfied: "unsatisfied";
-        }>;
-        snapshot: z.ZodPipe<z.ZodString, z.ZodTransform<SnapshotId, string>>;
-    }, z.core.$strict>>;
-    verificationSummary: z.ZodOptional<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>]>]>;
+    }, z.core.$strict>], "kind">>;
     placement: z.ZodOptional<z.ZodUnion<readonly [z.ZodObject<{
         refusal: z.ZodUnion<readonly [z.ZodUnion<readonly [z.ZodObject<{
             kind: z.ZodEnum<{
@@ -235,7 +226,14 @@ export declare const deliveryValueSchema: z.ZodObject<{
             "already-admitted": "already-admitted";
         }>;
         fact: z.ZodPipe<z.ZodString, z.ZodTransform<import("../core/facts/types.js").EntryUlid, string>>;
+        reusedIntegration: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<SnapshotId, string>>>;
     }, z.core.$strict>;
+    contentChange: z.ZodOptional<z.ZodObject<{
+        kind: z.ZodLiteral<"candidate-content-changed">;
+        target: z.ZodOptional<z.ZodString>;
+        previousChange: z.ZodPipe<z.ZodString, z.ZodTransform<import("../core/facts/types.js").ChangeId, string>>;
+        currentChange: z.ZodPipe<z.ZodString, z.ZodTransform<import("../core/facts/types.js").ChangeId, string>>;
+    }, z.core.$strict>>;
     continuation: z.ZodOptional<z.ZodObject<{
         claimed: z.ZodReadonly<z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<import("../core/facts/types.js").ContractId, string>>>>;
         stopped: z.ZodReadonly<z.ZodArray<z.ZodObject<{
@@ -511,6 +509,7 @@ export declare const deliveryValueSchema: z.ZodObject<{
             }, z.core.$strict>]>;
         }, z.core.$strict>>>;
     }, z.core.$strict>>;
+    note: z.ZodOptional<z.ZodString>;
     tenderSnapshot: z.ZodPipe<z.ZodString, z.ZodTransform<SnapshotId, string>>;
     integration: z.ZodObject<{
         predecessor: z.ZodPipe<z.ZodString, z.ZodTransform<SnapshotId, string>>;
@@ -526,18 +525,17 @@ export type DeliveryValue = z.infer<typeof deliveryValueSchema>;
 declare class DeliveryHandle {
     private readonly readDiff;
     readonly leading?: DeliveryValue["leading"];
+    readonly contentChange?: DeliveryValue["contentChange"];
     readonly completion?: DeliveryValue["completion"];
     readonly verification?: DeliveryValue["verification"];
-    readonly verificationReuse?: DeliveryValue["verificationReuse"];
-    readonly verificationSubject?: DeliveryValue["verificationSubject"];
-    readonly verificationSummary?: DeliveryValue["verificationSummary"];
     readonly placement?: DeliveryValue["placement"];
     readonly continuation?: DeliveryValue["continuation"];
     readonly tenderSnapshot: SnapshotId;
+    readonly note?: string;
     readonly integration: DeliveryValue["integration"];
     readonly method: DeliveryValue["method"];
     readonly policy: DeliveryValue["policy"];
-    constructor(identity: Pick<DeliveryValue, "tenderSnapshot" | "integration" | "method" | "policy">, readDiff: () => Promise<string | null>, outcomes?: Partial<Pick<DeliveryValue, "leading" | "completion" | "verification" | "verificationReuse" | "verificationSubject" | "verificationSummary" | "placement" | "continuation">>);
+    constructor(identity: Pick<DeliveryValue, "tenderSnapshot" | "integration" | "method" | "policy">, readDiff: () => Promise<string | null>, outcomes?: Partial<Pick<DeliveryValue, "leading" | "contentChange" | "completion" | "verification" | "placement" | "continuation">>);
     diff(): Promise<string | null>;
 }
 export type Delivery = DeliveryHandle;

package/build/src/library/delivery.js

@@ -1,11 +1,12 @@
 import { completionEvidenceSchema } from "../protocol/completion.js";
 import { deliverLeadingSchema } from "../protocol/deliver.js";
-import { deliverDataSchema, deliveryDiffOperation } from "../protocol/operations.js";
+import { candidateContentChangeSchema, deliverDataSchema, deliveryDiffOperation, } from "../protocol/operations.js";
 import { continuationReportSchema } from "./continuation.js";
 export const deliveryValueSchema = completionEvidenceSchema
     .extend({
     ...deliverDataSchema.shape,
     leading: deliverLeadingSchema,
+    contentChange: candidateContentChangeSchema.optional(),
     continuation: continuationReportSchema.optional(),
 })
     .strict();

package/build/src/library/input.d.ts

@@ -7,8 +7,6 @@ export declare function actorOption(actor: unknown): Readonly<{
 }>;
 export declare function requireMarkdown(value: unknown, label?: string): string;
 export declare function requireInput(value: unknown, label: string, allowed?: readonly string[]): Record<string, unknown>;
-/** Shared public-input failure path for operation owners. */
-export declare function invalidInput(message: string): never;
 export declare function taskOption(value: unknown): TaskId | undefined;
 export declare function optionalNonblank(value: unknown, label: string): string | undefined;
 export declare function optionalBoolean(value: unknown, label: string): boolean | undefined;

package/build/src/library/input.js

@@ -32,10 +32,6 @@ export function requireInput(value, label, allowed) {
     }
     return value;
 }
-/** Shared public-input failure path for operation owners. */
-export function invalidInput(message) {
-    throw new TypeError(message);
-}
 export function taskOption(value) {
     if (value === undefined)
         return undefined;

package/build/src/library/invocation.d.ts

@@ -83,5 +83,4 @@ export declare class InvocationAccumulator implements ProtocolProgress {
     private recordSeatClose;
     private recordLag;
 }
-export declare function physicalOf(snapshot: InvocationSnapshot): ReconcileResult;
 export {};

package/build/src/library/invocation.js

@@ -3,21 +3,10 @@ import { encodeEntry } from "../core/facts/codec.js";
 import { AuthorityCorruptionError } from "../core/facts/errors.js";
 import { observeExecution, } from "../protocol/execution-observation.js";
 import { reconcileLagScope } from "./reconcile.js";
-const CANDIDATE_CONCLUSION_KEYS = [
-    "completion",
-    "verification",
-    "verificationReuse",
-    "verificationSubject",
-    "verificationSummary",
-    "placement",
-];
+const CANDIDATE_CONCLUSION_KEYS = ["completion", "verification", "placement"];
 function entryKey(fact) {
     return `${fact.contract}\u0000${fact.entry}`;
 }
-/** The owner codec's canonical bytes: identity is (contract, entry), the payload is retained whole. */
-function entryBytes(fact) {
-    return encodeEntry(fact);
-}
 /**
  * The one invocation accumulator. It exists before any admission-capable await, satisfies the lower
  * Protocol progress sink, and holds every confirmed publication, candidate conclusion and physical
@@ -54,7 +43,7 @@ export class InvocationAccumulator {
         const incoming = new Map();
         for (const fact of facts) {
             const key = entryKey(fact);
-            const bytes = entryBytes(fact);
+            const bytes = encodeEntry(fact);
             const previous = incoming.get(key)?.bytes ?? this.entries.get(key);
             if (previous !== undefined && previous !== bytes)
                 throw new AuthorityCorruptionError("conflicting invocation receipt");
@@ -88,7 +77,7 @@ export class InvocationAccumulator {
         this.recordResidue(step.state.id, step);
     }
     hasFact(fact) {
-        return this.entries.get(entryKey(fact)) === entryBytes(fact);
+        return this.entries.get(entryKey(fact)) === encodeEntry(fact);
     }
     head(contract) {
         return this.admittedHeads.get(contract);
@@ -277,14 +266,3 @@ export class InvocationAccumulator {
             this.affectedContracts.add(contract);
     }
 }
-export function physicalOf(snapshot) {
-    const effects = [];
-    const lag = [];
-    for (const record of snapshot.effects) {
-        if (record.kind === "reconciliation-effect" && record.effect.kind !== "contract-file")
-            effects.push(record.effect);
-        else if (record.kind === "reconciliation-lag" && record.lag.kind !== "contract-file-failed")
-            lag.push(record.lag);
-    }
-    return { effects, lag };
-}