@astrosheep/keiyaku 4.5.12 → 4.5.13

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

@@ -1,4 +1,5 @@
 import { type ContractHead, type ContractId, type JournalEntry, type SnapshotId } from "../core/facts/types.js";
+import { type PrivateStateSeatCloseLag } from "../git/private-state-seat.js";
 import type { GitDecodeChannel } from "../git/read-observation.js";
 import type { ReconcileReport } from "../protocol/reconcile.js";
 import type { RepositoryScope } from "../protocol/operations.js";
@@ -8,9 +9,11 @@ import type { SettlementReport } from "../settlement/settle.js";
 import type { TaskHolderAdmission } from "../settlement/holder.js";
 import type { WorktreeHooks } from "./configuration.js";
 import { type ReconcileCompletion } from "./reconcile.js";
-import type { AuditReport } from "../protocol/audit.js";
-import type { IntegrationConflictMaterialized } from "../protocol/deliver.js";
-import type { ContinuationReport } from "./continuation.js";
+import { type AuditReport } from "../protocol/audit.js";
+import { type IntegrationConflictMaterialized } from "../protocol/deliver.js";
+import { type ReviewValue } from "../protocol/review.js";
+import { type ContinuationReport } from "./continuation.js";
+import { type DeliveryValue } from "./delivery.js";
 import type { KeiyakuRefused, KeiyakuRetry } from "./refusal.js";
 import { z } from "zod";
 export type MutationFinalitySurface = "verification" | "placement" | "continuation" | "reconciliation" | "settlement" | "cleanup";
@@ -49,7 +52,361 @@ export declare const mutationPendingSurfaceSchema: z.ZodType<Readonly<{
     surface: MutationFinalitySurface;
     required: boolean;
 }>, unknown>>;
+export type Review = ReviewValue & Readonly<{
+    continuation?: ContinuationReport;
+}>;
+export declare function decodeReview(value: unknown): Review;
+export declare const auditReportSchema: z.ZodType<Readonly<{
+    candidate: Readonly<{
+        kind: "blocked";
+        refusal: import("../protocol/operations.js").DeliveryPreparationRefusal;
+    }> | Readonly<{
+        kind: "ready";
+        workspace: Readonly<{
+            kind: "worktree";
+            path: string;
+        }>;
+        identity: import("../core/facts/types.js").DeliverData;
+        scope: Readonly<{
+            filesChanged: number;
+            insertions: number;
+            deletions: number;
+            paths?: readonly string[];
+        }>;
+        diff?: string;
+    }>;
+    verification: Readonly<{
+        kind: "not-run";
+    }> | Readonly<{
+        kind: "satisfied";
+        passed: number;
+        total: number;
+        summary?: string;
+    }> | Readonly<{
+        kind: "unsatisfied";
+        passed: number;
+        total: number;
+        summary?: string;
+    }> | Readonly<{
+        kind: "stopped";
+        stop: import("../protocol/operations.js").VerificationStop;
+    }>;
+    target: Readonly<{
+        kind: "not-observed";
+    }> | import("../git/target-placement.js").AuditTargetAnswer;
+    delivery?: Readonly<{
+        changeId: import("../core/facts/types.js").ChangeId;
+        relation: "identical" | "differs";
+    }>;
+}>, unknown, z.core.$ZodTypeInternals<Readonly<{
+    candidate: Readonly<{
+        kind: "blocked";
+        refusal: import("../protocol/operations.js").DeliveryPreparationRefusal;
+    }> | Readonly<{
+        kind: "ready";
+        workspace: Readonly<{
+            kind: "worktree";
+            path: string;
+        }>;
+        identity: import("../core/facts/types.js").DeliverData;
+        scope: Readonly<{
+            filesChanged: number;
+            insertions: number;
+            deletions: number;
+            paths?: readonly string[];
+        }>;
+        diff?: string;
+    }>;
+    verification: Readonly<{
+        kind: "not-run";
+    }> | Readonly<{
+        kind: "satisfied";
+        passed: number;
+        total: number;
+        summary?: string;
+    }> | Readonly<{
+        kind: "unsatisfied";
+        passed: number;
+        total: number;
+        summary?: string;
+    }> | Readonly<{
+        kind: "stopped";
+        stop: import("../protocol/operations.js").VerificationStop;
+    }>;
+    target: Readonly<{
+        kind: "not-observed";
+    }> | import("../git/target-placement.js").AuditTargetAnswer;
+    delivery?: Readonly<{
+        changeId: import("../core/facts/types.js").ChangeId;
+        relation: "identical" | "differs";
+    }>;
+}>, unknown>>;
 export declare const mutationResultSchema: <Value>(value: z.ZodType<Value>) => z.ZodType<MutationResult<Value>>;
+export declare const deliveryResultSchema: z.ZodUnion<readonly [z.ZodType<Readonly<{
+    kind: "accepted";
+    facts: readonly JournalEntry[];
+    head: ContractHead;
+    value: DeliveryValue;
+    lags: readonly (import("../git/reconcile.js").ReconcileLag | Readonly<{
+        kind: "contract-file-failed";
+        worktree: string;
+        path: string;
+        diagnostic: string;
+    }>)[];
+    settlementLags: readonly Readonly<{
+        kind: "settlement-failed";
+        surface: "task-holder" | "task";
+        contractId: ContractId;
+        taskId?: import("./contract.js").TaskId;
+        path?: string;
+        diagnostic: string;
+    }>[];
+    recoverySnapshot?: SnapshotId;
+    pending: readonly Readonly<{
+        surface: MutationFinalitySurface;
+        required: boolean;
+    }>[];
+} & Readonly<{
+    cleanup?: import("../protocol/intent.js").VerificationCleanupFailure;
+    leak?: import("../git/scratch.js").WorktreeLeak;
+    seatClose?: readonly PrivateStateSeatCloseLag[];
+}>>, unknown, z.core.$ZodTypeInternals<Readonly<{
+    kind: "accepted";
+    facts: readonly JournalEntry[];
+    head: ContractHead;
+    value: DeliveryValue;
+    lags: readonly (import("../git/reconcile.js").ReconcileLag | Readonly<{
+        kind: "contract-file-failed";
+        worktree: string;
+        path: string;
+        diagnostic: string;
+    }>)[];
+    settlementLags: readonly Readonly<{
+        kind: "settlement-failed";
+        surface: "task-holder" | "task";
+        contractId: ContractId;
+        taskId?: import("./contract.js").TaskId;
+        path?: string;
+        diagnostic: string;
+    }>[];
+    recoverySnapshot?: SnapshotId;
+    pending: readonly Readonly<{
+        surface: MutationFinalitySurface;
+        required: boolean;
+    }>[];
+} & Readonly<{
+    cleanup?: import("../protocol/intent.js").VerificationCleanupFailure;
+    leak?: import("../git/scratch.js").WorktreeLeak;
+    seatClose?: readonly PrivateStateSeatCloseLag[];
+}>>, unknown>>, z.ZodType<Readonly<{
+    kind: "integration-conflict-materialized";
+    targetHead: SnapshotId;
+    conflictPaths: readonly string[];
+    workspace: import("../protocol/deliver.js").AppointedWorkspace;
+}>, unknown, z.core.$ZodTypeInternals<Readonly<{
+    kind: "integration-conflict-materialized";
+    targetHead: SnapshotId;
+    conflictPaths: readonly string[];
+    workspace: import("../protocol/deliver.js").AppointedWorkspace;
+}>, unknown>>]>;
+export declare const reviewResultSchema: z.ZodType<Readonly<{
+    kind: "accepted";
+    facts: readonly JournalEntry[];
+    head: ContractHead;
+    value: Review;
+    lags: readonly (import("../git/reconcile.js").ReconcileLag | Readonly<{
+        kind: "contract-file-failed";
+        worktree: string;
+        path: string;
+        diagnostic: string;
+    }>)[];
+    settlementLags: readonly Readonly<{
+        kind: "settlement-failed";
+        surface: "task-holder" | "task";
+        contractId: ContractId;
+        taskId?: import("./contract.js").TaskId;
+        path?: string;
+        diagnostic: string;
+    }>[];
+    recoverySnapshot?: SnapshotId;
+    pending: readonly Readonly<{
+        surface: MutationFinalitySurface;
+        required: boolean;
+    }>[];
+} & Readonly<{
+    cleanup?: import("../protocol/intent.js").VerificationCleanupFailure;
+    leak?: import("../git/scratch.js").WorktreeLeak;
+    seatClose?: readonly PrivateStateSeatCloseLag[];
+}>>, unknown, z.core.$ZodTypeInternals<Readonly<{
+    kind: "accepted";
+    facts: readonly JournalEntry[];
+    head: ContractHead;
+    value: Review;
+    lags: readonly (import("../git/reconcile.js").ReconcileLag | Readonly<{
+        kind: "contract-file-failed";
+        worktree: string;
+        path: string;
+        diagnostic: string;
+    }>)[];
+    settlementLags: readonly Readonly<{
+        kind: "settlement-failed";
+        surface: "task-holder" | "task";
+        contractId: ContractId;
+        taskId?: import("./contract.js").TaskId;
+        path?: string;
+        diagnostic: string;
+    }>[];
+    recoverySnapshot?: SnapshotId;
+    pending: readonly Readonly<{
+        surface: MutationFinalitySurface;
+        required: boolean;
+    }>[];
+} & Readonly<{
+    cleanup?: import("../protocol/intent.js").VerificationCleanupFailure;
+    leak?: import("../git/scratch.js").WorktreeLeak;
+    seatClose?: readonly PrivateStateSeatCloseLag[];
+}>>, unknown>>;
+export declare const auditResultSchema: z.ZodType<Readonly<{
+    kind: "accepted";
+    facts: readonly JournalEntry[];
+    head: ContractHead;
+    value: Readonly<{
+        candidate: Readonly<{
+            kind: "blocked";
+            refusal: import("../protocol/operations.js").DeliveryPreparationRefusal;
+        }> | Readonly<{
+            kind: "ready";
+            workspace: Readonly<{
+                kind: "worktree";
+                path: string;
+            }>;
+            identity: import("../core/facts/types.js").DeliverData;
+            scope: Readonly<{
+                filesChanged: number;
+                insertions: number;
+                deletions: number;
+                paths?: readonly string[];
+            }>;
+            diff?: string;
+        }>;
+        verification: Readonly<{
+            kind: "not-run";
+        }> | Readonly<{
+            kind: "satisfied";
+            passed: number;
+            total: number;
+            summary?: string;
+        }> | Readonly<{
+            kind: "unsatisfied";
+            passed: number;
+            total: number;
+            summary?: string;
+        }> | Readonly<{
+            kind: "stopped";
+            stop: import("../protocol/operations.js").VerificationStop;
+        }>;
+        target: Readonly<{
+            kind: "not-observed";
+        }> | import("../git/target-placement.js").AuditTargetAnswer;
+        delivery?: Readonly<{
+            changeId: import("../core/facts/types.js").ChangeId;
+            relation: "identical" | "differs";
+        }>;
+    }>;
+    lags: readonly (import("../git/reconcile.js").ReconcileLag | Readonly<{
+        kind: "contract-file-failed";
+        worktree: string;
+        path: string;
+        diagnostic: string;
+    }>)[];
+    settlementLags: readonly Readonly<{
+        kind: "settlement-failed";
+        surface: "task-holder" | "task";
+        contractId: ContractId;
+        taskId?: import("./contract.js").TaskId;
+        path?: string;
+        diagnostic: string;
+    }>[];
+    recoverySnapshot?: SnapshotId;
+    pending: readonly Readonly<{
+        surface: MutationFinalitySurface;
+        required: boolean;
+    }>[];
+} & Readonly<{
+    cleanup?: import("../protocol/intent.js").VerificationCleanupFailure;
+    leak?: import("../git/scratch.js").WorktreeLeak;
+    seatClose?: readonly PrivateStateSeatCloseLag[];
+}>>, unknown, z.core.$ZodTypeInternals<Readonly<{
+    kind: "accepted";
+    facts: readonly JournalEntry[];
+    head: ContractHead;
+    value: Readonly<{
+        candidate: Readonly<{
+            kind: "blocked";
+            refusal: import("../protocol/operations.js").DeliveryPreparationRefusal;
+        }> | Readonly<{
+            kind: "ready";
+            workspace: Readonly<{
+                kind: "worktree";
+                path: string;
+            }>;
+            identity: import("../core/facts/types.js").DeliverData;
+            scope: Readonly<{
+                filesChanged: number;
+                insertions: number;
+                deletions: number;
+                paths?: readonly string[];
+            }>;
+            diff?: string;
+        }>;
+        verification: Readonly<{
+            kind: "not-run";
+        }> | Readonly<{
+            kind: "satisfied";
+            passed: number;
+            total: number;
+            summary?: string;
+        }> | Readonly<{
+            kind: "unsatisfied";
+            passed: number;
+            total: number;
+            summary?: string;
+        }> | Readonly<{
+            kind: "stopped";
+            stop: import("../protocol/operations.js").VerificationStop;
+        }>;
+        target: Readonly<{
+            kind: "not-observed";
+        }> | import("../git/target-placement.js").AuditTargetAnswer;
+        delivery?: Readonly<{
+            changeId: import("../core/facts/types.js").ChangeId;
+            relation: "identical" | "differs";
+        }>;
+    }>;
+    lags: readonly (import("../git/reconcile.js").ReconcileLag | Readonly<{
+        kind: "contract-file-failed";
+        worktree: string;
+        path: string;
+        diagnostic: string;
+    }>)[];
+    settlementLags: readonly Readonly<{
+        kind: "settlement-failed";
+        surface: "task-holder" | "task";
+        contractId: ContractId;
+        taskId?: import("./contract.js").TaskId;
+        path?: string;
+        diagnostic: string;
+    }>[];
+    recoverySnapshot?: SnapshotId;
+    pending: readonly Readonly<{
+        surface: MutationFinalitySurface;
+        required: boolean;
+    }>[];
+} & Readonly<{
+    cleanup?: import("../protocol/intent.js").VerificationCleanupFailure;
+    leak?: import("../git/scratch.js").WorktreeLeak;
+    seatClose?: readonly PrivateStateSeatCloseLag[];
+}>>, unknown>>;
 type ObligationPendingInput = Readonly<{
     lags: MutationResult<unknown>["lags"];
     settlementLags: MutationResult<unknown>["settlementLags"];

package/build/src/library/mutation.js

@@ -5,7 +5,13 @@ import { concatenatePrivateStateSeatClose } from "../git/private-state-seat.js";
 import { decodeVerificationCleanupFailure } from "../protocol/result-codec.js";
 import { decodeSettlementLag } from "../settlement/result-codec.js";
 import { completeReconcile, decodeReconciliationLag } from "./reconcile.js";
+import { decodeAuditReport } from "../protocol/audit.js";
+import { decodeMaterializedConflict } from "../protocol/deliver.js";
+import { decodeReviewValue } from "../protocol/review.js";
+import { decodeContinuationReport } from "./continuation.js";
+import { deliveryValueSchema } from "./delivery.js";
 import { ownerSchema } from "./result-codec.js";
+import { z } from "zod";
 function pendingSurface(surface, required) {
     return { surface, required };
 }
@@ -27,6 +33,16 @@ export function decodeMutationPendingSurface(value) {
     return { surface: object.surface, required: object.required };
 }
 export const mutationPendingSurfaceSchema = ownerSchema(decodeMutationPendingSurface, "expected pending surface");
+export function decodeReview(value) {
+    if (value === null || typeof value !== "object" || Array.isArray(value))
+        throw new Error("malformed review");
+    const { continuation, ...protocol } = value;
+    const review = decodeReviewValue(protocol);
+    return continuation === undefined ? review : { ...review, continuation: decodeContinuationReport(continuation) };
+}
+export const auditReportSchema = ownerSchema(decodeAuditReport, "expected audit report");
+const reviewSchema = ownerSchema(decodeReview, "expected review");
+const materializedConflictSchema = ownerSchema(decodeMaterializedConflict, "expected materialized conflict");
 export const mutationResultSchema = (value) => ownerSchema((input) => {
     if (input === null || typeof input !== "object" || Array.isArray(input))
         throw new Error("malformed mutation result");
@@ -83,6 +99,12 @@ export const mutationResultSchema = (value) => ownerSchema((input) => {
             }),
     };
 }, "expected mutation result");
+export const deliveryResultSchema = z.union([
+    mutationResultSchema(deliveryValueSchema),
+    materializedConflictSchema,
+]);
+export const reviewResultSchema = mutationResultSchema(reviewSchema);
+export const auditResultSchema = mutationResultSchema(auditReportSchema);
 export function noValuePending(_value) {
     return [];
 }

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

@@ -32,4 +32,6 @@ export declare class KeiyakuRetry extends Error {
     constructor(reason: KeiyakuRetryReason);
     get code(): KeiyakuRetryReason["kind"];
 }
+export declare function encodeContractLiveFailure(error: unknown): unknown | null;
+export declare function decodeContractLiveFailure(value: unknown): Error | null;
 export declare function requireAccepted<Value, Refusal extends KeiyakuRefusal>(result: IntentOutcome<Value, Refusal>): AcceptedIntent<Value>;

package/build/src/library/refusal.js

@@ -1,6 +1,7 @@
 import { contractId } from "../core/facts/types.js";
 import { decodeIntentRefusal, decodeProtocolTerminal } from "../protocol/result-codec.js";
 import { ownerSchema } from "./result-codec.js";
+import { z } from "zod";
 function decodeForkSourceRefusal(value) {
     if (value === null || typeof value !== "object" || Array.isArray(value))
         throw new Error("malformed fork-source refusal");
@@ -74,6 +75,27 @@ export class KeiyakuRetry extends Error {
         return this.reason.kind;
     }
 }
+const contractLiveFailureSchema = z.union([
+    z.object({ kind: z.literal("refused"), refusal: keiyakuRefusalSchema }).strict(),
+    z.object({ kind: z.literal("retry"), reason: keiyakuRetryReasonSchema }).strict(),
+]);
+export function encodeContractLiveFailure(error) {
+    if (error instanceof KeiyakuRefused) {
+        return { kind: "refused", refusal: error.refusal };
+    }
+    if (error instanceof KeiyakuRetry) {
+        return { kind: "retry", reason: error.reason };
+    }
+    return null;
+}
+export function decodeContractLiveFailure(value) {
+    const parsed = contractLiveFailureSchema.safeParse(value);
+    if (!parsed.success)
+        return null;
+    return parsed.data.kind === "refused"
+        ? new KeiyakuRefused(decodeKeiyakuRefusal(parsed.data.refusal))
+        : new KeiyakuRetry(parsed.data.reason);
+}
 export function requireAccepted(result) {
     if (result.kind === "refused")
         throw new KeiyakuRefused(result.refusal);

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

@@ -1,7 +1,6 @@
 import type { ContractId } from "../core/facts/types.js";
 import { type GitDecodeChannel } from "../git/read-observation.js";
 import { type RepositoryScope } from "../protocol/operations.js";
-import type { ContractDocumentProjection } from "../protocol/read/documents.js";
 export type RegionOverlap = Readonly<{
     contract: ContractId;
     patterns: readonly Readonly<{
@@ -20,12 +19,5 @@ export type AmendRegionObservation = RegionObservation | Readonly<{
     overlaps?: never;
     overlapFailure?: never;
 }>;
-export type RegionDeclarationRead = Readonly<{
-    contract: ContractId;
-    patterns: readonly string[];
-}>;
-export declare function readRegionDeclarations(documents: readonly ContractDocumentProjection[]): readonly RegionDeclarationRead[];
-export declare function regionOverlaps(mine: readonly string[], declarations: readonly RegionDeclarationRead[]): readonly RegionOverlap[];
-export declare function validateRegionPatterns(patterns: unknown): readonly [string, ...string[]];
 export declare function observeRegion(scope: RepositoryScope, channel: GitDecodeChannel, self: ContractId, mine: readonly string[]): Promise<RegionObservation>;
 export declare function observeChangedRegion(scope: RepositoryScope, self: ContractId, changed: ReadonlySet<string> | undefined, mine: readonly string[]): Promise<AmendRegionObservation>;

package/build/src/library/region.js

@@ -1,35 +1,7 @@
 import { decodeContractDocument } from "../body/decode.js";
-import { assertRegionPattern, regionsOverlap } from "../body/region.js";
+import { regionsOverlap } from "../body/region.js";
 import { withGitDecodeChannel } from "../git/read-observation.js";
 import { documentsOperationAt } from "../protocol/operations.js";
-export function readRegionDeclarations(documents) {
-    return documents.map((document) => ({
-        contract: document.contract,
-        patterns: decodeContractDocument(document.documentBytes).region,
-    }));
-}
-export function regionOverlaps(mine, declarations) {
-    const overlaps = [];
-    for (const declaration of declarations) {
-        const pairs = regionsOverlap(mine, declaration.patterns);
-        if (pairs.length === 0)
-            continue;
-        overlaps.push({
-            contract: declaration.contract,
-            patterns: pairs.map(([minePattern, theirsPattern]) => ({ mine: minePattern, theirs: theirsPattern })),
-        });
-    }
-    return overlaps;
-}
-export function validateRegionPatterns(patterns) {
-    if (!Array.isArray(patterns) || patterns.length === 0)
-        throw new Error("Region query requires one or more path patterns");
-    return patterns.map((pattern) => {
-        if (typeof pattern !== "string")
-            throw new Error("Region path patterns must be strings");
-        return assertRegionPattern(pattern);
-    });
-}
 function diagnostic(error) {
     return error instanceof Error ? error.message : String(error);
 }

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

@@ -2,6 +2,7 @@ import { type DeliveryDiffScope } from "../git/integration.js";
 import type { ChangeId, ContractState, DeliverData } from "../core/facts/types.js";
 import { type AuditTargetAnswer } from "../git/target-placement.js";
 import type { DeliveryPreparationRefusal, DocumentDerivation, IntentOutcome, MutationOperationInput, VerificationStop } from "./operations.js";
+export { decodeAuditReport } from "./result-codec.js";
 type AuditWorkspace = Readonly<{
     kind: "worktree";
     path: string;
@@ -50,4 +51,3 @@ type AuditOperationInput = MutationOperationInput & Readonly<{
     signal?: AbortSignal;
 }>;
 export declare function auditOperation(input: AuditOperationInput): Promise<IntentOutcome<AuditReport>>;
-export {};

package/build/src/protocol/audit.js

@@ -7,6 +7,7 @@ import { verifyDelivery } from "./intent.js";
 import { accepted, admitted } from "./outcome.js";
 import { prepareDelivery } from "./deliver.js";
 import { timestamp, unpackVerificationOutcome } from "./operations.js";
+export { decodeAuditReport } from "./result-codec.js";
 async function auditWorkspace(repository, state) {
     const appointed = await readManagedWorktreeAppointment(repository, state.id);
     if (appointed.kind === "failed")

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

@@ -16,6 +16,7 @@ export type IntegrationConflictMaterialized = Readonly<{
     conflictPaths: readonly string[];
     workspace: AppointedWorkspace;
 }>;
+export { decodeMaterializedConflict } from "./result-codec.js";
 type DeliverOperationInput = MutationOperationInput & Readonly<{
     deriveDocument: (state: ContractState) => DocumentDerivation;
     message?: string;
@@ -54,4 +55,3 @@ export declare function continueDeliveryOperation(input: Readonly<{
     signal?: AbortSignal;
 }>): Promise<CompletionResult>;
 export declare function deliverOperation(input: DeliverOperationInput): Promise<IntentOutcome<DeliverValue> | IntegrationConflictMaterialized>;
-export {};

package/build/src/protocol/deliver.js

@@ -10,6 +10,7 @@ import { admitted } from "./outcome.js";
 import { completeCandidate } from "./completion.js";
 import { appointmentFor, readPlaceRegister } from "../workspace-place.js";
 import { attemptDecisionWithSeatClose, timestamp } from "./operations.js";
+export { decodeMaterializedConflict } from "./result-codec.js";
 const DELIVER_CONFLICT_RECOVERY = Object.freeze({
     materialize: "deliver --materialize-conflict --include-dirty",
     continue: "deliver --include-dirty",

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

@@ -16,6 +16,7 @@ type ReviewOperationInput = MutationOperationInput & Readonly<{
 export type ReviewValue = CompletionEvidence & Readonly<{
     workspace?: WorkspaceDirtyDelta;
 }>;
+export { decodeReviewValue } from "./result-codec.js";
 export declare function prepareReview(repository: RepositoryScope, stage: Readonly<{
     contractId: import("../core/facts/types.js").ContractId;
     coordinates: ContractState["coordinates"];
@@ -30,4 +31,3 @@ export declare function prepareReview(repository: RepositoryScope, stage: Readon
     refusal: ReviewPreparationRefusal;
 }>;
 export declare function reviewOperation(input: ReviewOperationInput): Promise<IntentOutcome<ReviewValue, ReviewRefusal>>;
-export {};

package/build/src/protocol/review.js

@@ -12,6 +12,7 @@ import { completeCandidate } from "./completion.js";
 import { appointmentFor, readPlaceRegister } from "../workspace-place.js";
 import { attemptDecisionWithSeatClose, timestamp } from "./operations.js";
 const REVIEWED = gate("reviewed");
+export { decodeReviewValue } from "./result-codec.js";
 async function captureReviewableWorktree(repository, stage) {
     const appointed = stage.coordinates.workspace === "worktree"
         ? appointmentFor(await readPlaceRegister(repository), stage.contractId)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@astrosheep/keiyaku",
-  "version": "4.5.12",
+  "version": "4.5.13",
   "workspaces": [
     "plugins/*"
   ],
@@ -77,7 +77,7 @@
   "dependencies": {
     "@agentclientprotocol/sdk": "^1.3.0",
     "@anthropic-ai/claude-agent-sdk": "^0.3.226",
-    "@astrosheep/keiyaku-plugin-square": "0.1.0",
+    "@astrosheep/keiyaku-plugin-square": "0.1.1",
     "@earendil-works/pi-coding-agent": "0.80.10",
     "@opencode-ai/sdk": "1.18.3",
     "cross-spawn": "^7.0.6",