@astrosheep/keiyaku 4.6.4 → 4.6.7

package/build/src/library/outcome.js

@@ -1,7 +1,7 @@
 /** @architectureCompositionRoot */
 import { z } from "zod";
 import { contractFileEffectSchema } from "../contract-worktree.js";
-import { decodeJournalEntry } from "../core/facts/codec.js";
+import { validateEntry } from "../core/facts/codec.js";
 import { AuthorityCorruptionError } from "../core/facts/errors.js";
 import { contractHeadSchema } from "../git/identity.js";
 import { reconcileEffectSchema } from "../git/reconcile.js";
@@ -100,7 +100,7 @@ function phasePending(operation, value) {
     if (concluded === undefined)
         return [];
     const pending = [];
-    if (concluded.verification !== undefined)
+    if (concluded.verification?.kind === "stopped")
         pending.push(surface("verification", true));
     if (concluded.placement !== undefined)
         pending.push(surface("placement", true));
@@ -306,7 +306,7 @@ const amendEvidenceSchema = z
     .strict()
     .refine((value) => value.overlaps === undefined || value.overlapFailure === undefined);
 const partialDeliverySchema = deliveryValueSchema.partial().superRefine((value, context) => {
-    const fields = deliverDataSchema.keyof().options;
+    const fields = deliverDataSchema.omit({ note: true }).keyof().options;
     const present = fields.filter((field) => value[field] !== undefined);
     if (present.length !== 0 && present.length !== fields.length)
         context.addIssue({ code: "custom", message: "delivery identity must be complete when present" });
@@ -322,7 +322,7 @@ const partialValueSchemas = {
 };
 const journalEntrySchema = z.unknown().transform((value, context) => {
     try {
-        return decodeJournalEntry(value);
+        return validateEntry(value);
     }
     catch {
         context.addIssue({ code: "custom", message: "invalid journal fact" });

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

@@ -8,6 +8,7 @@ import type { ReconcileResult } from "../git/reconcile.js";
 import { type RepositoryScope } from "../protocol/operations.js";
 import { type ProtocolProgress } from "../protocol/progress.js";
 import { type SettlementReport } from "../settlement/settle.js";
+import type { InvocationAccumulator } from "./invocation.js";
 export type ReconcileReport = Readonly<{
     effects: readonly (ReconcileResult["effects"][number] | ContractFileEffect)[];
     lag: readonly (ReconcileResult["lag"][number] | ContractFileLag)[];
@@ -128,5 +129,10 @@ type ReconcileOptions = Readonly<{
 export declare function completeReconcile(input: ReconcileOptions & Readonly<{
     contractId: ContractId;
 }>): Promise<ReconcileCompletion>;
+/**
+ * The one post-admission reconciliation walk: every affected Contract is observed afresh, and an
+ * operational stop is recorded rather than thrown.
+ */
+export declare function reconcileAffectedContracts(accumulator: InvocationAccumulator, contractId: ContractId, scope: RepositoryScope, channel: GitDecodeChannel, hooks: WorktreeHooks): Promise<void>;
 export declare function completeRepoReconcile(input: ReconcileOptions): Promise<RepoReconcileReport>;
 export {};

package/build/src/library/reconcile.js

@@ -4,7 +4,7 @@ import { contractFileLagSchema, projectContractWorktree, } from "../contract-wor
 import { gitReconcileLagSchema, reconcileObservationFailure } from "../git/reconcile.js";
 import { worktreePath } from "../git/workspace.js";
 import { stateOperation } from "../protocol/operations.js";
-import { isOperationalFailure } from "../protocol/progress.js";
+import { isOperationalFailure, isOperationalStop, executionStop } from "../protocol/progress.js";
 import { reconcileAllOperation, reconcileOperation, worldContractStates } from "../protocol/reconcile.js";
 import { settle, settleAll } from "../settlement/settle.js";
 import { appointManagedWorktrees, placeRegisterPath, releaseManagedWorktrees, } from "../workspace-place.js";
@@ -205,6 +205,36 @@ export async function completeReconcile(input) {
     const terminal = await finishTerminalReconcile(input, retained, appointed);
     return assembleReconcile(retained.report, projection, settlement, terminal);
 }
+/**
+ * The one post-admission reconciliation walk: every affected Contract is observed afresh, and an
+ * operational stop is recorded rather than thrown.
+ */
+export async function reconcileAffectedContracts(accumulator, contractId, scope, channel, hooks) {
+    for (const contract of [...new Set([contractId, ...accumulator.snapshot().affected])]) {
+        try {
+            scope.signal?.throwIfAborted();
+            accumulator.observe({ kind: "stage", contractId: contract, stage: "reconciliation", state: "started" });
+            try {
+                await completeReconcile({
+                    scope,
+                    channel,
+                    contractId: contract,
+                    hooks,
+                    retryHooks: false,
+                    progress: accumulator,
+                });
+            }
+            finally {
+                accumulator.observe({ kind: "stage", contractId: contract, stage: "reconciliation", state: "finished" });
+            }
+        }
+        catch (error) {
+            if (!isOperationalStop(error, scope.signal))
+                throw error;
+            accumulator.recordStop(executionStop(contract, "reconciliation", error, scope.signal));
+        }
+    }
+}
 function attachReleaseLag(contracts, released, lag) {
     const affected = new Set(released);
     return {

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

@@ -1,7 +1,6 @@
 import { type RepositoryScope } from "../protocol/operations.js";
 import { NoGitWorldError } from "../git/repository.js";
 export { NoGitWorldError };
-export type { RepoContractReconcileReport, RepoReconcileReport } from "./reconcile.js";
 export type RepoAtInput = Readonly<{
     path?: string;
     gitPath?: string;

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

@@ -56,10 +56,7 @@ export type AkumaAskInput<T = string> = AkumaAddressInput & Readonly<{
     signal?: AbortSignal;
     observe?: AskObserver;
 }>;
-export type { TellResult, TellWake } from "../akuma/body.js";
-export type { AkumaAskResult, AkumaKillResult, AkumaObservation, AkumaObservationStage, AkumaTellResult, AkumaUnobserved, AkumaWaitResult, } from "../akuma/selection-observation.js";
-export type { DispatchAssociation } from "../dispatch/association.js";
-export type { CreatedTaskObservation } from "../task/created-observation.js";
+export type { AkumaAskResult, AkumaKillResult, AkumaObservation, AkumaObservationStage, AkumaTellResult, AkumaWaitResult, } from "../akuma/selection-observation.js";
 export type AkumaKillInput = AkumaSetAddressInput & Readonly<{
     signal?: AbortSignal;
 }>;
@@ -98,18 +95,12 @@ export type AkumaHistoryResult = Readonly<{
 export declare function statusAkuma(input: AkumaAddressInput & Readonly<{
     path: WorldRoot;
 }>): Promise<AkumaObservation>;
-export declare function waitAkuma(input: AkumaWaitInput & Readonly<{
-    path: WorldRoot;
-}>, execution?: ExecutionContext): Promise<AkumaWaitResult>;
 export declare function waitAkumaOn(seam: SelectionSeam, input: AkumaWaitInput & Readonly<{
     path: WorldRoot;
 }>): Promise<AkumaWaitResult>;
 export declare function killAkumaOn(seam: SelectionSeam, input: AkumaKillInput & Readonly<{
     path: WorldRoot;
 }>): Promise<AkumaKillResult>;
-export declare function tellAkuma(input: AkumaTellInput & Readonly<{
-    path: WorldRoot;
-}>, execution?: ExecutionContext): Promise<AkumaTellResult>;
 export declare function tellAkumaOn(seam: SelectionSeam, input: AkumaTellInput & Readonly<{
     path: WorldRoot;
 }>): Promise<AkumaTellResult>;

package/build/src/library/selection.js

@@ -5,14 +5,15 @@ 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 { parsePublicHistoryId } from "../akuma/identity.js";
-import { executionChannel, localExecutionContext } from "../akuma/requests.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 { observeDispatchAssociation } from "../dispatch/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 { addressAkuma, addressAkumaSet, resolveAkuma, resolveAkumaSet, } from "./address.js";
 import { requireInput } from "./input.js";
 import { scopeForRepo } from "./repo.js";
@@ -77,6 +78,7 @@ function localSelection() {
             const result = await executeAskAkuma({
                 path: addressed.path,
                 id: addressed.id,
+                outcomeObserved: outcomePluginObserver({ world: addressed.path, reportDiagnostic: console.error }),
                 body: input.body,
                 ...(input.timeoutMs === undefined ? {} : { timeoutMs: input.timeoutMs }),
                 ...(input.schema === undefined ? {} : { schemaJson: schemaJsonText(input.schema) }),
@@ -99,8 +101,8 @@ function observationError(id, error) {
         return error;
     return new AkumaObservationError(id, observationDiagnostic(error));
 }
-async function dispatchAssociation(repo, id) {
-    return await observeDispatchAssociation(repo === undefined ? undefined : scopeForRepo(repo), id);
+async function dispatchAssociations(repo, ids) {
+    return await observeDispatchAssociations(repo === undefined ? undefined : scopeForRepo(repo), ids);
 }
 /**
  * Read-time placement discharge. Reported changes describe a candidate that a
@@ -141,9 +143,12 @@ async function createdTasksFor(path, statuses) {
  * 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) {
+function waitIdentityFacts(path, repo, selected) {
     let aliases;
+    let contracts;
     return async (id) => {
         if (aliases === undefined) {
             const bound = new Map();
@@ -153,8 +158,9 @@ function waitIdentityFacts(path, repo) {
             }
             aliases = bound;
         }
+        contracts ??= await dispatchAssociations(repo, selected);
         const alias = aliases.get(id);
-        return { ...(alias === undefined ? {} : { alias }), contract: await dispatchAssociation(repo, id) };
+        return { ...(alias === undefined ? {} : { alias }), contract: contracts.get(id) };
     };
 }
 async function observeAkuma(status, path, repo) {
@@ -168,8 +174,9 @@ async function observeAkuma(status, path, repo) {
 async function composeAkumaAssociations(statuses, path, repo) {
     const created = await createdTasksFor(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) => {
-        const contract = await dispatchAssociation(repo, status.id);
+        const contract = contracts.get(status.id);
         return {
             status: await composeObservation(status, contract, discharged),
             contract,
@@ -234,7 +241,7 @@ function setAddress(values) {
 export async function statusAkuma(input) {
     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: console.error })).status(), addressed.path, input.repo);
     }
     catch (error) {
         throw observationError(addressed.id, error);
@@ -263,9 +270,10 @@ async function localWait(addressed, input) {
             path: addressed.path,
             ids: addressed.orderedIds,
             completion: input.completion,
+            outcomeObserved: outcomePluginObserver({ world: addressed.path, reportDiagnostic: console.error }),
             ...(input.timeoutMs === undefined ? {} : { timeoutMs: input.timeoutMs }),
             ...(input.signal === undefined ? {} : { signal: input.signal }),
-            identity: waitIdentityFacts(addressed.path, input.repo),
+            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 }),
@@ -277,9 +285,6 @@ async function localWait(addressed, input) {
         throw observationError(addressed.orderedIds[0], error);
     }
 }
-export async function waitAkuma(input, execution = localExecutionContext()) {
-    return await waitAkumaOn(selectionSeam(execution), input);
-}
 function waitObserver(value) {
     if (value === undefined)
         return undefined;
@@ -330,9 +335,6 @@ export async function killAkumaOn(seam, input) {
     }
     return await seam.kill(await seam.addressSet(setAddress(values)), signal(values.signal));
 }
-export async function tellAkuma(input, execution = localExecutionContext()) {
-    return await tellAkumaOn(selectionSeam(execution), input);
-}
 export async function tellAkumaOn(seam, input) {
     const values = requireInput(input, "Akumas.tell input");
     for (const key of Object.keys(values)) {
@@ -391,8 +393,8 @@ export async function historyAkuma(input) {
     validateHistoryInput(values);
     const addressed = await addressAkuma(directAddress(values));
     try {
-        const handle = new AkumaOwner(addressed.id, addressed.path);
-        const contract = await dispatchAssociation(values.repo, addressed.id);
+        const handle = new AkumaOwner(addressed.id, addressed.path, outcomePluginObserver({ world: addressed.path, reportDiagnostic: console.error }));
+        const contract = (await dispatchAssociations(values.repo, [addressed.id])).get(addressed.id);
         if (values.last === true) {
             const answer = await handle.lastAnswer();
             return answer.kind === "answer"

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

@@ -1,18 +1,17 @@
 import type { Settings } from "../settings.js";
 import type { WorldRoot } from "../world.js";
-type CalledPluginSignalInput = Readonly<{
+import type { PluginSignal } from "./public.js";
+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,38 @@
-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 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);
+    }
 }
-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);
+/** 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

@@ -24,6 +24,11 @@ export type PluginSignalMap = Readonly<{
         callerAkumaId?: 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,7 +18,7 @@ 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 {
@@ -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.called": 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/abandon.d.ts

@@ -1,7 +1,7 @@
 import type { ActiveContractRefusal } from "../core/facts/observation.js";
 import type { GitTreeSelection } from "../git/read-observation.js";
 import type { CompanionDecorator } from "./run.js";
-import type { IntentOutcome, MutationOperationInput } from "./operations.js";
+import { type IntentOutcome, type MutationOperationInput } from "./operations.js";
 export declare function abandonOperation(input: MutationOperationInput & Readonly<{
     note?: string;
     decorateOffer?: CompanionDecorator;

package/build/src/protocol/abandon.js

@@ -1,16 +1,9 @@
 import { decideAbandon } from "../core/verbs/abandon.js";
-import { admitIntent } from "./intent.js";
-import { complete } from "./outcome.js";
-import { timestamp } from "./operations.js";
+import { admitVoidIntent } from "./operations.js";
 export async function abandonOperation(input) {
-    return complete(await admitIntent(input.channel, input.scope, {
-        contractId: input.contractId,
-        ...(input.actor === undefined ? {} : { actor: input.actor }),
-        at: timestamp(),
-        ...(input.note === undefined ? {} : { note: input.note }),
-    }, decideAbandon, {
+    return admitVoidIntent(input, { ...(input.note === undefined ? {} : { note: input.note }) }, decideAbandon, {
         ...(input.decorateOffer === undefined ? {} : { decorateOffer: input.decorateOffer }),
         ...(input.observationSelection === undefined ? {} : { observationSelection: input.observationSelection }),
         ...(input.progress === undefined ? {} : { progress: input.progress }),
-    }), undefined);
+    });
 }

package/build/src/protocol/amend.js

@@ -63,14 +63,11 @@ export async function amendOperation(input) {
             if (decision.kind === "refused")
                 return decision;
             const admission = await admitDecidedOffer({
-                channel: input.channel,
-                repository: input.scope,
+                ...input,
                 seat,
-                decisionObservation: observation,
+                observation,
                 attempt: attempts[index],
                 offer: decision.offer,
-                primaryContract: input.contractId,
-                ...(input.progress === undefined ? {} : { progress: input.progress }),
             });
             if (admission.kind === "accepted") {
                 if (amendment === undefined)

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

@@ -1,5 +1,5 @@
 import type { ActiveContractRefusal } from "../core/facts/observation.js";
-import type { IntentOutcome, MutationOperationInput } from "./operations.js";
+import { type IntentOutcome, type MutationOperationInput } from "./operations.js";
 export declare function arcOperation(input: MutationOperationInput & Readonly<{
     chapter: Readonly<{
         title: string;

package/build/src/protocol/arc.js

@@ -1,12 +1,5 @@
 import { decideArc } from "../core/verbs/arc.js";
-import { admitIntent } from "./intent.js";
-import { complete } from "./outcome.js";
-import { timestamp } from "./operations.js";
+import { admitVoidIntent } from "./operations.js";
 export async function arcOperation(input) {
-    return complete(await admitIntent(input.channel, input.scope, {
-        contractId: input.contractId,
-        ...(input.actor === undefined ? {} : { actor: input.actor }),
-        at: timestamp(),
-        data: input.chapter,
-    }, decideArc), undefined);
+    return admitVoidIntent(input, { data: input.chapter }, decideArc);
 }