@astrosheep/keiyaku 4.6.6 → 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,12 +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, 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 {
@@ -55,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,
@@ -77,6 +78,7 @@ function localSelection() {
             const result = await executeAskAkuma({
                 path: addressed.path,
                 id: addressed.id,
+                outcomeObserved: outcomePluginObserver({ world: addressed.path, reportDiagnostic }),
                 body: input.body,
                 ...(input.timeoutMs === undefined ? {} : { timeoutMs: input.timeoutMs }),
                 ...(input.schema === undefined ? {} : { schemaJson: schemaJsonText(input.schema) }),
@@ -236,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).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);
@@ -262,12 +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 }),
             ...(input.timeoutMs === undefined ? {} : { timeoutMs: input.timeoutMs }),
             ...(input.signal === undefined ? {} : { signal: input.signal }),
             identity: waitIdentityFacts(addressed.path, input.repo, addressed.orderedIds),
@@ -385,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);
+        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,18 +1,19 @@
 import type { Settings } from "../settings.js";
 import type { WorldRoot } from "../world.js";
-type CalledPluginSignalInput = Readonly<{
+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;
     reportDiagnostic: (message: string) => void;
-    akumaId: string;
-    callerAkumaId?: string;
-    contractId?: string;
 }>;
-export declare function emitInitiatingPluginSignal(input: Readonly<{
-    world: WorldRoot;
-    settings?: Settings;
-    initiator: string;
-    reportDiagnostic: (message: string) => void;
-}>): Promise<void>;
-export declare function emitCalledPluginSignal(input: CalledPluginSignalInput): Promise<void>;
+/**
+ * The one producer entry for plugin signals. It owns runtime acquisition, the
+ * World Settings fallback, bounded delivery, and failure isolation: a delivery
+ * problem reaches the producer only as a diagnostic, never as a thrown error.
+ */
+export declare function emitPluginSignal(emission: PluginSignalEmission, signal: PluginSignal): Promise<void>;
+/** One public observer operation, never shared with incidental owner reads. */
+export declare function outcomePluginObserver(emission: PluginSignalEmission, observer?: string): (akumaId: string, historyIds: readonly string[]) => Promise<void>;
 export {};

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

@@ -1,22 +1,42 @@
-import { pluginRuntime } from "./runtime.js";
-export async function emitInitiatingPluginSignal(input) {
-    const runtime = await pluginRuntime({
-        world: input.world,
-        ...(input.settings === undefined ? {} : { settings: input.settings }),
-        reportDiagnostic: input.reportDiagnostic,
-    });
-    await runtime.emit({ kind: "akuma.initiating", initiator: input.initiator }, input.reportDiagnostic);
+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);
 }
-export async function emitCalledPluginSignal(input) {
-    const runtime = await pluginRuntime({
-        world: input.world,
-        ...(input.settings === undefined ? {} : { settings: input.settings }),
-        reportDiagnostic: input.reportDiagnostic,
-    });
-    await runtime.emit({
-        kind: "akuma.called",
-        akumaId: input.akumaId,
-        ...(input.callerAkumaId === undefined ? {} : { callerAkumaId: input.callerAkumaId }),
-        ...(input.contractId === undefined ? {} : { contractId: input.contractId }),
-    }, input.reportDiagnostic);
+/**
+ * The one producer entry for plugin signals. It owns runtime acquisition, the
+ * World Settings fallback, bounded delivery, and failure isolation: a delivery
+ * problem reaches the producer only as a diagnostic, never as a thrown error.
+ */
+export async function emitPluginSignal(emission, signal) {
+    try {
+        const runtime = await pluginRuntime({
+            world: emission.world,
+            ...(emission.settings === undefined ? {} : { settings: emission.settings }),
+            reportDiagnostic: emission.reportDiagnostic,
+        });
+        await runtime.emit(signal, emission.reportDiagnostic);
+    }
+    catch (error) {
+        reportPluginDiagnostic(emission.reportDiagnostic, "runtime", "signal", error);
+    }
+}
+/** One public observer operation, never shared with incidental owner reads. */
+export function outcomePluginObserver(emission, observer) {
+    const seen = new Set();
+    return async (akumaId, historyIds) => {
+        const fresh = historyIds.filter((historyId) => {
+            const key = `${akumaId}:${historyId}`;
+            if (seen.has(key))
+                return false;
+            seen.add(key);
+            return true;
+        });
+        await Promise.all(fresh.map(async (historyId) => await emitPluginSignal(emission, {
+            kind: "akuma.outcome-observed",
+            akumaId,
+            historyId,
+            ...(observer === undefined ? {} : { observer }),
+        })));
+    };
 }

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

@@ -15,15 +15,45 @@ 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<{
+        akumaId: string;
+        historyId: string;
+        observer?: string;
+    }>;
     "akuma.turn-outcome": Readonly<{
         akumaId: string;
         bodySequence: number;

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

@@ -10,5 +10,6 @@ type PluginRuntimeInput = Readonly<{
 export type PluginRuntime = Readonly<{
     emit(signal: PluginSignal, reportDiagnostic?: PluginDiagnostic): Promise<void>;
 }>;
+export declare function reportPluginDiagnostic(report: PluginDiagnostic | undefined, subject: string, stage: string, error: unknown): void;
 export declare function pluginRuntime(input: PluginRuntimeInput): Promise<PluginRuntime>;
 export {};

package/build/src/plugin/runtime.js

@@ -18,11 +18,11 @@ function object(value) {
 function message(error) {
     return (error instanceof Error ? error.message : String(error)).slice(0, DIAGNOSTIC_LIMIT);
 }
-function diagnostic(report, subject, stage, error) {
+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.
@@ -67,30 +67,30 @@ async function settleBefore(promise, cancellation) {
 }
 function selectedEntry(entry, report) {
     if (entry.name.trim().length === 0) {
-        diagnostic(report, "<unnamed>", "selection", new TypeError("plugin setting name must be nonblank"));
+        reportPluginDiagnostic(report, "<unnamed>", "selection", new TypeError("plugin setting name must be nonblank"));
         return null;
     }
     if (!object(entry.value)) {
-        diagnostic(report, entry.name, "selection", new TypeError("plugin setting must be an object"));
+        reportPluginDiagnostic(report, entry.name, "selection", new TypeError("plugin setting must be an object"));
         return null;
     }
     const names = Object.keys(entry.value);
     if (!names.includes("package") || names.some((name) => !["package", "enabled", "config"].includes(name))) {
-        diagnostic(report, entry.name, "selection", new TypeError("plugin setting has unknown or missing fields"));
+        reportPluginDiagnostic(report, entry.name, "selection", new TypeError("plugin setting has unknown or missing fields"));
         return null;
     }
     const packageName = entry.value.package;
     if (typeof packageName !== "string" || packageName.trim().length === 0) {
-        diagnostic(report, entry.name, "selection", new TypeError("plugin package must be a nonblank string"));
+        reportPluginDiagnostic(report, entry.name, "selection", new TypeError("plugin package must be a nonblank string"));
         return null;
     }
     if (packageName !== packageName.trim()) {
-        diagnostic(report, entry.name, "selection", new TypeError("plugin package must not have surrounding whitespace"));
+        reportPluginDiagnostic(report, entry.name, "selection", new TypeError("plugin package must not have surrounding whitespace"));
         return null;
     }
     const enabled = entry.value.enabled;
     if (enabled !== undefined && typeof enabled !== "boolean") {
-        diagnostic(report, entry.name, "selection", new TypeError("plugin enabled must be a boolean"));
+        reportPluginDiagnostic(report, entry.name, "selection", new TypeError("plugin enabled must be a boolean"));
         return null;
     }
     if (enabled === false)
@@ -101,7 +101,7 @@ function selectedPlugins(input, report) {
     const view = input.namespace(PLUGIN_NAMESPACE);
     if (view.kind === "failed") {
         for (const failure of view.failures)
-            diagnostic(report, "settings", failure.scope, failure.diagnostic);
+            reportPluginDiagnostic(report, "settings", failure.scope, failure.diagnostic);
         return BUILTIN_PLUGINS;
     }
     if (view.entries.length === 0)
@@ -197,6 +197,21 @@ async function writablePaths(world, declarations) {
     }
     return paths;
 }
+/**
+ * The runtime's acceptance vocabulary. The record is exhaustive over the public
+ * payload map, so adding a signal there fails compilation here until the same
+ * kind is accepted.
+ */
+const SIGNAL_KINDS = Object.freeze({
+    "akuma.initiating": true,
+    "akuma.born": true,
+    "akuma.outcome-observed": true,
+    "akuma.turn-outcome": true,
+    "akuma.body-ended": true,
+});
+function isSignalKind(kind) {
+    return Object.hasOwn(SIGNAL_KINDS, kind);
+}
 function handlers(pluginId, instance) {
     if (!object(instance))
         throw new TypeError("plugin activation must return an object");
@@ -208,12 +223,8 @@ function handlers(pluginId, instance) {
         throw new TypeError("plugin signals must be an object");
     const registered = [];
     for (const [kind, handler] of Object.entries(instance.signals)) {
-        if (kind !== "akuma.initiating" &&
-            kind !== "akuma.called" &&
-            kind !== "akuma.turn-outcome" &&
-            kind !== "akuma.body-ended") {
+        if (!isSignalKind(kind))
             throw new TypeError(`plugin signal is unknown: ${kind}`);
-        }
         if (typeof handler !== "function")
             throw new TypeError(`plugin signal handler is not a function: ${kind}`);
         registered.push({ pluginId, kind, handler });
@@ -270,7 +281,7 @@ async function activate(input) {
     }
     catch (error) {
         markStarted();
-        diagnostic(report, selected.id, "import", error);
+        reportPluginDiagnostic(report, selected.id, "import", error);
         return [];
     }
     if (cancellation.aborted) {
@@ -288,7 +299,7 @@ async function activate(input) {
     }
     catch (error) {
         markStarted();
-        diagnostic(report, selected.id, "validation", error);
+        reportPluginDiagnostic(report, selected.id, "validation", error);
         return [];
     }
     let context;
@@ -307,7 +318,7 @@ async function activate(input) {
     }
     catch (error) {
         markStarted();
-        diagnostic(report, selected.id, "validation", error);
+        reportPluginDiagnostic(report, selected.id, "validation", error);
         return [];
     }
     if (cancellation.aborted) {
@@ -324,16 +335,16 @@ async function activate(input) {
         return registered;
     }
     catch (error) {
-        diagnostic(report, selected.id, "activation", error);
+        reportPluginDiagnostic(report, selected.id, "activation", error);
         return [];
     }
 }
 async function deliver(entry, signal, reportDiagnostic, timeoutMs) {
     const result = await boundedAttempt((cancellation) => entry.handler(signal, cancellation), timeoutMs);
     if (result.kind === "timed-out")
-        diagnostic(reportDiagnostic, entry.pluginId, "signal", timeoutError());
+        reportPluginDiagnostic(reportDiagnostic, entry.pluginId, "signal", timeoutError());
     if (result.kind === "failed")
-        diagnostic(reportDiagnostic, entry.pluginId, "signal", result.error);
+        reportPluginDiagnostic(reportDiagnostic, entry.pluginId, "signal", result.error);
 }
 export async function pluginRuntime(input) {
     let runtime = PROCESS_RUNTIMES.get(input.world);
@@ -358,7 +369,7 @@ async function createPluginRuntime(input) {
             releaseStarted();
             if (result.kind === "settled")
                 return { handlers: result.value, timedOut: false };
-            diagnostic(report, entry.id, "activation", result.kind === "failed" ? result.error : timeoutError());
+            reportPluginDiagnostic(report, entry.id, "activation", result.kind === "failed" ? result.error : timeoutError());
             return { handlers: [], timedOut: result.kind === "timed-out" };
         });
         previousStarted = started;
@@ -372,16 +383,16 @@ async function createPluginRuntime(input) {
                     const activatedHandlers = await settleBefore(activation, cancellation);
                     if (activatedHandlers !== ABORTED) {
                         if (activatedHandlers.timedOut)
-                            diagnostic(reportDiagnostic, selected[index].id, "signal", timeoutError());
+                            reportPluginDiagnostic(reportDiagnostic, selected[index].id, "signal", timeoutError());
                         return activatedHandlers.handlers;
                     }
-                    diagnostic(reportDiagnostic, selected[index].id, "signal", timeoutError());
+                    reportPluginDiagnostic(reportDiagnostic, selected[index].id, "signal", timeoutError());
                     return [];
                 }));
                 return handlers.flat();
             });
             if (activated.kind === "failed") {
-                diagnostic(reportDiagnostic, "runtime", "signal", activated.error);
+                reportPluginDiagnostic(reportDiagnostic, "runtime", "signal", activated.error);
                 return;
             }
             if (activated.kind === "timed-out")

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;