@astrosheep/keiyaku 4.6.6 → 4.6.7

package/build/src/akuma/akuma-selection-execution.js

@@ -64,7 +64,7 @@ export function decodeAskObservation(observation, schema) {
     }
 }
 export async function observeAdmittedAskAkuma(input) {
-    const owner = new AkumaOwner(input.id, input.path);
+    const owner = new AkumaOwner(input.id, input.path, input.outcomeObserved);
     const tell = input.receipt ?? (await owner.admittedReceipt(input.tellId));
     await input.onObserve?.admitted?.(tell, input.id);
     let settled;
@@ -118,6 +118,7 @@ export async function executeAskAkuma(input) {
         wake: admission.wake,
         ...(input.signal === undefined ? {} : { signal: input.signal }),
         ...(input.onObserve === undefined ? {} : { onObserve: input.onObserve }),
+        ...(input.outcomeObserved === undefined ? {} : { outcomeObserved: input.outcomeObserved }),
     });
 }
 export async function executeKillAkuma(input) {

package/build/src/akuma/akuma-wait.d.ts

@@ -1,6 +1,6 @@
 import type { AkumaAlias } from "../identity/selector.js";
 import type { WorldRoot } from "../world.js";
-import { type WaitReason } from "./akuma-observe.js";
+import { type OutcomeObserver, type WaitReason } from "./akuma-observe.js";
 import type { AkumaStatus } from "./akuma.js";
 import type { DispatchAssociation } from "./dispatch-association.js";
 import type { ActivityRow } from "./projection.js";
@@ -33,6 +33,7 @@ type WaitExecutionInput = Readonly<{
     signal?: AbortSignal;
     /** Internal custom completion judge over the full final observation where supplied. */
     predicate?: (status: AkumaStatus) => boolean;
+    outcomeObserved?: OutcomeObserver;
     /** Resolves one Akuma's identity facts; consulted once per Akuma a viewer first sees. */
     identity?: (id: AkumaStatus["id"]) => Promise<WaitIdentityFacts>;
     /** The selected set in the caller's order; a viewer's head and scoreboard follow it. */

package/build/src/akuma/akuma-wait.js

@@ -1,5 +1,5 @@
 import { AkumaNotBornError } from "./akuma-errors.js";
-import { createLiveStatusReader, defaultWaitComplete, readLiveStatus, readWaitComplete, waitForObservation, } from "./akuma-observe.js";
+import { createLiveStatusReader, defaultWaitComplete, readLiveStatus, readWaitComplete, observeOutcomeRows, observeStatusOutcome, waitForObservation, } from "./akuma-observe.js";
 import { pathsForAkuId } from "./identity.js";
 const SHARED_ORDINARY_BUDGET = 30;
 async function observeWaitRound(path, ids, signal, readers) {
@@ -88,6 +88,9 @@ export async function executeWaitAkuma(input) {
             input.onSelected(ordered.map((id) => ({ id, ...facts.get(id) })));
         }
         const observeRound = async (round) => {
+            await Promise.all(round.observations.map(({ status, rows }) => input.observe === undefined
+                ? observeStatusOutcome(status, input.outcomeObserved)
+                : observeOutcomeRows(status.id, rows, input.outcomeObserved)));
             if (input.observe === undefined)
                 return;
             const observed = [];

package/build/src/akuma/body.d.ts

@@ -93,6 +93,7 @@ type BodyRuntime = Readonly<{
     world: WorldRoot;
     externalCommands: Readonly<Record<string, ErasedRequestCommand>>;
 }>;
+export declare function recordPluginDiagnostic(paths: AkumaPaths, occurrence: string, error: unknown): Promise<void>;
 export declare function bodyProcessInput(launch: BodyLaunch, bodyModuleUrl?: string): Promise<{
     argv: string[];
     cwd: string;

package/build/src/akuma/body.js

@@ -10,7 +10,7 @@ import { HeldAkumaLeash, breakBody, decidePendingTellDisposition, drainPendingTe
 import { akumaPathsSchema, pathsForAkuId, worldRootForAkumaPaths } from "./identity.js";
 import { admitCallInitialTell, } from "./call-initial-tell.js";
 import { akumaExecutionEnvironment } from "./providers/execution-environment.js";
-import { pluginRuntime } from "../plugin/runtime.js";
+import { emitPluginSignal } from "../plugin/akuma-signals.js";
 import { World } from "../world.js";
 import { resolveProviderExecution } from "./providers/index.js";
 import { clearBodyRequestTransport, settleBodyRequests } from "./request-serve.js";
@@ -156,7 +156,7 @@ function boundedDiagnostic(error) {
     const text = diagnostic(error);
     return text.length <= 500 ? text : `${text.slice(0, 500)}...`;
 }
-async function recordPluginDiagnostic(paths, occurrence, error) {
+export async function recordPluginDiagnostic(paths, occurrence, error) {
     try {
         await appendFile(paths.log, `plugin ${occurrence} failed: ${boundedDiagnostic(error)}\n`);
     }
@@ -306,8 +306,7 @@ async function recoverBodyRequests(input) {
     }
     return false;
 }
-function turnOutcomeEmitter(launch, soul) {
-    let plugins;
+function turnOutcomeEmitter(launch, soul, world) {
     const reportDiagnostic = (message) => {
         void recordPluginDiagnostic(launch.paths, "turn outcome", message);
     };
@@ -318,11 +317,7 @@ function turnOutcomeEmitter(launch, soul) {
                 if (turn === null)
                     throw new Error(`Committed Turn ${turnSequence} is missing from Heart`);
                 const participants = await readTurnParticipants(launch.paths, turnSequence);
-                plugins ??= pluginRuntime({
-                    world: await World.at(worldRootForAkumaPaths(launch.paths)),
-                    reportDiagnostic,
-                });
-                await (await plugins).emit({
+                await emitPluginSignal({ world, reportDiagnostic }, {
                     kind: "akuma.turn-outcome",
                     akumaId: soul.id,
                     bodySequence: turn.bodySequence,
@@ -333,7 +328,7 @@ function turnOutcomeEmitter(launch, soul) {
                         ? { kind: "answered", text: outcome.answer }
                         : { kind: "failed", reason: outcome.diagnostic },
                     ...(launch.completion?.contractId === undefined ? {} : { contractId: launch.completion.contractId }),
-                }, reportDiagnostic);
+                });
             }
             catch (error) {
                 await recordPluginDiagnostic(launch.paths, "turn outcome", error);
@@ -341,22 +336,16 @@ function turnOutcomeEmitter(launch, soul) {
         },
     };
 }
-function bodyEndEmitter(launch, soul) {
-    let plugins;
+function bodyEndEmitter(launch, soul, world) {
     const reportDiagnostic = (message) => {
         void recordPluginDiagnostic(launch.paths, "body end", message);
     };
-    return (bodySequence, end, diagnostic) => (async () => {
+    return async (bodySequence, end, diagnostic) => {
         try {
             const latestTurn = await readLatestTurnForBody(launch.paths, bodySequence);
             const initiator = latestTurn?.initiator;
             const participants = latestTurn === null ? [] : await readTurnParticipants(launch.paths, latestTurn.sequence);
-            plugins ??= pluginRuntime({
-                world: await World.at(worldRootForAkumaPaths(launch.paths)),
-                reportDiagnostic,
-            });
-            const runtime = await plugins;
-            await runtime.emit({
+            await emitPluginSignal({ world, reportDiagnostic }, {
                 kind: "akuma.body-ended",
                 akumaId: soul.id,
                 bodySequence,
@@ -365,12 +354,12 @@ function bodyEndEmitter(launch, soul) {
                 ...(participants.length === 0 ? {} : { participants }),
                 ...(diagnostic === undefined ? {} : { diagnostic }),
                 ...(launch.completion?.contractId === undefined ? {} : { contractId: launch.completion.contractId }),
-            }, reportDiagnostic);
+            });
         }
         catch (error) {
             await recordPluginDiagnostic(launch.paths, "body end", error);
         }
-    })();
+    };
 }
 async function admitInitialCallTell(runtime, input) {
     const paths = pathsForAkuId(runtime.world, input.id);
@@ -575,8 +564,8 @@ export async function driveAkumaBody(launch, adapter, runtimeInput = {}) {
         const prepared = await prepareBodyExecution(launch, leash, runtime, adapter);
         if (prepared === null)
             return;
-        emitBodyEnd = bodyEndEmitter(launch, prepared.soul);
-        emitTurnOutcome = turnOutcomeEmitter(launch, prepared.soul);
+        emitBodyEnd = bodyEndEmitter(launch, prepared.soul, world);
+        emitTurnOutcome = turnOutcomeEmitter(launch, prepared.soul, world);
         const body = await leash.recordBody(launch.paths, { leashTakenAt: runtime.now() });
         bodySequence = body.sequence;
         const supervisor = await BodySupervisor.open(launch.paths, body.sequence, leash);

package/build/src/akuma/selection-owner-port.d.ts

@@ -9,4 +9,4 @@ import type { SelectionRequestPort } from "./selection-request.js";
  * unaddressable member never starts; the executor's own access to the target is
  * then the product act, never a second addressing probe.
  */
-export declare function selectionRequestPort(world: WorldRoot): SelectionRequestPort;
+export declare function selectionRequestPort(world: WorldRoot, reportDiagnostic: (message: string) => void): SelectionRequestPort;

package/build/src/akuma/selection-owner-port.js

@@ -1,3 +1,4 @@
+import { outcomePluginObserver } from "../plugin/akuma-signals.js";
 import { requireBornAkuma } from "./akuma-probe.js";
 import { executeAskAkuma, executeKillAkuma, executeTellAkuma } from "./akuma-selection-execution.js";
 import { executeWaitAkuma } from "./akuma-wait.js";
@@ -11,26 +12,36 @@ import { akumaObservationOf } from "./selection-observation.js";
  * unaddressable member never starts; the executor's own access to the target is
  * then the product act, never a second addressing probe.
  */
-export function selectionRequestPort(world) {
+export function selectionRequestPort(world, reportDiagnostic) {
     const prove = async (targets) => {
         for (const id of targets)
             await requireBornAkuma(world, id);
     };
     return {
-        wait: async ({ targets, ...request }) => {
+        wait: async ({ targets, observer, ...request }) => {
             await prove(targets);
             // The lower wait owner returns association-free native evidence; the
             // actual request crossing composes its canonical transport shape.
-            const native = await executeWaitAkuma({ path: world, ids: targets, ...request });
+            const native = await executeWaitAkuma({
+                path: world,
+                ids: targets,
+                ...request,
+                outcomeObserved: outcomePluginObserver({ world, reportDiagnostic }, observer),
+            });
             return { ...native, observations: native.observations.map(akumaObservationOf) };
         },
         tell: async ({ target, ...request }) => {
             await prove([target]);
             return await executeTellAkuma({ path: world, id: target, ...request });
         },
-        ask: async ({ target, ...request }) => {
+        ask: async ({ target, observer, ...request }) => {
             await prove([target]);
-            return await executeAskAkuma({ path: world, id: target, ...request });
+            return await executeAskAkuma({
+                path: world,
+                id: target,
+                ...request,
+                outcomeObserved: outcomePluginObserver({ world, reportDiagnostic }, observer),
+            });
         },
         kill: async ({ targets, ...request }) => {
             await prove(targets);

package/build/src/akuma/selection-request.d.ts

@@ -106,6 +106,7 @@ export type SelectionRequestPort = Readonly<{
         targets: readonly AkumaStatus["id"][];
         completion: "any" | "all";
         timeoutMs?: number;
+        observer: string;
         signal: AbortSignal;
     }>): Promise<AkumaWaitResult>;
     tell(input: Readonly<{
@@ -126,6 +127,7 @@ export type SelectionRequestPort = Readonly<{
         schemaJson?: string;
         initiator?: string;
         interrupt?: boolean;
+        observer: string;
         signal: AbortSignal;
     }>): Promise<AkumaAskResult>;
     kill(input: Readonly<{

package/build/src/akuma/selection-request.js

@@ -167,7 +167,7 @@ export function selectionRequestCommand(action, port) {
             if (request.action === "akuma.wait") {
                 return {
                     kind: "served",
-                    result: await port.wait({ ...request, signal: facts.signal }),
+                    result: await port.wait({ ...request, observer: facts.requester, signal: facts.signal }),
                     service: { action: request.action },
                 };
             }
@@ -196,6 +196,7 @@ export function selectionRequestCommand(action, port) {
                         body: request.body,
                         tellId: facts.id,
                         recordedAt: facts.admittedAt,
+                        observer: facts.requester,
                         ...(request.timeoutMs === undefined ? {} : { timeoutMs: request.timeoutMs }),
                         ...(request.schemaJson === undefined ? {} : { schemaJson: request.schemaJson }),
                         ...(request.initiator === undefined ? {} : { initiator: request.initiator }),

package/build/src/akuma-body.js

@@ -1,6 +1,6 @@
 import { resolve } from "node:path";
 import { fileURLToPath } from "node:url";
-import { bodyLaunchSchema, LEASH_HELD_EXIT, runAkumaBody } from "./akuma/body.js";
+import { bodyLaunchSchema, LEASH_HELD_EXIT, runAkumaBody, recordPluginDiagnostic, } from "./akuma/body.js";
 import { worldRootForAkumaPaths } from "./akuma/identity.js";
 import { composeRequestCommands } from "./akuma/request-wire.js";
 import { localExecutionContext } from "./akuma/requests.js";
@@ -108,7 +108,9 @@ export async function externalRequestCommandsFor(launch, processConfiguration) {
     const world = await World.prove(worldRootForAkumaPaths(launch.paths));
     return {
         world,
-        commands: composeRequestCommands(selectionRequestCommands(selectionRequestPort(world)), contractRequestCommands(contractUpstream(processConfiguration)), taskMutationRequestCommands(taskMutationRequestPort())),
+        commands: composeRequestCommands(selectionRequestCommands(selectionRequestPort(world, (message) => {
+            void recordPluginDiagnostic(launch.paths, "outcome observation", message);
+        })), contractRequestCommands(contractUpstream(processConfiguration)), taskMutationRequestCommands(taskMutationRequestPort())),
     };
 }
 function bodyProcessConfiguration() {

package/build/src/cli/commands/akuma.js

@@ -2,7 +2,7 @@ import { CliUsageError, isBlankInput } from "../usage.js";
 import { readFile } from "node:fs/promises";
 import { resolve } from "node:path";
 import { squareAssignedParticipantName } from "@astrosheep/square";
-import { emitInitiatingPluginSignal } from "../../plugin/akuma-signals.js";
+import { emitPluginSignal } from "../../plugin/akuma-signals.js";
 import { canonicalBirthCwd } from "../../akuma/call-input.js";
 import { Schema } from "../../akuma/index.js";
 import { executionChannel } from "../../akuma/requests.js";
@@ -73,17 +73,11 @@ async function inputInitiator(input) {
     // The initiator still travels with the request either way.
     if (!(await World.established(input.path)))
         return { initiator };
-    try {
-        await emitInitiatingPluginSignal({
-            world: input.path,
-            ...(input.settings === undefined ? {} : { settings: input.settings }),
-            initiator,
-            reportDiagnostic: (message) => writeStderr(message),
-        });
-    }
-    catch (error) {
-        writeStderr(`! plugin initiation: ${error instanceof Error ? error.message : String(error)}`);
-    }
+    await emitPluginSignal({
+        world: input.path,
+        ...(input.settings === undefined ? {} : { settings: input.settings }),
+        reportDiagnostic: (message) => writeStderr(message),
+    }, { kind: "akuma.initiating", initiator });
     return { initiator };
 }
 function emitAnswer(body, exact) {

package/build/src/cli/commands/install.js

@@ -47,8 +47,8 @@ export function renderInstallHelp() {
     return `${INSTALL_ROOT_PURPOSE}\n\n${usageLine(INSTALL_USAGE)}\n\n--all continues past failures; any failure exits 1.`;
 }
 const INSTALL_TIMEOUT_MS = 5 * 60 * 1000;
-const ASSET_ROOT = resolve(dirname(fileURLToPath(import.meta.url)), "../../../integrations/marketplace");
-const PLUGIN_ROOT = resolve(ASSET_ROOT, "plugins/keiyaku");
+const ASSET_ROOT = resolve(dirname(fileURLToPath(import.meta.url)), "../../../plugins");
+const OPENCODE_PLUGIN_ROOT = resolve(ASSET_ROOT, "opencode");
 const PI_PACKAGE_SOURCE = "npm:@astrosheep/keiyaku";
 function recipes(harness) {
     switch (harness) {
@@ -64,7 +64,7 @@ function recipes(harness) {
                 ["claude", "plugin", "update", "keiyaku@keiyaku", "--scope", "user"],
             ];
         case "opencode":
-            return [["opencode", "plugin", PLUGIN_ROOT, "--global", "--force"]];
+            return [["opencode", "plugin", OPENCODE_PLUGIN_ROOT, "--global", "--force"]];
         case "pi":
             return [["pi", "install", PI_PACKAGE_SOURCE]];
     }

package/build/src/library/akuma-creation.js

@@ -13,7 +13,7 @@ import { moveAlias } from "../alias/index.js";
 import { AuthorityCorruptionError } from "../core/facts/errors.js";
 import { publishDispatch, readDispatch } from "../dispatch/index.js";
 import { parseAkumaAlias } from "../identity/selector.js";
-import { emitCalledPluginSignal } from "../plugin/akuma-signals.js";
+import { emitPluginSignal, outcomePluginObserver } from "../plugin/akuma-signals.js";
 import { World } from "../world.js";
 import { addressAkuma } from "./address.js";
 import { requireInput } from "./input.js";
@@ -108,9 +108,9 @@ function pluginDiagnostic(error) {
     const message = error instanceof Error ? error.message : String(error);
     return message.length <= 500 ? message : `${message.slice(0, 500)}...`;
 }
-async function recordPluginDiagnostic(paths, error) {
+async function recordPluginDiagnostic(paths, error, occurrence = "call admission") {
     try {
-        await appendFile(paths.log, `plugin call admission failed: ${pluginDiagnostic(error)}\n`);
+        await appendFile(paths.log, `plugin ${occurrence} failed: ${pluginDiagnostic(error)}\n`);
     }
     catch {
         // Plugin diagnostic loss must not change an already admitted call.
@@ -126,22 +126,16 @@ async function emitCalledSignal(input) {
     try {
         const paths = pathsForAkuId(input.path, input.admitted.id);
         const callerAkumaId = input.admitted.requested ? await requestedParent(input.path, input.admitted.id) : undefined;
-        const reportDiagnostic = (message) => {
-            void recordPluginDiagnostic(paths, message);
-        };
-        try {
-            await emitCalledPluginSignal({
-                world: input.path,
-                ...(input.settings === undefined ? {} : { settings: input.settings }),
-                reportDiagnostic,
-                akumaId: input.admitted.id,
-                ...(callerAkumaId === undefined ? {} : { callerAkumaId }),
-                ...(input.contractId === undefined ? {} : { contractId: input.contractId }),
-            });
-        }
-        catch (error) {
-            await recordPluginDiagnostic(paths, error);
-        }
+        await emitPluginSignal({
+            world: input.path,
+            ...(input.settings === undefined ? {} : { settings: input.settings }),
+            reportDiagnostic: (message) => void recordPluginDiagnostic(paths, message),
+        }, {
+            kind: "akuma.called",
+            akumaId: input.admitted.id,
+            ...(callerAkumaId === undefined ? {} : { callerAkumaId }),
+            ...(input.contractId === undefined ? {} : { contractId: input.contractId }),
+        });
     }
     catch {
         // Plugin delivery must not change an already admitted call.
@@ -320,6 +314,13 @@ async function observeCall(input) {
             tellId: input.initialTell.tellId,
             timeoutMs: input.timeoutMs,
             receipt: input.receipt,
+            outcomeObserved: outcomePluginObserver({
+                world: input.path,
+                ...(input.settings === undefined ? {} : { settings: input.settings }),
+                reportDiagnostic: (message) => {
+                    void recordPluginDiagnostic(pathsForAkuId(input.path, input.akuma), message, "outcome observation");
+                },
+            }),
             ...(input.signal === undefined ? {} : { signal: input.signal }),
             onObserve,
         });
@@ -400,6 +401,7 @@ export async function callAkumas(input, execution = localExecutionContext()) {
             initialTell: parsed.initialTell,
             receipt,
             timeoutMs: parsed.timeoutMs,
+            ...(parsed.settings === undefined ? {} : { settings: parsed.settings }),
             ...(parsed.signal === undefined ? {} : { signal: parsed.signal }),
             ...(parsed.observe === undefined ? {} : { observe: parsed.observe }),
         });

package/build/src/library/selection.js

@@ -13,6 +13,7 @@ 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) }),
@@ -239,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);
@@ -268,6 +270,7 @@ 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, addressed.orderedIds),
@@ -390,7 +393,7 @@ export async function historyAkuma(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: console.error }));
         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,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 {};