@astrosheep/keiyaku 4.6.4 → 4.6.6

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

@@ -1,7 +1,7 @@
 import { observeActiveContractWorld, observeContractsForAdmissionInObservationAt, observeDeliveryTargetAt, withContractReadObservationAt, } from "../../git/observe.js";
-import { decodeContractDocument, verificationDefinition } from "../../body/decode.js";
+import { decodeContractDocument } from "../../body/decode.js";
 import { dependencyKeys } from "../../core/subject.js";
-import { observeTargetLag, observeWorkspace, conflictHandoffFor, conflictRecovery, worktreePath, } from "../../git/workspace.js";
+import { observeTargetLag, observeWorkspace, readConflictHandoffs, conflictRecovery, worktreePath, } from "../../git/workspace.js";
 import { appointmentFor, readPlaceRegister } from "../../workspace-place.js";
 import { gateReports, latestCurrentAttestations } from "../../core/facts/gate.js";
 import { gate, } from "../../core/facts/types.js";
@@ -26,12 +26,10 @@ function phaseFor(state) {
         return "abandoned";
     return "bound";
 }
-function verificationFor(state, document) {
-    if (document === undefined)
-        return undefined;
-    if (verificationDefinition(document) === null)
-        return { kind: "undeclared" };
+function verificationFor(state) {
     const verifiedGate = gate("verified");
+    if (!state.terms.gates.includes(verifiedGate))
+        return { kind: "undeclared" };
     const current = latestCurrentAttestations(state, new Set([verifiedGate])).get(verifiedGate);
     if (current !== undefined) {
         const snapshot = dependencyKeys(current.data.subject).find((key) => key.kind === "snapshot")?.value;
@@ -53,20 +51,26 @@ export function lastJournalAtFor(entries) {
         throw new Error("present Contract journal is empty");
     return last.at;
 }
-async function managedWorkspaceFacts(repository, state, register, targetObservation) {
+function appointedWorkspace(repository, register, state) {
     const appointed = appointmentFor(register, state.id);
+    return appointed === undefined
+        ? undefined
+        : { contractId: state.id, place: appointed.place, workspace: worktreePath(repository, appointed.place) };
+}
+async function readSelectedHandoffs(observation, workspaces) {
+    return await readConflictHandoffs(observation.repository, observation.readBlobs, workspaces.flatMap((workspace) => (workspace === undefined ? [] : [workspace])));
+}
+async function managedWorkspaceFacts(repository, state, appointed, targetObservation, handoff) {
     if (appointed === undefined) {
         return {
-            appointed,
             workspaceObservation: { kind: "unappointed" },
             targetLag: state.coordinates.target === undefined ? { kind: "none" } : { kind: "unknown" },
         };
     }
-    const path = worktreePath(repository, appointed.place);
-    const [workspaceObservation, targetLag, handoff] = await Promise.all([
+    const path = appointed.workspace;
+    const [workspaceObservation, targetLag] = await Promise.all([
         observeWorkspace(repository, { kind: "worktree", path }, path),
         observeTargetLag(repository, path, targetObservation?.head),
-        conflictHandoffFor(repository, { contractId: state.id, place: appointed.place, workspace: path }),
     ]);
     const projectedWorkspaceObservation = handoff !== undefined &&
         (workspaceObservation.kind === "clean" || workspaceObservation.kind === "dirty") &&
@@ -80,7 +84,7 @@ async function managedWorkspaceFacts(repository, state, register, targetObservat
             },
         }
         : workspaceObservation;
-    return { appointed, workspaceObservation: projectedWorkspaceObservation, targetLag };
+    return { workspaceObservation: projectedWorkspaceObservation, targetLag };
 }
 function afterEndpoint(state) {
     if (state === undefined || state === null)
@@ -104,12 +108,11 @@ function reverseDependents(id, rows) {
         .sort((left, right) => left.contractId.localeCompare(right.contractId));
 }
 async function rowFor(input) {
-    const { repository, state, bindAt, lastJournalAt, targetObservation, register, after, dependents } = input;
-    const workspace = state.coordinates.workspace;
+    const { repository, state, bindAt, lastJournalAt, targetObservation, workspace, handoff, after, dependents } = input;
     const gates = gateReports(state);
     const document = documentFor(state);
-    const verification = verificationFor(state, document);
-    const { appointed, workspaceObservation, targetLag } = await managedWorkspaceFacts(repository, state, register, targetObservation);
+    const verification = verificationFor(state);
+    const facts = await managedWorkspaceFacts(repository, state, workspace, targetObservation, handoff);
     return {
         id: state.id,
         title: titleFor(document),
@@ -117,11 +120,11 @@ async function rowFor(input) {
         phaseAt: phaseAtFor(state, bindAt),
         lastJournalAt,
         disposition: state.terminal === null ? "active" : "terminal",
-        workspace,
-        worktreePath: appointed === undefined ? null : worktreePath(repository, appointed.place),
-        workspaceObservation,
+        workspace: state.coordinates.workspace,
+        worktreePath: workspace?.workspace ?? null,
+        workspaceObservation: facts.workspaceObservation,
         target: state.coordinates.target ?? null,
-        targetLag,
+        targetLag: facts.targetLag,
         delivery: state.delivery === null || state.currentIntegration === null
             ? null
             : { ...state.delivery.data, integration: state.currentIntegration },
@@ -163,23 +166,27 @@ export async function readContractBoard(observation, include) {
         }
     }
     const register = await readPlaceRegister(observation.repository);
-    const projected = await Promise.all([...contracts.values()].flatMap((value) => {
-        if (value.state === null)
-            return [];
-        const state = value.state;
-        return [
-            observeDeliveryTargetAt(observation, state).then((target) => rowFor({
-                repository: observation.repository,
-                state,
-                bindAt: value.entries[0].at,
-                lastJournalAt: lastJournalAtFor(value.entries),
-                targetObservation: target,
-                register,
-                after: afterEdges(state, endpoints),
-                dependents: [],
-            })),
-        ];
-    }));
+    const selected = [...contracts.values()].flatMap((value) => value.state === null
+        ? []
+        : [
+            {
+                ...value,
+                state: value.state,
+                workspace: appointedWorkspace(observation.repository, register, value.state),
+            },
+        ]);
+    const handoffs = await readSelectedHandoffs(observation, selected.map(({ workspace }) => workspace));
+    const projected = await Promise.all(selected.map(async ({ state, entries, workspace }) => await rowFor({
+        repository: observation.repository,
+        state,
+        bindAt: entries[0].at,
+        lastJournalAt: lastJournalAtFor(entries),
+        targetObservation: await observeDeliveryTargetAt(observation, state),
+        workspace,
+        handoff: handoffs.get(state.id),
+        after: afterEdges(state, endpoints),
+        dependents: [],
+    })));
     const rows = projected.map((row) => ({ ...row, dependents: reverseDependents(row.id, projected) }));
     return {
         root: observation.repository.primaryWorktree,
@@ -218,13 +225,19 @@ export async function readContractCatalogue(observation, 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({
+    const selectedWorkspaces = selected.rows.map((value) => ({
+        ...value,
+        workspace: appointedWorkspace(observation.repository, register, value.state),
+    }));
+    const handoffs = await readSelectedHandoffs(observation, selectedWorkspaces.map(({ workspace }) => workspace));
+    const rows = await Promise.all(selectedWorkspaces.map(async ({ state, bindAt, lastJournalAt, workspace }) => await rowFor({
         repository: observation.repository,
         state,
         bindAt,
         lastJournalAt,
         targetObservation: await observeDeliveryTargetAt(observation, state),
-        register,
+        workspace,
+        handoff: handoffs.get(state.id),
         after: afterEdges(state, endpoints),
         dependents: reverseDependentsFromStates(state.id, active),
     })));
@@ -257,6 +270,9 @@ export async function readContractObservation(observation, id) {
     if (state === null)
         return { kind: "missing", id };
     const endpoints = await afterEndpointMap(observation, new Map([[id, state]]), state.terms.after);
+    const register = await readPlaceRegister(observation.repository);
+    const workspace = appointedWorkspace(observation.repository, register, state);
+    const handoffs = await readSelectedHandoffs(observation, [workspace]);
     return {
         kind: "present",
         row: await rowFor({
@@ -265,7 +281,8 @@ export async function readContractObservation(observation, id) {
             bindAt: record.entries[0].at,
             lastJournalAt: lastJournalAtFor(record.entries),
             targetObservation: await observeDeliveryTargetAt(observation, state),
-            register: await readPlaceRegister(observation.repository),
+            workspace,
+            handoff: handoffs.get(state.id),
             after: afterEdges(state, endpoints),
             dependents: [],
         }),

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

@@ -11,7 +11,7 @@ type TargetMissing = Readonly<{
     kind: "target-missing";
     contractId: ContractId;
 }>;
-export type ReintegrationRefusal = ReintegrateRefusal | TargetMissing | IntegrationPreparationRefusal;
+type ReintegrationRefusal = ReintegrateRefusal | TargetMissing | IntegrationPreparationRefusal;
 export type ReintegrationResult = (AcceptedAdmission & Readonly<{
     value: ReintegratedData;
 }>) | Readonly<{

package/build/src/protocol/reintegrate.js

@@ -1,11 +1,11 @@
 import { contractState } from "../core/facts/observation.js";
 import { decideReintegrate } from "../core/verbs/reintegrate.js";
-import { materializeReintegrationSnapshot, persistedTender, planIntegration, } from "../git/integration.js";
+import { materializeReintegrationSnapshot, persistedTender, planIntegration, reusableIntegrationSnapshot, } from "../git/integration.js";
 import { observeContractsForAdmissionAt } from "../git/observe.js";
 import { appendPrivateStateSeatClose, mergePrivateStateSeatClose, withPrivateStatePublicationSeat, } from "../git/private-state-seat.js";
 import { admitDecidedOffer, mintAttempts } from "./attempt.js";
-import { timestamp } from "./operations.js";
-import { contractStateWitness, STALE_PRIVATE_STATE_PREPARATION, } from "./run.js";
+import { recordedIntegrationSnapshots, timestamp } from "./operations.js";
+import { externalPreparation, STALE_PRIVATE_STATE_PREPARATION, } from "./run.js";
 import { runUnderTargetPlacementFence } from "./placement.js";
 function reintegrationResultWithSeatClose(outcome) {
     return mergePrivateStateSeatClose(outcome, (value, closeLag) => {
@@ -16,23 +16,16 @@ function reintegrationResultWithSeatClose(outcome) {
 }
 /** Plan and materialize the target-specific reintegration artifacts outside the publication seat. */
 async function prepareExternalReintegration(input) {
-    const observation = await observeContractsForAdmissionAt(input.repository, input.channel, [input.contractId]);
-    const state = contractState(observation.decision, input.contractId);
-    if (state === null)
-        return { kind: "unavailable" };
-    return {
-        kind: "artifacts",
-        witness: contractStateWitness(state),
-        artifacts: await planReintegrationArtifacts(input, state),
-    };
+    return await externalPreparation({ ...input, scope: input.repository }, (observation, state) => planReintegrationArtifacts(input, state, recordedIntegrationSnapshots(observation.journals.get(state.id)?.entries ?? [])));
 }
-async function planReintegrationArtifacts(input, state) {
+async function planReintegrationArtifacts(input, state, recordedIntegrations) {
     if (state.delivery === null || state.currentIntegration === null)
         return { kind: "defer" };
     const planned = await planIntegration(input.repository, { contractId: input.contractId, coordinates: state.coordinates }, await persistedTender(input.repository, state.delivery.data.tenderSnapshot), state.delivery.data.policy.requireBranchesToBeUpToDate);
     if (planned.kind === "refused")
         return { kind: "refused", refusal: planned.refusal };
-    const snapshot = await materializeReintegrationSnapshot(input.repository, planned.data.tree, planned.data.predecessor, state.delivery.data.integration.snapshot);
+    const snapshot = (await reusableIntegrationSnapshot(input.repository, planned.data.tree, planned.data.predecessor, recordedIntegrations)) ??
+        (await materializeReintegrationSnapshot(input.repository, planned.data.tree, planned.data.predecessor, state.delivery.data.integration.snapshot));
     return {
         kind: "prepared",
         data: { predecessor: planned.data.predecessor, snapshot },
@@ -80,14 +73,12 @@ async function runReintegration(input) {
             if (decision.kind === "refused")
                 return { kind: "refused", refusal: decision.refusal };
             const admitted = await admitDecidedOffer({
-                channel: input.channel,
-                repository: input.repository,
+                ...input,
+                scope: input.repository,
                 seat,
-                decisionObservation: observation,
+                observation,
                 attempt,
                 offer: decision.offer,
-                primaryContract: input.contractId,
-                ...(input.progress === undefined ? {} : { progress: input.progress }),
                 ...(assembled.kind === "prepared" ? { assertions: [assembled.assertion] } : {}),
             });
             if (admitted.kind === "accepted") {

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

@@ -1,8 +1,8 @@
 import { z } from "zod";
 import { type ActiveContractRefusal } from "../core/facts/observation.js";
-import type { AttestationData, ContractState, DeliverData } from "../core/facts/types.js";
+import type { AttestationData } from "../core/facts/types.js";
 import type { LeadingOutcome } from "./outcome.js";
-import type { MutationOperationInput, RepositoryScope } from "./operations.js";
+import type { MutationOperationInput } from "./operations.js";
 type ReviewPreparationRefusal = Readonly<{
     kind: "worktree-missing";
     contractId: import("../core/facts/types.js").ContractId;
@@ -12,18 +12,6 @@ type ReviewOperationInput = MutationOperationInput & Readonly<{
     verdict: AttestationData["verdict"];
     summary?: string;
 }>;
-declare const reviewWorkspaceEvidenceSchema: z.ZodObject<{
-    staged: z.ZodReadonly<z.ZodArray<z.ZodString>>;
-    unstaged: z.ZodReadonly<z.ZodArray<z.ZodString>>;
-    untracked: z.ZodReadonly<z.ZodArray<z.ZodString>>;
-    shortStat: z.ZodObject<{
-        filesChanged: z.ZodNumber;
-        insertions: z.ZodNumber;
-        deletions: z.ZodNumber;
-    }, z.core.$strict>;
-    unmergedPaths: z.ZodReadonly<z.ZodArray<z.ZodString>>;
-}, z.core.$strict>;
-type ReviewWorkspaceEvidence = z.infer<typeof reviewWorkspaceEvidenceSchema>;
 export declare const reviewAdmissionValueSchema: z.ZodObject<{
     workspace: z.ZodOptional<z.ZodObject<{
         staged: z.ZodReadonly<z.ZodArray<z.ZodString>>;
@@ -37,19 +25,6 @@ export declare const reviewAdmissionValueSchema: z.ZodObject<{
         unmergedPaths: z.ZodReadonly<z.ZodArray<z.ZodString>>;
     }, z.core.$strict>>;
 }, z.core.$strict>;
-export type ReviewAdmissionValue = z.infer<typeof reviewAdmissionValueSchema>;
-export declare function prepareReview(repository: RepositoryScope, stage: Readonly<{
-    contractId: import("../core/facts/types.js").ContractId;
-    coordinates: ContractState["coordinates"];
-}>): Promise<{
-    kind: "prepared";
-    data: Readonly<{
-        changeId: DeliverData["integration"]["changeId"];
-        workspace?: ReviewWorkspaceEvidence;
-    }>;
-} | {
-    kind: "refused";
-    refusal: ReviewPreparationRefusal;
-}>;
+type ReviewAdmissionValue = z.infer<typeof reviewAdmissionValueSchema>;
 export declare function admitReviewOperation(input: ReviewOperationInput): Promise<LeadingOutcome<ReviewAdmissionValue, ReviewRefusal>>;
 export {};

package/build/src/protocol/review.js

@@ -4,7 +4,7 @@ import { worktreeChangeId } from "../git/integration.js";
 import { captureTender, dirtyTenderDelta, dirtyTenderRefusal } from "../git/tender.js";
 import { observeContractsForAdmissionAt } from "../git/observe.js";
 import { unmergedWorkspacePaths, worktreePath } from "../git/workspace.js";
-import { contractStateWitness, privateStateSeatAttempt, runBoundedAttempts, sameWorktreeWitness, STALE_PRIVATE_STATE_PREPARATION, } from "./run.js";
+import { externalPreparation, privateStateSeatAttempt, runBoundedAttempts, sameWorktreeWitness, STALE_PRIVATE_STATE_PREPARATION, } from "./run.js";
 import { dependencyKeySet } from "../core/subject.js";
 import { contractState } from "../core/facts/observation.js";
 import { gate } from "../core/facts/types.js";
@@ -51,18 +51,6 @@ async function captureReviewableWorktree(repository, stage) {
         },
     };
 }
-export async function prepareReview(repository, stage) {
-    const prepared = await captureReviewableWorktree(repository, stage);
-    if (prepared.kind === "refused")
-        return prepared;
-    return {
-        kind: "prepared",
-        data: {
-            changeId: prepared.data.changeId,
-            ...(prepared.data.workspace === undefined ? {} : { workspace: prepared.data.workspace }),
-        },
-    };
-}
 function preparedReviewCapture(input, state, changeId) {
     return {
         kind: "prepared",
@@ -95,25 +83,19 @@ async function recaptureReviewWorktree(input, state) {
 }
 /** Capture the reviewable worktree from one non-authoritative private-state read. */
 async function prepareExternalReview(input) {
-    const observation = await observeContractsForAdmissionAt(input.scope, input.channel, [input.contractId]);
-    const state = contractState(observation.decision, input.contractId);
-    if (state === null)
-        return { kind: "unavailable" };
-    const prepared = await captureReviewableWorktree(input.scope, {
-        contractId: state.id,
-        coordinates: state.coordinates,
-    });
-    return {
-        kind: "artifacts",
-        witness: contractStateWitness(state),
-        artifacts: prepared.kind === "refused"
+    return await externalPreparation(input, async (_, state) => {
+        const prepared = await captureReviewableWorktree(input.scope, {
+            contractId: state.id,
+            coordinates: state.coordinates,
+        });
+        return prepared.kind === "refused"
             ? { kind: "refused", refusal: prepared.refusal }
             : {
                 kind: "captured",
                 ...(prepared.data.workspace === undefined ? {} : { workspace: prepared.data.workspace }),
                 worktree: reviewWorktreeInput(prepared),
-            },
-    };
+            };
+    });
 }
 /** Assemble the in-custody attestation input from the fresh Contract and validated artifacts. */
 async function assembleReviewAttempt(input, observation, external) {
@@ -149,16 +131,7 @@ async function decideAndAdmitReview(input, attempt, seat, observation, assembled
     });
     if (decision.kind === "refused")
         return { kind: "refused", refusal: decision.refusal };
-    const admission = await admitDecidedOffer({
-        channel: input.channel,
-        repository: input.scope,
-        seat,
-        decisionObservation: observation,
-        attempt,
-        offer: decision.offer,
-        primaryContract: input.contractId,
-        ...(input.progress === undefined ? {} : { progress: input.progress }),
-    });
+    const admission = await admitDecidedOffer({ ...input, seat, observation, attempt, offer: decision.offer });
     if (admission.kind !== "accepted")
         return admission;
     return {

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

@@ -7,7 +7,7 @@ import type { GitRepository } from "../git/process.js";
 import { type GitRefAssertion } from "../git/repository.js";
 import type { AttemptContext, DecideInput, OfferDecision } from "../core/decide.js";
 import type { Offer, TreeUpdate } from "../core/facts/offer.js";
-import type { ChangeId, ContractHead, ContractId, SnapshotId } from "../core/facts/types.js";
+import type { ChangeId, ContractHead, ContractId, ContractState, SnapshotId } from "../core/facts/types.js";
 import type { GitObjectId } from "../git/identity.js";
 import { type AcceptedAdmission, type AttemptTerminal } from "./attempt.js";
 export declare const STALE_PRIVATE_STATE_PREPARATION: {
@@ -104,14 +104,14 @@ type ProtocolAdmission<Input extends Readonly<{
     observationSelection?: GitTreeSelection;
 }>;
 /** An intent whose invocation is already its decision input. */
-export type DirectRunProtocolInput<Seed extends Readonly<{
+type DirectRunProtocolInput<Seed extends Readonly<{
     contractId: ContractId;
 }>, Refusal> = ProtocolAdmission<Seed, Refusal> & Readonly<{
     input: Seed;
     preparation?: undefined;
 }>;
 /** An intent whose repeatable preparation runs outside custody and is assembled inside it. */
-export type SplitRunProtocolInput<Input extends Readonly<{
+type SplitRunProtocolInput<Input extends Readonly<{
     contractId: ContractId;
 }>, Refusal, Seed extends Readonly<{
     contractId: ContractId;
@@ -124,7 +124,7 @@ export type RunProtocolInput<Input extends Readonly<{
 }>, Refusal, Seed extends Readonly<{
     contractId: ContractId;
 }> = Input, Prepared = Seed> = DirectRunProtocolInput<Seed, Refusal> | SplitRunProtocolInput<Input, Refusal, Seed, Prepared>;
-export type PreparedProtocolAttempt<Refusal> = Readonly<{
+type PreparedProtocolAttempt<Refusal> = Readonly<{
     kind: "stale";
 }> | Readonly<{
     kind: "refused";
@@ -143,7 +143,6 @@ export type PreparedProtocolAttempt<Refusal> = Readonly<{
 export type ContractStateWitness = Readonly<{
     head: ContractHead | null;
 }>;
-export declare function contractStateWitness(state: ContractStateWitness): ContractStateWitness;
 /**
  * A physical worktree capture carried across custody as a witness, never as authority.
  *
@@ -162,8 +161,21 @@ export type WorktreeWitness = Readonly<{
     changeId: ChangeId;
 }>;
 export declare function sameWorktreeWitness(prepared: WorktreeWitness | undefined, fresh: WorktreeWitness | undefined): boolean;
-export declare function privateStateAssertionsMatch(repository: GitRepository, assertions: readonly GitRefAssertion[]): Promise<boolean>;
-export declare function publicationFailedFromSeatError(error: unknown): AttemptTerminal;
+/**
+ * The repeatable outside-custody preamble shared by prepared operations: one non-authoritative
+ * observation of the invoked Contract, and the artifacts its fresh state justifies.
+ */
+export declare function externalPreparation<Artifacts>(input: Readonly<{
+    scope: GitRepository;
+    channel: GitDecodeChannel;
+    contractId: ContractId;
+}>, artifacts: (observation: GitDecisionObservation, state: ContractState) => Promise<Artifacts>): Promise<Readonly<{
+    kind: "unavailable";
+}> | Readonly<{
+    kind: "artifacts";
+    witness: ContractStateWitness;
+    artifacts: Artifacts;
+}>>;
 export declare function privateStateSeatAttempt<T>(repository: GitRepository, action: (seat: PrivateStatePublicationSeat) => Promise<T>, wrap: (outcome: PrivateStateSeatOutcome<T>) => T): Promise<T | AttemptTerminal>;
 /** Form one decided offer without admitting or reinterpreting it. */
 export declare function prepareProtocolAttempt<Input extends Readonly<{

package/build/src/protocol/run.js

@@ -3,6 +3,7 @@ import { publicationFailedSchema } from "../git/admission.js";
 import { extendAdmissionPathsAt, observeContractsForAdmissionAt } from "../git/observe.js";
 import { appendPrivateStateSeatClose, isPrivateStateSeatContention, mergePrivateStateSeatClose, withPrivateStatePublicationSeat, } from "../git/private-state-seat.js";
 import { GIT_REF, readRefs } from "../git/repository.js";
+import { contractState } from "../core/facts/observation.js";
 import { admitDecidedOffer } from "./attempt.js";
 export const STALE_PRIVATE_STATE_PREPARATION = {
     kind: "stale",
@@ -26,7 +27,7 @@ export async function runBoundedAttempts(attempts, attempt) {
     }
     return { kind: "exhausted" };
 }
-export function contractStateWitness(state) {
+function contractStateWitness(state) {
     return { head: state.head };
 }
 export function sameWorktreeWitness(prepared, fresh) {
@@ -38,17 +39,28 @@ export function sameWorktreeWitness(prepared, fresh) {
         prepared.dirty === fresh.dirty &&
         prepared.changeId === fresh.changeId);
 }
-export async function privateStateAssertionsMatch(repository, assertions) {
+async function privateStateAssertionsMatch(repository, assertions) {
     if (assertions.length === 0)
         return true;
     const refs = await readRefs(repository, [GIT_REF, ...assertions.map((assertion) => assertion.ref)]);
     return assertions.every((assertion) => refs.get(assertion.ref) === assertion.oid);
 }
-export function publicationFailedFromSeatError(error) {
+function publicationFailedFromSeatError(error) {
     if (isPrivateStateSeatContention(error))
         return { kind: "publication-failed", diagnostic: error.message };
     throw error;
 }
+/**
+ * The repeatable outside-custody preamble shared by prepared operations: one non-authoritative
+ * observation of the invoked Contract, and the artifacts its fresh state justifies.
+ */
+export async function externalPreparation(input, artifacts) {
+    const observation = await observeContractsForAdmissionAt(input.scope, input.channel, [input.contractId]);
+    const state = contractState(observation.decision, input.contractId);
+    if (state === null)
+        return { kind: "unavailable" };
+    return { kind: "artifacts", witness: contractStateWitness(state), artifacts: await artifacts(observation, state) };
+}
 export async function privateStateSeatAttempt(repository, action, wrap) {
     try {
         return wrap(await withPrivateStatePublicationSeat(repository, action));
@@ -100,16 +112,14 @@ async function admitDecidedProtocolOffer(admission, primaryContract, seat, decis
     if (decided.kind === "refused")
         return decided;
     return await admitDecidedOffer({
-        channel: admission.channel,
-        repository: admission.repository,
+        ...admission,
+        scope: admission.repository,
+        contractId: primaryContract,
         seat,
-        decisionObservation: decided.observation,
+        observation: decided.observation,
         attempt: decided.attempt,
         offer: decided.offer,
-        primaryContract,
-        ...(admission.progress === undefined ? {} : { progress: admission.progress }),
         assertions: decided.assertions,
-        ...(admission.validateAdmission === undefined ? {} : { validateAdmission: admission.validateAdmission }),
     });
 }
 function protocolAttemptWithSeatClose(outcome) {

package/build/src/settlement/holder.d.ts

@@ -26,10 +26,9 @@ type TaskHolderAdmission<T extends AdmissionOutcome> = Readonly<{
     taskId: TaskId;
     diagnostic: string;
 }>;
-export declare function finishTaskHolderAdmission<T extends AdmissionOutcome>(taskId: TaskId, result: T, close: () => void): TaskHolderAdmission<T>;
-export declare function claimTaskHolderWithFence<T extends AdmissionOutcome>(repository: GitRepository, taskId: TaskId, action: () => T | Promise<T>): Promise<TaskHolderAdmission<T>>;
+export declare function admitWithTaskHolderFence<T extends AdmissionOutcome>(repository: GitRepository, taskId: TaskId, action: () => T | Promise<T>): Promise<TaskHolderAdmission<T>>;
 export declare function releaseTaskHolder(channel: GitDecodeChannel, observation: GitDecisionObservation, owner: ContractId): Promise<TreeUpdate | null>;
-export type TaskHolderReleasePublication = Readonly<{
+type TaskHolderReleasePublication = Readonly<{
     kind: "released";
 }> | Readonly<{
     kind: "not-held";
@@ -40,7 +39,6 @@ export type TaskHolderReleasePublication = Readonly<{
 /** Publish the released holder against the same frozen observation that decided the release. */
 export declare function publishTaskHolderRelease(repository: GitRepository, channel: GitDecodeChannel, observation: GitDecisionObservation, owner: ContractId, seat: PrivateStatePublicationSeat): Promise<TaskHolderReleasePublication>;
 export declare function readTaskHolderProjectionFromDecision(channel: GitDecodeChannel, observation: GitDecisionObservation): Promise<TaskHolderProjection>;
-export declare function observeTaskHolderProjection(repository: GitRepository, channel: GitDecodeChannel): Promise<TaskHolderProjection>;
 export declare function releaseTaskHolderWithFence<T extends AdmissionOutcome>(repository: GitRepository, channel: GitDecodeChannel, owner: ContractId, action: () => T | Promise<T>): Promise<TaskHolderAdmission<T>>;
 export declare function readTaskHoldersAt(observation: Pick<GitReadObservation, "snapshot" | "readBlobs">): Promise<readonly TaskHolder[]>;
 export declare function readTaskHolderProjectionAt(observation: GitReadObservation): Promise<TaskHolderProjection>;

package/build/src/settlement/holder.js

@@ -87,7 +87,7 @@ export function claimTaskHolder(taskId, owner) {
 function detail(error) {
     return error instanceof Error ? error.message : String(error);
 }
-export function finishTaskHolderAdmission(taskId, result, close) {
+function finishTaskHolderAdmission(taskId, result, close) {
     try {
         close();
         return { kind: "completed", result };
@@ -98,7 +98,7 @@ export function finishTaskHolderAdmission(taskId, result, close) {
         return { kind: "accepted-release-failed", result, taskId, diagnostic: detail(error) };
     }
 }
-async function admitWithTaskHolderFence(repository, taskId, action) {
+export async function admitWithTaskHolderFence(repository, taskId, action) {
     const held = await acquireTaskSettlementFence(repository, taskId);
     let result;
     try {
@@ -115,9 +115,6 @@ async function admitWithTaskHolderFence(repository, taskId, action) {
     }
     return finishTaskHolderAdmission(taskId, result, () => held.close());
 }
-export function claimTaskHolderWithFence(repository, taskId, action) {
-    return admitWithTaskHolderFence(repository, taskId, action);
-}
 export async function releaseTaskHolder(channel, observation, owner) {
     const current = (await readTaskHolderProjectionFromDecision(channel, observation)).get(owner) ?? null;
     return current === null || current.disposition !== "held" ? null : update({ ...current, disposition: "released" });
@@ -180,7 +177,7 @@ export async function readTaskHolderProjectionFromDecision(channel, observation)
     };
     return projectTaskHolders(await readTaskHoldersAt(read));
 }
-export function observeTaskHolderProjection(repository, channel) {
+function observeTaskHolderProjection(repository, channel) {
     return withGitTargetedReadObservation(repository, channel, taskHolderObservationSelection(), readTaskHolderProjectionAt);
 }
 async function heldTaskForContract(repository, channel, owner) {

package/build/src/task/board.d.ts

@@ -118,6 +118,12 @@ export declare function projectOwnedDetailFacts(board: TaskBoard, id: TaskId): T
 export declare function projectDetailFacts(board: TaskBoard, id: TaskId, relations: TaskRelationProjection): TaskDetailFacts | null;
 export declare function projectTaskRow(board: TaskBoard, relations: TaskRelationProjection, task: TaskDocument): TaskRow;
 export declare function projectRows(board: TaskBoard, relations: TaskRelationProjection, scope: readonly string[] | null, selection: "active" | "closed" | "all"): readonly TaskRow[];
+/**
+ * Rows for the identities that created work, grouped by creator. Only documents a
+ * requested identity created reach row projection, and each group keeps the
+ * established row order.
+ */
+export declare function projectCreatedByRows(board: TaskBoard, relations: TaskRelationProjection, createdByIds: readonly string[]): ReadonlyMap<string, readonly TaskRow[]>;
 export declare function projectBlocked(board: TaskBoard, scope: readonly string[] | null, relations: TaskRelationProjection): readonly BlockedTaskRow[];
 export declare function projectStatusRows(board: TaskBoard, relations: TaskRelationProjection, scope: readonly string[] | null): ({
     id: `task/${string}`;

package/build/src/task/board.js

@@ -142,7 +142,36 @@ export function projectRows(board, relations, scope, selection) {
         .filter((task) => inScope(task, scope))
         .filter((task) => selection === "all" || (selection === "closed") === terminal(task.state))
         .map((task) => projectTaskRow(board, relations, task))
-        .sort((a, b) => a.priority - b.priority || Buffer.compare(Buffer.from(a.id), Buffer.from(b.id)));
+        .sort(compareTaskRows);
+}
+/** The established Task row order: priority first, then canonical identity bytes. */
+function compareTaskRows(left, right) {
+    return left.priority - right.priority || Buffer.compare(Buffer.from(left.id), Buffer.from(right.id));
+}
+/**
+ * Rows for the identities that created work, grouped by creator. Only documents a
+ * requested identity created reach row projection, and each group keeps the
+ * established row order.
+ */
+export function projectCreatedByRows(board, relations, createdByIds) {
+    const requested = new Set(createdByIds);
+    const attributed = [];
+    for (const task of board.tasks.values()) {
+        const createdBy = task.createdBy;
+        if (createdBy === undefined || !requested.has(createdBy))
+            continue;
+        attributed.push({ createdBy, row: projectTaskRow(board, relations, task) });
+    }
+    attributed.sort((left, right) => compareTaskRows(left.row, right.row));
+    const grouped = new Map();
+    for (const { createdBy, row } of attributed) {
+        const rows = grouped.get(createdBy);
+        if (rows === undefined)
+            grouped.set(createdBy, [row]);
+        else
+            rows.push(row);
+    }
+    return grouped;
 }
 export function projectBlocked(board, scope, relations) {
     return projectRows(board, relations, scope, "active").flatMap((row) => {