@astrosheep/keiyaku 4.6.7 → 4.6.8

package/build/src/library/outcome.js

@@ -257,6 +257,16 @@ export function errorCategory(error) {
         return "aborted";
     return "internal";
 }
+export async function readContractValue(operation) {
+    try {
+        return await operation();
+    }
+    catch (error) {
+        if (error instanceof KeiyakuError)
+            throw error;
+        throw new KeiyakuError(errorCategory(error), errorDiagnostic(error), { cause: error });
+    }
+}
 function errorDiagnostic(error) {
     return error instanceof Error ? error.message : String(error);
 }

package/build/src/library/reconcile.js

@@ -54,11 +54,8 @@ function registerLag(scope, error) {
 function emptySettlement() {
     return { actions: [], lags: [] };
 }
-function isManagedWorktree(state) {
-    return state.coordinates.workspace === "worktree";
-}
 function isManagedTerminal(state) {
-    return state !== null && isManagedWorktree(state) && state.terminal !== null;
+    return state !== null && state.terminal !== null;
 }
 /**
  * Terminal cleanup retires the appointed worktree. Name its short name only when this
@@ -76,7 +73,7 @@ function terminalWorktreeOutcome(scope, cleanup, place) {
     return undefined;
 }
 function appointableManagedContracts(states) {
-    return states.filter((state) => isManagedWorktree(state) && state.terminal === null).map((state) => state.id);
+    return states.filter((state) => state.terminal === null).map((state) => state.id);
 }
 async function appointPlaces(scope, states) {
     return await appointManagedWorktrees(scope, appointableManagedContracts(states));
@@ -114,8 +111,6 @@ async function observeState(scope, channel, contractId) {
     }
 }
 async function appointForContract(scope, state) {
-    if (!isManagedWorktree(state))
-        return {};
     try {
         const register = await appointPlaces(scope, [state]);
         const place = register.byContract.get(state.id)?.place;
@@ -265,16 +260,13 @@ export async function completeRepoReconcile(input) {
         if (!isOperationalFailure(error))
             throw error;
         const lag = registerLag(input.scope, error);
-        const contracts = [];
-        for (const state of states) {
-            contracts.push({
+        return {
+            kind: "completed",
+            contracts: states.map((state) => ({
                 contractId: state.id,
-                report: isManagedWorktree(state)
-                    ? { effects: [], lag: [lag], settlement: emptySettlement() }
-                    : await completeReconcile({ ...input, contractId: state.id }),
-            });
-        }
-        return { kind: "completed", contracts };
+                report: { effects: [], lag: [lag], settlement: emptySettlement() },
+            })),
+        };
     }
     const places = new Map(appointed.appointments.map((appointment) => [appointment.contract, appointment.place]));
     const retained = await reconcileAllOperation({

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

@@ -177,8 +177,8 @@ export declare const keiyakuRefusalSchema: z.ZodUnion<readonly [z.ZodUnion<reado
     }, z.core.$strict>>>;
 }, z.core.$strict>]>, z.ZodObject<{
     kind: z.ZodEnum<{
-        "unborn-head": "unborn-head";
         "target-missing": "target-missing";
+        "unborn-head": "unborn-head";
         "invalid-target": "invalid-target";
     }>;
 }, z.core.$strict>, z.ZodObject<{
@@ -302,8 +302,8 @@ export declare const operationRefusalSchemas: {
         contractId: z.ZodPipe<z.ZodString, z.ZodTransform<import("../index.js").ContractId, string>>;
     }, z.core.$strict>, z.ZodObject<{
         kind: z.ZodEnum<{
-            "unborn-head": "unborn-head";
             "target-missing": "target-missing";
+            "unborn-head": "unborn-head";
             "invalid-target": "invalid-target";
         }>;
     }, z.core.$strict>, z.ZodUnion<readonly [z.ZodObject<{

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

@@ -1,8 +1,9 @@
 import { type RepositoryScope } from "../protocol/operations.js";
 import { NoGitWorldError } from "../git/repository.js";
 export { NoGitWorldError };
+/** One explicit worktree coordinate. The caller resolves relative and ambient spellings, never this edge. */
 export type RepoAtInput = Readonly<{
-    path?: string;
+    path: string;
     gitPath?: string;
 }>;
 /** One Git world shared by its worktrees; it is coordinate proof and branch observation only. */
@@ -10,7 +11,7 @@ export declare class Repo {
     readonly root: string;
     readonly cwd: string;
     private constructor();
-    static at(input?: RepoAtInput): Promise<Repo>;
+    static at(input: RepoAtInput): Promise<Repo>;
     currentBranch(): Promise<string | null>;
 }
 export declare function scopeForRepo(value: unknown): RepositoryScope;

package/build/src/library/repo.js

@@ -1,13 +1,19 @@
 import { realpath } from "node:fs/promises";
-import { resolve } from "node:path";
+import { isAbsolute } from "node:path";
 import { currentBranchOperation, scopeOperation } from "../protocol/operations.js";
 import { NoGitWorldError } from "../git/repository.js";
 import { optionalNonblank, requireInput } from "./input.js";
 export { NoGitWorldError };
 const REPO_SCOPES = new WeakMap();
-async function resolvePinnedScope(path, gitPath) {
+async function resolvePinnedScope(values) {
+    const path = values.path;
+    if (typeof path !== "string" || path.trim().length === 0)
+        throw new TypeError("repository path must be a nonblank string");
+    if (!isAbsolute(path))
+        throw new TypeError(`repository path must be absolute: ${path}`);
+    const gitPath = optionalNonblank(values.gitPath, "Git executable path");
     return await scopeOperation({
-        coordinate: await realpath(resolve(path === undefined ? process.cwd() : path)),
+        coordinate: await realpath(path),
         ...(gitPath === undefined ? {} : { gitPath }),
     });
 }
@@ -21,8 +27,7 @@ export class Repo {
         REPO_SCOPES.set(this, scope);
     }
     static async at(input) {
-        const values = input === undefined ? undefined : requireInput(input, "Repo.at input");
-        return new Repo(await resolvePinnedScope(optionalNonblank(values?.path, "repository path"), optionalNonblank(values?.gitPath, "Git executable path")));
+        return new Repo(await resolvePinnedScope(requireInput(input, "Repo.at input", ["path", "gitPath"])));
     }
     async currentBranch() {
         return await currentBranchOperation({ scope: scopeForRepo(this) });

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

@@ -5,7 +5,7 @@ import { type ActivityHistory, type OutcomeRow } from "../akuma/projection.js";
 import { type ExecutionContext } from "../akuma/requests.js";
 import { type Schema } from "../akuma/schema.js";
 import type { AkumaAskResult, AkumaKillResult, AkumaObservation, AkumaTellResult, AkumaWaitResult } from "../akuma/selection-observation.js";
-import { type DispatchAssociation } from "../dispatch/index.js";
+import type { DispatchAssociation } from "../akuma/dispatch-association.js";
 import type { WorldRoot } from "../world.js";
 import { addressAkuma, addressAkumaSet, type AkumaAddressInput, type AkumaSetAddressInput } from "./address.js";
 import { type Repo } from "./repo.js";
@@ -33,7 +33,7 @@ export type SelectionSeam = Readonly<{
     tell(addressed: AddressedAkuma, input: AkumaTellInput, signal?: AbortSignal): Promise<AkumaTellResult>;
     ask<T>(addressed: AddressedAkuma, input: AkumaAskInput<T>, signal?: AbortSignal): Promise<AkumaAskResult<T>>;
 }>;
-export declare function selectionSeam(execution: ExecutionContext): SelectionSeam;
+export declare function selectionSeam(execution: ExecutionContext, reportDiagnostic?: (message: string) => void): SelectionSeam;
 export type AkumaWaitInput = AkumaSetAddressInput & Readonly<{
     completion?: "any" | "all";
     timeoutMs?: number;
@@ -94,7 +94,7 @@ export type AkumaHistoryResult = Readonly<{
 }>;
 export declare function statusAkuma(input: AkumaAddressInput & Readonly<{
     path: WorldRoot;
-}>): Promise<AkumaObservation>;
+}>, reportDiagnostic?: (message: string) => void): Promise<AkumaObservation>;
 export declare function waitAkumaOn(seam: SelectionSeam, input: AkumaWaitInput & Readonly<{
     path: WorldRoot;
 }>): Promise<AkumaWaitResult>;
@@ -109,4 +109,4 @@ export declare function askAkumaOn<T = string>(seam: SelectionSeam, input: Akuma
 }>): Promise<AkumaAskResult<T>>;
 export declare function historyAkuma(input: AkumaHistoryInput & Readonly<{
     path: WorldRoot;
-}>): Promise<AkumaHistoryResult>;
+}>, reportDiagnostic?: (message: string) => void): Promise<AkumaHistoryResult>;

package/build/src/library/selection.js

@@ -13,13 +13,13 @@ import { observeDispatchAssociations } from "../dispatch/index.js";
 import { observeContractAt } from "../git/observe.js";
 import { withGitDecodeChannel } from "../git/read-observation.js";
 import { observeCreatedTaskObservations } from "../task/created-observation.js";
-import { outcomePluginObserver } from "../plugin/akuma-signals.js";
+import { outcomePluginObserver, stderrPluginDiagnostic } from "../plugin/akuma-signals.js";
 import { addressAkuma, addressAkumaSet, resolveAkuma, resolveAkumaSet, } from "./address.js";
 import { requireInput } from "./input.js";
 import { scopeForRepo } from "./repo.js";
-export function selectionSeam(execution) {
+export function selectionSeam(execution, reportDiagnostic = stderrPluginDiagnostic) {
     const channel = executionChannel(execution);
-    return channel.kind === "body-request" ? forwardedSelection(channel.directory) : localSelection();
+    return channel.kind === "body-request" ? forwardedSelection(channel.directory) : localSelection(reportDiagnostic);
 }
 function forwardedSelection(directory) {
     return {
@@ -56,11 +56,11 @@ function forwardedSelection(directory) {
         },
     };
 }
-function localSelection() {
+function localSelection(reportDiagnostic) {
     return {
         addressOne: addressAkuma,
         addressSet: addressAkumaSet,
-        wait: async (addressed, mode, observer) => await localWait(addressed, { ...mode, ...(observer === undefined ? {} : { observer }) }),
+        wait: async (addressed, mode, observer) => await localWait(addressed, { ...mode, ...(observer === undefined ? {} : { observer }) }, reportDiagnostic),
         kill: async (addressed, abort) => await executeKillAkuma({
             path: addressed.path,
             ids: addressed.orderedIds,
@@ -78,7 +78,7 @@ function localSelection() {
             const result = await executeAskAkuma({
                 path: addressed.path,
                 id: addressed.id,
-                outcomeObserved: outcomePluginObserver({ world: addressed.path, reportDiagnostic: console.error }),
+                outcomeObserved: outcomePluginObserver({ world: addressed.path, reportDiagnostic }),
                 body: input.body,
                 ...(input.timeoutMs === undefined ? {} : { timeoutMs: input.timeoutMs }),
                 ...(input.schema === undefined ? {} : { schemaJson: schemaJsonText(input.schema) }),
@@ -238,10 +238,10 @@ function setAddress(values) {
         ...(values.repo === undefined ? {} : { repo: values.repo }),
     };
 }
-export async function statusAkuma(input) {
+export async function statusAkuma(input, reportDiagnostic = stderrPluginDiagnostic) {
     const addressed = await addressAkuma(input);
     try {
-        return await observeAkuma(await new AkumaOwner(addressed.id, addressed.path, outcomePluginObserver({ world: addressed.path, reportDiagnostic: console.error })).status(), addressed.path, input.repo);
+        return await observeAkuma(await new AkumaOwner(addressed.id, addressed.path, outcomePluginObserver({ world: addressed.path, reportDiagnostic })).status(), addressed.path, input.repo);
     }
     catch (error) {
         throw observationError(addressed.id, error);
@@ -264,13 +264,13 @@ async function forwardedWait(addressed, input) {
         ...(input.signal === undefined ? {} : { signal: input.signal }),
     }));
 }
-async function localWait(addressed, input) {
+async function localWait(addressed, input, reportDiagnostic) {
     try {
         return await composeWaitResult(addressed.path, input.repo, await executeWaitAkuma({
             path: addressed.path,
             ids: addressed.orderedIds,
             completion: input.completion,
-            outcomeObserved: outcomePluginObserver({ world: addressed.path, reportDiagnostic: console.error }),
+            outcomeObserved: outcomePluginObserver({ world: addressed.path, reportDiagnostic }),
             ...(input.timeoutMs === undefined ? {} : { timeoutMs: input.timeoutMs }),
             ...(input.signal === undefined ? {} : { signal: input.signal }),
             identity: waitIdentityFacts(addressed.path, input.repo, addressed.orderedIds),
@@ -388,12 +388,12 @@ function validateHistoryInput(values) {
         (values.last === true || values.before !== undefined || values.since !== undefined || values.limit !== undefined))
         throw new TypeError("id cannot be combined with last, before, since, or limit");
 }
-export async function historyAkuma(input) {
+export async function historyAkuma(input, reportDiagnostic = stderrPluginDiagnostic) {
     const values = requireInput(input, "Akumas.history input");
     validateHistoryInput(values);
     const addressed = await addressAkuma(directAddress(values));
     try {
-        const handle = new AkumaOwner(addressed.id, addressed.path, outcomePluginObserver({ world: addressed.path, reportDiagnostic: console.error }));
+        const handle = new AkumaOwner(addressed.id, addressed.path, outcomePluginObserver({ world: addressed.path, reportDiagnostic }));
         const contract = (await dispatchAssociations(values.repo, [addressed.id])).get(addressed.id);
         if (values.last === true) {
             const answer = await handle.lastAnswer();

package/build/src/plugin/akuma-signals.d.ts

@@ -1,6 +1,8 @@
 import type { Settings } from "../settings.js";
 import type { WorldRoot } from "../world.js";
 import type { PluginSignal } from "./public.js";
+/** The local library observation default; CLI and Body supply their own sinks. */
+export declare function stderrPluginDiagnostic(message: string): void;
 type PluginSignalEmission = Readonly<{
     world: WorldRoot;
     settings?: Settings;

package/build/src/plugin/akuma-signals.js

@@ -1,4 +1,8 @@
 import { pluginRuntime, reportPluginDiagnostic } from "./runtime.js";
+/** The local library observation default; CLI and Body supply their own sinks. */
+export function stderrPluginDiagnostic(message) {
+    console.error(message);
+}
 /**
  * The one producer entry for plugin signals. It owns runtime acquisition, the
  * World Settings fallback, bounded delivery, and failure isolation: a delivery

package/build/src/plugin/public.d.ts

@@ -15,13 +15,38 @@ export type PluginOutcome = Readonly<{
     reason: string;
 }>;
 export type PluginBodyEnd = "exited" | "broke-off" | "put-down" | "hung";
+export type PluginAkumaOrigin = Readonly<{
+    kind: "direct";
+}> | Readonly<{
+    kind: "request";
+    parent: string;
+    requestId: string;
+}> | Readonly<{
+    kind: "fork";
+    parent: string;
+    at: string;
+}>;
+export type PluginAkumaCaller = Readonly<{
+    kind: "akuma";
+    world: string;
+    akuId: string;
+}> | Readonly<{
+    kind: "external";
+    integration: string;
+    id: string;
+}> | Readonly<{
+    kind: "unknown";
+}>;
 export type PluginSignalMap = Readonly<{
     "akuma.initiating": Readonly<{
         initiator: string;
     }>;
-    "akuma.called": Readonly<{
+    "akuma.born": Readonly<{
         akumaId: string;
-        callerAkumaId?: string;
+        bodySequence: number;
+        origin: PluginAkumaOrigin;
+        caller: PluginAkumaCaller;
+        initiator?: string;
         contractId?: string;
     }>;
     "akuma.outcome-observed": Readonly<{

package/build/src/plugin/runtime.js

@@ -22,7 +22,7 @@ export function reportPluginDiagnostic(report, subject, stage, error) {
     if (report === undefined)
         return;
     try {
-        report(`plugin ${subject} ${stage}: ${message(error)}`.slice(0, DIAGNOSTIC_LIMIT));
+        void Promise.resolve(report(`plugin ${subject} ${stage}: ${message(error)}`.slice(0, DIAGNOSTIC_LIMIT))).catch(() => { });
     }
     catch {
         // Diagnostics are optional side effects too.
@@ -204,7 +204,7 @@ async function writablePaths(world, declarations) {
  */
 const SIGNAL_KINDS = Object.freeze({
     "akuma.initiating": true,
-    "akuma.called": true,
+    "akuma.born": true,
     "akuma.outcome-observed": true,
     "akuma.turn-outcome": true,
     "akuma.body-ended": true,

package/build/src/protocol/amend.js

@@ -3,7 +3,8 @@ import { withPrivateStatePublicationSeat } from "../git/private-state-seat.js";
 import { contractState } from "../core/facts/observation.js";
 import { decideAmend } from "../core/verbs/amend.js";
 import { admitDecidedOffer, mintAttempts } from "./attempt.js";
-import { admitted, intentOutcomeWithSeatClose } from "./outcome.js";
+import { admitted } from "./outcome.js";
+import { protocolSeatClose } from "./run.js";
 import { timestamp } from "./operations.js";
 async function extendPrerequisiteClosureAt(channel, observation, seeds) {
     let current = observation;
@@ -34,7 +35,7 @@ export async function amendOperation(input) {
     const amendment = source === undefined || input.deriveAmendment === undefined
         ? undefined
         : { source, ...input.deriveAmendment(source) };
-    return intentOutcomeWithSeatClose(await withPrivateStatePublicationSeat(input.scope, async (seat) => {
+    return protocolSeatClose(await withPrivateStatePublicationSeat(input.scope, async (seat) => {
         const attempts = mintAttempts({ entryCount: 1 });
         for (let index = 0; index < attempts.length; index += 1) {
             let observation = await observeContractsForAdmissionAt(input.scope, input.channel, [input.contractId]);

package/build/src/protocol/attempt.js

@@ -65,12 +65,6 @@ function validateOffer(offer, attempt) {
     if (actualEntries.size === 0)
         throw new Error("offer requires at least one current-attempt ULID");
 }
-function snapshotFor(append, journals, head) {
-    const record = journals.get(append.contractId);
-    if (record === undefined)
-        throw new Error("accepted offer contract is missing from its observation");
-    return foldJournal(append.contractId, [...record.entries, ...append.entries], head);
-}
 function journalFor(append, journals) {
     const record = journals.get(append.contractId);
     if (record === undefined)
@@ -118,11 +112,12 @@ export async function admitDecidedOffer(input) {
     if (admission.kind === "accepted") {
         confirmPrivateStatePublication(seat);
         input.progress?.recordPublication(primaryContract, admission.heads[primary.contractId], offerEntries(offer));
+        const journal = journalFor(primary, decisionObservation.journals);
         const accepted = {
             kind: "accepted",
             facts: offerEntries(offer),
-            state: snapshotFor(primary, decisionObservation.journals, admission.heads[primary.contractId]),
-            journal: journalFor(primary, decisionObservation.journals),
+            state: foldJournal(primary.contractId, journal, admission.heads[primary.contractId]),
+            journal,
         };
         input.progress?.recordAdmission(accepted);
         return accepted;

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

@@ -11,8 +11,8 @@ export type { BindRefusal } from "../core/verbs/bind.js";
 export type { BindTargetSelection };
 export declare const targetInputRefusalSchema: z.ZodObject<{
     kind: z.ZodEnum<{
-        "unborn-head": "unborn-head";
         "target-missing": "target-missing";
+        "unborn-head": "unborn-head";
         "invalid-target": "invalid-target";
     }>;
 }, z.core.$strict>;
@@ -27,7 +27,7 @@ type BindOperationInput = Readonly<{
     channel: GitDecodeChannel;
     terms: BindData["terms"];
     verification: VerificationDeclarationPreparation;
-    targetSelection?: BindTargetSelection;
+    targetSelection: BindTargetSelection;
     workspace: "worktree";
     actor?: ActorId;
     decorateOffer?: CompanionDecorator;

package/build/src/protocol/bind.js

@@ -67,7 +67,7 @@ async function assembleBindInput(input, selection, seed, prepared) {
     };
 }
 export async function bindOperation(input) {
-    let selection = input.targetSelection ?? { kind: "targetless" };
+    let selection = input.targetSelection;
     if (selection.kind === "explicit") {
         const normalized = await normalizeTargetBranch(input.scope, selection.target);
         if (normalized === null)

package/build/src/protocol/deliver.js

@@ -6,13 +6,13 @@ import { materializeIntegrationSnapshot, materializeJudgedConflict, planIntegrat
 import { captureTender, dirtyTenderRefusal, materializeTenderSnapshot, prepareDeliveryCommitMetadata, } from "../git/tender.js";
 import { checkoutDetachedSnapshot, recordConflictHandoff, retireConflictHandoff, workspaceMergeStatePresent, worktreePath, conflictRecovery, } from "../git/workspace.js";
 import { observeContractsForAdmissionAt } from "../git/observe.js";
-import { externalPreparation, privateStateSeatAttempt, runBoundedAttempts, sameWorktreeWitness, STALE_PRIVATE_STATE_PREPARATION, } from "./run.js";
+import { externalPreparation, privateStateSeatAttempt, protocolSeatClose, runBoundedAttempts, sameWorktreeWitness, STALE_PRIVATE_STATE_PREPARATION, } from "./run.js";
 import { contractState } from "../core/facts/observation.js";
 import { decideDeliver } from "../core/verbs/deliver.js";
 import { currentVerifiedAttestation } from "./intent.js";
 import { admitDecidedOffer, mintAttempts } from "./attempt.js";
 import { appointmentFor, readPlaceRegister } from "../workspace-place.js";
-import { attemptDecisionWithSeatClose, recordedIntegrationSnapshots, timestamp } from "./operations.js";
+import { recordedIntegrationSnapshots, timestamp } from "./operations.js";
 export const deliverLeadingSchema = z
     .object({
     kind: z.enum(["admitted-now", "already-admitted"]),
@@ -418,7 +418,7 @@ async function deliverAttempt(input, attempt) {
         if (assembled.kind === "stale")
             return STALE_PRIVATE_STATE_PREPARATION;
         return await decideAndAdmitDelivery(input, attempt, seat, observation, assembled);
-    }, attemptDecisionWithSeatClose);
+    }, protocolSeatClose);
 }
 function isIntegrationConflict(refusal) {
     return refusal.kind === "integration-failed" && refusal.reason === "conflict";

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

@@ -2,7 +2,6 @@ import { z } from "zod";
 import type { DecideInput, OfferDecision } from "../core/decide.js";
 import type { ActorId, ContractId, ContractState, DeliverData, DocumentKey, JournalEntry, SnapshotId } from "../core/facts/types.js";
 import type { IntegrationPreparationRefusal } from "../git/integration.js";
-import { type PrivateStateSeatOutcome } from "../git/private-state-seat.js";
 import type { GitRepository } from "../git/process.js";
 import { type GitDecodeChannel } from "../git/read-observation.js";
 import type { WorktreeLeak } from "../git/scratch.js";
@@ -389,8 +388,8 @@ export declare const intentRefusalSchema: z.ZodUnion<readonly [z.ZodObject<{
     }, z.core.$strict>>>;
 }, z.core.$strict>]>, z.ZodObject<{
     kind: z.ZodEnum<{
-        "unborn-head": "unborn-head";
         "target-missing": "target-missing";
+        "unborn-head": "unborn-head";
         "invalid-target": "invalid-target";
     }>;
 }, z.core.$strict>, z.ZodObject<{
@@ -630,7 +629,6 @@ 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 unpackVerificationOutcome(verification: VerificationResult): Readonly<{
     cleanup?: VerificationCleanupFailure;
     leak?: WorktreeLeak;

package/build/src/protocol/operations.js

@@ -4,7 +4,6 @@ import { gate } from "../core/facts/types.js";
 import { changeIdSchema, contractIdSchema, snapshotIdSchema } from "../git/identity.js";
 import { integrationPreparationRefusalSchema, readDeliveryDiff } from "../git/integration.js";
 import { currentBranch, observeContractAt } from "../git/observe.js";
-import { appendPrivateStateSeatClose, mergePrivateStateSeatClose, } from "../git/private-state-seat.js";
 import { withGitReadObservation } from "../git/read-observation.js";
 import { repositoryAt } from "../git/repository.js";
 import { checkoutNotFollowableRefusalSchema } from "../git/target-placement.js";
@@ -216,13 +215,6 @@ export const placementStopSchema = z.union([
 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) };
-    });
-}
 function stepStop(result) {
     if (result.kind === "accepted")
         return undefined;

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

@@ -1,7 +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 { PrivateStateSeatCloseLag } 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";
@@ -38,5 +38,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>;
 export {};

package/build/src/protocol/outcome.js

@@ -1,4 +1,3 @@
-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");
@@ -16,12 +15,8 @@ export function accepted(state, facts, value, physical, obligations) {
 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, admissionObligations(admission));
+    return accepted(admission.state, admission.facts, value, admission.physical, admission.seatClose === undefined ? undefined : { seatClose: admission.seatClose });
 }
 export function complete(result, value) {
     if (result.kind === "refused")
@@ -30,10 +25,3 @@ 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,12 +3,12 @@ import { AuthorityCorruptionError } from "../core/facts/errors.js";
 import { contractState } from "../core/facts/observation.js";
 import { decidePlacement } from "../core/verbs/placement.js";
 import { observeContractsForAdmissionAt, observeGitForAdmissionAt } from "../git/observe.js";
-import { appendPrivateStateSeatClose, mergePrivateStateSeatClose, withPrivateStatePublicationSeat, } from "../git/private-state-seat.js";
+import { withPrivateStatePublicationSeat } from "../git/private-state-seat.js";
 import { reconcileEffectFailure } from "../git/reconcile.js";
 import { GitPlumbingError } from "../git/process.js";
 import { acquireTargetPlacementFence, followTargetPlacement, prepareTargetPlacement, prepareTargetPlacementChanges, observeTargetHead, observedTreeEqualsCandidate, } from "../git/target-placement.js";
 import { admitDecidedOffer, mintAttempts } from "./attempt.js";
-import { prepareProtocolAttempt, runProtocol } from "./run.js";
+import { prepareProtocolAttempt, protocolSeatClose, runProtocol, } from "./run.js";
 export { observeTargetPlacement } from "../git/target-placement.js";
 export async function observeIntegrationTargetMovement(repository, state) {
     const target = state.coordinates.target;
@@ -39,13 +39,6 @@ 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 placementChangesHint(repository, channel, contractId) {
     const observation = await observeContractsForAdmissionAt(repository, channel, [contractId]);
     const state = contractState(observation.decision, contractId);
@@ -63,7 +56,7 @@ async function runFencedPlacement(repository, input, protocol) {
             (changes?.predecessor !== movement.expectedOid || changes.candidate !== movement.newOid))
             changes = await prepareTargetPlacementChanges(repository, movement);
         let preparedPhysical;
-        const result = placementResultWithSeatClose(await withPrivateStatePublicationSeat(repository, async (seat) => {
+        const result = protocolSeatClose(await withPrivateStatePublicationSeat(repository, async (seat) => {
             // The hint carries no acceptance authority. Form a fresh semantic offer under the seat.
             const prepared = await prepareProtocolAttempt(protocol, protocol.attempts[index]);
             if (prepared.kind !== "offered")