@astrosheep/keiyaku 4.0.1 → 4.0.2

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

@@ -1,5 +1,6 @@
 import type { AkuId } from "../identity.js";
 import type { ResumeCoordinate } from "../coordinate.js";
+import type { ProviderExecution, ProviderOptions, ReadonlyRestraint } from "../provider-recipe.js";
 export type { ResumeCoordinate } from "../coordinate.js";
 export type Confinement = Readonly<{
     kind: "unconfined";
@@ -7,20 +8,6 @@ export type Confinement = Readonly<{
     kind: "declared";
     writableRoots: readonly string[];
 }>;
-export type ProviderOptions = Readonly<{
-    model?: string;
-    effort?: string;
-    access?: "read" | "write" | "auto";
-    network?: "disabled" | "enabled";
-    systemPrompt?: string;
-}>;
-export type ProviderExecution = Readonly<{
-    name: string;
-    kind: "claude-agent-sdk" | "codex-app-server" | "opencode-sdk" | "pi";
-    executable?: string;
-    config?: Readonly<Record<string, unknown>>;
-    env?: Readonly<Record<string, string>>;
-}>;
 export type AkumaOrigin = Readonly<{
     kind: "direct";
 }> | Readonly<{
@@ -38,22 +25,21 @@ export type Soul = Readonly<{
     description?: string;
     provider: ProviderExecution;
     options: ProviderOptions;
+    readonly?: ReadonlyRestraint;
     cwd: string;
     origin: AkumaOrigin;
     confinement: Confinement;
     createdAt: string;
 }>;
-export type RequestRecipe = Pick<Soul, "description" | "provider" | "options" | "confinement">;
-export type Collar = Readonly<{
-    pid: number;
-    processGroup: number;
-    spawnedAt: string;
-}>;
+export type RequestRecipe = Pick<Soul, "description" | "provider" | "options" | "readonly" | "confinement">;
 export type BodyEnd = "exited" | "broke-off" | "put-down";
 export type BodyFact = Readonly<{
     sequence: number;
-    collar: Collar;
     leashTakenAt: string;
+    hung?: Readonly<{
+        diagnostic: string;
+        at: string;
+    }>;
     end?: BodyEnd;
     endedAt?: string;
 }>;
@@ -74,7 +60,7 @@ export type ForkPoint = Readonly<{
 }>;
 export type TurnOutcome = Readonly<{
     kind: "answered";
-    historyId: string;
+    historyId?: string;
     session: ResumeCoordinate;
     answer: string;
 }> | Readonly<{
@@ -166,7 +152,7 @@ export type RequestFact = RequestInput & Readonly<{
     state: "voided";
     evidence: string;
 }>);
-export type KillEvidence = "killed" | "already-killed" | "alive-after-sigkill" | "unavailable";
+export type KillEvidence = "killed" | "already-killed" | "already-stopped" | "hung" | "untidy" | "unavailable";
 export type KillFact = Readonly<{
     sequence: number;
     bodySequence: number;
@@ -177,26 +163,31 @@ export type StopFact = Readonly<{
     bodySequence: number;
     requestedAt: string;
 }>;
+export type PauseFact = Readonly<{
+    bodySequence: number;
+    requestedAt: string;
+}>;
 export type SealFact = Readonly<{
     evidence: string;
     at: string;
 }>;
 export type LeashProbe = "held" | "free";
-export type CollarProbe = Readonly<{
-    kind: "gone";
-    end: BodyEnd | null;
-}> | Readonly<{
-    kind: "alive";
-}> | Readonly<{
-    kind: "unverifiable";
-    diagnostic: string;
-}>;
-export type AkumaLife = "running" | "asleep" | "stranded" | "headless" | "killed";
+export type AkumaLife = "running" | "asleep" | "stranded" | "hung" | "untidy" | "killed";
 export type HeartSnapshot = Readonly<{
     soul: Soul | null;
     latestBody: BodyFact | null;
     latestSession: SessionFact | null;
     pending: readonly TellFact[];
     latestKill: KillFact | null;
+    stop: StopFact | null;
+    pause: PauseFact | null;
+}>;
+export declare function life(input: Readonly<{
+    leash: LeashProbe;
+    body: BodyFact | null;
+    kill: KillFact | null;
+}>): AkumaLife;
+export declare function lifeAt(current: AkumaLife, body: BodyFact | null, kill: KillFact | null, createdAt: string): string | null;
+export type SoulRow = Readonly<{
+    soul_json: string;
 }>;
-export declare function life(leashProbe: LeashProbe, collarProbe: CollarProbe, latestBody: BodyFact | null, latestKill: KillFact | null): AkumaLife;

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

@@ -1,9 +1,20 @@
-export function life(leashProbe, collarProbe, latestBody, latestKill) {
-    if (leashProbe === "held")
-        return "running";
-    if (collarProbe.kind !== "gone")
-        return "headless";
-    if (latestBody !== null && latestKill?.bodySequence === latestBody.sequence)
+export function life(input) {
+    if (input.leash === "held")
+        return input.body?.hung === undefined ? "running" : "hung";
+    if (input.body === null || input.body.end === undefined)
+        return "untidy";
+    if (input.kill?.bodySequence === input.body.sequence)
         return "killed";
-    return collarProbe.end === "exited" ? "asleep" : "stranded";
+    return input.body.end === "exited" ? "asleep" : "stranded";
+}
+export function lifeAt(current, body, kill, createdAt) {
+    if (current === "running")
+        return body?.leashTakenAt ?? null;
+    if (current === "hung")
+        return body?.hung?.at ?? null;
+    if (current === "killed")
+        return kill?.at ?? null;
+    if (current === "asleep")
+        return body?.endedAt ?? createdAt;
+    return current === "stranded" ? body?.endedAt ?? null : null;
 }

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

@@ -1,25 +1,21 @@
 import type { AkuId, AkumaPaths } from "../identity.js";
-import type { BodyEnd, BodyFact, Collar, ForkPoint, HeartSnapshot, KillFact, RequestFact, RequestInput, SealFact, SessionFact, Soul, TellDeliveryInput, TellFact, TellReceiptInput, TurnEndFact, TurnFact, TurnOutcome, TurnStartFact } from "./facts.js";
+import type { BodyEnd, BodyFact, ForkPoint, HeartSnapshot, KillFact, RequestFact, RequestInput, SealFact, SessionFact, Soul, TellDeliveryInput, TellFact, TellReceiptInput, TurnEndFact, TurnFact, TurnOutcome, TurnStartFact } from "./facts.js";
 export type { CallFact } from "./facts.js";
 import type { ActivityFact } from "./rows.js";
 import { type ActivityFactSlice } from "./timeline.js";
-export { HeldAkumaLeash, initializeHeart, probeLeash } from "./storage.js";
-export { life } from "./facts.js";
-export type { AkumaLife, AkumaOrigin, BodyEnd, BodyFact, Collar, CollarProbe, Confinement, HeartSnapshot, ForkPoint, KillEvidence, KillFact, LeashProbe, ProviderOptions, ProviderExecution, RequestFact, RequestInput, RequestRecipe, SealFact, SessionFact, Soul, StopFact, TellFact, TellDelivery, TellDeliveryInput, TellReceiptInput, TurnEndFact, TurnFact, TurnOutcome, TurnStartFact, } from "./facts.js";
+export { HeartAbsentError, HeldAkumaLeash, initializeHeart, isHeartAbsent, probeLeash } from "./storage.js";
+export { life, lifeAt } from "./facts.js";
+export type { AkumaLife, AkumaOrigin, BodyEnd, BodyFact, Confinement, HeartSnapshot, ForkPoint, KillEvidence, KillFact, LeashProbe, PauseFact, RequestFact, RequestInput, RequestRecipe, SealFact, SessionFact, Soul, StopFact, TellFact, TellDelivery, TellDeliveryInput, TellReceiptInput, TurnEndFact, TurnFact, TurnOutcome, TurnStartFact, } from "./facts.js";
 export type { ResumeCoordinate } from "../coordinate.js";
-export declare function readSoul(paths: AkumaPaths): Soul | null;
-export declare function heartExists(paths: AkumaPaths): boolean;
-export declare function readSeal(paths: AkumaPaths): SealFact | null;
-export declare function recordBody(paths: AkumaPaths, input: Readonly<{
-    collar: Collar;
-    leashTakenAt: string;
-}>): BodyFact;
-export declare function recordSession(paths: AkumaPaths, input: Omit<SessionFact, "sequence">): SessionFact;
+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>;
+export declare function recordSession(paths: AkumaPaths, input: Omit<SessionFact, "sequence">): Promise<SessionFact>;
 export declare function appendActivity(paths: AkumaPaths, input: Readonly<{
     turnSequence: number;
     event: unknown;
     at: string;
-}>): number;
+}>): Promise<number>;
 export type ActivitySliceInput = Readonly<{
     before?: number;
     since?: number;
@@ -28,63 +24,64 @@ export type ActivitySliceInput = Readonly<{
 export type ActivitySlice = ActivityFactSlice;
 export type { ActivityFact };
 export type { TimelineFact } from "./timeline.js";
-export declare function activitySlice(paths: AkumaPaths, input?: ActivitySliceInput): ActivitySlice;
-export declare function recordTell(paths: AkumaPaths, tell: Omit<TellFact, "sequence" | "state" | "deliveries">): Readonly<{
+export declare function activitySlice(paths: AkumaPaths, input?: ActivitySliceInput): Promise<ActivitySlice>;
+export declare function recordTell(paths: AkumaPaths, tell: Omit<TellFact, "sequence" | "state" | "deliveries">): Promise<Readonly<{
     kind: "not-born";
 } | {
     kind: "recorded";
     tell: TellFact;
-}>;
-export declare function recordTellDeliveries(paths: AkumaPaths, inputs: readonly TellDeliveryInput[]): void;
-export declare function recordTellReceipt(paths: AkumaPaths, input: TellReceiptInput): void;
+}>>;
+export declare function recordTellDeliveries(paths: AkumaPaths, inputs: readonly TellDeliveryInput[]): Promise<void>;
+export declare function recordTellReceipt(paths: AkumaPaths, input: TellReceiptInput): Promise<void>;
 export declare function admitRequest(paths: AkumaPaths, input: RequestInput & Readonly<{
     admittedAt: string;
-}>): RequestFact;
-export declare function reserveRequest(paths: AkumaPaths, id: string, child: AkuId): RequestFact;
-export declare function serveRequest(paths: AkumaPaths, id: string, child: AkuId): RequestFact;
-export declare function refuseRequest(paths: AkumaPaths, id: string, diagnostic: string): RequestFact;
-export declare function voidRequest(paths: AkumaPaths, id: string, evidence: string): RequestFact;
-export declare function readRequest(paths: AkumaPaths, id: string): RequestFact | null;
-export declare function readNonterminalRequests(paths: AkumaPaths): readonly RequestFact[];
-export declare function readKill(paths: AkumaPaths, bodySequence: number): KillFact | null;
-export declare function requestStop(paths: AkumaPaths, at: string): Readonly<{
+}>): Promise<RequestFact>;
+export declare function reserveRequest(paths: AkumaPaths, id: string, child: AkuId): Promise<RequestFact>;
+export declare function serveRequest(paths: AkumaPaths, id: string, child: AkuId): Promise<RequestFact>;
+export declare function refuseRequest(paths: AkumaPaths, id: string, diagnostic: string): Promise<RequestFact>;
+export declare function voidRequest(paths: AkumaPaths, id: string, evidence: string): Promise<RequestFact>;
+export declare function readRequest(paths: AkumaPaths, id: string): Promise<RequestFact | null>;
+export declare function readNonterminalRequests(paths: AkumaPaths): Promise<readonly RequestFact[]>;
+export declare function readKill(paths: AkumaPaths, bodySequence: number): Promise<KillFact | null>;
+export declare function requestStop(paths: AkumaPaths, at: string): Promise<Readonly<{
     kind: "requested";
     body: BodyFact;
 }> | Readonly<{
-    kind: "already-killed";
+    kind: "already-killed" | "already-stopped";
     body: BodyFact;
-}>;
-export declare function requestPause(paths: AkumaPaths, at: string): Readonly<{
+}>>;
+export declare function requestPause(paths: AkumaPaths, at: string): Promise<Readonly<{
     kind: "not-born";
 } | {
     kind: "requested";
-}>;
-export declare function stopRequested(paths: AkumaPaths, bodySequence?: number): boolean;
-export declare function pauseRequested(paths: AkumaPaths): boolean;
+    body: BodyFact;
+}>>;
+export declare function stopRequested(paths: AkumaPaths, bodySequence?: number): Promise<boolean>;
+export declare function pauseRequested(paths: AkumaPaths, bodySequence?: number): Promise<boolean>;
 export declare function breakBody(paths: AkumaPaths, input: Readonly<{
     sequence: number;
     end: Exclude<BodyEnd, "exited">;
     at: string;
-}>): void;
+}>): Promise<void>;
 export declare function beginTurn(paths: AkumaPaths, input: Readonly<{
     bodySequence: number;
     startedAt: string;
     call?: string;
-}>): TurnStartFact;
+}>): Promise<TurnStartFact>;
 export declare function endTurn(paths: AkumaPaths, input: Readonly<{
     turnSequence: number;
     outcome: TurnOutcome;
     completedAt: string;
-}>): TurnEndFact;
+}>): Promise<TurnEndFact>;
 export declare function finishBodyIfIdle(paths: AkumaPaths, input: Readonly<{
     sequence: number;
     at: string;
-}>): Readonly<{
-    kind: "finished";
+}>): Promise<Readonly<{
+    kind: "controlled" | "finished";
 } | {
     kind: "pending";
     tells: readonly string[];
-}>;
-export declare function readHeart(paths: AkumaPaths): HeartSnapshot;
-export declare function readLastAnsweredTurn(paths: AkumaPaths): TurnFact | null;
-export declare function readForkPoint(paths: AkumaPaths, historyId: string): ForkPoint | null;
+}>>;
+export declare function readHeart(paths: AkumaPaths): Promise<HeartSnapshot>;
+export declare function readLastAnsweredTurn(paths: AkumaPaths): Promise<TurnFact | null>;
+export declare function readForkPoint(paths: AkumaPaths, historyId: string): Promise<ForkPoint | null>;

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

@@ -1,43 +1,57 @@
-import { existsSync } from "node:fs";
-import { answeredTurnFact, endBodyFact, finishBodyFact, insertActivityFact, insertBodyFact, insertTurnEndFact, insertTurnStartFact, insertPauseControl, insertRequestFact, insertSessionFact, insertStopControl, killFactForBody, latestBodyFact, latestKillFact, latestSessionFact, lastAnsweredTurnFact, nonterminalRequestFacts, pauseExists, requestFact, sessionFactForCoordinate, soulFact, stopFact, updateRequestRefused, updateRequestReserved, updateRequestServed, updateRequestVoided, } from "./rows.js";
+import { answeredTurnFact, endBodyFact, finishBodyFact, insertActivityFact, insertTurnEndFact, insertTurnStartFact, insertPauseControl, insertRequestFact, insertSessionFact, insertStopControl, killFactForBody, latestBodyFact, latestKillFact, latestSessionFact, lastAnsweredTurnFact, nonterminalRequestFacts, pauseFact, requestFact, sessionFactForCoordinate, stopFact, updateRequestRefused, updateRequestReserved, updateRequestServed, updateRequestVoided, } from "./rows.js";
 import { insertTellDeliveryFact, insertTellFact, insertTellReceiptFact, pendingTellFacts, tellFact, tellIdsForFence, } from "./tells.js";
 import { activityFactSlice, pruneActivityFacts, } from "./timeline.js";
-import { readSealFromLeash, transaction, withHeart } from "./storage.js";
-export { HeldAkumaLeash, initializeHeart, probeLeash } from "./storage.js";
-export { life } from "./facts.js";
+import { isHeartAbsent, readSealFromLeash, transaction, withHeart } from "./storage.js";
+import { soulFact } from "./soul.js";
+export { HeartAbsentError, HeldAkumaLeash, initializeHeart, isHeartAbsent, probeLeash } from "./storage.js";
+export { life, lifeAt } from "./facts.js";
 const ACTIVITY_LIMIT = 5_000;
-export function readSoul(paths) {
-    if (!existsSync(paths.heart))
-        return null;
-    return withHeart(paths, soulFact);
-}
-export function heartExists(paths) { return existsSync(paths.heart); }
-export function readSeal(paths) {
-    if (!existsSync(paths.leash))
-        return null;
-    return readSealFromLeash(paths);
-}
-export function recordBody(paths, input) {
-    return withHeart(paths, (heart) => {
-        return { sequence: insertBodyFact(heart, input), collar: input.collar, leashTakenAt: input.leashTakenAt };
-    });
+export async function readSoul(paths) {
+    try {
+        return await withHeart(paths, soulFact);
+    }
+    catch (error) {
+        if (isHeartAbsent(error))
+            return null;
+        throw error;
+    }
+}
+export async function heartExists(paths) {
+    try {
+        return await withHeart(paths, () => true);
+    }
+    catch (error) {
+        if (isHeartAbsent(error))
+            return false;
+        throw error;
+    }
+}
+export async function readSeal(paths) {
+    try {
+        return await readSealFromLeash(paths);
+    }
+    catch (error) {
+        if (isHeartAbsent(error))
+            return null;
+        throw error;
+    }
 }
-export function recordSession(paths, input) {
-    return withHeart(paths, (heart) => ({ sequence: insertSessionFact(heart, input), ...input }));
+export async function recordSession(paths, input) {
+    return await withHeart(paths, (heart) => ({ sequence: insertSessionFact(heart, input), ...input }));
 }
-export function appendActivity(paths, input) {
-    return withHeart(paths, (heart) => transaction(heart, () => {
+export async function appendActivity(paths, input) {
+    return await withHeart(paths, (heart) => transaction(heart, () => {
         const sequence = insertActivityFact(heart, input);
         pruneActivityFacts(heart, ACTIVITY_LIMIT);
         return sequence;
     }));
 }
-export function activitySlice(paths, input = {}) {
+export async function activitySlice(paths, input = {}) {
     const limit = input.limit ?? ACTIVITY_LIMIT;
-    return withHeart(paths, (heart) => activityFactSlice(heart, { ...input, limit }));
+    return await withHeart(paths, (heart) => activityFactSlice(heart, { ...input, limit }));
 }
-export function recordTell(paths, tell) {
-    return withHeart(paths, (heart) => transaction(heart, () => {
+export async function recordTell(paths, tell) {
+    return await withHeart(paths, (heart) => transaction(heart, () => {
         if (soulFact(heart) === null)
             return { kind: "not-born" };
         const sequence = insertTellFact(heart, tell);
@@ -45,8 +59,8 @@ export function recordTell(paths, tell) {
         return { kind: "recorded", tell: { sequence, ...tell, state: "pending", deliveries: [] } };
     }));
 }
-export function recordTellDeliveries(paths, inputs) {
-    withHeart(paths, (heart) => transaction(heart, () => {
+export async function recordTellDeliveries(paths, inputs) {
+    await withHeart(paths, (heart) => transaction(heart, () => {
         for (const input of inputs) {
             const current = tellFact(heart, input.tellId);
             if (current === null)
@@ -57,8 +71,8 @@ export function recordTellDeliveries(paths, inputs) {
         pruneActivityFacts(heart, ACTIVITY_LIMIT);
     }));
 }
-export function recordTellReceipt(paths, input) {
-    withHeart(paths, (heart) => transaction(heart, () => {
+export async function recordTellReceipt(paths, input) {
+    await withHeart(paths, (heart) => transaction(heart, () => {
         const tellIds = input.evidence === "exact"
             ? [input.tellId]
             : tellIdsForFence(heart, input.turnSequence, input.fence);
@@ -76,8 +90,8 @@ function sameRequestInput(fact, input) {
         && fact.world === input.world
         && JSON.stringify(fact.recipe) === JSON.stringify(input.recipe);
 }
-export function admitRequest(paths, input) {
-    return withHeart(paths, (heart) => transaction(heart, () => {
+export async function admitRequest(paths, input) {
+    return await withHeart(paths, (heart) => transaction(heart, () => {
         insertRequestFact(heart, input);
         const fact = requestFact(heart, input.id);
         if (fact === null)
@@ -87,8 +101,8 @@ export function admitRequest(paths, input) {
         return fact;
     }));
 }
-export function reserveRequest(paths, id, child) {
-    return withHeart(paths, (heart) => transaction(heart, () => {
+export async function reserveRequest(paths, id, child) {
+    return await withHeart(paths, (heart) => transaction(heart, () => {
         const before = requestFact(heart, id);
         if (before === null)
             throw new Error(`unknown Akuma request ${id}`);
@@ -100,8 +114,8 @@ export function reserveRequest(paths, id, child) {
         return requestFact(heart, id);
     }));
 }
-export function serveRequest(paths, id, child) {
-    return withHeart(paths, (heart) => transaction(heart, () => {
+export async function serveRequest(paths, id, child) {
+    return await withHeart(paths, (heart) => transaction(heart, () => {
         const before = requestFact(heart, id);
         if (before === null)
             throw new Error(`unknown Akuma request ${id}`);
@@ -113,8 +127,8 @@ export function serveRequest(paths, id, child) {
         return requestFact(heart, id);
     }));
 }
-export function refuseRequest(paths, id, diagnostic) {
-    return withHeart(paths, (heart) => transaction(heart, () => {
+export async function refuseRequest(paths, id, diagnostic) {
+    return await withHeart(paths, (heart) => transaction(heart, () => {
         const before = requestFact(heart, id);
         if (before === null)
             throw new Error(`unknown Akuma request ${id}`);
@@ -126,8 +140,8 @@ export function refuseRequest(paths, id, diagnostic) {
         return requestFact(heart, id);
     }));
 }
-export function voidRequest(paths, id, evidence) {
-    return withHeart(paths, (heart) => transaction(heart, () => {
+export async function voidRequest(paths, id, evidence) {
+    return await withHeart(paths, (heart) => transaction(heart, () => {
         const before = requestFact(heart, id);
         if (before === null)
             throw new Error(`unknown Akuma request ${id}`);
@@ -139,22 +153,24 @@ export function voidRequest(paths, id, evidence) {
         return requestFact(heart, id);
     }));
 }
-export function readRequest(paths, id) {
-    return withHeart(paths, (heart) => requestFact(heart, id));
+export async function readRequest(paths, id) {
+    return await withHeart(paths, (heart) => requestFact(heart, id));
 }
-export function readNonterminalRequests(paths) {
-    return withHeart(paths, nonterminalRequestFacts);
+export async function readNonterminalRequests(paths) {
+    return await withHeart(paths, nonterminalRequestFacts);
 }
-export function readKill(paths, bodySequence) {
-    return withHeart(paths, (heart) => killFactForBody(heart, bodySequence));
+export async function readKill(paths, bodySequence) {
+    return await withHeart(paths, (heart) => killFactForBody(heart, bodySequence));
 }
-export function requestStop(paths, at) {
-    return withHeart(paths, (heart) => transaction(heart, () => {
+export async function requestStop(paths, at) {
+    return await withHeart(paths, (heart) => transaction(heart, () => {
         const body = latestBodyFact(heart);
         if (body === null)
             throw new Error("Akuma has no Body to kill");
         if (latestKillFact(heart)?.bodySequence === body.sequence)
             return { kind: "already-killed", body };
+        if (body.end !== undefined)
+            return { kind: "already-stopped", body };
         const existing = stopFact(heart);
         if (existing !== null && existing.bodySequence !== body.sequence) {
             throw new Error("Akuma stop target is not the latest Body");
@@ -163,40 +179,52 @@ export function requestStop(paths, at) {
         return { kind: "requested", body };
     }));
 }
-export function requestPause(paths, at) {
-    return withHeart(paths, (heart) => transaction(heart, () => {
+export async function requestPause(paths, at) {
+    return await withHeart(paths, (heart) => transaction(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" };
+        return { kind: "requested", body };
     }));
 }
-export function stopRequested(paths, bodySequence) {
-    return withHeart(paths, (heart) => {
+export async function stopRequested(paths, bodySequence) {
+    return await withHeart(paths, (heart) => {
         const target = stopFact(heart);
         return target !== null && (bodySequence === undefined || target.bodySequence === bodySequence);
     });
 }
-export function pauseRequested(paths) { return withHeart(paths, pauseExists); }
-export function breakBody(paths, input) {
-    withHeart(paths, (heart) => endBodyFact(heart, input));
+export async function pauseRequested(paths, bodySequence) {
+    return await withHeart(paths, (heart) => {
+        const target = pauseFact(heart);
+        return target !== null && (bodySequence === undefined || target.bodySequence === bodySequence);
+    });
+}
+export async function breakBody(paths, input) {
+    await withHeart(paths, (heart) => endBodyFact(heart, input));
 }
-export function beginTurn(paths, input) {
-    return withHeart(paths, (heart) => transaction(heart, () => {
+export async function beginTurn(paths, input) {
+    return await withHeart(paths, (heart) => transaction(heart, () => {
         const fact = insertTurnStartFact(heart, input);
         pruneActivityFacts(heart, ACTIVITY_LIMIT);
         return fact;
     }));
 }
-export function endTurn(paths, input) {
-    return withHeart(paths, (heart) => transaction(heart, () => {
+export async function endTurn(paths, input) {
+    return await withHeart(paths, (heart) => transaction(heart, () => {
         const fact = insertTurnEndFact(heart, { kind: "turn-end", ...input });
         pruneActivityFacts(heart, ACTIVITY_LIMIT);
         return fact;
     }));
 }
-export function finishBodyIfIdle(paths, input) {
-    return withHeart(paths, (heart) => transaction(heart, () => {
+export async function finishBodyIfIdle(paths, input) {
+    return await withHeart(paths, (heart) => transaction(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);
         if (pending.length > 0)
             return { kind: "pending", tells: pending.map((tell) => tell.id) };
@@ -204,37 +232,50 @@ export function finishBodyIfIdle(paths, input) {
         return { kind: "finished" };
     }));
 }
-export function readHeart(paths) {
-    if (!existsSync(paths.heart)) {
-        return { soul: null, latestBody: null, latestSession: null, pending: [], latestKill: null };
+export async function readHeart(paths) {
+    try {
+        return await withHeart(paths, (heart) => ({
+            soul: soulFact(heart),
+            latestBody: latestBodyFact(heart),
+            latestSession: latestSessionFact(heart),
+            pending: pendingTellFacts(heart),
+            latestKill: latestKillFact(heart),
+            stop: stopFact(heart),
+            pause: pauseFact(heart),
+        }));
+    }
+    catch (error) {
+        if (isHeartAbsent(error)) {
+            return { soul: null, latestBody: null, latestSession: null, pending: [], latestKill: null, stop: null, pause: null };
+        }
+        throw error;
     }
-    return withHeart(paths, (heart) => ({
-        soul: soulFact(heart),
-        latestBody: latestBodyFact(heart),
-        latestSession: latestSessionFact(heart),
-        pending: pendingTellFacts(heart),
-        latestKill: latestKillFact(heart),
-    }));
 }
-export function readLastAnsweredTurn(paths) {
-    return withHeart(paths, lastAnsweredTurnFact);
+export async function readLastAnsweredTurn(paths) {
+    return await withHeart(paths, lastAnsweredTurnFact);
 }
-export function readForkPoint(paths, historyId) {
-    if (!existsSync(paths.heart))
-        return null;
-    return withHeart(paths, (heart) => {
-        const turn = answeredTurnFact(heart, historyId);
-        if (turn?.end?.outcome.kind !== "answered")
+export async function readForkPoint(paths, historyId) {
+    try {
+        return await withHeart(paths, (heart) => {
+            const turn = answeredTurnFact(heart, historyId);
+            const outcome = turn?.end?.outcome;
+            if (outcome?.kind !== "answered" || outcome.historyId === undefined)
+                return null;
+            const recipe = sessionFactForCoordinate(heart, outcome.session);
+            if (recipe === null)
+                throw new Error(`Akuma fork point ${historyId} has no session recipe`);
+            return {
+                historyId: outcome.historyId,
+                session: outcome.session,
+                provider: recipe.provider,
+                cwd: recipe.cwd,
+                options: recipe.options,
+            };
+        });
+    }
+    catch (error) {
+        if (isHeartAbsent(error))
             return null;
-        const recipe = sessionFactForCoordinate(heart, turn.end.outcome.session);
-        if (recipe === null)
-            throw new Error(`Akuma fork point ${historyId} has no session recipe`);
-        return {
-            historyId: turn.end.outcome.historyId,
-            session: turn.end.outcome.session,
-            provider: recipe.provider,
-            cwd: recipe.cwd,
-            options: recipe.options,
-        };
-    });
+        throw error;
+    }
 }