@astrosheep/keiyaku 4.6.8 → 4.6.9

package/build/src/akuma/body.js

@@ -313,6 +313,29 @@ async function recoverBodyRequests(input) {
     }
     return false;
 }
+function turnStartedEmitter(launch, soul, world) {
+    const reportDiagnostic = (message) => {
+        void recordPluginDiagnostic(launch.paths, "turn started", message);
+    };
+    return {
+        async emit(turnSequence) {
+            try {
+                const turn = await readTurn(launch.paths, turnSequence);
+                if (turn === null)
+                    throw new Error(`Committed Turn ${turnSequence} is missing from Heart`);
+                await emitPluginSignal({ world, reportDiagnostic }, {
+                    kind: "akuma.turn-started",
+                    akumaId: soul.id,
+                    turnSequence,
+                    ...(turn.initiator === undefined ? {} : { initiator: turn.initiator }),
+                });
+            }
+            catch (error) {
+                await recordPluginDiagnostic(launch.paths, "turn started", error);
+            }
+        },
+    };
+}
 function turnOutcomeEmitter(launch, soul, world) {
     const reportDiagnostic = (message) => {
         void recordPluginDiagnostic(launch.paths, "turn outcome", message);
@@ -383,7 +406,7 @@ async function admitInitialCallTell(runtime, input) {
     });
 }
 async function runBodyTurns(input) {
-    const { launch, soul, adapter, bodySequence, supervisor, runtime, turnOutcome } = 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));
@@ -418,6 +441,7 @@ async function runBodyTurns(input) {
             world: runtime.world,
             externalCommands: runtime.externalCommands,
             now: runtime.now,
+            turnStarted,
         });
         if (result.kind === "hung") {
             await failOpenBoundTurnsIfPresent(launch.paths, bodySequence, "Body hung with open bound Turns", runtime.now());
@@ -566,12 +590,14 @@ export async function driveAkumaBody(launch, adapter, runtimeInput = {}) {
     let pendingTellDisposition = undefined;
     let bodySequence;
     let emitBodyEnd;
+    let emitTurnStarted;
     let emitTurnOutcome;
     try {
         const prepared = await prepareBodyExecution(launch, leash, runtime, adapter);
         if (prepared === null)
             return;
         emitBodyEnd = bodyEndEmitter(launch, prepared.soul, world);
+        emitTurnStarted = turnStartedEmitter(launch, prepared.soul, world);
         emitTurnOutcome = turnOutcomeEmitter(launch, prepared.soul, world);
         const body = await leash.recordBody(launch.paths, { leashTakenAt: runtime.now() });
         bodySequence = body.sequence;
@@ -598,6 +624,7 @@ export async function driveAkumaBody(launch, adapter, runtimeInput = {}) {
             bodySequence: body.sequence,
             supervisor,
             runtime,
+            turnStarted: emitTurnStarted,
             turnOutcome: emitTurnOutcome,
         });
     }

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

@@ -8,23 +8,18 @@ import type { WorldRoot } from "../world.js";
 declare const akumaCallRecipeSchema: z.ZodObject<{
     description: z.ZodOptional<z.ZodString>;
     allowed: z.ZodPipe<z.ZodArray<z.ZodEnum<{
-        "task.add": "task.add";
-        "task.addDocument": "task.addDocument";
-        "task.compose": "task.compose";
-        "task.done": "task.done";
-        "task.drop": "task.drop";
-        "task.hold": "task.hold";
-        "task.resume": "task.resume";
-        "task.start": "task.start";
-        "task.stop": "task.stop";
-        "task.update": "task.update";
+        "debt.add": "debt.add";
+        "debt.addDocument": "debt.addDocument";
+        "debt.done": "debt.done";
+        "debt.drop": "debt.drop";
+        "debt.update": "debt.update";
         "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, ("task.add" | "task.addDocument" | "task.compose" | "task.done" | "task.drop" | "task.hold" | "task.resume" | "task.start" | "task.stop" | "task.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.audit" | "contract.deliver" | "contract.review")[]>>;
     provider: z.ZodPipe<z.ZodObject<{
         name: z.ZodString;
         kind: z.ZodEnum<{
@@ -93,23 +88,18 @@ declare const akumaCallPayloadSchema: z.ZodObject<{
     recipe: z.ZodObject<{
         description: z.ZodOptional<z.ZodString>;
         allowed: z.ZodPipe<z.ZodArray<z.ZodEnum<{
-            "task.add": "task.add";
-            "task.addDocument": "task.addDocument";
-            "task.compose": "task.compose";
-            "task.done": "task.done";
-            "task.drop": "task.drop";
-            "task.hold": "task.hold";
-            "task.resume": "task.resume";
-            "task.start": "task.start";
-            "task.stop": "task.stop";
-            "task.update": "task.update";
+            "debt.add": "debt.add";
+            "debt.addDocument": "debt.addDocument";
+            "debt.done": "debt.done";
+            "debt.drop": "debt.drop";
+            "debt.update": "debt.update";
             "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, ("task.add" | "task.addDocument" | "task.compose" | "task.done" | "task.drop" | "task.hold" | "task.resume" | "task.start" | "task.stop" | "task.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.audit" | "contract.deliver" | "contract.review")[]>>;
         provider: z.ZodPipe<z.ZodObject<{
             name: z.ZodString;
             kind: z.ZodEnum<{

package/build/src/akuma/heart/activity-schema.d.ts

@@ -24,6 +24,7 @@ export declare const fileChangeSchema: z.ZodObject<{
         added: z.ZodNumber;
         removed: z.ZodNumber;
     }, z.core.$strip>>;
+    patch: z.ZodOptional<z.ZodString>;
 }, z.core.$strip>;
 export declare const toolCallSchema: z.ZodUnion<readonly [z.ZodObject<{
     kind: z.ZodLiteral<"run">;
@@ -57,6 +58,7 @@ export declare const toolCallSchema: z.ZodUnion<readonly [z.ZodObject<{
             added: z.ZodNumber;
             removed: z.ZodNumber;
         }, z.core.$strip>>;
+        patch: z.ZodOptional<z.ZodString>;
     }, z.core.$strip>>>;
 }, z.core.$strip>, z.ZodObject<{
     kind: z.ZodLiteral<"other">;
@@ -72,6 +74,7 @@ export declare const toolResultSchema: z.ZodObject<{
         ok: "ok";
     }>;
     message: z.ZodOptional<z.ZodString>;
+    output: z.ZodOptional<z.ZodString>;
     exitCode: z.ZodOptional<z.ZodNumber>;
 }, z.core.$strip>;
 declare const toolEventSchema: z.ZodUnion<readonly [z.ZodObject<{
@@ -112,6 +115,7 @@ declare const toolEventSchema: z.ZodUnion<readonly [z.ZodObject<{
                 added: z.ZodNumber;
                 removed: z.ZodNumber;
             }, z.core.$strip>>;
+            patch: z.ZodOptional<z.ZodString>;
         }, z.core.$strip>>>;
     }, z.core.$strip>, z.ZodObject<{
         kind: z.ZodLiteral<"other">;
@@ -130,6 +134,7 @@ declare const toolEventSchema: z.ZodUnion<readonly [z.ZodObject<{
             ok: "ok";
         }>;
         message: z.ZodOptional<z.ZodString>;
+        output: z.ZodOptional<z.ZodString>;
         exitCode: z.ZodOptional<z.ZodNumber>;
     }, z.core.$strip>;
     type: z.ZodLiteral<"tool">;
@@ -167,6 +172,7 @@ declare const toolEventSchema: z.ZodUnion<readonly [z.ZodObject<{
                 added: z.ZodNumber;
                 removed: z.ZodNumber;
             }, z.core.$strip>>;
+            patch: z.ZodOptional<z.ZodString>;
         }, z.core.$strip>>>;
     }, z.core.$strip>, z.ZodObject<{
         kind: z.ZodLiteral<"other">;
@@ -195,6 +201,9 @@ export declare const agentEventSchema: z.ZodUnion<readonly [z.ZodObject<{
     }>>, z.ZodObject<{
         sessionId: z.ZodString;
     }, z.core.$strict>]>;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"model">;
+    model: z.ZodOptional<z.ZodString>;
 }, z.core.$strip>, z.ZodObject<{
     type: z.ZodLiteral<"assistant">;
     text: z.ZodString;
@@ -241,6 +250,7 @@ export declare const agentEventSchema: z.ZodUnion<readonly [z.ZodObject<{
                 added: z.ZodNumber;
                 removed: z.ZodNumber;
             }, z.core.$strip>>;
+            patch: z.ZodOptional<z.ZodString>;
         }, z.core.$strip>>>;
     }, z.core.$strip>, z.ZodObject<{
         kind: z.ZodLiteral<"other">;
@@ -259,6 +269,7 @@ export declare const agentEventSchema: z.ZodUnion<readonly [z.ZodObject<{
             ok: "ok";
         }>;
         message: z.ZodOptional<z.ZodString>;
+        output: z.ZodOptional<z.ZodString>;
         exitCode: z.ZodOptional<z.ZodNumber>;
     }, z.core.$strip>;
     type: z.ZodLiteral<"tool">;
@@ -296,6 +307,7 @@ export declare const agentEventSchema: z.ZodUnion<readonly [z.ZodObject<{
                 added: z.ZodNumber;
                 removed: z.ZodNumber;
             }, z.core.$strip>>;
+            patch: z.ZodOptional<z.ZodString>;
         }, z.core.$strip>>>;
     }, z.core.$strip>, z.ZodObject<{
         kind: z.ZodLiteral<"other">;

package/build/src/akuma/heart/activity-schema.js

@@ -11,6 +11,7 @@ export const fileChangeSchema = z.object({
     op: z.enum(["add", "update", "delete", "unspecified"]),
     path: text,
     diffstat: diffstatSchema.optional(),
+    patch: text.optional(),
 });
 export const toolCallSchema = z.union([
     z.object({ kind: z.literal("run"), command: text }),
@@ -33,6 +34,7 @@ export const toolCallSchema = z.union([
 export const toolResultSchema = z.object({
     status: z.enum(["ok", "error"]),
     message: text.optional(),
+    output: text.optional(),
     exitCode: z.number().int().safe().optional(),
 });
 const toolFields = { type: z.literal("tool"), id: text, name: text, call: toolCallSchema, truncated };
@@ -42,6 +44,10 @@ const toolEventSchema = z.union([
 ]);
 export const agentEventSchema = z.union([
     z.object({ type: z.literal("session"), coordinate: resumeCoordinateSchema }),
+    // One provider-neutral runtime-model observation in the shared agent-event
+    // vocabulary. Body admits it into the Soul's single current model; it is
+    // never appended to activity, so compaction cannot lose or resurrect it.
+    z.object({ type: z.literal("model"), model: text.optional() }),
     z.object({ type: z.literal("assistant"), text, truncated }),
     z.object({ type: z.literal("thought"), text, truncated }),
     toolEventSchema,

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

@@ -2,6 +2,7 @@ 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 { 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";
@@ -19,10 +20,61 @@ export declare function appendActivity(paths: AkumaPaths, input: Readonly<{
 }>): Promise<number>;
 type ActivitySlice = ActivityFactSlice;
 export type { TimelineFact } from "./timeline.js";
+export type CurrentModelUpdate = "recorded" | "unchanged" | "not-current-body";
+/**
+ * Admit one runtime-model observation from the Body that is actually running.
+ * The model is the one mutable member of an otherwise frozen recipe, so only
+ * the exact latest Running Body may move it: evidence that arrives after that
+ * Body settled, or from a superseded Body, is refused rather than applied.
+ */
+export declare function recordCurrentModel(paths: AkumaPaths, input: Readonly<{
+    bodySequence: number;
+    model: string | undefined;
+}>): Promise<CurrentModelUpdate>;
 export declare function activitySlice(paths: AkumaPaths): Promise<ActivitySlice>;
 export declare function readStatusFacts(paths: AkumaPaths, input: StatusFactInput, signal?: AbortSignal): Promise<ActivitySlice["rows"]>;
-/** One live observation's successful raw input and decoded frontier, never a connection. */
+/** One live observation's current retained timeline, or a no-change witness. */
+export type TimelineRead = Readonly<{
+    changed: false;
+}> | Readonly<{
+    changed: true;
+    born: boolean;
+    slice: ActivityFactSlice;
+}>;
+/**
+ * One operation-owned reader of the retained timeline. It keeps its read
+ * custody between observations, skips decoding when the same connection's
+ * change counter still names the observed snapshot, and renews that gate
+ * whenever a replaced Heart gives it a new connection.
+ */
+export declare function createTimelineReader(paths: AkumaPaths): Readonly<{
+    read(signal?: AbortSignal): Promise<TimelineRead>;
+    clear(): void;
+}>;
+/** One observer owns its connection and successful decoded frontier. */
 export declare function createStatusFactReader(paths: AkumaPaths): {
+    life: (signal?: AbortSignal) => Promise<LifeSnapshot>;
+    tellOutcome: (id: string, signal?: AbortSignal) => Promise<{
+        tell: Readonly<{
+            kind: "tell";
+            sequence: number;
+            id: string;
+            body: string;
+            initiator?: string;
+            schemaJson?: string;
+            recordedAt: string;
+            state: "pending" | "told";
+            deliveries: readonly import("./facts.js").TellDelivery[];
+            binding?: import("./facts.js").TellBinding;
+        }> | null;
+        end: Readonly<{
+            kind: "turn-end";
+            sequence: number;
+            turnSequence: number;
+            outcome: TurnOutcome;
+            completedAt: string;
+        }> | undefined;
+    }>;
     clear(): void;
     read(input: StatusFactInput, signal?: AbortSignal): Promise<ActivitySlice["rows"]>;
 };
@@ -30,7 +82,7 @@ type LifeSnapshot = Pick<HeartSnapshot, "soul" | "latestBody" | "latestSession"
     hasPendingTell: boolean;
 }>;
 /** Lifecycle probes do not load narration, Tell bodies, or delivery histories. */
-export declare function readLifeSnapshot(paths: AkumaPaths, signal?: AbortSignal): Promise<LifeSnapshot>;
+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<{
@@ -111,6 +163,11 @@ export declare function finishBodyIfIdle(paths: AkumaPaths, input: Readonly<{
     kind: "pending";
     tells: readonly string[];
 }>>;
+export type BodyControlSnapshot = Pick<HeartSnapshot, "soul" | "pending" | "stop" | "pause">;
+export declare function createBodyHeartReader(paths: AkumaPaths): {
+    clear: () => void;
+    read(): Promise<BodyControlSnapshot>;
+};
 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,9 +1,10 @@
 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 { activityFactSlice, statusFacts, readStatusBatch, decodeTimelineBatch, lastActivityAt as readLastActivityAt, pruneActivityFacts, } from "./timeline.js";
-import { isHeartAbsent, readSealFromLeash, recordPendingTell, withHeartTransaction, withReadOnlyHeart, } from "./storage.js";
-import { soulFact } from "./soul.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";
@@ -50,12 +51,57 @@ export async function appendActivity(paths, input) {
         return sequence;
     });
 }
+/**
+ * Admit one runtime-model observation from the Body that is actually running.
+ * The model is the one mutable member of an otherwise frozen recipe, so only
+ * the exact latest Running Body may move it: evidence that arrives after that
+ * Body settled, or from a superseded Body, is refused rather than applied.
+ */
+export async function recordCurrentModel(paths, input) {
+    const model = decodeRuntimeModel(input.model);
+    return await withHeartTransaction(paths, (heart) => {
+        const body = latestBodyFact(heart);
+        if (body === null || body.sequence !== input.bodySequence || body.end !== undefined || body.hung !== undefined) {
+            return "not-current-body";
+        }
+        return setSoulModel(heart, model) ? "recorded" : "unchanged";
+    });
+}
 export async function activitySlice(paths) {
     return await withReadOnlyHeart(paths, (heart) => activityFactSlice(heart));
 }
 export async function readStatusFacts(paths, input, signal) {
     return await withReadOnlyHeart(paths, (heart) => statusFacts(heart, input), signal);
 }
+/**
+ * One operation-owned reader of the retained timeline. It keeps its read
+ * custody between observations, skips decoding when the same connection's
+ * change counter still names the observed snapshot, and renews that gate
+ * whenever a replaced Heart gives it a new connection.
+ */
+export function createTimelineReader(paths) {
+    const reader = createHeartReader(paths);
+    let generation = -1;
+    let version;
+    return {
+        clear: reader.clear,
+        async read(signal) {
+            // Publication follows COMMIT, so a failed read never leaves a memo behind.
+            return await reader.read((heart) => {
+                const current = reader.generation();
+                if (current !== generation) {
+                    generation = current;
+                    version = undefined;
+                }
+                const observed = timelineDataVersion(heart);
+                if (version !== undefined && observed === version)
+                    return { changed: false };
+                version = observed;
+                return { changed: true, born: soulFact(heart) !== null, slice: activityFactSlice(heart) };
+            }, signal);
+        },
+    };
+}
 // Each query returns a fixed set of scalar columns; compare JSON columns as text.
 function sameRawRows(left, right) {
     if (left.length !== right.length)
@@ -75,16 +121,24 @@ function sameStatusBatch(left, right) {
         sameRawRows(left.tells.deliveries, right.tells.deliveries) &&
         sameRawRows(left.tells.bindings, right.tells.bindings));
 }
-/** One live observation's successful raw input and decoded frontier, never a connection. */
+/** One observer owns its connection and successful decoded frontier. */
 export function createStatusFactReader(paths) {
+    const reader = createHeartReader(paths);
     let memo;
     return {
+        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;
+            return { tell, end };
+        }, signal),
         clear() {
+            reader.clear();
             memo = undefined;
         },
         async read(input, signal) {
             try {
-                const next = await withReadOnlyHeart(paths, (heart) => {
+                const next = await reader.read((heart) => {
                     const batch = readStatusBatch(heart, input);
                     if (memo !== undefined && sameStatusBatch(batch, memo.batch))
                         return memo;
@@ -95,6 +149,7 @@ export function createStatusFactReader(paths) {
                 return next.facts;
             }
             catch (error) {
+                reader.clear();
                 memo = undefined;
                 throw error;
             }
@@ -102,9 +157,9 @@ export function createStatusFactReader(paths) {
     };
 }
 /** Lifecycle probes do not load narration, Tell bodies, or delivery histories. */
-export async function readLifeSnapshot(paths, signal) {
+export async function readLifeSnapshot(paths, signal, read = (body, signal) => withReadOnlyHeart(paths, body, signal)) {
     try {
-        return await withReadOnlyHeart(paths, (heart) => ({
+        return await read((heart) => ({
             soul: soulFact(heart),
             latestBody: latestBodyFact(heart),
             latestSession: latestSessionFact(heart),
@@ -321,6 +376,27 @@ export async function finishBodyIfIdle(paths, input) {
         return { kind: "finished" };
     });
 }
+export function createBodyHeartReader(paths) {
+    const reader = createHeartReader(paths);
+    return {
+        clear: reader.clear,
+        async read() {
+            try {
+                return await reader.read((heart) => ({
+                    soul: soulFact(heart),
+                    pending: pendingTellFacts(heart),
+                    stop: stopFact(heart),
+                    pause: pauseFact(heart),
+                }));
+            }
+            catch (error) {
+                if (isHeartAbsent(error))
+                    return { soul: null, pending: [], stop: null, pause: null };
+                throw error;
+            }
+        },
+    };
+}
 export async function readHeart(paths) {
     try {
         return await withReadOnlyHeart(paths, (heart) => ({
@@ -366,12 +442,15 @@ export async function readForkPoint(paths, historyId) {
             const recipe = sessionFactForCoordinate(heart, outcome.session);
             if (recipe === null)
                 throw new Error(`Akuma fork point ${historyId} has no session recipe`);
+            // The source's current model is the admitted child selection. The session
+            // row's obsolete copy is dropped, and an absent current model stays absent.
+            const current = soulFact(heart)?.options.model;
             return {
                 historyId: outcome.historyId,
                 session: outcome.session,
                 provider: recipe.provider,
                 cwd: recipe.cwd,
-                options: recipe.options,
+                options: { ...withoutModel(recipe.options), ...(current === undefined ? {} : { model: current }) },
             };
         });
     }

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

@@ -1,5 +1,5 @@
 import { z } from "zod";
-import { providerOptionsSchema } from "../provider-recipe.js";
+import { providerOptionsSchema, withoutModel } from "../provider-recipe.js";
 import { resumeCoordinateSchema } from "../coordinate.js";
 import { decodeResumeCoordinate, encodeResumeCoordinate as encodeCoordinate } from "../coordinate.js";
 import { agentEventSchema } from "./activity-schema.js";
@@ -32,7 +32,7 @@ export function encodeSessionRow(session) {
         session.provider,
         encodeResumeCoordinate(session.coordinate),
         session.cwd,
-        json(session.options),
+        json(withoutModel(session.options)),
         session.admittedAt,
     ];
 }
@@ -45,7 +45,9 @@ export function decodeSessionRow(row) {
         provider: row.provider,
         coordinate: resumeCoordinate(parsed(row.coordinate_json)),
         cwd: row.cwd,
-        options: parsed(row.options_json),
+        // A session's own model copy is obsolete: the Soul owns the one current
+        // model, so an old row never re-admits the model it happened to start with.
+        options: withoutModel(parsed(row.options_json)),
         admittedAt: row.admitted_at,
     };
 }

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

@@ -7,3 +7,12 @@ export declare function encodeSoulRow(soul: Soul): readonly [string];
 export declare function decodeSoulRow(row: SoulRow): Soul;
 export declare function soulFact(database: DatabaseSync): Soul | null;
 export declare function insertSoulFact(database: DatabaseSync, soul: Soul): void;
+/**
+ * Replace only the current-model member of the singleton Soul and report
+ * whether the stored value actually moved. Every other raw member is carried
+ * through byte-identically: the codec normalizes recipe options, origin and
+ * allowed, so decoding and re-encoding a whole Soul here would silently
+ * rewrite fields this update never touched. A Soul this build cannot read is
+ * refused rather than mutated.
+ */
+export declare function setSoulModel(database: DatabaseSync, model: string | undefined): boolean;

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

@@ -78,3 +78,32 @@ export function soulFact(database) {
 export function insertSoulFact(database, soul) {
     database.prepare("INSERT INTO soul(singleton, soul_json) VALUES (1, ?)").run(...encodeSoulRow(soul));
 }
+/**
+ * Replace only the current-model member of the singleton Soul and report
+ * whether the stored value actually moved. Every other raw member is carried
+ * through byte-identically: the codec normalizes recipe options, origin and
+ * allowed, so decoding and re-encoding a whole Soul here would silently
+ * rewrite fields this update never touched. A Soul this build cannot read is
+ * refused rather than mutated.
+ */
+export function setSoulModel(database, model) {
+    const row = database.prepare("SELECT soul_json FROM soul WHERE singleton = 1").get();
+    if (row === undefined)
+        throw new Error("Akuma soul is absent");
+    const raw = JSON.parse(row.soul_json);
+    decodeSoul(raw);
+    const soul = record(raw);
+    const options = record(soul.options);
+    if (options === null)
+        throw new Error("Akuma soul options must be an object");
+    const current = options.model;
+    if (model === undefined ? current === undefined : current === model)
+        return false;
+    const next = { ...options };
+    if (model === undefined)
+        delete next.model;
+    else
+        next.model = model;
+    database.prepare("UPDATE soul SET soul_json = ? WHERE singleton = 1").run(JSON.stringify({ ...soul, options: next }));
+    return true;
+}

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

@@ -9,6 +9,21 @@ export declare class HeartAbsentError extends Error {
 export declare function isHeartAbsent(error: unknown): error is HeartAbsentError;
 export declare function classifyHeartSchema(paths: AkumaPaths): Promise<"current" | "unsupported">;
 export declare function withReadOnlyHeart<T>(paths: AkumaPaths, body: (database: DatabaseSync) => T, signal?: AbortSignal): Promise<T>;
+export type HeartRead = <T>(body: (database: DatabaseSync) => T, signal?: AbortSignal) => Promise<T>;
+export type HeartReader = Readonly<{
+    read: HeartRead;
+    clear(): void;
+    /** Counts opened connections, so a caller's own reuse cannot survive a replaced Heart. */
+    generation(): number;
+}>;
+/**
+ * A bounded observer owns its connection between observations, never a
+ * transaction: each read settles the transaction it began, and a removed or
+ * replaced Heart invalidates the retained custody through file identity.
+ * Release never interrupts an executing read; it settles after the current
+ * observation, so a caller may release while a pull is still in flight.
+ */
+export declare function createHeartReader(paths: AkumaPaths): HeartReader;
 export declare function withHeartTransaction<T>(paths: AkumaPaths, body: (database: DatabaseSync) => T, signal?: AbortSignal): Promise<T>;
 /** Insert one already-admitted pending Tell into an already-open Heart transaction. */
 export declare function recordPendingTell(heart: DatabaseSync, tell: Omit<TellFact, "sequence" | "state" | "deliveries" | "binding">): Readonly<{

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

@@ -112,6 +112,61 @@ export async function withReadOnlyHeart(paths, body, signal) {
         database.close();
     }
 }
+/**
+ * A bounded observer owns its connection between observations, never a
+ * transaction: each read settles the transaction it began, and a removed or
+ * replaced Heart invalidates the retained custody through file identity.
+ * Release never interrupts an executing read; it settles after the current
+ * observation, so a caller may release while a pull is still in flight.
+ */
+export function createHeartReader(paths) {
+    let database;
+    let identity;
+    let tail = Promise.resolve();
+    let opened = 0;
+    const release = () => {
+        const retained = database;
+        database = undefined;
+        identity = undefined;
+        try {
+            retained?.close();
+        }
+        catch {
+            // A connection already released by its own failed read stays released.
+        }
+    };
+    const clear = () => {
+        tail = tail.then(release, release);
+    };
+    const read = (body, signal) => {
+        const pending = tail.then(async () => {
+            try {
+                signal?.throwIfAborted();
+                const current = await lstat(paths.heart).catch((error) => {
+                    if (error.code === "ENOENT")
+                        throw new HeartAbsentError(paths.heart, { cause: error });
+                    throw error;
+                });
+                if (identity?.dev !== current.dev || identity?.ino !== current.ino)
+                    release();
+                if (database === undefined) {
+                    database = await openHeart(paths.heart, "ro");
+                    identity = current;
+                    opened += 1;
+                }
+                await beginTransaction(database, "read", signal);
+                return finishTransaction(database, body);
+            }
+            catch (error) {
+                release();
+                throw error;
+            }
+        });
+        tail = pending.catch(() => undefined);
+        return pending;
+    };
+    return { read, clear, generation: () => opened };
+}
 export async function withHeartTransaction(paths, body, signal) {
     signal?.throwIfAborted();
     const database = await openHeart(paths.heart, "rw");