@astrosheep/keiyaku 4.6.11 → 4.6.13

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

@@ -10,7 +10,7 @@ import { documentDiff } from "../markdown/diff.js";
 import { abandonOperation } from "../protocol/abandon.js";
 import { amendOperation } from "../protocol/amend.js";
 import { arcOperation } from "../protocol/arc.js";
-import { auditOperation } from "../protocol/audit.js";
+import { previewDeliveryOperation } from "../protocol/delivery-preview.js";
 import { completeCandidate } from "../protocol/completion.js";
 import { admitDeliveryOperation } from "../protocol/deliver.js";
 import { withScopeAbortSignal, } from "../protocol/operations.js";
@@ -20,7 +20,7 @@ import { releaseDebtHolder, releaseDebtHolderWithFence, debtHolderObservationSel
 import { continueDeliveredDependents } from "./continuation.js";
 import { requestForwardedContractLive } from "./contract-operations.js";
 import { acceptedOutcome, expected, retainAdmission } from "./contract-outcomes.js";
-import { derivedContractPolicy, derivedGates, derivedHooks, gateNames, } from "./contract-settings.js";
+import { derivedContractPolicy, derivedFreshness, derivedGates, derivedHooks, gateNames, } from "./contract-settings.js";
 import { deliveryForContract } from "./delivery.js";
 import { actorOption, contractTerms, documentDerivation, normalizedList, optionalBoolean, optionalNonblank, optionalSignal, requireInput, requireMarkdown, } from "./input.js";
 import { InvocationAccumulator } from "./invocation.js";
@@ -300,8 +300,10 @@ export class ContractExecution {
             return acceptedOutcome("arc", this.id, accumulator, undefined);
         });
     }
-    async audit(input, options) {
-        const values = validated(() => input === undefined ? undefined : requireInput(input, "audit input", ["includeDirty", "showDiff", "signal"]));
+    async previewDelivery(input, options) {
+        const values = validated(() => input === undefined
+            ? undefined
+            : requireInput(input, "delivery preview input", ["includeDirty", "showDiff", "signal"]));
         const includeDirty = validated(() => optionalBoolean(values?.includeDirty, "includeDirty") ?? false);
         const showDiff = validated(() => optionalBoolean(values?.showDiff, "showDiff") ?? false);
         const signal = validated(() => optionalSignal(values?.signal));
@@ -310,20 +312,20 @@ export class ContractExecution {
         if (channel.kind === "body-request")
             return await forwardedContractOutcome({
                 directory: channel.directory,
-                action: "contract.audit",
+                action: "contract.preview-delivery",
                 ...(observer === undefined ? {} : { observe: observer }),
                 ...(signal === undefined ? {} : { signal }),
                 request: {
-                    action: "contract.audit",
+                    action: "contract.preview-delivery",
                     repoRoot: this.scope.primaryWorktree,
                     contractId: this.id,
                     includeDirty,
                     showDiff,
                 },
             });
-        const { hooks, requireBranchesToBeUpToDate } = derivedContractPolicy(this.composition);
-        return await this.local("audit", async (accumulator, localChannel, scope) => {
-            const admission = await auditOperation({
+        const requireBranchesToBeUpToDate = derivedFreshness(this.composition);
+        return await this.local("deliver-preview", async (accumulator, localChannel, scope) => {
+            const admission = await previewDeliveryOperation({
                 scope,
                 channel: localChannel,
                 progress: accumulator,
@@ -337,14 +339,8 @@ export class ContractExecution {
             });
             if (admission.kind !== "accepted")
                 return expected(this.id, admission);
-            const report = await this.conclude(accumulator, {
-                scope,
-                channel: localChannel,
-                leading: admission,
-                hooks,
-                value: (value) => value,
-            });
-            return acceptedOutcome("audit", this.id, accumulator, report);
+            accumulator.recordDeliveryPreview(this.id, admission.value);
+            return { kind: "accepted", contract: this.id, head: admission.head, value: admission.value };
         }, signal, observer);
     }
     /** One accumulator before the first admission-capable await, one projector after teardown. */

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

@@ -4,10 +4,10 @@ import type { ActorId } from "../core/facts/types.js";
 import { type ExecutionObserver } from "../protocol/execution-observation.js";
 type DeliveryResult = import("./contract-outcomes.js").DeliverOutcome;
 type ReviewResult = import("./contract-outcomes.js").ReviewOutcome;
-type AuditResult = import("./contract-outcomes.js").AuditOutcome;
-type ContractResult = DeliveryResult | ReviewResult | AuditResult;
+type DeliveryPreviewResult = import("./contract-outcomes.js").DeliveryPreviewOutcome;
+type ContractResult = DeliveryResult | ReviewResult | DeliveryPreviewResult;
 type ContractRequester = ActorId;
-declare const auditRequestSchema: z.ZodPipe<z.ZodObject<{
+declare const previewRequestSchema: z.ZodPipe<z.ZodObject<{
     repoRoot: z.ZodString;
     contractId: z.ZodPipe<z.ZodString, z.ZodTransform<import("../core/facts/types.js").ContractId, string>>;
     includeDirty: z.ZodBoolean;
@@ -17,7 +17,7 @@ declare const auditRequestSchema: z.ZodPipe<z.ZodObject<{
     contractId: import("../core/facts/types.js").ContractId;
     includeDirty: boolean;
     showDiff: boolean;
-    action: "contract.audit";
+    action: "contract.preview-delivery";
 }, {
     repoRoot: string;
     contractId: import("../core/facts/types.js").ContractId;
@@ -70,17 +70,17 @@ declare const reviewRequestSchema: z.ZodPipe<z.ZodObject<{
     summary?: string | undefined;
     actor?: string | undefined;
 }>>;
-export type ContractRequest = z.infer<typeof auditRequestSchema> | z.infer<typeof deliverRequestSchema> | z.infer<typeof reviewRequestSchema>;
+export type ContractRequest = z.infer<typeof previewRequestSchema> | z.infer<typeof deliverRequestSchema> | z.infer<typeof reviewRequestSchema>;
 type DeliverRequest = Extract<ContractRequest, {
     action: "contract.deliver";
 }>;
 type ReviewRequest = Extract<ContractRequest, {
     action: "contract.review";
 }>;
-type AuditRequest = Extract<ContractRequest, {
-    action: "contract.audit";
+type DeliveryPreviewRequest = Extract<ContractRequest, {
+    action: "contract.preview-delivery";
 }>;
-type ContractResultFor<Action extends ContractRequest["action"]> = Action extends "contract.deliver" ? DeliveryResult : Action extends "contract.review" ? ReviewResult : AuditResult;
+type ContractResultFor<Action extends ContractRequest["action"]> = Action extends "contract.deliver" ? DeliveryResult : Action extends "contract.review" ? ReviewResult : DeliveryPreviewResult;
 type ContractRequestFor<Action extends ContractRequest["action"]> = Extract<ContractRequest, {
     action: Action;
 }>;
@@ -100,7 +100,7 @@ declare const materializedHandoffReferenceSchema: z.ZodObject<{
     }, z.core.$strict>;
 }, z.core.$strict>;
 declare const contractServiceSchema: z.ZodUnion<readonly [z.ZodObject<{
-    kind: z.ZodLiteral<"audit-report">;
+    kind: z.ZodLiteral<"delivery-preview-report">;
     repoRoot: z.ZodString;
     contractId: z.ZodPipe<z.ZodString, z.ZodTransform<import("../core/facts/types.js").ContractId, string>>;
     report: z.ZodObject<{
@@ -196,92 +196,49 @@ declare const contractServiceSchema: z.ZodUnion<readonly [z.ZodObject<{
                 paths: z.ZodOptional<z.ZodReadonly<z.ZodArray<z.ZodString>>>;
             }, z.core.$strict>;
             diff: z.ZodOptional<z.ZodString>;
+            requirements: z.ZodObject<{
+                gates: z.ZodReadonly<z.ZodArray<z.ZodObject<{
+                    gate: z.ZodPipe<z.ZodString, z.ZodTransform<import("../core/facts/types.js").Gate, string>>;
+                    current: z.ZodUnion<readonly [z.ZodObject<{
+                        kind: z.ZodLiteral<"missing">;
+                    }, z.core.$strict>, z.ZodObject<{
+                        kind: z.ZodLiteral<"attested">;
+                        verdict: z.ZodEnum<{
+                            satisfied: "satisfied";
+                            unsatisfied: "unsatisfied";
+                        }>;
+                        at: z.ZodString;
+                        summary: z.ZodOptional<z.ZodString>;
+                    }, z.core.$strict>, z.ZodObject<{
+                        kind: z.ZodLiteral<"stale">;
+                        priorVerdict: z.ZodEnum<{
+                            satisfied: "satisfied";
+                            unsatisfied: "unsatisfied";
+                        }>;
+                        reason: 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>>;
+                    }, z.core.$strict>]>;
+                }, z.core.$strict>>>;
+                unmetPrerequisites: z.ZodReadonly<z.ZodArray<z.ZodObject<{
+                    contractId: z.ZodPipe<z.ZodString, z.ZodTransform<import("../core/facts/types.js").ContractId, string>>;
+                    state: z.ZodEnum<{
+                        abandoned: "abandoned";
+                        missing: "missing";
+                        active: "active";
+                    }>;
+                }, z.core.$strict>>>;
+            }, z.core.$strict>;
         }, z.core.$strict>]>;
         verification: z.ZodUnion<readonly [z.ZodObject<{
             kind: z.ZodLiteral<"not-run">;
         }, z.core.$strict>, z.ZodObject<{
             kind: z.ZodLiteral<"undeclared">;
         }, z.core.$strict>, z.ZodObject<{
-            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.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>]>]>;
-        }, z.core.$strict>, z.ZodObject<{
-            kind: z.ZodEnum<{
-                satisfied: "satisfied";
-                unsatisfied: "unsatisfied";
-            }>;
-            passed: z.ZodNumber;
-            total: z.ZodNumber;
-            summary: z.ZodOptional<z.ZodString>;
+            kind: z.ZodLiteral<"required">;
         }, z.core.$strict>, z.ZodObject<{
             entry: z.ZodPipe<z.ZodString, z.ZodTransform<import("../core/facts/types.js").EntryUlid, string>>;
             verdict: z.ZodEnum<{
@@ -289,7 +246,7 @@ declare const contractServiceSchema: z.ZodUnion<readonly [z.ZodObject<{
                 unsatisfied: "unsatisfied";
             }>;
             summary: z.ZodOptional<z.ZodString>;
-            kind: z.ZodLiteral<"reused">;
+            kind: z.ZodLiteral<"recorded">;
         }, z.core.$strict>]>;
         target: z.ZodUnion<readonly [z.ZodObject<{
             kind: z.ZodLiteral<"not-observed">;
@@ -297,6 +254,14 @@ declare const contractServiceSchema: z.ZodUnion<readonly [z.ZodObject<{
             kind: z.ZodLiteral<"placeable">;
             ref: z.ZodString;
             head: z.ZodPipe<z.ZodString, z.ZodTransform<import("../core/facts/types.js").SnapshotId, string>>;
+            checkouts: z.ZodReadonly<z.ZodArray<z.ZodUnion<readonly [z.ZodObject<{
+                kind: z.ZodLiteral<"followable">;
+                path: z.ZodString;
+            }, z.core.$strict>, z.ZodObject<{
+                kind: z.ZodLiteral<"not-followable">;
+                path: z.ZodString;
+                diagnostic: z.ZodString;
+            }, z.core.$strict>]>>>;
         }, z.core.$strict>, z.ZodObject<{
             kind: z.ZodLiteral<"moved">;
             ref: z.ZodString;
@@ -383,11 +348,11 @@ declare const contractServiceSchema: z.ZodUnion<readonly [z.ZodObject<{
 type ContractService = z.infer<typeof contractServiceSchema>;
 type ContractReference = ContractService | z.infer<typeof materializedHandoffReferenceSchema>;
 export type ContractRequestPort = Readonly<{
-    audit(input: AuditRequest & Readonly<{
+    previewDelivery(input: DeliveryPreviewRequest & Readonly<{
         requester: ContractRequester;
         signal: AbortSignal;
         observe?: ExecutionObserver;
-    }>): Promise<AuditResult>;
+    }>): Promise<DeliveryPreviewResult>;
     deliver(input: DeliverRequest & Readonly<{
         requester: ContractRequester;
         signal: AbortSignal;
@@ -401,7 +366,7 @@ export type ContractRequestPort = Readonly<{
 }>;
 export declare function contractRequestProtocol(action: ContractRequest["action"]): RequestProtocol<ContractRequest, ContractResult, ContractReference>;
 export declare function contractRequestCommand(action: ContractRequest["action"], port: ContractRequestPort): ServiceRequestCommand<ContractRequest, ContractResult, ContractService, ContractReference>;
-export declare function contractRequestCommands(port: ContractRequestPort): Readonly<Record<"contract.audit" | "contract.deliver" | "contract.review", ErasedRequestCommand>>;
+export declare function contractRequestCommands(port: ContractRequestPort): Readonly<Record<"contract.preview-delivery" | "contract.deliver" | "contract.review", ErasedRequestCommand>>;
 export declare function requestForwardedContractLive<Action extends ContractRequest["action"]>(input: Readonly<{
     directory: string;
     action: Action;
@@ -412,6 +377,6 @@ export declare function requestForwardedContractLive<Action extends ContractRequ
 /** Map durable request disposition without reconstructing an expired owner answer. */
 export declare function mapForwardedContractFailure(error: unknown, request: ContractRequest): {
     kind: "returned";
-    result: import("./outcome.js").ProjectedOutcome<"deliver" | "review" | "audit", unknown, unknown>;
+    result: import("./outcome.js").ProjectedOutcome<"deliver" | "review" | "deliver-preview", unknown, unknown>;
 };
 export {};

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

@@ -2,7 +2,7 @@ import { isAbsolute, resolve } from "node:path";
 import { z } from "zod";
 import { AkumaBodyRequestError, requestBodyCommand } from "../akuma/request-rendezvous.js";
 import { eraseRequestCommand, } from "../akuma/request-wire.js";
-import { auditReportSchema } from "../protocol/audit.js";
+import { deliveryPreviewReportSchema } from "../protocol/delivery-preview.js";
 import { materializedConflictSchema } from "../protocol/deliver.js";
 import { observationSchema, observeExecution } from "../protocol/execution-observation.js";
 import { contractIdSchema } from "../protocol/operations.js";
@@ -12,12 +12,12 @@ import { decodeFailureWire, encodeFailureWire, KeiyakuError, outcomeSchema, proj
 const absolutePathSchema = z.string().refine((value) => isAbsolute(value) && resolve(value) === value);
 const nonblankStringSchema = z.string().refine((value) => value.trim() !== "");
 const contractRequestBaseSchema = z.object({ repoRoot: absolutePathSchema, contractId: contractIdSchema }).strict();
-const auditRequestSchema = contractRequestBaseSchema
+const previewRequestSchema = contractRequestBaseSchema
     .extend({
     includeDirty: z.boolean(),
     showDiff: z.boolean(),
 })
-    .transform((request) => ({ action: "contract.audit", ...request }));
+    .transform((request) => ({ action: "contract.preview-delivery", ...request }));
 const deliverRequestSchema = contractRequestBaseSchema
     .extend({
     includeDirty: z.boolean(),
@@ -33,12 +33,12 @@ const reviewRequestSchema = contractRequestBaseSchema
     actor: z.string().optional(),
 })
     .transform((request) => ({ action: "contract.review", ...request }));
-const auditServiceSchema = z
+const previewServiceSchema = z
     .object({
-    kind: z.literal("audit-report"),
+    kind: z.literal("delivery-preview-report"),
     repoRoot: absolutePathSchema,
     contractId: contractIdSchema,
-    report: auditReportSchema,
+    report: deliveryPreviewReportSchema,
 })
     .strict();
 const deliveryReferenceSchema = z
@@ -66,14 +66,14 @@ const materializedHandoffServiceSchema = materializedConflictSchema
 })
     .strict();
 const contractServiceSchema = z.union([
-    auditServiceSchema,
+    previewServiceSchema,
     deliveryReferenceSchema,
     materializedHandoffServiceSchema,
     reviewReferenceSchema,
 ]);
 function decodeContractRequest(action, value) {
-    const schema = action === "contract.audit"
-        ? auditRequestSchema
+    const schema = action === "contract.preview-delivery"
+        ? previewRequestSchema
         : action === "contract.deliver"
             ? deliverRequestSchema
             : reviewRequestSchema;
@@ -81,8 +81,8 @@ function decodeContractRequest(action, value) {
     return parsed.success ? parsed.data : null;
 }
 function decodeContractService(action, value) {
-    const schema = action === "contract.audit"
-        ? auditServiceSchema
+    const schema = action === "contract.preview-delivery"
+        ? previewServiceSchema
         : action === "contract.deliver"
             ? z.union([deliveryReferenceSchema, materializedHandoffServiceSchema])
             : reviewReferenceSchema;
@@ -125,8 +125,8 @@ function acceptedReviewEvidence(result, contractId) {
 }
 async function executeContractRequest(request, facts, port) {
     const observation = executionObservation(facts);
-    if (request.action === "contract.audit") {
-        const result = await port.audit({
+    if (request.action === "contract.preview-delivery") {
+        const result = await port.previewDelivery({
             ...request,
             ...observation,
             requester: facts.requester,
@@ -138,7 +138,7 @@ async function executeContractRequest(request, facts, port) {
             kind: "served",
             result,
             service: {
-                kind: "audit-report",
+                kind: "delivery-preview-report",
                 repoRoot: request.repoRoot,
                 contractId: request.contractId,
                 report: result.value,
@@ -202,8 +202,8 @@ async function executeContractRequest(request, facts, port) {
     };
 }
 function decodedContractResult(action, value) {
-    const schema = action === "contract.audit"
-        ? outcomeSchema("audit", auditReportSchema)
+    const schema = action === "contract.preview-delivery"
+        ? outcomeSchema("deliver-preview", deliveryPreviewReportSchema)
         : action === "contract.deliver"
             ? outcomeSchema("deliver", deliveryValueSchema, materializedHandoffReferenceSchema)
             : outcomeSchema("review", reviewSchema);
@@ -226,7 +226,7 @@ export function contractRequestProtocol(action) {
         encodeFailure: encodeFailureWire,
         decodeFailure: (value) => decodeFailureWire(value),
         decodeReference: (reference) => decodeContractReference(action, reference),
-        isPermitted: (allowed) => allowed.includes(action),
+        isPermitted: (allowed) => action === "contract.preview-delivery" || allowed.includes(action),
     };
 }
 export function contractRequestCommand(action, port) {
@@ -241,7 +241,7 @@ export function contractRequestCommand(action, port) {
 }
 export function contractRequestCommands(port) {
     return {
-        "contract.audit": eraseRequestCommand(contractRequestCommand("contract.audit", port)),
+        "contract.preview-delivery": eraseRequestCommand(contractRequestCommand("contract.preview-delivery", port)),
         "contract.deliver": eraseRequestCommand(contractRequestCommand("contract.deliver", port)),
         "contract.review": eraseRequestCommand(contractRequestCommand("contract.review", port)),
     };
@@ -271,7 +271,11 @@ export async function requestForwardedContractLive(input) {
 /** Map durable request disposition without reconstructing an expired owner answer. */
 export function mapForwardedContractFailure(error, request) {
     if (error instanceof AkumaBodyRequestError && error.outcome === "voided") {
-        const operation = request.action === "contract.audit" ? "audit" : request.action === "contract.review" ? "review" : "deliver";
+        const operation = request.action === "contract.preview-delivery"
+            ? "deliver-preview"
+            : request.action === "contract.review"
+                ? "review"
+                : "deliver";
         const projected = project(operation, new InvocationAccumulator().snapshot(), {
             kind: "retry",
             contract: request.contractId,

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

@@ -1,6 +1,6 @@
 /** @architectureCompositionRoot */
 import type { ContractId, Gate } from "../core/facts/types.js";
-import type { AuditReport } from "../protocol/audit.js";
+import type { DeliveryPreviewReport } from "../protocol/delivery-preview.js";
 import type { ExecutionObserver } from "../protocol/execution-observation.js";
 import type { IntentOutcome, IntentRetry } from "../protocol/operations.js";
 import type { ContractWorkspaceLocation } from "../workspace-place.js";
@@ -26,13 +26,13 @@ export type BindOutcome = OperationOutcome<"bind", BindValue, OperationRefusals[
 export type AmendOutcome = OperationOutcome<"amend", AmendValue, OperationRefusals["amend"]>;
 export type DeliverOutcome = OperationOutcome<"deliver", Delivery & DeliveryValue, OperationRefusals["deliver"]> | HandoffOutcome;
 export type ReviewOutcome = OperationOutcome<"review", Review, OperationRefusals["review"]>;
-export type AuditOutcome = OperationOutcome<"audit", AuditReport, OperationRefusals["audit"]>;
+export type DeliveryPreviewOutcome = OperationOutcome<"deliver-preview", DeliveryPreviewReport, OperationRefusals["deliver-preview"]>;
 export type ArcOutcome = OperationOutcome<"arc", void, OperationRefusals["arc"]>;
 export type AbandonOutcome = OperationOutcome<"abandon", void, OperationRefusals["abandon"]>;
 export type MutationObservation = Readonly<{
     observe?: ExecutionObserver;
 }>;
-export type AuditInput = Readonly<{
+export type DeliveryPreviewInput = Readonly<{
     includeDirty?: boolean;
     showDiff?: boolean;
     signal?: AbortSignal;

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

@@ -14,6 +14,7 @@ export type LocalContractCompositionCapture = Readonly<{
  * built-in gate words; a broken selected namespace fails before any admission.
  */
 export declare function derivedHooks(composition: LocalContractCompositionCapture): WorktreeHooks;
+export declare function derivedFreshness(composition: LocalContractCompositionCapture): boolean;
 /** The two Settings-derived Contract policies one mutating operation may consume. */
 export declare function derivedContractPolicy(composition: LocalContractCompositionCapture): Readonly<{
     hooks: WorktreeHooks;

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

@@ -25,7 +25,7 @@ export function derivedHooks(composition) {
         return settingsScopedFailure(error);
     }
 }
-function derivedFreshness(composition) {
+export function derivedFreshness(composition) {
     if (composition.settings === undefined)
         return false;
     try {

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

@@ -1,6 +1,6 @@
 import type { ContractHead, ContractId, JournalEntry } from "../core/facts/types.js";
 import type { ReconcileResult } from "../git/reconcile.js";
-import type { AuditReport } from "../protocol/audit.js";
+import type { DeliveryPreviewReport } from "../protocol/delivery-preview.js";
 import type { CandidateCompletion, CompletionEvidence } from "../protocol/completion.js";
 import { type ExecutionObservation, type ExecutionObserver } from "../protocol/execution-observation.js";
 import type { AcceptedProtocolStep } from "../protocol/outcome.js";
@@ -60,7 +60,7 @@ export declare class InvocationAccumulator implements ProtocolProgress {
     recordCandidate(contract: ContractId, evidence: CompletionEvidence): void;
     /** The candidate's completion base, known before an optional observation can fail. */
     recordCompletion(contract: ContractId, completion: CandidateCompletion): void;
-    recordAudit(contract: ContractId, report: Partial<AuditReport>): void;
+    recordDeliveryPreview(contract: ContractId, report: Partial<DeliveryPreviewReport>): void;
     /** Physical residue a continuation's dependent reconciliation observed. */
     recordPhysical(contract: ContractId, physical: ReconcileResult): void;
     recordPlacementPhysical(contract: ContractId, physical: ReconcileResult): void;

package/build/src/library/invocation.js

@@ -129,7 +129,7 @@ export class InvocationAccumulator {
     recordCompletion(contract, completion) {
         this.extendConclusions(contract, { completion });
     }
-    recordAudit(contract, report) {
+    recordDeliveryPreview(contract, report) {
         this.extendConclusions(contract, report);
     }
     /** Physical residue a continuation's dependent reconciliation observed. */

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

@@ -3,7 +3,7 @@ import { type ExecutionContext } from "../akuma/requests.js";
 import type { ContractId, ContractState } from "../core/facts/types.js";
 import { type RepositoryScope } from "../protocol/operations.js";
 import { type KeiyakuLibrary } from "./contract-composition.js";
-import type { AbandonOutcome, AmendOutcome, ArcOutcome, AuditInput, AuditOutcome, DeliverOutcome, MutationObservation, ReviewOutcome } from "./contract-outcomes.js";
+import type { AbandonOutcome, AmendOutcome, ArcOutcome, DeliveryPreviewInput, DeliveryPreviewOutcome, DeliverOutcome, MutationObservation, ReviewOutcome } from "./contract-outcomes.js";
 import type { LocalContractCompositionCapture } from "./contract-settings.js";
 import type { AbandonInput, AmendInput, ArcInput, ContractHistory, DeliverInput, LocalContractComposition, ReviewInput } from "./contract-types.js";
 import { type Delivery } from "./delivery.js";
@@ -31,7 +31,7 @@ export declare class Keiyaku {
     review(input: ReviewInput, options?: MutationObservation): Promise<ReviewOutcome>;
     abandon(input?: AbandonInput): Promise<AbandonOutcome>;
     arc(input: ArcInput): Promise<ArcOutcome>;
-    audit(input?: AuditInput, options?: MutationObservation): Promise<AuditOutcome>;
+    previewDelivery(input?: DeliveryPreviewInput, options?: MutationObservation): Promise<DeliveryPreviewOutcome>;
 }
 /** Internal constructor capability; callers select a Contract through Keiyaku.with. */
 export declare function createKeiyakuHandle(id: ContractId, scope: RepositoryScope, execution: ExecutionContext, composition: LocalContractCompositionCapture): Keiyaku;

package/build/src/library/keiyaku.js

@@ -112,8 +112,8 @@ export class Keiyaku {
     async arc(input) {
         return await this.operations.arc(input);
     }
-    async audit(input, options) {
-        return await this.operations.audit(input, options);
+    async previewDelivery(input, options) {
+        return await this.operations.previewDelivery(input, options);
     }
 }
 /** Internal constructor capability; callers select a Contract through Keiyaku.with. */