@astrosheep/keiyaku 4.6.19 → 4.6.21

package/build/src/akuma/call-input.js

@@ -1,5 +1,25 @@
 import { realpath, stat } from "node:fs/promises";
-import { resolve } from "node:path";
+import { isAbsolute, resolve } from "node:path";
+export function bareOption(value) {
+    if (value !== undefined && typeof value !== "boolean")
+        throw new TypeError("bare must be a boolean");
+    return value;
+}
+export async function writableDirectoriesOption(value) {
+    if (value === undefined)
+        return [];
+    if (!Array.isArray(value))
+        throw new TypeError("writableDirectories must be an array of canonical directories");
+    const directories = await Promise.all(value.map(async (path) => {
+        if (typeof path !== "string" || path.trim() === "" || !isAbsolute(path))
+            throw new TypeError("writableDirectories must contain nonblank canonical absolute directories");
+        const canonical = await canonicalBirthCwd(path);
+        if (canonical !== path)
+            throw new TypeError(`writableDirectories path is not canonical: ${path}`);
+        return canonical;
+    }));
+    return Object.freeze([...new Set(directories)]);
+}
 export async function canonicalBirthCwd(input, diagnostic = `cwd is not an existing directory: ${input}`) {
     const selected = resolve(input);
     try {

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

@@ -2,7 +2,7 @@ import { type Soul } from "./heart/index.js";
 import { type AkuId, type AkumaPaths } from "./identity.js";
 import { type CallInitialTell, type CallInitialTellAdmission } from "./call-initial-tell.js";
 import { type ChildRequestCommand, type ErasedRequestCommand, type RequestProtocol } from "./request-wire.js";
-import type { OwnedProcess } from "../runtime/proc/run.js";
+import type { LiveBodyLaunch } from "./body-launch.js";
 import { z } from "zod";
 import type { WorldRoot } from "../world.js";
 declare const akumaCallRecipeSchema: z.ZodObject<{
@@ -71,6 +71,7 @@ declare const akumaCallRecipeSchema: z.ZodObject<{
         systemPrompt?: string | undefined;
         systemPromptMode?: "replace" | "append" | undefined;
     }>>;
+    bare: z.ZodOptional<z.ZodBoolean>;
 }, z.core.$strict>;
 declare const akumaCallPayloadSchema: z.ZodObject<{
     world: z.ZodString;
@@ -84,6 +85,7 @@ declare const akumaCallPayloadSchema: z.ZodObject<{
     birthInitiator: z.ZodOptional<z.ZodString>;
     contractId: z.ZodOptional<z.ZodString>;
     cwd: z.ZodOptional<z.ZodString>;
+    writableDirectories: z.ZodOptional<z.ZodReadonly<z.ZodArray<z.ZodString>>>;
     recipe: z.ZodObject<{
         description: z.ZodOptional<z.ZodString>;
         allowed: z.ZodPipe<z.ZodArray<z.ZodEnum<{
@@ -150,6 +152,7 @@ declare const akumaCallPayloadSchema: z.ZodObject<{
             systemPrompt?: string | undefined;
             systemPromptMode?: "replace" | "append" | undefined;
         }>>;
+        bare: z.ZodOptional<z.ZodBoolean>;
     }, z.core.$strict>;
 }, z.core.$strict>;
 export type AkumaCallRecipe = z.infer<typeof akumaCallRecipeSchema>;
@@ -167,13 +170,14 @@ export type AkumaCallRequestChildLaunch = Readonly<{
 export type InitialTellAdmissionRequest = Readonly<{
     id: AkuId;
     initialTell: CallInitialTell;
+    contractId?: string;
     signal: AbortSignal;
 }>;
 type AkumaCallRequestCapabilities = Readonly<{
     world: WorldRoot;
     paths: AkumaPaths;
     parent: Soul;
-    spawn(launch: AkumaCallRequestChildLaunch): Promise<OwnedProcess | void>;
+    spawn(launch: AkumaCallRequestChildLaunch): Promise<LiveBodyLaunch | void>;
     admitInitialTell(input: InitialTellAdmissionRequest): Promise<CallInitialTellAdmission>;
 }>;
 declare const liveResultSchema: z.ZodObject<{

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

@@ -25,6 +25,7 @@ const akumaCallRecipeSchema = z
     allowed: allowedActionsSchema,
     provider: providerRecipeSchema,
     options: providerOptionsSchema,
+    bare: z.boolean().optional(),
 })
     .strict();
 const initialTellSchema = z
@@ -43,6 +44,7 @@ const akumaCallPayloadSchema = z
     birthInitiator: z.string().optional(),
     contractId: z.string().optional(),
     cwd: absolutePathSchema.optional(),
+    writableDirectories: z.array(absolutePathSchema).readonly().optional(),
     recipe: akumaCallRecipeSchema,
 })
     .strict();
@@ -68,6 +70,7 @@ async function executeAkumaCall(request, facts, capabilities) {
     const outcome = await executePreparedCall({
         archetype: request.archetype,
         cwd: request.cwd ?? parent.cwd,
+        ...(request.writableDirectories === undefined ? {} : { writableDirectories: request.writableDirectories }),
         ...(request.initialTell === undefined
             ? {}
             : {
@@ -88,6 +91,7 @@ async function executeAkumaCall(request, facts, capabilities) {
                 provider: request.recipe.provider,
                 options: request.recipe.options,
                 allowed: request.recipe.allowed,
+                ...(request.recipe.bare === undefined ? {} : { bare: request.recipe.bare }),
             },
             parent,
             requestId: facts.id,
@@ -103,7 +107,11 @@ async function executeAkumaCall(request, facts, capabilities) {
                 ...(request.birthInitiator === undefined ? {} : { birthInitiator: request.birthInitiator }),
                 ...(request.contractId === undefined ? {} : { completion: { contractId: request.contractId } }),
             }),
-            admitInitialTell,
+            admitInitialTell: async (input) => await admitInitialTell({
+                ...input,
+                signal: facts.signal,
+                ...(request.contractId === undefined ? {} : { contractId: request.contractId }),
+            }),
         },
     });
     return {

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

@@ -0,0 +1,9 @@
+import type { BodyLaunch, LiveBodyLaunch } from "./body-launch.js";
+export declare const LEASH_HELD_EXIT = 75;
+export declare function bodyProcessInput(launch: BodyLaunch, bodyModuleUrl?: string): Promise<{
+    argv: string[];
+    cwd: string;
+    env: Record<string, string>;
+    log: string;
+}>;
+export declare function spawnAkumaBody(launch: BodyLaunch): Promise<LiveBodyLaunch>;

package/build/src/akuma/detached-body.js

@@ -0,0 +1,94 @@
+import { stat } from "node:fs/promises";
+import { fileURLToPath } from "node:url";
+import { spawnDetachedProcess } from "../runtime/proc/run.js";
+import { readHeart } from "./heart/index.js";
+import { worldRootForAkumaPaths } from "./identity.js";
+import { akumaExecutionEnvironment } from "./providers/execution-environment.js";
+export const LEASH_HELD_EXIT = 75;
+async function launchCwd(launch) {
+    if (launch.seed !== undefined)
+        return launch.seed.cwd;
+    const soul = (await readHeart(launch.paths)).soul;
+    if (soul === null)
+        throw new Error("Akuma wake has no born soul");
+    return soul.cwd;
+}
+async function executableMissing(path) {
+    try {
+        return !(await stat(path)).isFile();
+    }
+    catch {
+        return true;
+    }
+}
+async function frozenCwdMissing(path) {
+    try {
+        await stat(path);
+        return false;
+    }
+    catch {
+        return true;
+    }
+}
+/** Diagnose the attempted executable and frozen cwd independently; never substitute either. */
+async function diagnoseSpawnEnoent(input, cause) {
+    const executable = input.argv[0] ?? process.execPath;
+    const cwd = input.cwd;
+    const [noExecutable, noCwd] = await Promise.all([executableMissing(executable), frozenCwdMissing(cwd)]);
+    if (!noExecutable && !noCwd)
+        return cause instanceof Error ? cause : new Error(String(cause));
+    const missing = [];
+    if (noCwd)
+        missing.push(`frozen execution directory ${cwd} no longer exists`);
+    if (noExecutable)
+        missing.push(`waking process executable ${executable} no longer exists (the host likely removed the running process binary)`);
+    const remedies = [];
+    if (noCwd)
+        remedies.push("a missing execution directory likely means its Contract was accepted and the worktree cleaned up, with deliverables already in Git");
+    if (noExecutable)
+        remedies.push("a missing executable likely means the host removed the running process binary: re-enter with a fresh CLI process and retry");
+    const remedy = `kill this Akuma and call a fresh one; ${remedies.join("; ")}`;
+    const error = new Error(`Body spawn failed: ${missing.join(" and ")}; ${remedy}`, { cause });
+    error.code = "ENOENT";
+    return error;
+}
+export async function bodyProcessInput(launch, bodyModuleUrl = import.meta.url) {
+    const encoded = Buffer.from(JSON.stringify(launch), "utf8").toString("base64url");
+    const actorId = launch.seed?.id ?? (await readHeart(launch.paths)).soul?.id;
+    if (actorId === undefined)
+        throw new Error("Akuma wake has no born soul");
+    const executable = process.execPath;
+    const source = bodyModuleUrl.endsWith(".ts");
+    const entry = fileURLToPath(new URL(source ? "../akuma-body.ts" : "../akuma-body.js", bodyModuleUrl));
+    return {
+        argv: source ? [executable, "--import", import.meta.resolve("tsx"), entry, encoded] : [executable, entry, encoded],
+        cwd: await launchCwd(launch),
+        env: akumaExecutionEnvironment(process.env, {
+            KEIYAKU_ACTOR_ID: actorId,
+            KEIYAKU_ACTOR_WORLD: worldRootForAkumaPaths(launch.paths),
+        }),
+        log: launch.paths.log,
+    };
+}
+export async function spawnAkumaBody(launch) {
+    const input = await bodyProcessInput(launch);
+    try {
+        const owned = await spawnDetachedProcess(input);
+        const completed = owned.exited.then((exit) => ({
+            diagnostic: exit.code === null ? `pre-admission signal ${exit.signal ?? "unknown"}` : `pre-admission exit ${exit.code}`,
+            held: exit.code === LEASH_HELD_EXIT,
+            child: { code: exit.code, signal: exit.signal, log: exit.log },
+        }));
+        void completed.catch(() => undefined);
+        return {
+            completed,
+            cancel: (force) => owned.terminate(force),
+            release: () => owned.release(),
+        };
+    }
+    catch (error) {
+        if (error?.code !== "ENOENT")
+            throw error;
+        throw await diagnoseSpawnEnoent(input, error);
+    }
+}

package/build/src/akuma/execution-instructions.d.ts

@@ -0,0 +1,8 @@
+import type { Soul } from "./heart/index.js";
+/** Association is supplied by composition, never read or persisted by Akuma. */
+export type ExecutionAssociation = Readonly<{
+    contractId: string;
+}>;
+export type ExecutionAssociationReader = () => Promise<ExecutionAssociation | undefined>;
+/** One current execution section; provider adapters only choose its native channel. */
+export declare function keiyakuExecutionInstructions(soul: Soul, association?: ExecutionAssociation): string | undefined;

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

@@ -0,0 +1,17 @@
+/** One current execution section; provider adapters only choose its native channel. */
+export function keiyakuExecutionInstructions(soul, association) {
+    if (soul.bare !== false) {
+        return soul.bare === true && soul.origin.kind === "fork"
+            ? "Any inherited Keiyaku execution context is inactive for this execution."
+            : undefined;
+    }
+    return [
+        "<keiyaku>",
+        "This context supersedes any earlier Keiyaku execution context.",
+        `Akuma: ${soul.id}`,
+        `Archetype: ${soul.archetype}`,
+        ...(association === undefined ? [] : [`Contract context (not a Dispatch receipt): ${association.contractId}`]),
+        'Use `keiyaku report "..."` to share updates without stopping your work.',
+        "</keiyaku>",
+    ].join("\n");
+}

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

@@ -30,9 +30,10 @@ export type Soul = Readonly<{
     origin: AkumaOrigin;
     caller?: AkumaCaller;
     allowed: AllowedActions;
+    bare?: boolean;
     createdAt: string;
 }>;
-export type RequestRecipe = Pick<Soul, "description" | "provider" | "options" | "allowed">;
+export type RequestRecipe = Pick<Soul, "description" | "provider" | "options" | "allowed" | "bare">;
 export type BodyEnd = "exited" | "broke-off" | "put-down";
 export type BodyFact = Readonly<{
     sequence: number;
@@ -60,6 +61,8 @@ export type TurnOutcome = Readonly<{
     session: ResumeCoordinate;
     answer: string;
     answerJson?: string;
+}> | Readonly<{
+    kind: "canceled";
 }> | Readonly<{
     kind: "failed";
     diagnostic: string;
@@ -88,6 +91,23 @@ export type TurnEndFact = Readonly<{
 export type TurnFact = TurnStartFact & Readonly<{
     end?: TurnEndFact;
 }>;
+export declare const reportFactSchema: z.ZodObject<{
+    kind: z.ZodLiteral<"report">;
+    sequence: z.ZodNumber;
+    bodySequence: z.ZodNumber;
+    turnSequence: z.ZodNumber;
+    text: z.ZodString;
+    at: z.ZodString;
+}, z.core.$strict>;
+export type ReportFact = z.infer<typeof reportFactSchema>;
+export type ReportAdmission = Readonly<{
+    kind: "recorded";
+    report: ReportFact;
+    initiator?: string;
+}> | Readonly<{
+    kind: "refused";
+    reason: "not-born" | "not-current-execution";
+}>;
 export type CallFact = Readonly<{
     kind: "call";
     sequence: number;

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

@@ -12,6 +12,16 @@ export const akumaOriginSchema = z.discriminatedUnion("kind", [
     z.object({ kind: z.literal("request"), parent: akumaIdSchema, requestId: originText }),
     z.object({ kind: z.literal("fork"), parent: akumaIdSchema, at: originText }),
 ]);
+export const reportFactSchema = z
+    .object({
+    kind: z.literal("report"),
+    sequence: z.number().int().positive().safe(),
+    bodySequence: z.number().int().positive().safe(),
+    turnSequence: z.number().int().positive().safe(),
+    text: z.string().refine((value) => value.trim() !== "", "expected nonblank report text"),
+    at: z.string().refine((value) => Number.isFinite(Date.parse(value)), "expected report timestamp"),
+})
+    .strict();
 export function projectTell(fact) {
     return {
         kind: "tell",

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

@@ -1,5 +1,5 @@
 import type { AkumaPaths } from "../identity.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 { BodyEnd, BodyFact, ForkPoint, HeartSnapshot, InterruptCompletion, KillFact, PauseFact, SealFact, SessionFact, Soul, TellDeliveryInput, TellFact, TellReceiptInput, TurnEndFact, TurnFact, TurnOutcome, TurnStartFact, ReportAdmission } from "./facts.js";
 import type { AgentEvent } from "./activity-schema.js";
 import { type StatusFactInput, type ActivityFactSlice } from "./timeline.js";
 import { type HeartRead } from "./storage.js";
@@ -112,6 +112,12 @@ export declare function recordTell(paths: AkumaPaths, tell: TellInput, options?:
     interrupt?: false;
     signal?: AbortSignal;
 }>): Promise<TellAdmission>;
+export declare function recordReport(paths: AkumaPaths, input: Readonly<{
+    bodySequence: number;
+    turnSequence: number;
+    text: string;
+    at: string;
+}>, signal?: AbortSignal): Promise<ReportAdmission>;
 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>;
@@ -143,6 +149,15 @@ export declare function breakBody(paths: AkumaPaths, input: Readonly<{
     end: Exclude<BodyEnd, "exited">;
     at: string;
 }>): Promise<void>;
+/** The owning Body calls this only after proving its provider custody retired. */
+export declare function cancelBodyTurns(paths: AkumaPaths, input: Readonly<{
+    bodySequence: number;
+    at: string;
+    handoff?: boolean;
+}>): Promise<Readonly<{
+    canceled: readonly number[];
+    disposition: PendingTellDisposition | null;
+}>>;
 export declare function beginTurn(paths: AkumaPaths, input: Readonly<{
     bodySequence: number;
     startedAt: string;

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

@@ -1,7 +1,7 @@
 import { parsePublicHistoryId } from "../identity.js";
 import { decodeRuntimeModel, withoutModel } from "../provider-recipe.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 { answeredTurnFact, completeInterruptBarrier as judgeInterruptBarrier, endBodyFact, finishBodyFact, deleteStopControl, insertReportFact, insertActivityFact, insertTurnEndFact, insertTurnStartFact, insertKillFact, insertSessionFact, insertStopControl, killFactForBody, hasBodyHandoffControl, latestBodyFact, insertInterruptBarrier, isTellProtectedByPause, latestKillFact, latestSessionFact, latestTurnFactForBody, lastAnsweredTurnFact, pauseFact, sessionFactForCoordinate, stopFact, turnFact, openTurnsForBody, terminalTurnForTell, } 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";
@@ -121,6 +121,7 @@ function sameStatusBatch(left, right) {
         sameRawRows(left.rows, right.rows) &&
         sameRawRows(left.turns, right.turns) &&
         sameRawRows(left.calls, right.calls) &&
+        sameRawRows(left.reports, right.reports) &&
         sameRawRows(left.activity, right.activity) &&
         sameRawRows(left.tells.rows, right.tells.rows) &&
         sameRawRows(left.tells.deliveries, right.tells.deliveries) &&
@@ -134,7 +135,9 @@ export function createStatusFactReader(paths) {
         life: (signal) => readLifeSnapshot(paths, signal, reader.read),
         tellOutcome: (id, signal) => reader.read((heart) => {
             const tell = tellFact(heart, id);
-            const end = tell?.binding === undefined ? undefined : turnFact(heart, tell.binding.turnSequence)?.end;
+            // A pending Tell may be retried by a successor after cancellation. Its
+            // first retained terminal still belongs to this exact admission.
+            const end = terminalTurnForTell(heart, id)?.end;
             return { tell, end };
         }, signal),
         clear() {
@@ -227,6 +230,36 @@ export async function recordTell(paths, tell, options = {}) {
         return existing === null ? judgeNewTell(inputs) : judgeExistingTell(inputs, existing);
     }, options.signal);
 }
+export async function recordReport(paths, input, signal) {
+    try {
+        return await withHeartTransaction(paths, (heart) => {
+            if (soulFact(heart) === null)
+                return { kind: "refused", reason: "not-born" };
+            const body = latestBodyFact(heart);
+            const turn = body === null ? null : latestTurnFactForBody(heart, body.sequence);
+            if (body === null ||
+                body.sequence !== input.bodySequence ||
+                body.end !== undefined ||
+                body.hung !== undefined ||
+                turn === null ||
+                turn.sequence !== input.turnSequence ||
+                turn.end !== undefined)
+                return { kind: "refused", reason: "not-current-execution" };
+            const report = insertReportFact(heart, input);
+            pruneActivityFacts(heart, ACTIVITY_LIMIT);
+            return {
+                kind: "recorded",
+                report,
+                ...(turn.initiator === undefined ? {} : { initiator: turn.initiator }),
+            };
+        }, signal);
+    }
+    catch (error) {
+        if (isHeartAbsent(error))
+            return { kind: "refused", reason: "not-born" };
+        throw error;
+    }
+}
 export async function readTell(paths, id) {
     return await withReadOnlyHeart(paths, (heart) => tellFact(heart, id));
 }
@@ -264,36 +297,39 @@ export async function recordTellReceipt(paths, input) {
         pruneActivityFacts(heart, ACTIVITY_LIMIT, changed);
     });
 }
-export async function decidePendingTellDisposition(paths, input) {
-    return await withHeartTransaction(paths, (heart) => {
-        const body = latestBodyFact(heart);
-        if (body === null || body.sequence !== input.bodySequence)
-            return null;
-        if (tellDispositionResolved(heart, input.bodySequence) === true)
-            return null;
-        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)
-            return null;
-        if (body.end === undefined) {
-            if (!input.handoff)
-                return null;
+function decidePendingTellDispositionInHeart(heart, input) {
+    const body = latestBodyFact(heart);
+    if (body === null || body.sequence !== input.bodySequence)
+        return null;
+    if (tellDispositionResolved(heart, input.bodySequence) === true)
+        return null;
+    if (hasBodyHandoffControl(heart, input.bodySequence)) {
+        if (input.handoff && body.end === undefined)
             endBodyFact(heart, { sequence: input.bodySequence, end: "put-down", at: input.at });
-        }
-        else if (body.end === "broke-off") {
+        return null;
+    }
+    const existing = openTellDispositionIds(heart, input.bodySequence);
+    if (existing !== null)
+        return { bodySequence: input.bodySequence, tellIds: existing };
+    const tellIds = pendingTellFacts(heart).map((tell) => tell.id);
+    if (tellIds.length === 0)
+        return null;
+    if (body.end === undefined) {
+        if (!input.handoff)
             return null;
-        }
-        insertTellDispositionSnapshot(heart, input.bodySequence, tellIds, input.at);
+        endBodyFact(heart, { sequence: input.bodySequence, end: "put-down", at: input.at });
+    }
+    else if (body.end === "broke-off") {
+        return null;
+    }
+    insertTellDispositionSnapshot(heart, input.bodySequence, tellIds, input.at);
+    return { bodySequence: input.bodySequence, tellIds };
+}
+export async function decidePendingTellDisposition(paths, input) {
+    return await withHeartTransaction(paths, (heart) => {
+        const decided = decidePendingTellDispositionInHeart(heart, input);
         pruneActivityFacts(heart, ACTIVITY_LIMIT);
-        return { bodySequence: input.bodySequence, tellIds };
+        return decided;
     });
 }
 export async function readOpenPendingTellDisposition(paths) {
@@ -307,6 +343,11 @@ export async function resolvePendingTellDisposition(paths, bodySequence, at, out
         const tellIds = openTellDispositionIds(heart, bodySequence);
         if (tellIds === null)
             throw new HeartAuthorityCorruptionError(`Akuma disposition ${bodySequence} is missing`);
+        if (hasBodyHandoffControl(heart, bodySequence)) {
+            resolveTellDispositionSnapshot(heart, bodySequence, at);
+            pruneActivityFacts(heart, ACTIVITY_LIMIT, true);
+            return true;
+        }
         if (outcome === "undelivered")
             insertUndeliveredTellReceipts(heart, tellIds, at);
         if (!dispositionSnapshotProven(heart, tellIds))
@@ -332,6 +373,9 @@ export async function requestStop(paths, at, signal) {
             // exited Body remains already-stopped, and hung custody is untouched.
             if (body.hung === undefined && body.end !== "exited") {
                 insertKillFact(heart, body.sequence, at);
+                const released = tellDispositionResolved(heart, body.sequence) === false;
+                resolveTellDispositionSnapshot(heart, body.sequence, at);
+                pruneActivityFacts(heart, ACTIVITY_LIMIT, released);
                 if (stopFact(heart)?.bodySequence === body.sequence)
                     deleteStopControl(heart);
                 return { kind: "witnessed", body };
@@ -349,6 +393,28 @@ export async function requestStop(paths, at, signal) {
 export async function breakBody(paths, input) {
     await withHeartTransaction(paths, (heart) => endBodyFact(heart, input));
 }
+/** The owning Body calls this only after proving its provider custody retired. */
+export async function cancelBodyTurns(paths, input) {
+    return await withHeartTransaction(paths, (heart) => {
+        const body = latestBodyFact(heart);
+        if (body?.sequence !== input.bodySequence ||
+            body.hung !== undefined ||
+            (body.end !== undefined && body.end !== "put-down"))
+            throw new Error(`Akuma Body ${input.bodySequence} cannot settle controlled cancellation`);
+        const sequences = openTurnsForBody(heart, input.bodySequence);
+        for (const turnSequence of sequences)
+            insertTurnEndFact(heart, {
+                kind: "turn-end",
+                turnSequence,
+                outcome: { kind: "canceled" },
+                completedAt: input.at,
+            });
+        endBodyFact(heart, { sequence: input.bodySequence, end: "put-down", at: input.at });
+        const disposition = input.handoff === true ? decidePendingTellDispositionInHeart(heart, { ...input, handoff: true }) : null;
+        pruneActivityFacts(heart, ACTIVITY_LIMIT, sequences.length > 0);
+        return { canceled: sequences, disposition };
+    });
+}
 export async function beginTurn(paths, input) {
     return await withHeartTransaction(paths, (heart) => {
         if (pauseFact(heart)?.bodySequence === input.bodySequence)
@@ -412,7 +478,6 @@ export async function endTurn(paths, input) {
 export async function finishBodyIfIdle(paths, input) {
     return await withHeartTransaction(paths, (heart) => {
         if (stopFact(heart)?.bodySequence === input.sequence || pauseFact(heart)?.bodySequence === input.sequence) {
-            endBodyFact(heart, { ...input, end: "put-down" });
             return { kind: "controlled" };
         }
         const pending = pendingTellFacts(heart);

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

@@ -1,6 +1,6 @@
 import { z } from "zod";
 import type { DatabaseSync } from "node:sqlite";
-import type { BodyEnd, BodyFact, CallFact, InterruptCompletion, KillFact, PauseFact, ResumeCoordinate, SessionFact, StopFact, TurnFact, TurnStartFact, TurnEndFact } from "./facts.js";
+import type { BodyEnd, BodyFact, CallFact, InterruptCompletion, KillFact, PauseFact, ReportFact, ResumeCoordinate, SessionFact, StopFact, TurnFact, TurnStartFact, TurnEndFact } from "./facts.js";
 import { type AgentEvent } from "./activity-schema.js";
 export type SealRow = Readonly<{
     evidence: string;
@@ -72,7 +72,7 @@ export type TurnRow = Readonly<{
     body_sequence: number;
     started_at: string;
     end_sequence: number | null;
-    outcome: "answered" | "failed" | "invalid-output" | null;
+    outcome: "answered" | "failed" | "invalid-output" | "canceled" | null;
     history_id: string | null;
     session_json: string | null;
     answer: string | null;
@@ -113,6 +113,14 @@ export declare function decodeSessionRow(row: SessionRow): SessionFact;
 export declare function decodeBodyRow(row: BodyRow): BodyFact;
 export declare function decodeTurnRow(row: TurnRow): TurnFact;
 export declare function decodeCallRow(row: CallRow): CallFact;
+export type ReportRow = Readonly<{
+    sequence: number;
+    body_sequence: number;
+    turn_sequence: number;
+    text: string;
+    at: string;
+}>;
+export declare function decodeReportRow(row: ReportRow): ReportFact;
 export declare function encodeActivityEvent(event: unknown): string;
 export declare function decodeActivityRow(row: ActivityRow): ActivityFact;
 export declare function sealExists(database: DatabaseSync): boolean;
@@ -130,6 +138,7 @@ export declare function insertBodyFact(database: DatabaseSync, input: Readonly<{
     leashTakenAt: string;
 }>): number;
 export declare function insertSessionFact(database: DatabaseSync, input: Omit<SessionFact, "sequence">): number;
+export declare function insertReportFact(database: DatabaseSync, input: Omit<ReportFact, "kind" | "sequence">): ReportFact;
 export declare function insertActivityFact(database: DatabaseSync, input: Readonly<{
     turnSequence: number;
     event: AgentEvent;
@@ -144,6 +153,7 @@ export declare function insertInterruptBarrier(database: DatabaseSync, input: Re
 export declare function completeInterruptBarrier(database: DatabaseSync, expected?: PauseFact, consume?: boolean): InterruptCompletion;
 export declare function stopFact(database: DatabaseSync): StopFact | null;
 export declare function pauseFact(database: DatabaseSync): PauseFact | null;
+export declare function hasBodyHandoffControl(database: DatabaseSync, bodySequence: number): boolean;
 export declare function bodyFact(database: DatabaseSync, sequence: number): BodyFact | null;
 export declare function isTellProtectedByPause(database: DatabaseSync, tellId: string, bodySequence: number): boolean;
 export declare function insertKillFact(database: DatabaseSync, bodySequence: number, at: string): void;
@@ -164,6 +174,8 @@ export declare function insertTurnStartFact(database: DatabaseSync, input: Reado
     schemaJson?: string;
     initiator?: string;
 }>): TurnStartFact;
+export declare function openTurnsForBody(database: DatabaseSync, bodySequence: number): readonly number[];
+export declare function terminalTurnForTell(database: DatabaseSync, tellId: string): TurnFact | null;
 export declare function insertTurnEndFact(database: DatabaseSync, input: Omit<TurnEndFact, "sequence">): TurnEndFact;
 export declare function finishBodyFact(database: DatabaseSync, input: Readonly<{
     sequence: number;