@astrosheep/keiyaku 4.6.7 → 4.6.9

package/build/src/library/outcome.js

@@ -22,7 +22,7 @@ import { regionOverlapSchema } from "./region.js";
 // One invocation-wide tagged Effect carrier
 // ---------------------------------------------------------------------------
 const reconciliationEffectSchema = z.union([reconcileEffectSchema, contractFileEffectSchema]);
-const resetOwnerSchema = z.enum(["akuma", "git", "task", "world"]);
+const resetOwnerSchema = z.enum(["akuma", "git", "debt", "world"]);
 const resetEffectFields = { world: z.string().min(1), owner: resetOwnerSchema, diagnostic: z.string().min(1) };
 const resetEffectSchema = z.union([
     z.object({ kind: z.literal("reset-owner-stopped"), ...resetEffectFields }).strict(),
@@ -158,7 +158,7 @@ export function project(operation, snapshot, projection) {
         if (operation !== "nuke")
             throw new Error("reset projection requires nuke");
         const effects = snapshot.effects.filter((effect) => effect.kind === "reset-owner-stopped" || effect.kind === "reset-residue");
-        const value = { removed: snapshot.reset?.removed ?? { refs: 0, worktrees: 0, tasks: 0 } };
+        const value = { removed: snapshot.reset?.removed ?? { refs: 0, worktrees: 0, debts: 0 } };
         const base = { operation, world: projection.world, effects, pending: projectPending(operation, value, effects) };
         if (projection.kind === "failed")
             return {
@@ -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);
 }
@@ -394,7 +404,7 @@ const resetCountsSchema = z
     .object({
     refs: z.number().int().nonnegative(),
     worktrees: z.number().int().nonnegative(),
-    tasks: z.number().int().nonnegative(),
+    debts: z.number().int().nonnegative(),
 })
     .strict();
 const resetValueSchema = z.object({ removed: resetCountsSchema }).strict();

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

@@ -1,11 +1,10 @@
 import { type AskObserver } from "../akuma/akuma-selection-execution.js";
-import { type WaitObserver } from "../akuma/akuma-wait.js";
 import { type AkumaStatus } from "../akuma/akuma.js";
 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";
@@ -28,18 +27,16 @@ type SelectionWaitMode = Readonly<{
 export type SelectionSeam = Readonly<{
     addressOne(input: UncheckedSelectionAddress): Promise<AddressedAkuma>;
     addressSet(input: UncheckedSelectionAddress): Promise<AddressedAkumaSet>;
-    wait(addressed: AddressedAkumaSet, mode: SelectionWaitMode, observer?: WaitObserver): Promise<AkumaWaitResult>;
+    wait(addressed: AddressedAkumaSet, mode: SelectionWaitMode): Promise<AkumaWaitResult>;
     kill(addressed: AddressedAkumaSet, signal?: AbortSignal): Promise<AkumaKillResult>;
     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;
     signal?: AbortSignal;
-    /** The existing optional live-observation seam, validated here like Ask's. */
-    observe?: WaitObserver;
 }>;
 export type AkumaTellInput = AkumaAddressInput & Readonly<{
     body: string;
@@ -94,7 +91,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 +106,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

@@ -3,23 +3,22 @@ import { withoutReportedChanges } from "../akuma/projection.js";
 import { AkumaNotBornError, AkumaObservationError } from "../akuma/akuma-errors.js";
 import { AkumaOwner } from "../akuma/akuma-owner.js";
 import { decodeAskObservation, executeAskAkuma, executeKillAkuma, executeTellAkuma, } from "../akuma/akuma-selection-execution.js";
-import { executeWaitAkuma, } from "../akuma/akuma-wait.js";
+import { executeWaitAkuma } from "../akuma/akuma-wait.js";
 import { parsePublicHistoryId } from "../akuma/identity.js";
 import { executionChannel } from "../akuma/requests.js";
 import { schemaJsonText } from "../akuma/schema.js";
 import { requestForwardedSelectionAsk, requestForwardedSelectionKill, requestForwardedSelectionTell, requestForwardedSelectionWait, } from "../akuma/selection-request.js";
-import { readAliases } from "../alias/index.js";
 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 { observeCreatedDebtObservations } from "../debt/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 {
@@ -56,11 +55,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) => await localWait(addressed, mode, reportDiagnostic),
         kill: async (addressed, abort) => await executeKillAkuma({
             path: addressed.path,
             ids: addressed.orderedIds,
@@ -78,7 +77,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) }),
@@ -136,43 +135,19 @@ function placementDischarged(repo) {
 async function composeObservation(status, contract, discharged) {
     return (await discharged(contract)) ? { ...status, timeline: withoutReportedChanges(status.timeline) } : status;
 }
-async function createdTasksFor(path, statuses) {
-    return await observeCreatedTaskObservations(path, statuses.map((status) => status.id));
-}
-/**
- * One wait's identity-fact resolver: the alias bound to an Akuma in its world and
- * its Dispatch association. The alias index is read once, on the first observed
- * Akuma, and each Akuma's alias is the first binding the canonical order offers.
- * Alias bindings and selected Dispatch associations are read once for this live
- * stage. Final result composition owns a separate, fresh Dispatch observation.
- */
-function waitIdentityFacts(path, repo, selected) {
-    let aliases;
-    let contracts;
-    return async (id) => {
-        if (aliases === undefined) {
-            const bound = new Map();
-            for (const binding of await readAliases(path)) {
-                if (!bound.has(binding.akuId))
-                    bound.set(binding.akuId, binding.alias);
-            }
-            aliases = bound;
-        }
-        contracts ??= await dispatchAssociations(repo, selected);
-        const alias = aliases.get(id);
-        return { ...(alias === undefined ? {} : { alias }), contract: contracts.get(id) };
-    };
+async function createdDebtsFor(path, statuses) {
+    return await observeCreatedDebtObservations(path, statuses.map((status) => status.id));
 }
 async function observeAkuma(status, path, repo) {
     return (await composeAkumaAssociations([status], path, repo))[0];
 }
 /**
  * The one upper composition of association-free native status evidence into its
- * public observation shape. It reads Alias-independent Dispatch and Task
+ * public observation shape. It reads Alias-independent Dispatch and Debt
  * associations after the lower values, never before or inside them.
  */
 async function composeAkumaAssociations(statuses, path, repo) {
-    const created = await createdTasksFor(path, statuses);
+    const created = await createdDebtsFor(path, statuses);
     const discharged = placementDischarged(repo);
     const contracts = await dispatchAssociations(repo, statuses.map((status) => status.id));
     return await Promise.all(statuses.map(async (status, index) => {
@@ -180,7 +155,7 @@ async function composeAkumaAssociations(statuses, path, repo) {
         return {
             status: await composeObservation(status, contract, discharged),
             contract,
-            createdTasks: created[index],
+            createdDebts: created[index],
         };
     }));
 }
@@ -214,7 +189,7 @@ async function composeWaitResult(path, repo, result) {
 }
 /**
  * Re-attach upper associations after a wait result crosses a forwarded
- * boundary; the serving side must observe its own Dispatch and Task state.
+ * boundary; the serving side must observe its own Dispatch and Debt state.
  */
 async function attachWaitAssociations(path, repo, result) {
     return await composeWaitResult(path, repo, {
@@ -238,10 +213,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,19 +239,15 @@ 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),
-            selectionOrder: addressed.orderedIds,
-            ...(input.observer?.selected === undefined ? {} : { onSelected: input.observer.selected }),
-            ...(input.observer?.observe === undefined ? {} : { observe: input.observer.observe }),
         }));
     }
     catch (error) {
@@ -285,35 +256,13 @@ async function localWait(addressed, input) {
         throw observationError(addressed.orderedIds[0], error);
     }
 }
-function waitObserver(value) {
-    if (value === undefined)
-        return undefined;
-    if (typeof value !== "object" || value === null || Array.isArray(value))
-        throw new TypeError("observe must be a WaitObserver");
-    const record = value;
-    for (const key of Object.keys(record)) {
-        if (key !== "selected" && key !== "observe")
-            throw new TypeError(`observe has unknown field: ${key}`);
-        if (record[key] !== undefined && typeof record[key] !== "function")
-            throw new TypeError(`observe.${key} must be a function`);
-    }
-    return {
-        ...(record.selected === undefined
-            ? {}
-            : { selected: record.selected }),
-        ...(record.observe === undefined
-            ? {}
-            : { observe: record.observe }),
-    };
-}
 export async function waitAkumaOn(seam, input) {
     const values = requireInput(input, "Akumas.wait input");
     for (const key of Object.keys(values)) {
-        if (!["path", "akuma", "repo", "completion", "timeoutMs", "signal", "observe"].includes(key)) {
+        if (!["path", "akuma", "repo", "completion", "timeoutMs", "signal"].includes(key)) {
             throw new TypeError(`Akumas.wait input has unknown field: ${key}`);
         }
     }
-    const observer = waitObserver(values.observe);
     const selected = completionMode(values.completion);
     const timeoutMs = timeout(values.timeoutMs);
     const callerSignal = signal(values.signal);
@@ -324,7 +273,7 @@ export async function waitAkumaOn(seam, input) {
         ...(timeoutMs === undefined ? {} : { timeoutMs }),
         ...(callerSignal === undefined ? {} : { signal: callerSignal }),
         ...(repo === undefined ? {} : { repo }),
-    }, observer);
+    });
 }
 export async function killAkumaOn(seam, input) {
     const values = requireInput(input, "Akumas.kill input");
@@ -388,12 +337,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<{
@@ -29,6 +54,11 @@ export type PluginSignalMap = Readonly<{
         historyId: string;
         observer?: string;
     }>;
+    "akuma.turn-started": Readonly<{
+        akumaId: string;
+        turnSequence: number;
+        initiator?: string;
+    }>;
     "akuma.turn-outcome": Readonly<{
         akumaId: string;
         bodySequence: number;

package/build/src/plugin/runtime.js

@@ -7,6 +7,7 @@ const DIAGNOSTIC_LIMIT = 500;
 const PLUGIN_ATTEMPT_TIMEOUT_MS = 5_000;
 const PLUGIN_NAMESPACE = "plugins";
 const SQUARE_PLUGIN_PACKAGE = "@astrosheep/keiyaku-plugin-square";
+const BUNDLED_PLUGIN_PACKAGES = new Set([SQUARE_PLUGIN_PACKAGE, "@astrosheep/keiyaku-plugin-paseo"]);
 const BUILTIN_PLUGINS = Object.freeze([
     Object.freeze({ id: "square", package: SQUARE_PLUGIN_PACKAGE, config: undefined }),
 ]);
@@ -22,7 +23,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,8 +205,9 @@ 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-started": true,
     "akuma.turn-outcome": true,
     "akuma.body-ended": true,
 });
@@ -245,7 +247,7 @@ function sourceUrl(world, packageName) {
     return null;
 }
 async function importFromWorld(world, packageName) {
-    if (packageName === SQUARE_PLUGIN_PACKAGE)
+    if (BUNDLED_PLUGIN_PACKAGES.has(packageName))
         return (await import(packageName));
     const direct = sourceUrl(world, packageName);
     if (direct !== null)

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";