@astrosheep/keiyaku 4.6.11 → 4.6.12

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

@@ -7,12 +7,13 @@ export async function executeTellAkuma(input) {
     if (input.interrupt === true) {
         const interrupted = await owner.interrupt(input.body, {
             ...(input.tellId === undefined ? {} : { tellId: input.tellId }),
+            ...(input.recordedAt === undefined ? {} : { recordedAt: input.recordedAt }),
             ...(input.initiator === undefined ? {} : { initiator: input.initiator }),
             ...(input.signal === undefined ? {} : { signal: input.signal }),
         });
-        if (interrupted.kind === "unavailable")
+        if ("kind" in interrupted)
             throw new AkumaProviderError(`Tell interrupt unavailable: ${interrupted.evidence}`);
-        tell = interrupted.tell;
+        tell = interrupted;
     }
     else {
         tell = await owner.tell(input.body, input.tellId, input.recordedAt, undefined, {
@@ -73,7 +74,10 @@ export async function observeAdmittedAskAkuma(input) {
     void input.wake?.then((receipt) => {
         settled = receipt;
         wakeState = receipt.wake.kind === "failed" ? "failed" : "settled";
-    }, (error) => { wakeError = { error }; wakeState = "failed"; });
+    }, (error) => {
+        wakeError = { error };
+        wakeState = "failed";
+    });
     const admittedAt = Date.parse(tell.row.at);
     const observedAt = performance.timeOrigin + performance.now();
     const elapsed = input.startedAt === undefined
@@ -98,23 +102,61 @@ export async function observeAdmittedAskAkuma(input) {
         completedAt: observed.completedAt,
     };
 }
+/**
+ * The interrupt half of Ask: admit the Tell together with its yield request,
+ * then observe the answer bound to that same admission. Kept out of the public
+ * operation so ordinary and interrupted admission each read as one flow; both
+ * share `observeAdmittedAskAkuma`.
+ */
+async function executeInterruptAskAkuma(input, owner) {
+    const admission = await owner.admitInterrupt(input.body, {
+        ...(input.tellId === undefined ? {} : { tellId: input.tellId }),
+        ...(input.recordedAt === undefined ? {} : { recordedAt: input.recordedAt }),
+        ...(input.schemaJson === undefined ? {} : { schemaJson: input.schemaJson }),
+        ...(input.initiator === undefined ? {} : { initiator: input.initiator }),
+        ...(input.signal === undefined ? {} : { signal: input.signal }),
+    });
+    if (admission.kind === "unavailable")
+        throw new AkumaProviderError(`Tell interrupt unavailable: ${admission.evidence}`);
+    const observing = new AbortController();
+    const signal = input.signal === undefined ? observing.signal : AbortSignal.any([input.signal, observing.signal]);
+    const wake = owner.completeInterruptAdmission(admission, undefined, signal);
+    try {
+        const receipt = admission.barrier === undefined
+            ? undefined
+            : {
+                ...(await owner.admittedReceipt(admission.tell.id)),
+                interruption: { kind: "pending", bodySequence: admission.barrier.bodySequence },
+            };
+        return await observeAdmittedAskAkuma({
+            path: input.path,
+            id: input.id,
+            tellId: admission.tell.id,
+            ...(input.timeoutMs === undefined ? {} : { timeoutMs: input.timeoutMs }),
+            startedAt: performance.now(),
+            wake,
+            ...(receipt === undefined ? {} : { receipt }),
+            ...(input.signal === undefined ? {} : { signal: input.signal }),
+            ...(input.onObserve === undefined ? {} : { onObserve: input.onObserve }),
+            ...(input.outcomeObserved === undefined ? {} : { outcomeObserved: input.outcomeObserved }),
+        });
+    }
+    finally {
+        if (!observing.signal.aborted)
+            observing.abort(new Error("interrupt observation ended"));
+        await wake.catch(() => undefined);
+    }
+}
 export async function executeAskAkuma(input) {
     input.signal?.throwIfAborted();
     const owner = new AkumaOwner(input.id, input.path);
-    const admission = input.interrupt === true
-        ? await owner.admitInterrupt(input.body, {
-            ...(input.tellId === undefined ? {} : { tellId: input.tellId }),
-            ...(input.schemaJson === undefined ? {} : { schemaJson: input.schemaJson }),
-            ...(input.initiator === undefined ? {} : { initiator: input.initiator }),
-            ...(input.signal === undefined ? {} : { signal: input.signal }),
-        })
-        : await owner.admitTell(input.body, input.tellId, input.recordedAt, undefined, {
-            ...(input.schemaJson === undefined ? {} : { schemaJson: input.schemaJson }),
-            ...(input.initiator === undefined ? {} : { initiator: input.initiator }),
-            ...(input.signal === undefined ? {} : { signal: input.signal }),
-        });
-    if (admission.kind === "unavailable")
-        throw new AkumaProviderError(`Tell interrupt unavailable: ${admission.evidence}`);
+    if (input.interrupt === true)
+        return await executeInterruptAskAkuma(input, owner);
+    const admission = await owner.admitTell(input.body, input.tellId, input.recordedAt, undefined, {
+        ...(input.schemaJson === undefined ? {} : { schemaJson: input.schemaJson }),
+        ...(input.initiator === undefined ? {} : { initiator: input.initiator }),
+        ...(input.signal === undefined ? {} : { signal: input.signal }),
+    });
     if (admission.kind === "not-born")
         throw new AkumaNotBornError(input.id);
     return await observeAdmittedAskAkuma({

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

@@ -78,10 +78,9 @@ export declare const akumaStatusSchema: z.ZodObject<{
         "akuma.call": "akuma.call";
         "akuma.kill": "akuma.kill";
         "akuma.tell": "akuma.tell";
-        "contract.audit": "contract.audit";
         "contract.deliver": "contract.deliver";
         "contract.review": "contract.review";
-    }>>, z.ZodTransform<import("./allowed.js").AllowedActions, ("debt.add" | "debt.addDocument" | "debt.done" | "debt.drop" | "debt.update" | "akuma.call" | "akuma.kill" | "akuma.tell" | "contract.audit" | "contract.deliver" | "contract.review")[]>>;
+    }>>, z.ZodTransform<import("./allowed.js").AllowedActions, ("debt.add" | "debt.addDocument" | "debt.done" | "debt.drop" | "debt.update" | "akuma.call" | "akuma.kill" | "akuma.tell" | "contract.deliver" | "contract.review")[]>>;
     timeline: z.ZodUnion<readonly [z.ZodObject<{
         reportedChanges: z.ZodReadonly<z.ZodArray<z.ZodObject<{
             sequence: z.ZodNumber;

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

@@ -1,5 +1,5 @@
 import { z } from "zod";
-export declare const ALLOWED_ACTIONS: readonly ["akuma.call", "akuma.kill", "akuma.tell", "contract.audit", "contract.deliver", "contract.review", "debt.add", "debt.addDocument", "debt.done", "debt.drop", "debt.update"];
+export declare const ALLOWED_ACTIONS: readonly ["akuma.call", "akuma.kill", "akuma.tell", "contract.deliver", "contract.review", "debt.add", "debt.addDocument", "debt.done", "debt.drop", "debt.update"];
 export type AllowedAction = (typeof ALLOWED_ACTIONS)[number];
 export type AllowedActions = readonly AllowedAction[];
 export declare const DEFAULT_ALLOWED_ACTIONS: AllowedActions;
@@ -15,10 +15,9 @@ export declare const allowedActionsSchema: z.ZodPipe<z.ZodArray<z.ZodEnum<{
     "akuma.call": "akuma.call";
     "akuma.kill": "akuma.kill";
     "akuma.tell": "akuma.tell";
-    "contract.audit": "contract.audit";
     "contract.deliver": "contract.deliver";
     "contract.review": "contract.review";
-}>>, z.ZodTransform<AllowedActions, ("debt.add" | "debt.addDocument" | "debt.done" | "debt.drop" | "debt.update" | "akuma.call" | "akuma.kill" | "akuma.tell" | "contract.audit" | "contract.deliver" | "contract.review")[]>>;
+}>>, z.ZodTransform<AllowedActions, ("debt.add" | "debt.addDocument" | "debt.done" | "debt.drop" | "debt.update" | "akuma.call" | "akuma.kill" | "akuma.tell" | "contract.deliver" | "contract.review")[]>>;
 export declare function historicalAllowedActions(value: unknown): AllowedActions;
 export declare function unionAllowedActions(base: AllowedActions, additions: AllowedActions): AllowedActions;
 export declare function clipAllowedActions(requested: AllowedActions, parent: AllowedActions): AllowedActions;

package/build/src/akuma/allowed.js

@@ -3,14 +3,12 @@ import { z } from "zod";
 const AKUMA_MUTATION_ACTIONS = Object.freeze(["akuma.call", "akuma.kill", "akuma.tell"]);
 export const ALLOWED_ACTIONS = Object.freeze([
     ...AKUMA_MUTATION_ACTIONS,
-    "contract.audit",
     "contract.deliver",
     "contract.review",
     ...DEBT_MUTATION_ACTIONS,
 ]);
 export const DEFAULT_ALLOWED_ACTIONS = Object.freeze([
     ...AKUMA_MUTATION_ACTIONS,
-    "contract.audit",
     "contract.deliver",
     ...DEBT_MUTATION_ACTIONS,
 ]);
@@ -48,7 +46,7 @@ export function historicalAllowedActions(value) {
         return decodeAllowedActions(value);
     // Persisted permissions retain the same surviving capabilities after rename;
     // removed planning/progress operations confer no replacement permission.
-    const retired = new Set(["task.compose", "task.start", "task.stop", "task.hold", "task.resume"]);
+    const retired = new Set(["contract.audit", "task.compose", "task.start", "task.stop", "task.hold", "task.resume"]);
     return decodeAllowedActions(value
         .filter((action) => !retired.has(action))
         .map((action) => typeof action === "string" && action.startsWith("task.") ? `debt.${action.slice("task.".length)}` : action));

package/build/src/akuma/body.js

@@ -7,7 +7,7 @@ import { fileURLToPath } from "node:url";
 import { abortable, abortableDelay } from "./abort.js";
 import { BodySupervisor } from "./body-supervisor.js";
 import { driveTurn, turnRecipe } from "./turn-drive.js";
-import { HeldAkumaLeash, breakBody, decidePendingTellDisposition, drainPendingTells, endTurn, failOpenBoundTurns, finishBodyIfIdle, heartExists, isHeartAbsent, probeLeash, projectTell, readHeart, readLatestTurnForBody, readOpenBoundTurns, readOpenPendingTellDisposition, readTell, readTurn, readTurnParticipants, readNonterminalRequests, resolvePendingTellDisposition, } from "./heart/index.js";
+import { HeldAkumaLeash, BodyControlledError, breakBody, decidePendingTellDisposition, drainPendingTells, endTurn, failOpenBoundTurns, finishBodyIfIdle, heartExists, isHeartAbsent, probeLeash, projectTell, readHeart, readLatestTurnForBody, readOpenBoundTurns, readOpenPendingTellDisposition, readTell, readTurn, readTurnParticipants, readNonterminalRequests, resolvePendingTellDisposition, } from "./heart/index.js";
 import { akumaPathsSchema, pathsForAkuId, worldRootForAkumaPaths } from "./identity.js";
 import { admitCallInitialTell, } from "./call-initial-tell.js";
 import { akumaExecutionEnvironment } from "./providers/execution-environment.js";
@@ -248,14 +248,14 @@ async function prepareBodyExecution(launch, leash, runtime, adapter) {
     if (birth === null)
         return null;
     const { soul } = birth;
+    if (!(await prepareBodyStart(launch.paths, leash)))
+        return null;
     if (launch.seed === undefined && launch.initialBody === undefined) {
         const [heart, requests] = await Promise.all([readHeart(launch.paths), readNonterminalRequests(launch.paths)]);
         if (heart.pending.length === 0 && requests.length === 0)
             return null;
     }
     const selected = adapter ?? (await resolveProviderExecution(soul.provider)).adapter;
-    if (!(await prepareBodyStart(launch.paths, leash)))
-        return null;
     return { ...birth, adapter: selected };
 }
 async function runPreparedBody(input) {
@@ -283,9 +283,10 @@ async function preserveBodyFailure(paths, leash, error, at) {
     }
 }
 async function prepareBodyStart(paths, leash) {
-    const before = await readHeart(paths);
-    if (before.pause !== null)
+    const completion = await leash.completeInterruptBarrier(paths);
+    if (completion.kind === "unavailable")
         return false;
+    const before = await readHeart(paths);
     if (before.stop === null)
         return true;
     if (before.latestBody?.sequence === before.stop.bodySequence && before.latestBody.end === "put-down") {
@@ -409,7 +410,8 @@ async function runBodyTurns(input) {
     const { launch, soul, adapter, bodySequence, supervisor, runtime, turnStarted, turnOutcome } = input;
     let initial = launch.initialBody;
     for (;;) {
-        const launchTells = drainPendingTells(supervisor.current().pending, await readOpenBoundTurns(launch.paths, bodySequence));
+        const control = supervisor.current();
+        const launchTells = drainPendingTells(control.pending, await readOpenBoundTurns(launch.paths, bodySequence), control.pause, bodySequence);
         if (supervisor.signal.aborted) {
             await putDownIfControlled(launch.paths, supervisor, bodySequence, runtime.now);
             return;
@@ -594,8 +596,11 @@ export async function driveAkumaBody(launch, adapter, runtimeInput = {}) {
     let emitTurnOutcome;
     try {
         const prepared = await prepareBodyExecution(launch, leash, runtime, adapter);
-        if (prepared === null)
+        if (prepared === null) {
+            if ((await readHeart(launch.paths)).pause !== null)
+                return "held";
             return;
+        }
         emitBodyEnd = bodyEndEmitter(launch, prepared.soul, world);
         emitTurnStarted = turnStartedEmitter(launch, prepared.soul, world);
         emitTurnOutcome = turnOutcomeEmitter(launch, prepared.soul, world);
@@ -629,6 +634,11 @@ export async function driveAkumaBody(launch, adapter, runtimeInput = {}) {
         });
     }
     catch (error) {
+        if (error instanceof BodyControlledError) {
+            if (bodySequence !== undefined)
+                await breakBody(launch.paths, { sequence: bodySequence, end: "put-down", at: runtime.now() });
+            return "held";
+        }
         await preserveBodyFailure(launch.paths, leash, error, runtime.now());
         throw error;
     }

package/build/src/akuma/call-initial-tell.d.ts

@@ -140,6 +140,24 @@ export declare const tellResultSchema: z.ZodObject<{
             };
         } | undefined;
     }>>]>;
+    interruption: z.ZodOptional<z.ZodDiscriminatedUnion<[z.ZodObject<{
+        kind: z.ZodLiteral<"completed">;
+        bodySequence: z.ZodNumber;
+        putDown: z.ZodEnum<{
+            "was-idle": "was-idle";
+            "self-aborted": "self-aborted";
+        }>;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"pending">;
+        bodySequence: z.ZodNumber;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"unavailable">;
+        bodySequence: z.ZodNumber;
+        evidence: z.ZodEnum<{
+            hung: "hung";
+            untidy: "untidy";
+        }>;
+    }, z.core.$strict>], "kind">>;
 }, z.core.$strict>;
 export type TellWake = z.infer<typeof tellWakeSchema>;
 export type TellResult = z.infer<typeof tellResultSchema>;

package/build/src/akuma/call-initial-tell.js

@@ -19,6 +19,23 @@ const failedTellWakeSchema = z
 })
     .strict()
     .transform(({ child, ...wake }) => (child === undefined ? wake : { ...wake, child }));
+const interruptReceiptSchema = z.discriminatedUnion("kind", [
+    z
+        .object({
+        kind: z.literal("completed"),
+        bodySequence: z.number().int().positive(),
+        putDown: z.enum(["was-idle", "self-aborted"]),
+    })
+        .strict(),
+    z.object({ kind: z.literal("pending"), bodySequence: z.number().int().positive() }).strict(),
+    z
+        .object({
+        kind: z.literal("unavailable"),
+        bodySequence: z.number().int().positive(),
+        evidence: z.enum(["hung", "untidy"]),
+    })
+        .strict(),
+]);
 const tellWakeSchema = z.union([
     z.object({ kind: z.literal("told") }).strict(),
     z.object({ kind: z.literal("held") }).strict(),
@@ -30,6 +47,7 @@ export const tellResultSchema = z
     admission: z.object({ fact: z.literal("recorded"), tellId: nonblankTextSchema }).strict(),
     row: tellRowSchema,
     wake: tellWakeSchema,
+    interruption: interruptReceiptSchema.optional(),
 })
     .strict();
 export async function admitCallInitialTell(input) {

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

@@ -16,10 +16,9 @@ declare const akumaCallRecipeSchema: z.ZodObject<{
         "akuma.call": "akuma.call";
         "akuma.kill": "akuma.kill";
         "akuma.tell": "akuma.tell";
-        "contract.audit": "contract.audit";
         "contract.deliver": "contract.deliver";
         "contract.review": "contract.review";
-    }>>, z.ZodTransform<import("./allowed.js").AllowedActions, ("debt.add" | "debt.addDocument" | "debt.done" | "debt.drop" | "debt.update" | "akuma.call" | "akuma.kill" | "akuma.tell" | "contract.audit" | "contract.deliver" | "contract.review")[]>>;
+    }>>, z.ZodTransform<import("./allowed.js").AllowedActions, ("debt.add" | "debt.addDocument" | "debt.done" | "debt.drop" | "debt.update" | "akuma.call" | "akuma.kill" | "akuma.tell" | "contract.deliver" | "contract.review")[]>>;
     provider: z.ZodPipe<z.ZodObject<{
         name: z.ZodString;
         kind: z.ZodEnum<{
@@ -96,10 +95,9 @@ declare const akumaCallPayloadSchema: z.ZodObject<{
             "akuma.call": "akuma.call";
             "akuma.kill": "akuma.kill";
             "akuma.tell": "akuma.tell";
-            "contract.audit": "contract.audit";
             "contract.deliver": "contract.deliver";
             "contract.review": "contract.review";
-        }>>, z.ZodTransform<import("./allowed.js").AllowedActions, ("debt.add" | "debt.addDocument" | "debt.done" | "debt.drop" | "debt.update" | "akuma.call" | "akuma.kill" | "akuma.tell" | "contract.audit" | "contract.deliver" | "contract.review")[]>>;
+        }>>, z.ZodTransform<import("./allowed.js").AllowedActions, ("debt.add" | "debt.addDocument" | "debt.done" | "debt.drop" | "debt.update" | "akuma.call" | "akuma.kill" | "akuma.tell" | "contract.deliver" | "contract.review")[]>>;
         provider: z.ZodPipe<z.ZodObject<{
             name: z.ZodString;
             kind: z.ZodEnum<{
@@ -266,6 +264,24 @@ declare const liveResultSchema: z.ZodObject<{
                 };
             } | undefined;
         }>>]>;
+        interruption: z.ZodOptional<z.ZodDiscriminatedUnion<[z.ZodObject<{
+            kind: z.ZodLiteral<"completed">;
+            bodySequence: z.ZodNumber;
+            putDown: z.ZodEnum<{
+                "was-idle": "was-idle";
+                "self-aborted": "self-aborted";
+            }>;
+        }, z.core.$strict>, z.ZodObject<{
+            kind: z.ZodLiteral<"pending">;
+            bodySequence: z.ZodNumber;
+        }, z.core.$strict>, z.ZodObject<{
+            kind: z.ZodLiteral<"unavailable">;
+            bodySequence: z.ZodNumber;
+            evidence: z.ZodEnum<{
+                hung: "hung";
+                untidy: "untidy";
+            }>;
+        }, z.core.$strict>], "kind">>;
     }, z.core.$strict>>;
     tellFailure: z.ZodOptional<z.ZodString>;
 }, z.core.$strict>;

package/build/src/akuma/heart/facts.d.ts

@@ -199,7 +199,20 @@ export type StopFact = Readonly<{
 export type PauseFact = Readonly<{
     bodySequence: number;
     requestedAt: string;
+    frontierTellId?: string;
 }>;
+export type InterruptCompletion = Readonly<{
+    kind: "clear";
+}> | Readonly<{
+    kind: "completed";
+    body: BodyFact;
+}> | Readonly<{
+    kind: "unavailable";
+    evidence: "hung" | "untidy";
+}>;
+export declare class BodyControlledError extends Error {
+    constructor();
+}
 export type SealFact = Readonly<{
     evidence: string;
     at: string;

package/build/src/akuma/heart/facts.js

@@ -30,6 +30,12 @@ export class AkumaBusyError extends Error {
         this.name = "AkumaBusyError";
     }
 }
+export class BodyControlledError extends Error {
+    constructor() {
+        super("Akuma Body admission is fenced by durable control");
+        this.name = "BodyControlledError";
+    }
+}
 export function life(input) {
     if (input.body?.hung !== undefined)
         return "hung";

package/build/src/akuma/heart/index.d.ts

@@ -1,14 +1,17 @@
 import type { AkumaPaths } from "../identity.js";
-import type { BodyEnd, BodyFact, ForkPoint, HeartSnapshot, KillFact, SealFact, SessionFact, Soul, TellDeliveryInput, TellFact, TellReceiptInput, TurnEndFact, TurnFact, TurnOutcome, TurnStartFact } from "./facts.js";
+import type { BodyEnd, BodyFact, ForkPoint, HeartSnapshot, InterruptCompletion, KillFact, PauseFact, SealFact, SessionFact, Soul, TellDeliveryInput, TellFact, TellReceiptInput, TurnEndFact, TurnFact, TurnOutcome, TurnStartFact } from "./facts.js";
 import type { AgentEvent } from "./activity-schema.js";
 import { type StatusFactInput, type ActivityFactSlice } from "./timeline.js";
 import { type HeartRead } from "./storage.js";
 export { HeartAbsentError, HeldAkumaLeash, classifyHeartSchema, initializeHeart, isHeartAbsent, probeLeash, } from "./storage.js";
 export { admitRequest, beginRequest, isRequestInputConflict, readNonterminalRequests, readRequest, refuseRequest, reserveRequest, serveRequest, serveUpstreamRequest, unproveRequest, voidRequest, } from "./request-authority.js";
-export { AkumaBusyError, life, lifeAt, projectTell } from "./facts.js";
+export { AkumaBusyError, BodyControlledError, life, lifeAt, projectTell } from "./facts.js";
 export { drainPendingTells } from "./tells.js";
-export type { AkumaLife, AkumaOrigin, BodyEnd, HeartSnapshot, KillEvidence, RequestFact, SessionFact, Soul, TellFact, TurnEndFact, TurnOutcome, } from "./facts.js";
+export type { AkumaLife, AkumaOrigin, BodyEnd, BodyFact, InterruptCompletion, PauseFact, HeartSnapshot, KillEvidence, RequestFact, SessionFact, Soul, TellFact, TurnEndFact, TurnOutcome, } from "./facts.js";
 export type { ResumeCoordinate } from "../coordinate.js";
+export declare function readInterruptCompletion(paths: AkumaPaths, expected: PauseFact): Promise<Extract<InterruptCompletion, {
+    kind: "completed" | "unavailable";
+}>>;
 export declare function readSoul(paths: AkumaPaths): Promise<Soul | null>;
 export declare function heartExists(paths: AkumaPaths): Promise<boolean>;
 export declare function readSeal(paths: AkumaPaths): Promise<SealFact | null>;
@@ -83,14 +86,32 @@ type LifeSnapshot = Pick<HeartSnapshot, "soul" | "latestBody" | "latestSession"
 }>;
 /** Lifecycle probes do not load narration, Tell bodies, or delivery histories. */
 export declare function readLifeSnapshot(paths: AkumaPaths, signal?: AbortSignal, read?: HeartRead): Promise<LifeSnapshot>;
-export declare function recordTell(paths: AkumaPaths, tell: Omit<TellFact, "sequence" | "state" | "deliveries" | "binding">, options?: Readonly<{
-    interrupt?: boolean;
-}>): Promise<Readonly<{
+export type InterruptTellAdmission = Readonly<{
     kind: "not-born";
-} | {
+}> | Readonly<{
+    kind: "unavailable";
+    evidence: "hung" | "untidy";
+}> | Readonly<{
     kind: "recorded";
     tell: TellFact;
-}>>;
+    predecessorWasRunning: boolean;
+    barrier?: PauseFact;
+}>;
+type TellAdmission = Readonly<{
+    kind: "not-born";
+}> | Readonly<{
+    kind: "recorded";
+    tell: TellFact;
+}>;
+type TellInput = Omit<TellFact, "sequence" | "state" | "deliveries" | "binding">;
+export declare function recordTell(paths: AkumaPaths, tell: TellInput, options: Readonly<{
+    interrupt: true;
+    signal?: AbortSignal;
+}>): Promise<InterruptTellAdmission>;
+export declare function recordTell(paths: AkumaPaths, tell: TellInput, options?: Readonly<{
+    interrupt?: false;
+    signal?: AbortSignal;
+}>): Promise<TellAdmission>;
 export declare function readTell(paths: AkumaPaths, id: string): Promise<TellFact | null>;
 export declare function recordTellDeliveries(paths: AkumaPaths, inputs: readonly TellDeliveryInput[]): Promise<void>;
 export declare function recordTellReceipt(paths: AkumaPaths, input: TellReceiptInput): Promise<void>;
@@ -117,12 +138,6 @@ export declare function requestStop(paths: AkumaPaths, at: string, signal?: Abor
     kind: "already-killed" | "already-stopped";
     body: BodyFact;
 }>>;
-export declare function requestPause(paths: AkumaPaths, at: string, signal?: AbortSignal): Promise<Readonly<{
-    kind: "not-born";
-} | {
-    kind: "requested";
-    body: BodyFact;
-}>>;
 export declare function breakBody(paths: AkumaPaths, input: Readonly<{
     sequence: number;
     end: Exclude<BodyEnd, "exited">;

package/build/src/akuma/heart/index.js

@@ -1,16 +1,21 @@
 import { parsePublicHistoryId } from "../identity.js";
 import { decodeRuntimeModel, withoutModel } from "../provider-recipe.js";
-import { answeredTurnFact, endBodyFact, finishBodyFact, deleteStopControl, insertActivityFact, insertTurnEndFact, insertTurnStartFact, insertPauseControl, insertKillFact, insertSessionFact, insertStopControl, killFactForBody, latestBodyFact, latestKillFact, latestSessionFact, latestTurnFactForBody, lastAnsweredTurnFact, pauseFact, sessionFactForCoordinate, stopFact, turnFact, } from "./rows.js";
-import { insertTellDeliveryFact, dispositionSnapshotProven, insertTellBindingFact, insertTellDispositionSnapshot, insertTellReceiptFact, insertUndeliveredTellReceipts, latestOpenTellDisposition, openBoundTurns, openTellDispositionIds, pendingTellFacts, hasPendingTell, resolveTellDispositionSnapshot, tellDispositionResolved, tellFact, tellIdsForFence, turnParticipants, } from "./tells.js";
+import { BodyControlledError } from "./facts.js";
+import { answeredTurnFact, completeInterruptBarrier as judgeInterruptBarrier, endBodyFact, finishBodyFact, deleteStopControl, insertActivityFact, insertTurnEndFact, insertTurnStartFact, insertKillFact, insertSessionFact, insertStopControl, killFactForBody, latestBodyFact, insertInterruptBarrier, isTellProtectedByPause, latestKillFact, latestSessionFact, latestTurnFactForBody, lastAnsweredTurnFact, pauseFact, sessionFactForCoordinate, stopFact, turnFact, } from "./rows.js";
+import { insertTellDeliveryFact, dispositionSnapshotProven, insertTellBindingFact, insertTellDispositionSnapshot, insertTellReceiptFact, insertUndeliveredTellReceipts, latestOpenTellDisposition, openBoundTurns, openTellDispositionIds, pendingTellFacts, hasPendingTell, resolveTellDispositionSnapshot, sameTellInput, tellDispositionResolved, tellFact, tellIdsForFence, turnParticipants, } from "./tells.js";
 import { activityFactSlice, statusFacts, readStatusBatch, decodeTimelineBatch, timelineDataVersion, lastActivityAt as readLastActivityAt, pruneActivityFacts, } from "./timeline.js";
 import { createHeartReader, isHeartAbsent, readSealFromLeash, recordPendingTell, withHeartTransaction, withReadOnlyHeart, } from "./storage.js";
 import { setSoulModel, soulFact } from "./soul.js";
 import { AkumaBusyError, HeartAuthorityCorruptionError } from "./facts.js";
 export { HeartAbsentError, HeldAkumaLeash, classifyHeartSchema, initializeHeart, isHeartAbsent, probeLeash, } from "./storage.js";
 export { admitRequest, beginRequest, isRequestInputConflict, readNonterminalRequests, readRequest, refuseRequest, reserveRequest, serveRequest, serveUpstreamRequest, unproveRequest, voidRequest, } from "./request-authority.js";
-export { AkumaBusyError, life, lifeAt, projectTell } from "./facts.js";
+export { AkumaBusyError, BodyControlledError, life, lifeAt, projectTell } from "./facts.js";
 export { drainPendingTells } from "./tells.js";
 const ACTIVITY_LIMIT = 5_000;
+export async function readInterruptCompletion(paths, expected) {
+    const result = await withReadOnlyHeart(paths, (heart) => judgeInterruptBarrier(heart, expected, false));
+    return result.kind === "clear" ? { kind: "unavailable", evidence: "untidy" } : result;
+}
 export async function readSoul(paths) {
     try {
         return await withReadOnlyHeart(paths, soulFact);
@@ -173,28 +178,54 @@ export async function readLifeSnapshot(paths, signal, read = (body, signal) => w
         throw error;
     }
 }
-function sameTellInput(existing, tell) {
-    return (existing.body === tell.body &&
-        existing.recordedAt === tell.recordedAt &&
-        existing.schemaJson === tell.schemaJson &&
-        existing.initiator === tell.initiator);
+function judgeExistingTell(inputs, existing) {
+    const { heart, tell, body, pause, interrupt } = inputs;
+    if (!sameTellInput(existing, interrupt ? { ...tell, recordedAt: existing.recordedAt } : tell))
+        throw new Error(`tell ${tell.id} reused different input`);
+    if (!interrupt)
+        return { kind: "recorded", tell: existing };
+    const barrier = body !== null && pause !== null && isTellProtectedByPause(heart, tell.id, body.sequence) ? pause : undefined;
+    return {
+        kind: "recorded",
+        tell: existing,
+        predecessorWasRunning: body !== null && body.end === undefined,
+        ...(barrier === undefined ? {} : { barrier }),
+    };
+}
+function judgeNewTell(inputs) {
+    const { heart, tell, body, pause, interrupt } = inputs;
+    if (interrupt) {
+        if (body?.hung !== undefined)
+            return { kind: "unavailable", evidence: "hung" };
+        if (body === null)
+            return { kind: "unavailable", evidence: "untidy" };
+        if (pause !== null && pause.bodySequence !== body.sequence)
+            return { kind: "unavailable", evidence: "untidy" };
+        const admitted = recordPendingTell(heart, tell);
+        const barrier = pause ??
+            insertInterruptBarrier(heart, {
+                bodySequence: body.sequence,
+                tellId: tell.id,
+                at: tell.recordedAt,
+            });
+        return { ...admitted, predecessorWasRunning: body.end === undefined, barrier };
+    }
+    const running = body !== null && body.end === undefined && body.hung === undefined;
+    if (tell.schemaJson !== undefined && running)
+        throw new AkumaBusyError();
+    return recordPendingTell(heart, tell);
 }
 export async function recordTell(paths, tell, options = {}) {
+    const interrupt = options.interrupt === true;
     return await withHeartTransaction(paths, (heart) => {
         if (soulFact(heart) === null)
             return { kind: "not-born" };
         const existing = tellFact(heart, tell.id);
-        if (existing !== null) {
-            if (!sameTellInput(existing, tell))
-                throw new Error(`tell ${tell.id} reused different input`);
-            return { kind: "recorded", tell: existing };
-        }
         const body = latestBodyFact(heart);
-        const running = body !== null && body.end === undefined && body.hung === undefined;
-        if (tell.schemaJson !== undefined && running && options.interrupt !== true)
-            throw new AkumaBusyError();
-        return recordPendingTell(heart, tell);
-    });
+        const pause = interrupt ? pauseFact(heart) : null;
+        const inputs = { heart, tell, body, pause, interrupt };
+        return existing === null ? judgeNewTell(inputs) : judgeExistingTell(inputs, existing);
+    }, options.signal);
 }
 export async function readTell(paths, id) {
     return await withReadOnlyHeart(paths, (heart) => tellFact(heart, id));
@@ -205,6 +236,11 @@ export async function recordTellDeliveries(paths, inputs) {
             const current = tellFact(heart, input.tellId);
             if (current === null)
                 throw new Error(`unknown tell ${input.tellId}`);
+            const turn = turnFact(heart, input.turnSequence);
+            if (turn === null)
+                throw new Error(`unknown Akuma Turn ${input.turnSequence}`);
+            if (isTellProtectedByPause(heart, input.tellId, turn.bodySequence))
+                throw new BodyControlledError();
         }
         let changed = false;
         for (const input of inputs)
@@ -217,6 +253,13 @@ export async function recordTellReceipt(paths, input) {
         const tellIds = input.evidence === "exact" ? [input.tellId] : tellIdsForFence(heart, input.turnSequence, input.fence);
         if (tellIds.length === 0)
             throw new Error("tell receipt has no delivery mapping");
+        const pause = pauseFact(heart);
+        for (const tellId of tellIds) {
+            if (tellFact(heart, tellId) === null)
+                throw new Error(`unknown tell ${tellId}`);
+            if (pause !== null && isTellProtectedByPause(heart, tellId, pause.bodySequence))
+                throw new BodyControlledError();
+        }
         const changed = insertTellReceiptFact(heart, input);
         pruneActivityFacts(heart, ACTIVITY_LIMIT, changed);
     });
@@ -231,6 +274,11 @@ export async function decidePendingTellDisposition(paths, input) {
         const existing = openTellDispositionIds(heart, input.bodySequence);
         if (existing !== null)
             return { bodySequence: input.bodySequence, tellIds: existing };
+        if (pauseFact(heart)?.bodySequence === input.bodySequence) {
+            if (input.handoff && body.end === undefined)
+                endBodyFact(heart, { sequence: input.bodySequence, end: "put-down", at: input.at });
+            return null;
+        }
         const pending = pendingTellFacts(heart);
         const tellIds = pending.map((tell) => tell.id);
         if (tellIds.length === 0)
@@ -298,22 +346,15 @@ export async function requestStop(paths, at, signal) {
         return { kind: "requested", body };
     }, signal);
 }
-export async function requestPause(paths, at, signal) {
-    return await withHeartTransaction(paths, (heart) => {
-        if (soulFact(heart) === null)
-            return { kind: "not-born" };
-        const body = latestBodyFact(heart);
-        if (body === null)
-            throw new Error("Akuma has no Body to interrupt");
-        insertPauseControl(heart, at);
-        return { kind: "requested", body };
-    }, signal);
-}
 export async function breakBody(paths, input) {
     await withHeartTransaction(paths, (heart) => endBodyFact(heart, input));
 }
 export async function beginTurn(paths, input) {
     return await withHeartTransaction(paths, (heart) => {
+        if (pauseFact(heart)?.bodySequence === input.bodySequence)
+            throw new BodyControlledError();
+        if (stopFact(heart)?.bodySequence === input.bodySequence)
+            throw new BodyControlledError();
         const fact = insertTurnStartFact(heart, input);
         pruneActivityFacts(heart, ACTIVITY_LIMIT);
         return fact;
@@ -321,9 +362,14 @@ export async function beginTurn(paths, input) {
 }
 export async function bindTellsToTurn(paths, input) {
     await withHeartTransaction(paths, (heart) => {
+        const turn = turnFact(heart, input.turnSequence);
+        if (turn === null)
+            throw new Error(`Akuma Turn ${input.turnSequence} is missing`);
         for (const tellId of input.tellIds) {
             if (tellFact(heart, tellId) === null)
                 throw new Error(`unknown tell ${tellId}`);
+            if (isTellProtectedByPause(heart, tellId, turn.bodySequence))
+                throw new BodyControlledError();
             insertTellBindingFact(heart, { tellId, turnSequence: input.turnSequence, boundAt: input.boundAt });
         }
         pruneActivityFacts(heart, ACTIVITY_LIMIT);