@astrosheep/keiyaku 4.5.11 → 4.5.13

package/build/src/protocol/deliver.js

@@ -1,20 +1,21 @@
 import { materializeIntegrationSnapshot, materializeJudgedConflict, planIntegration, worktreeChangeId, } from "../git/integration.js";
 import { captureTender, dirtyTenderRefusal, materializeTenderSnapshot, prepareDeliveryCommitMetadata, } from "../git/tender.js";
-import { recordConflictHandoff, retireConflictHandoff, workspaceMergeStatePresent, worktreePath, } from "../git/workspace.js";
+import { checkoutDetachedSnapshot, recordConflictHandoff, retireConflictHandoff, workspaceMergeStatePresent, worktreePath, } from "../git/workspace.js";
 import { observeContractsForAdmissionAt } from "../git/observe.js";
-import { withPrivateStatePublicationSeat } from "../git/private-state-seat.js";
+import { matchingPrivateRootObservation, privateStateSeatAttempt, sameSpeculativeWorktreeInput, } from "./run.js";
 import { contractState } from "../core/facts/observation.js";
 import { decideDeliver } from "../core/verbs/deliver.js";
 import { admitDecidedOffer, mintAttempts } from "./attempt.js";
 import { admitted } from "./outcome.js";
 import { completeCandidate } from "./completion.js";
 import { appointmentFor, readPlaceRegister } from "../workspace-place.js";
-import { timestamp } from "./operations.js";
+import { attemptDecisionWithSeatClose, timestamp } from "./operations.js";
+export { decodeMaterializedConflict } from "./result-codec.js";
 const DELIVER_CONFLICT_RECOVERY = Object.freeze({
-    materialize: "deliver --materialize-conflict",
+    materialize: "deliver --materialize-conflict --include-dirty",
     continue: "deliver --include-dirty",
 });
-export async function prepareDelivery(repository, stage, input) {
+async function captureAuthorizedDeliveryTender(repository, stage, includeDirty) {
     const { contractId, coordinates } = stage;
     const appointed = coordinates.workspace === "worktree"
         ? stage.appointment === undefined
@@ -29,10 +30,17 @@ export async function prepareDelivery(repository, stage, input) {
     });
     if (tender.kind === "refused")
         return tender;
-    if (((tender.data.dirty || tender.data.mergeHead !== undefined) && input.includeDirty !== true) ||
+    if (((tender.data.dirty || tender.data.mergeHead !== undefined) && includeDirty !== true) ||
         tender.data.changes.submodules.length > 0) {
         return { kind: "refused", refusal: await dirtyTenderRefusal(repository, contractId, tender.data) };
     }
+    return { kind: "prepared", data: tender.data };
+}
+async function prepareDeliveryWithWorktree(repository, stage, input) {
+    const { contractId, coordinates } = stage;
+    const tender = await captureAuthorizedDeliveryTender(repository, stage, input.includeDirty);
+    if (tender.kind === "refused")
+        return tender;
     const commit = await prepareDeliveryCommitMetadata(repository, {
         contractId,
         title: input.title,
@@ -46,6 +54,7 @@ export async function prepareDelivery(repository, stage, input) {
     const integration = await planIntegration(repository, { contractId, coordinates }, { ...tender.data, head: tenderSnapshot }, requireBranchesToBeUpToDate);
     if (integration.kind === "refused")
         return integration;
+    const changeId = await worktreeChangeId(repository, { contractId, coordinates }, tender.data);
     const integrationSnapshot = coordinates.target === undefined
         ? tenderSnapshot
         : await materializeIntegrationSnapshot(repository, integration.data.tree, integration.data.predecessor, commit);
@@ -56,53 +65,96 @@ export async function prepareDelivery(repository, stage, input) {
             integration: {
                 predecessor: integration.data.predecessor,
                 snapshot: integrationSnapshot,
-                changeId: await worktreeChangeId(repository, { contractId, coordinates }, tender.data),
+                changeId,
             },
             method: "squash",
             policy: { requireBranchesToBeUpToDate },
         },
+        worktree: {
+            tree: tender.data.tree,
+            head: tender.data.head,
+            ...(tender.data.mergeHead === undefined ? {} : { mergeHead: tender.data.mergeHead }),
+            dirty: tender.data.dirty,
+            changeId,
+        },
     };
 }
-async function deliverAttempt(input, attempt) {
-    return await withPrivateStatePublicationSeat(input.scope, async (seat) => await deliverAttemptInPrivateStateSeat(input, attempt, seat));
+export async function prepareDelivery(repository, stage, input) {
+    const prepared = await prepareDeliveryWithWorktree(repository, stage, input);
+    return prepared.kind === "refused" ? prepared : { kind: "prepared", data: prepared.data };
+}
+function deliveryPreparationInput(input, derivation) {
+    return {
+        title: derivation.title,
+        document: derivation.bytes,
+        ...(input.actor === undefined ? {} : { actor: input.actor }),
+        ...(input.message === undefined ? {} : { message: input.message }),
+        requireBranchesToBeUpToDate: input.requireBranchesToBeUpToDate,
+        includeDirty: input.includeDirty,
+    };
+}
+async function recaptureDeliveryWorktree(input, state) {
+    const tender = await captureAuthorizedDeliveryTender(input.scope, { contractId: state.id, coordinates: state.coordinates }, input.includeDirty);
+    if (tender.kind === "refused")
+        return undefined;
+    return {
+        tree: tender.data.tree,
+        head: tender.data.head,
+        ...(tender.data.mergeHead === undefined ? {} : { mergeHead: tender.data.mergeHead }),
+        dirty: tender.data.dirty,
+        changeId: await worktreeChangeId(input.scope, { contractId: state.id, coordinates: state.coordinates }, tender.data),
+    };
+}
+async function mechanicalDeliveryPreparation(input, state, derivation) {
+    const prepared = await prepareDeliveryWithWorktree(input.scope, { contractId: state.id, coordinates: state.coordinates }, deliveryPreparationInput(input, derivation));
+    if (prepared.kind === "refused") {
+        return { kind: "refused", document: derivation.document, refusal: prepared.refusal };
+    }
+    return {
+        kind: "prepared",
+        document: derivation.document,
+        data: prepared.data,
+        worktree: prepared.worktree,
+    };
 }
-async function deliverAttemptInPrivateStateSeat(input, attempt, seat) {
-    const decisionObservation = await observeContractsForAdmissionAt(input.scope, input.channel, [input.contractId]);
-    const state = contractState(decisionObservation.decision, input.contractId);
+async function speculateDelivery(input) {
+    const observation = await observeContractsForAdmissionAt(input.scope, input.channel, [input.contractId]);
+    const state = contractState(observation.decision, input.contractId);
     const derivation = state === null ? undefined : input.deriveDocument(state);
-    let preparation;
     if (state === null || derivation === undefined) {
-        preparation = { kind: "unavailable" };
+        return { observation, state, preparation: { kind: "unavailable" } };
     }
-    else if (derivation.verification.kind === "refused") {
-        preparation = { kind: "refused", document: derivation.document, refusal: derivation.verification.refusal };
+    if (derivation.verification.kind === "refused") {
+        return {
+            observation,
+            state,
+            derivation,
+            preparation: { kind: "refused", document: derivation.document, refusal: derivation.verification.refusal },
+        };
     }
-    else {
-        const materialization = input.materializeConflict === true && state.terminal === null
-            ? await materializationMergeStateRefusal(input)
-            : undefined;
-        const prepared = materialization === undefined
-            ? await prepareDelivery(input.scope, {
-                contractId: state.id,
-                coordinates: state.coordinates,
-            }, {
-                title: derivation.title,
-                document: derivation.bytes,
-                ...(input.actor === undefined ? {} : { actor: input.actor }),
-                ...(input.message === undefined ? {} : { message: input.message }),
-                requireBranchesToBeUpToDate: input.requireBranchesToBeUpToDate,
-                includeDirty: input.includeDirty,
-            })
-            : { kind: "refused", refusal: materialization };
-        preparation =
-            prepared.kind === "refused"
-                ? { kind: "refused", document: derivation.document, refusal: prepared.refusal }
-                : {
-                    kind: "prepared",
-                    document: derivation.document,
-                    data: prepared.data,
-                };
+    if (input.materializeConflict === true && state.terminal === null)
+        return { observation, state, derivation };
+    const prepared = await mechanicalDeliveryPreparation(input, state, derivation);
+    return prepared.kind === "prepared"
+        ? { observation, state, derivation, preparation: prepared, worktree: prepared.worktree }
+        : { observation, state, derivation, preparation: prepared };
+}
+async function resolveDeliveryPreparation(input, speculated) {
+    if (speculated.preparation !== undefined)
+        return speculated.preparation;
+    if (speculated.state === null || speculated.derivation === undefined)
+        return { kind: "unavailable" };
+    const materialization = await materializationMergeStateRefusal(input);
+    if (materialization !== undefined) {
+        return { kind: "refused", document: speculated.derivation.document, refusal: materialization };
     }
+    const prepared = await mechanicalDeliveryPreparation(input, speculated.state, speculated.derivation);
+    return prepared.kind === "prepared"
+        ? { kind: "prepared", document: prepared.document, data: prepared.data }
+        : prepared;
+}
+async function decideAndAdmitDelivery(input, attempt, seat, observation, speculated) {
+    const preparation = await resolveDeliveryPreparation(input, speculated);
     const decision = decideDeliver({
         input: {
             contractId: input.contractId,
@@ -111,7 +163,7 @@ async function deliverAttemptInPrivateStateSeat(input, attempt, seat) {
             preparation,
         },
         attempt,
-        observation: decisionObservation.decision,
+        observation: observation.decision,
     });
     if (decision.kind === "refused")
         return { kind: "refused", refusal: decision.refusal };
@@ -121,23 +173,36 @@ async function deliverAttemptInPrivateStateSeat(input, attempt, seat) {
         channel: input.channel,
         repository: input.scope,
         seat,
-        decisionObservation,
+        decisionObservation: observation,
         attempt,
         offer: decision.offer,
         primaryContract: input.contractId,
     });
-    if (admission.kind === "accepted") {
-        if (derivation === undefined)
-            throw new Error("accepted delivery is missing its document derivation");
-        return {
-            ...admission,
-            value: {
-                delivery: preparation.data,
-                derivation,
-            },
-        };
-    }
-    return admission;
+    if (admission.kind !== "accepted")
+        return admission;
+    if (speculated.derivation === undefined)
+        throw new Error("accepted delivery is missing its document derivation");
+    return {
+        ...admission,
+        value: { delivery: preparation.data, derivation: speculated.derivation },
+    };
+}
+async function deliverAttemptInPrivateStateSeat(input, attempt, seat, speculated) {
+    const observation = await matchingPrivateRootObservation(input.scope, input.channel, input.contractId, speculated.observation, async (fresh) => {
+        if (speculated.worktree === undefined)
+            return true;
+        const state = contractState(fresh.decision, input.contractId);
+        if (state === null)
+            return false;
+        return sameSpeculativeWorktreeInput(speculated.worktree, await recaptureDeliveryWorktree(input, state));
+    });
+    return "kind" in observation
+        ? observation
+        : await decideAndAdmitDelivery(input, attempt, seat, observation, speculated);
+}
+async function deliverAttempt(input, attempt) {
+    const speculated = await speculateDelivery(input);
+    return await privateStateSeatAttempt(input.scope, async (seat) => await deliverAttemptInPrivateStateSeat(input, attempt, seat, speculated), attemptDecisionWithSeatClose);
 }
 async function completeDelivery(input, first) {
     const derivation = first.value.derivation;
@@ -246,14 +311,28 @@ async function materializeDeliverConflict(input, refusal) {
     });
     if (tender.kind === "refused")
         return tender;
-    if (tender.data.dirty || tender.data.changes.submodules.length > 0) {
+    if (tender.data.changes.submodules.length > 0 || (tender.data.dirty && input.includeDirty !== true)) {
         return { kind: "refused", refusal: await dirtyTenderRefusal(input.scope, input.contractId, tender.data) };
     }
+    let handoffHead = tender.data.head;
+    if (tender.data.dirty) {
+        const derivation = input.deriveDocument(appointed.state);
+        const commit = await prepareDeliveryCommitMetadata(input.scope, {
+            contractId: input.contractId,
+            title: derivation.title,
+            document: derivation.bytes,
+            at: tender.data.at,
+            ...(input.actor === undefined ? {} : { actor: input.actor }),
+            ...(input.message === undefined ? {} : { message: input.message }),
+        });
+        handoffHead = await materializeTenderSnapshot(input.scope, tender.data, commit);
+        await checkoutDetachedSnapshot(input.scope, workspace.path, handoffHead);
+    }
     await recordConflictHandoff(input.scope, {
         contractId: input.contractId,
         place: appointment.place,
         workspace: workspace.path,
-        head: tender.data.head,
+        head: handoffHead,
         mergeHead: refusal.targetHead,
     });
     await materializeJudgedConflict(input.scope, workspace.path, refusal.targetHead);

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

@@ -45,7 +45,6 @@ type VerifyDeliveryInput = Readonly<{
     at: string;
     state: ContractState;
     snapshot?: SnapshotId;
-    environment: NodeJS.ProcessEnv;
     signal?: AbortSignal;
     verification?: VerificationDefinition;
 }>;

package/build/src/protocol/intent.js

@@ -69,7 +69,6 @@ export async function verifyDelivery(input) {
         repository: input.repository,
         candidate: snapshot,
         declarations: input.verification.declarations,
-        environment: input.environment,
         materializeScratchCandidate,
         projectSettings,
         ...(input.signal === undefined ? {} : { signal: input.signal }),

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

@@ -14,12 +14,13 @@ import type { IntegrationPreparationRefusal } from "../git/integration.js";
 import type { TargetPlacementRefusal } from "../git/target-placement.js";
 import type { VerificationCleanupFailure, VerificationRuntimeStop, VerificationResult } from "./intent.js";
 import type { VerificationDeclarationPreparation, VerificationDeclarationRefusal } from "../verification/declaration.js";
+import { type PrivateStateSeatOutcome } from "../git/private-state-seat.js";
 import type { PlacementProtocolResult } from "./placement.js";
 import type { AcceptedAdmission, DecidedOfferResult } from "./attempt.js";
 import type { AcceptedProtocolStep, IntentOutcome as ProtocolIntentOutcome } from "./outcome.js";
 import type { ProtocolResult, ProtocolTerminal } from "./run.js";
 import { type ContractDocumentProjection } from "./read/documents.js";
-import { type ContractBoard, type ContractObservation } from "./read/status.js";
+import { type ContractBoard, type ContractCatalogue, type ContractObservation } from "./read/status.js";
 export type MergeStatePresentRefusal = Readonly<{
     kind: "merge-state-present";
     contractId: ContractId;
@@ -40,7 +41,7 @@ export type DeliverConflictRefusal = Readonly<{
     targetHead: SnapshotId;
     conflictPaths: readonly string[];
     recovery: Readonly<{
-        materialize: "deliver --materialize-conflict";
+        materialize: "deliver --materialize-conflict --include-dirty";
         continue: "deliver --include-dirty";
     }>;
 }>;
@@ -108,6 +109,7 @@ export type AttemptDecision<Value, Refusal = IntentRefusal> = (AcceptedAdmission
     kind: "publication-failed";
 }>;
 export declare function timestamp(): string;
+export declare function attemptDecisionWithSeatClose<Value, Refusal = IntentRefusal>(outcome: PrivateStateSeatOutcome<AttemptDecision<Value, Refusal>>): AttemptDecision<Value, Refusal>;
 export declare function mergeAdmissions(current: AcceptedProtocolStep, next: AcceptedProtocolStep): AcceptedProtocolStep;
 export declare function stepStop<Refusal>(result: ProtocolResult<Refusal>): StepStop<Refusal> | undefined;
 export declare function unpackVerificationOutcome(verification: VerificationResult): Readonly<{
@@ -131,6 +133,11 @@ export declare function contractsOperation(input: Readonly<{
     scope: RepositoryScope;
     channel: GitDecodeChannel;
 }>): Promise<ContractBoard>;
+export declare function contractCatalogueOperation(input: Readonly<{
+    scope: RepositoryScope;
+    channel: GitDecodeChannel;
+    limit?: number;
+}>): Promise<ContractCatalogue>;
 export declare function contractObservationOperation(input: Readonly<{
     scope: RepositoryScope;
     channel: GitDecodeChannel;

package/build/src/protocol/operations.js

@@ -2,18 +2,29 @@ import { readDeliveryDiff } from "../git/integration.js";
 import { currentBranch, observeContractAt } from "../git/observe.js";
 import { repositoryAt } from "../git/repository.js";
 import { withGitReadObservation } from "../git/read-observation.js";
+import { appendPrivateStateSeatClose, concatenatePrivateStateSeatClose, mergePrivateStateSeatClose, } from "../git/private-state-seat.js";
 import { readDocuments } from "./read/documents.js";
-import { readContractBoard, readContractObservationAt, } from "./read/status.js";
+import { readContractBoard, readContractCatalogue, readContractObservationAt, } from "./read/status.js";
+import { boundedListLimit } from "../bounded-list.js";
 export function timestamp() {
     return new Date().toISOString();
 }
+export function attemptDecisionWithSeatClose(outcome) {
+    return mergePrivateStateSeatClose(outcome, (value, closeLag) => {
+        if (value.kind !== "accepted")
+            throw new Error(closeLag.diagnostic);
+        return { ...value, seatClose: appendPrivateStateSeatClose(value.seatClose, closeLag) };
+    });
+}
 export function mergeAdmissions(current, next) {
     const effects = [...(current.physical?.effects ?? []), ...(next.physical?.effects ?? [])];
     const lag = [...(current.physical?.lag ?? []), ...(next.physical?.lag ?? [])];
+    const seatClose = concatenatePrivateStateSeatClose(current.seatClose, next.seatClose);
     return {
         ...next,
         facts: [...current.facts, ...next.facts],
         ...(effects.length === 0 && lag.length === 0 ? {} : { physical: { effects, lag } }),
+        ...(seatClose === undefined ? {} : { seatClose }),
     };
 }
 export function stepStop(result) {
@@ -56,6 +67,10 @@ export async function currentBranchOperation(input) {
 export async function contractsOperation(input) {
     return withGitReadObservation(input.scope, input.channel, (observation) => readContractBoard(observation));
 }
+export async function contractCatalogueOperation(input) {
+    const limit = boundedListLimit(input.limit);
+    return withGitReadObservation(input.scope, input.channel, (observation) => readContractCatalogue(observation, limit));
+}
 export async function contractObservationOperation(input) {
     return await readContractObservationAt(input.scope, input.channel, input.contractId);
 }

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

@@ -1,6 +1,7 @@
 import type { ContractHead, ContractState, JournalEntry } from "../core/facts/types.js";
 import type { WorktreeLeak } from "../git/scratch.js";
 import type { ReconcileResult } from "../git/reconcile.js";
+import { type PrivateStateSeatCloseLag, type PrivateStateSeatOutcome } from "../git/private-state-seat.js";
 import type { AcceptedAdmission } from "./attempt.js";
 import type { VerificationCleanupFailure } from "./intent.js";
 import type { ProtocolResult, ProtocolTerminal } from "./run.js";
@@ -10,6 +11,7 @@ export type AcceptedProtocolStep = AcceptedAdmission & Readonly<{
 export type AcceptedObligations = Readonly<{
     cleanup?: VerificationCleanupFailure;
     leak?: WorktreeLeak;
+    seatClose?: readonly PrivateStateSeatCloseLag[];
 }>;
 export type IntentOutcome<Value, Refusal = never> = Readonly<{
     kind: "accepted";
@@ -27,3 +29,4 @@ export type IntentOutcome<Value, Refusal = never> = Readonly<{
 export declare function accepted<Value, Refusal = never>(state: ContractState, facts: readonly JournalEntry[], value: Value, physical?: ReconcileResult, obligations?: AcceptedObligations): IntentOutcome<Value, Refusal>;
 export declare function admitted<Value, Refusal = never>(admission: AcceptedProtocolStep, value: Value): IntentOutcome<Value, Refusal>;
 export declare function complete<Value, Refusal>(result: ProtocolResult<Refusal>, value: Value): IntentOutcome<Value, Refusal>;
+export declare function intentOutcomeWithSeatClose<Value, Refusal>(outcome: PrivateStateSeatOutcome<IntentOutcome<Value, Refusal>>): IntentOutcome<Value, Refusal>;

package/build/src/protocol/outcome.js

@@ -1,3 +1,4 @@
+import { appendPrivateStateSeatClose, mergePrivateStateSeatClose, } from "../git/private-state-seat.js";
 export function accepted(state, facts, value, physical, obligations) {
     if (state.head === null)
         throw new Error("accepted contract is missing its journal head");
@@ -9,10 +10,18 @@ export function accepted(state, facts, value, physical, obligations) {
         ...(physical === undefined ? {} : { physical }),
         ...(obligations?.cleanup === undefined ? {} : { cleanup: obligations.cleanup }),
         ...(obligations?.leak === undefined ? {} : { leak: obligations.leak }),
+        ...seatCloseObligations(obligations?.seatClose),
     };
 }
+function seatCloseObligations(seatClose) {
+    return seatClose === undefined || seatClose.length === 0 ? {} : { seatClose };
+}
+function admissionObligations(admission) {
+    const seatClose = admission.seatClose;
+    return seatClose === undefined || seatClose.length === 0 ? undefined : { seatClose };
+}
 export function admitted(admission, value) {
-    return accepted(admission.state, admission.facts, value, admission.physical);
+    return accepted(admission.state, admission.facts, value, admission.physical, admissionObligations(admission));
 }
 export function complete(result, value) {
     if (result.kind === "refused")
@@ -21,3 +30,10 @@ export function complete(result, value) {
         return { kind: "retry", reason: result };
     return admitted(result, value);
 }
+export function intentOutcomeWithSeatClose(outcome) {
+    return mergePrivateStateSeatClose(outcome, (value, closeLag) => {
+        if (value.kind !== "accepted")
+            throw new Error(closeLag.diagnostic);
+        return { ...value, seatClose: appendPrivateStateSeatClose(value.seatClose, closeLag) };
+    });
+}

package/build/src/protocol/placement.js

@@ -3,7 +3,7 @@ import { AuthorityCorruptionError } from "../core/facts/errors.js";
 import { contractState } from "../core/facts/observation.js";
 import { decidePlacement } from "../core/verbs/placement.js";
 import { observeGitForAdmissionAt } from "../git/observe.js";
-import { withPrivateStatePublicationSeat } from "../git/private-state-seat.js";
+import { appendPrivateStateSeatClose, mergePrivateStateSeatClose, withPrivateStatePublicationSeat, } from "../git/private-state-seat.js";
 import { reconcileEffectFailure } from "../git/reconcile.js";
 import { GitPlumbingError } from "../git/process.js";
 import { acquireTargetPlacementFence, followTargetPlacement, prepareTargetPlacement, observeTargetHead, observedTreeEqualsCandidate, } from "../git/target-placement.js";
@@ -21,9 +21,16 @@ function expectedOperationalDiagnostic(error) {
 function expectedPlacementFailure(error) {
     return { kind: "placement-failed", diagnostic: expectedOperationalDiagnostic(error) };
 }
+function placementResultWithSeatClose(outcome) {
+    return mergePrivateStateSeatClose(outcome, (value, closeLag) => {
+        if (value.kind !== "accepted")
+            throw new Error(closeLag.diagnostic);
+        return { ...value, seatClose: appendPrivateStateSeatClose(value.seatClose, closeLag) };
+    });
+}
 async function runFencedPlacement(repository, input, protocol) {
     let preparedPhysical;
-    const result = await withPrivateStatePublicationSeat(repository, async (seat) => {
+    const result = placementResultWithSeatClose(await withPrivateStatePublicationSeat(repository, async (seat) => {
         for (let index = 0; index < protocol.attempts.length; index += 1) {
             const prepared = await prepareProtocolAttempt(protocol, protocol.attempts[index]);
             if (prepared.kind === "refused")
@@ -67,7 +74,7 @@ async function runFencedPlacement(repository, input, protocol) {
                 return result;
         }
         return { kind: "exhausted" };
-    });
+    }));
     if (result.kind !== "accepted")
         return result;
     if (preparedPhysical === undefined) {

package/build/src/protocol/read/status.d.ts

@@ -3,6 +3,7 @@ import type { GitRepository } from "../../git/process.js";
 import type { GitDecodeChannel, GitReadObservation } from "../../git/read-observation.js";
 import { type GateCurrent } from "../../core/facts/gate.js";
 import type { ContractId, ContractState, DeliverData, JournalEntry, SnapshotId } from "../../core/facts/types.js";
+import { type BoundedList } from "../../bounded-list.js";
 export type ContractPhase = "waiting" | "bound" | "tendered" | "claimed" | "abandoned";
 export type ContractDisposition = "active" | "terminal";
 export type ContractGateCurrent = GateCurrent;
@@ -59,6 +60,11 @@ export type ContractBoard = Readonly<{
     observedAt: string;
     rows: readonly ContractRow[];
 }>;
+export type ContractCatalogue = Readonly<{
+    root: string;
+    state: SnapshotId | null;
+    observedAt: string;
+}> & BoundedList<ContractRow>;
 export type ContractObservation = Readonly<{
     kind: "missing";
     id: ContractId;
@@ -70,6 +76,8 @@ export declare function phaseAtFor(state: Pick<ContractState, "terminal" | "deli
 export declare function lastJournalAtFor(entries: readonly Pick<JournalEntry, "at">[]): string;
 /** Build the Contract board from one immutable git observation. */
 export declare function readContractBoard(observation: GitReadObservation, include?: ContractId): Promise<ContractBoard>;
+/** Observe a bounded recent active Contract catalogue from one immutable git observation. */
+export declare function readContractCatalogue(observation: GitReadObservation, limit: number): Promise<ContractCatalogue>;
 /** Observe one Contract and its target from one fresh ref epoch. */
 export declare function readContractObservation(observation: GitReadObservation, id: ContractId): Promise<ContractObservation>;
 /** Observe one Contract and its target from one fresh ref epoch. */

package/build/src/protocol/read/status.js

@@ -3,6 +3,7 @@ import { decodeContractDocument } from "../../body/decode.js";
 import { observeTargetLag, observeWorkspace, worktreePath } from "../../git/workspace.js";
 import { appointmentFor, readPlaceRegister } from "../../workspace-place.js";
 import { gateReports } from "../../core/facts/gate.js";
+import { projectBoundedList } from "../../bounded-list.js";
 function titleFor(state) {
     try {
         return decodeContractDocument(state.terms.document.bytes).title;
@@ -149,6 +150,54 @@ export async function readContractBoard(observation, include) {
         rows,
     };
 }
+function compareRecentContracts(left, right) {
+    return (right.lastJournalAt.localeCompare(left.lastJournalAt) ||
+        Buffer.compare(Buffer.from(left.state.id), Buffer.from(right.state.id)));
+}
+function activeContractStates(contracts) {
+    return [...contracts.values()].flatMap((record) => record.state === null || record.state.terminal !== null
+        ? []
+        : [
+            {
+                state: record.state,
+                bindAt: record.entries[0].at,
+                lastJournalAt: lastJournalAtFor(record.entries),
+            },
+        ]);
+}
+function reverseDependentsFromStates(id, states) {
+    return states
+        .filter(({ state }) => state.terms.after.includes(id))
+        .map(({ state }) => ({ contractId: state.id, phase: phaseFor(state) }))
+        .sort((left, right) => left.contractId.localeCompare(right.contractId));
+}
+/** Observe a bounded recent active Contract catalogue from one immutable git observation. */
+export async function readContractCatalogue(observation, limit) {
+    const observedAt = new Date().toISOString();
+    const observed = await observeActiveContractWorld(observation);
+    const active = activeContractStates(observed.contracts);
+    const selected = projectBoundedList([...active].sort(compareRecentContracts), limit);
+    const afterIds = selected.rows.flatMap(({ state }) => state.terms.after);
+    const endpoints = await afterEndpointMap(observation, new Map(observed.eligibility), afterIds);
+    const register = await readPlaceRegister(observation.repository);
+    const rows = await Promise.all(selected.rows.map(async ({ state, bindAt, lastJournalAt }) => await rowFor({
+        repository: observation.repository,
+        state,
+        bindAt,
+        lastJournalAt,
+        targetObservation: await observeDeliveryTargetAt(observation, state),
+        register,
+        after: afterEdges(state, endpoints),
+        dependents: reverseDependentsFromStates(state.id, active),
+    })));
+    return {
+        root: observation.repository.primaryWorktree,
+        state: observed.snapshot,
+        observedAt,
+        rows,
+        hasMore: selected.hasMore,
+    };
+}
 /** Observe one Contract and its target from one fresh ref epoch. */
 export async function readContractObservation(observation, id) {
     const observed = await observeContractsForAdmissionInObservationAt(observation, [id]);

package/build/src/protocol/reintegrate.js

@@ -2,12 +2,19 @@ import { contractState } from "../core/facts/observation.js";
 import { decideReintegrate } from "../core/verbs/reintegrate.js";
 import { materializeReintegrationSnapshot, persistedTender, planIntegration, } from "../git/integration.js";
 import { observeContractsForAdmissionAt } from "../git/observe.js";
-import { withPrivateStatePublicationSeat } from "../git/private-state-seat.js";
+import { appendPrivateStateSeatClose, mergePrivateStateSeatClose, withPrivateStatePublicationSeat, } from "../git/private-state-seat.js";
 import { admitDecidedOffer, mintAttempts } from "./attempt.js";
 import { timestamp } from "./operations.js";
 import { runUnderTargetPlacementFence } from "./placement.js";
+function reintegrationResultWithSeatClose(outcome) {
+    return mergePrivateStateSeatClose(outcome, (value, closeLag) => {
+        if (value.kind !== "accepted")
+            throw new Error(closeLag.diagnostic);
+        return { ...value, seatClose: appendPrivateStateSeatClose(value.seatClose, closeLag) };
+    });
+}
 async function runReintegration(input) {
-    return await withPrivateStatePublicationSeat(input.repository, async (seat) => {
+    return reintegrationResultWithSeatClose(await withPrivateStatePublicationSeat(input.repository, async (seat) => {
         const attempts = mintAttempts({ entryCount: 1 });
         for (let index = 0; index < attempts.length; index += 1) {
             const attempt = attempts[index];
@@ -71,7 +78,7 @@ async function runReintegration(input) {
                 return { kind: "retry", reason: result };
         }
         return { kind: "retry", reason: { kind: "exhausted" } };
-    });
+    }));
 }
 export async function reintegrateOperation(input) {
     return await runUnderTargetPlacementFence(input.repository, input.target, async () => await runReintegration(input));

package/build/src/protocol/result-codec.d.ts

@@ -0,0 +1,22 @@
+import type { AuditReport } from "./audit.js";
+import type { CandidateCompletion, CompletionEvidence } from "./completion.js";
+import type { IntegrationConflictMaterialized } from "./deliver.js";
+import type { CurrentVerifiedAttestation, VerificationCleanupFailure, VerificationRuntimeStop } from "./intent.js";
+import type { DeliverConflictRefusal, DeliveryPreparationRefusal, IntentRefusal, MergeStatePresentRefusal, PlacementStop, VerificationStop } from "./operations.js";
+import type { ReviewValue } from "./review.js";
+import type { ProtocolTerminal } from "./run.js";
+export declare function decodeProtocolTerminal(value: unknown): ProtocolTerminal;
+export declare function decodeMergeStatePresentRefusal(value: unknown): MergeStatePresentRefusal;
+export declare function decodeDeliverConflictRefusal(value: unknown): DeliverConflictRefusal;
+export declare function decodeDeliveryPreparationRefusal(value: unknown): DeliveryPreparationRefusal;
+export declare function decodeIntentRefusal(value: unknown): IntentRefusal;
+export declare function decodeVerificationRuntimeStop(value: unknown): VerificationRuntimeStop;
+export declare function decodeVerificationStop(value: unknown): VerificationStop;
+export declare function decodeVerificationReuse(value: unknown): CurrentVerifiedAttestation;
+export declare function decodePlacementStop(value: unknown): PlacementStop;
+export declare function decodeVerificationCleanupFailure(value: unknown): VerificationCleanupFailure;
+export declare function decodeCandidateCompletion(value: unknown): CandidateCompletion;
+export declare function decodeCompletionEvidence(value: unknown): CompletionEvidence;
+export declare function decodeMaterializedConflict(value: unknown): IntegrationConflictMaterialized;
+export declare function decodeAuditReport(value: unknown): AuditReport;
+export declare function decodeReviewValue(value: unknown): ReviewValue;