@astrosheep/keiyaku 4.5.20 → 4.5.21

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

@@ -12,6 +12,7 @@ export type BodyLaunch = Readonly<{
     seed?: Omit<Soul, "createdAt">;
     birthSession?: Omit<SessionFact, "sequence">;
     initialBody?: string;
+    initiator?: string;
     initialSchemaJson?: string;
     refuseIfHeld?: boolean;
     completion?: Readonly<{
@@ -53,16 +54,35 @@ type BodyRuntime = Readonly<{
     world: WorldRoot;
     externalCommands: Readonly<Record<string, ErasedRequestCommand>>;
 }>;
-export declare function bodyProcessInput(launch: BodyLaunch, bodyModuleUrl?: string): Promise<{
+type RuntimeEnvironment = Readonly<{
+    /** The current process executable, preferred only while it is a different live value. */
+    current?: string;
+    /** The present PATH used to resolve the recorded executable basename. */
+    path?: string | undefined;
+    exists?: (path: string) => boolean | Promise<boolean>;
+}>;
+/** One Body launch's runtime input: the runtime recorded for it and its resolution environment. */
+export type BodyLaunchRuntime = Readonly<{
+    recorded?: string;
+    environment?: RuntimeEnvironment;
+}>;
+/**
+ * Resolve the runtime executable a Body spawn will use. The path recorded for
+ * this process's birth wins while it exists. Once it is gone, wake re-resolves
+ * the runtime before any spawn can fail: the current process executable while
+ * that is a different live value, then the recorded executable basename on the
+ * present PATH. An unresolvable runtime refuses with the stale record, the
+ * failed re-resolution, and the kill-and-call-fresh remedy.
+ */
+export declare function resolveRuntimeExecutable(recorded?: string, environment?: RuntimeEnvironment): Promise<string>;
+export declare function bodyProcessInput(launch: BodyLaunch, bodyModuleUrl?: string, runtime?: BodyLaunchRuntime): Promise<{
     argv: string[];
     cwd: string;
-    env: {
-        KEIYAKU_ACTOR_ID: import("./identity.js").AkuId;
-    };
+    env: Record<string, string>;
     log: string;
 }>;
 export declare function handoffPendingTells(paths: AkumaPaths, spawn?: (launch: BodyLaunch) => Promise<OwnedProcess>): Promise<void>;
 export declare function driveAkumaBody(launch: BodyLaunch, adapter?: ProviderAdapter, runtimeInput?: Partial<BodyRuntime>): Promise<"held" | void>;
-export declare function spawnAkumaBody(launch: BodyLaunch): Promise<OwnedProcess>;
+export declare function spawnAkumaBody(launch: BodyLaunch, runtime?: BodyLaunchRuntime): Promise<OwnedProcess>;
 export declare function runAkumaBody(launch: BodyLaunch, world: WorldRoot, externalCommands: Readonly<Record<string, ErasedRequestCommand>>): Promise<"held" | void>;
 export declare function wakeRecordedTell(paths: AkumaPaths, tellId: string, runtime?: TellWakeRuntime): Promise<TellResult>;

package/build/src/akuma/body.js

@@ -1,10 +1,12 @@
-import { appendFile } from "node:fs/promises";
+import { appendFile, stat } from "node:fs/promises";
+import { basename, delimiter, join } from "node:path";
 import { fileURLToPath } from "node:url";
 import { abortableDelay } from "./abort.js";
 import { BodySupervisor } from "./body-supervisor.js";
 import { driveTurn, turnRecipe } from "./turn-drive.js";
 import { HeldAkumaLeash, breakBody, decidePendingTellDisposition, drainPendingTells, endTurn, failOpenBoundTurns, finishBodyIfIdle, heartExists, isHeartAbsent, probeLeash, projectTell, readHeart, readOpenBoundTurns, readOpenPendingTellDisposition, readTell, readTurn, readNonterminalRequests, resolvePendingTellDisposition, } from "./heart/index.js";
 import { worldRootForAkumaPaths } from "./identity.js";
+import { akumaExecutionEnvironment } from "./providers/execution-environment.js";
 import { pluginRuntime } from "../plugin/runtime.js";
 import { World } from "../world.js";
 import { resolveProviderExecution } from "./providers/index.js";
@@ -144,19 +146,71 @@ const DEFAULT_RUNTIME = {
     externalCommands: {},
     spawnBody: spawnAkumaBody,
 };
-export async function bodyProcessInput(launch, bodyModuleUrl = import.meta.url) {
+/**
+ * The runtime executable this process recorded at its birth. A package-manager
+ * upgrade can remove the file under a live process, so a wake re-resolves that
+ * record instead of surfacing a bare missing-file launch failure.
+ */
+const RECORDED_RUNTIME = process.execPath;
+async function runtimeFileExists(path) {
+    try {
+        return (await stat(path)).isFile();
+    }
+    catch {
+        return false;
+    }
+}
+async function runtimeCommandOnPath(command, path, exists) {
+    if (command.length === 0 || command.includes("/") || command.includes("\\"))
+        return null;
+    for (const directory of (path ?? "").split(delimiter)) {
+        if (directory.length === 0)
+            continue;
+        const candidate = join(directory, command);
+        if (await exists(candidate))
+            return candidate;
+    }
+    return null;
+}
+class StaleRuntimeError extends Error {
+    constructor(recorded, current, command) {
+        super(`recorded Body runtime ${recorded} no longer exists and re-resolution failed: neither this process executable ` +
+            `${current} nor the command "${command}" on PATH names an existing file; kill this Akuma and call a fresh one`);
+        this.name = "StaleRuntimeError";
+    }
+}
+/**
+ * Resolve the runtime executable a Body spawn will use. The path recorded for
+ * this process's birth wins while it exists. Once it is gone, wake re-resolves
+ * the runtime before any spawn can fail: the current process executable while
+ * that is a different live value, then the recorded executable basename on the
+ * present PATH. An unresolvable runtime refuses with the stale record, the
+ * failed re-resolution, and the kill-and-call-fresh remedy.
+ */
+export async function resolveRuntimeExecutable(recorded = RECORDED_RUNTIME, environment = {}) {
+    const exists = environment.exists ?? runtimeFileExists;
+    if (await exists(recorded))
+        return recorded;
+    const current = environment.current ?? process.execPath;
+    const command = basename(recorded);
+    const reResolved = (current !== recorded && (await exists(current)) ? current : null) ??
+        (await runtimeCommandOnPath(command, environment.path ?? process.env.PATH, exists));
+    if (reResolved === null)
+        throw new StaleRuntimeError(recorded, current, command);
+    return reResolved;
+}
+export async function bodyProcessInput(launch, bodyModuleUrl = import.meta.url, runtime = {}) {
     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 = await resolveRuntimeExecutable(runtime.recorded, runtime.environment);
     const source = bodyModuleUrl.endsWith(".ts");
     const entry = fileURLToPath(new URL(source ? "../akuma-body.ts" : "../akuma-body.js", bodyModuleUrl));
     return {
-        argv: source
-            ? [process.execPath, "--import", import.meta.resolve("tsx"), entry, encoded]
-            : [process.execPath, entry, encoded],
+        argv: source ? [executable, "--import", import.meta.resolve("tsx"), entry, encoded] : [executable, entry, encoded],
         cwd: await launchCwd(launch),
-        env: { ...process.env, KEIYAKU_ACTOR_ID: actorId },
+        env: akumaExecutionEnvironment(process.env, { KEIYAKU_ACTOR_ID: actorId }),
         log: launch.paths.log,
     };
 }
@@ -237,6 +291,7 @@ function turnOutcomeEmitter(launch, soul) {
     return {
         async emit(turnSequence, outcome) {
             try {
+                const initiator = (await readTurn(launch.paths, turnSequence))?.initiator;
                 plugins ??= pluginRuntime({
                     world: await World.at(worldRootForAkumaPaths(launch.paths)),
                     reportDiagnostic,
@@ -245,6 +300,7 @@ function turnOutcomeEmitter(launch, soul) {
                     kind: "akuma.turn-outcome",
                     akumaId: soul.id,
                     turnSequence,
+                    ...(initiator === undefined ? {} : { initiator }),
                     outcome: outcome.outcome === "answered"
                         ? { kind: "answered", text: outcome.answer }
                         : { kind: "failed", reason: outcome.diagnostic },
@@ -312,6 +368,7 @@ async function runBodyTurns(input) {
             runtimeSpawn: runtime.spawnChild ?? spawnAkumaBody,
             body: initial ?? "",
             ...(initial === undefined ? {} : { call: initial }),
+            ...(launch.initiator === undefined ? {} : { initiator: launch.initiator }),
             launchTells,
             ...(schema === undefined ? {} : { schemaJson: schema }),
             world: runtime.world,
@@ -498,8 +555,8 @@ export async function driveAkumaBody(launch, adapter, runtimeInput = {}) {
             await finished.notification;
     }
 }
-export async function spawnAkumaBody(launch) {
-    return await spawnDetachedProcess(await bodyProcessInput(launch));
+export async function spawnAkumaBody(launch, runtime = {}) {
+    return await spawnDetachedProcess(await bodyProcessInput(launch, import.meta.url, runtime));
 }
 export async function runAkumaBody(launch, world, externalCommands) {
     return await driveAkumaBody(launch, undefined, { world, externalCommands });

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

@@ -29,6 +29,7 @@ declare const akumaCallPayloadSchema: z.ZodObject<{
     world: z.ZodString;
     archetype: z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>;
     body: z.ZodOptional<z.ZodString>;
+    initiator: z.ZodOptional<z.ZodString>;
     awaitAsleep: z.ZodOptional<z.ZodLiteral<true>>;
     cwd: z.ZodOptional<z.ZodString>;
     recipe: z.ZodObject<{
@@ -61,6 +62,7 @@ export type AkumaCallRequestChildLaunch = Readonly<{
     paths: AkumaPaths;
     seed: Omit<Soul, "createdAt">;
     initialBody?: string;
+    initiator?: string;
 }>;
 type AkumaCallRequestCapabilities = Readonly<{
     world: WorldRoot;

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

@@ -67,6 +67,7 @@ const akumaCallPayloadSchema = z
     world: absolutePathSchema,
     archetype: archetypeSchema,
     body: z.string().optional(),
+    initiator: z.string().min(1).optional(),
     awaitAsleep: z.literal(true).optional(),
     cwd: absolutePathSchema.optional(),
     recipe: akumaCallRecipeSchema,
@@ -119,6 +120,7 @@ async function executeAkumaCall(request, facts, capabilities) {
                     origin: { kind: "request", parent: parent.id, requestId: facts.id },
                 },
                 ...(request.body === undefined ? {} : { initialBody: request.body }),
+                ...(request.initiator === undefined ? {} : { initiator: request.initiator }),
             });
         },
     });

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

@@ -1,12 +1,39 @@
 import { type AkumaStatus } from "./akuma.js";
+import { type DispatchAssociation } from "./dispatch-association.js";
+import type { AkumaAlias } from "../identity/selector.js";
 import type { WorldRoot } from "../world.js";
 import { type AkumaKillResult, type AkumaTellResult, type AkumaWaitResult } from "./fleet-observation.js";
+export type WaitIdentityFacts = Readonly<{
+    /** The alias currently addressing this Akuma in its world, when one is bound to it. */
+    alias?: AkumaAlias;
+    /** This Akuma's Dispatch association, read from the observing repository. */
+    contract: DispatchAssociation;
+}>;
+/** One observed Akuma as a live wait viewer sees it: its status plus its identity facts. */
+export type WaitObservedAkuma = Readonly<{
+    status: AkumaStatus;
+}> & WaitIdentityFacts;
+/** One selected Akuma's frozen identity, resolved before the first observation round. */
+export type WaitSelectedAkuma = Readonly<{
+    id: AkumaStatus["id"];
+}> & WaitIdentityFacts;
+/** A live wait viewer: the frozen selected set, then every observation round. */
+export type WaitObserver = Readonly<{
+    selected?: (selected: readonly WaitSelectedAkuma[]) => void;
+    observe?: (observed: readonly WaitObservedAkuma[]) => void;
+}>;
 export type WaitExecutionInput = Readonly<{
     path: WorldRoot;
     ids: readonly AkumaStatus["id"][];
     completion: "any" | "all";
     timeoutMs?: number;
     signal?: AbortSignal;
+    /** Resolves one Akuma's identity facts; consulted once per Akuma a viewer first sees. */
+    identity?: (id: AkumaStatus["id"]) => Promise<WaitIdentityFacts>;
+    /** Reports the frozen selected set before the first round, so a viewer can fix its layout. */
+    onSelected?: (selected: readonly WaitSelectedAkuma[]) => void;
+    /** Reports every observation round to a live viewer; absent keeps the cheap completion probe. */
+    observe?: (observed: readonly WaitObservedAkuma[]) => void;
 }>;
 export declare function executeWaitAkuma(input: WaitExecutionInput): Promise<AkumaWaitResult>;
 export type TellExecutionInput = Readonly<{
@@ -15,6 +42,7 @@ export type TellExecutionInput = Readonly<{
     body: string;
     tellId?: string;
     recordedAt?: string;
+    initiator?: string;
     signal?: AbortSignal;
 }>;
 export declare function executeTellAkuma(input: TellExecutionInput): Promise<AkumaTellResult>;

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

@@ -89,10 +89,44 @@ function delay(milliseconds, signal) {
 }
 export async function executeWaitAkuma(input) {
     const deadline = input.timeoutMs === undefined ? undefined : performance.now() + input.timeoutMs;
+    // Identity facts are read once per observed Akuma, not once per 100ms round.
+    const facts = new Map();
+    if (input.onSelected !== undefined) {
+        const selected = [];
+        for (const id of input.ids) {
+            input.signal?.throwIfAborted();
+            const known = input.identity === undefined ? undefined : await input.identity(id);
+            const resolved = known ?? { contract: NO_DISPATCH_ASSOCIATION };
+            facts.set(id, resolved);
+            selected.push({ id, ...resolved });
+        }
+        input.onSelected(selected);
+    }
+    const observeRound = async (statuses) => {
+        if (input.observe === undefined)
+            return;
+        const observed = [];
+        for (const status of statuses) {
+            input.signal?.throwIfAborted();
+            let known = facts.get(status.id);
+            if (known === undefined && input.identity !== undefined) {
+                known = await input.identity(status.id);
+                facts.set(status.id, known);
+            }
+            if (known === undefined) {
+                observed.push({ status, contract: NO_DISPATCH_ASSOCIATION });
+                continue;
+            }
+            observed.push({ status, ...known });
+        }
+        input.observe(observed);
+    };
     for (;;) {
-        if ((deadline !== undefined && performance.now() >= deadline) || (await probeWaitRound(input))) {
+        const expired = deadline !== undefined && performance.now() >= deadline;
+        if (expired || input.observe !== undefined || (await probeWaitRound(input))) {
             const round = await observeWaitRound(input.path, input.ids, input.signal);
             input.signal?.throwIfAborted();
+            await observeRound(round.statuses);
             // The probe is not a completion receipt. Judge the actual returned values.
             if (roundComplete(round, input.completion) || (deadline !== undefined && performance.now() >= deadline)) {
                 return fleetResultSchemas.wait.parse({
@@ -108,9 +142,7 @@ export async function executeWaitAkuma(input) {
 export async function executeTellAkuma(input) {
     input.signal?.throwIfAborted();
     const handle = source(input.path).selectHandle({ id: input.id });
-    const tell = input.tellId === undefined
-        ? await handle.tell(input.body)
-        : await handle.tell(input.body, input.tellId, input.recordedAt);
+    const tell = await handle.tell(input.body, input.tellId, input.recordedAt, undefined, input.initiator === undefined ? {} : { initiator: input.initiator });
     input.signal?.throwIfAborted();
     return fleetResultSchemas.tell.parse({
         akuma: input.id,

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

@@ -24,29 +24,35 @@ declare const waitRequestSchema: z.ZodPipe<z.ZodObject<{
 declare const tellRequestSchema: z.ZodPipe<z.ZodObject<{
     target: z.ZodPipe<z.ZodString, z.ZodTransform<import("./identity.js").AkuId, string>>;
     body: z.ZodString;
+    initiator: z.ZodOptional<z.ZodString>;
 }, z.core.$strict>, z.ZodTransform<{
     target: import("./identity.js").AkuId;
     body: string;
+    initiator?: string | undefined;
     action: "akuma.tell";
 }, {
     target: import("./identity.js").AkuId;
     body: string;
+    initiator?: string | undefined;
 }>>;
 declare const tellAnswerRequestSchema: z.ZodPipe<z.ZodObject<{
     target: z.ZodPipe<z.ZodString, z.ZodTransform<import("./identity.js").AkuId, string>>;
     body: z.ZodString;
     schemaJson: z.ZodString;
+    initiator: z.ZodOptional<z.ZodString>;
     interrupt: z.ZodOptional<z.ZodBoolean>;
 }, z.core.$strict>, z.ZodTransform<{
     target: import("./identity.js").AkuId;
     body: string;
     schemaJson: string;
+    initiator?: string | undefined;
     interrupt?: boolean | undefined;
     action: "akuma.tell-answer";
 }, {
     target: import("./identity.js").AkuId;
     body: string;
     schemaJson: string;
+    initiator?: string | undefined;
     interrupt?: boolean | undefined;
 }>>;
 declare const killRequestSchema: z.ZodPipe<z.ZodObject<{
@@ -102,12 +108,14 @@ export type FleetRequestPort = Readonly<{
         body: string;
         tellId: string;
         recordedAt: string;
+        initiator?: string;
         signal: AbortSignal;
     }>): Promise<AkumaTellResult>;
     tellAnswer?(input: Readonly<{
         target: AkumaStatus["id"];
         body: string;
         schemaJson: string;
+        initiator?: string;
         interrupt?: boolean;
         signal: AbortSignal;
     }>): Promise<unknown>;
@@ -131,6 +139,7 @@ export declare function requestForwardedFleetTellAnswer(input: Readonly<{
     target: AkumaStatus["id"];
     body: string;
     schema: Schema<unknown>;
+    initiator?: string;
     interrupt?: boolean;
     signal?: AbortSignal;
 }>): Promise<unknown>;
@@ -145,6 +154,7 @@ export declare function requestForwardedFleetTell(input: Readonly<{
     directory: string;
     target: AkumaStatus["id"];
     body: string;
+    initiator?: string;
     signal?: AbortSignal;
 }>): Promise<AkumaTellResult>;
 export declare function requestForwardedFleetKill(input: Readonly<{

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

@@ -26,7 +26,7 @@ const waitRequestSchema = z
     ...(timeoutMs === undefined ? {} : { timeoutMs }),
 }));
 const tellRequestSchema = z
-    .object({ target: akumaIdSchema, body: z.string() })
+    .object({ target: akumaIdSchema, body: z.string(), initiator: nonblankTextSchema.optional() })
     .strict()
     .transform((request) => ({ action: "akuma.tell", ...request }));
 const tellAnswerRequestSchema = z
@@ -34,6 +34,7 @@ const tellAnswerRequestSchema = z
     target: akumaIdSchema,
     body: z.string(),
     schemaJson: nonblankTextSchema,
+    initiator: nonblankTextSchema.optional(),
     interrupt: z.boolean().optional(),
 })
     .strict()
@@ -124,6 +125,7 @@ export function fleetRequestCommand(action, port) {
                         target: request.target,
                         body: request.body,
                         tellId: facts.id,
+                        ...(request.initiator === undefined ? {} : { initiator: request.initiator }),
                         recordedAt: facts.admittedAt,
                         signal: facts.signal,
                     }),
@@ -138,6 +140,7 @@ export function fleetRequestCommand(action, port) {
                         target: request.target,
                         body: request.body,
                         schemaJson: request.schemaJson,
+                        ...(request.initiator === undefined ? {} : { initiator: request.initiator }),
                         ...(request.interrupt === undefined ? {} : { interrupt: request.interrupt }),
                         signal: facts.signal,
                     }),
@@ -171,6 +174,7 @@ export async function requestForwardedFleetTellAnswer(input) {
             target: input.target,
             body: input.body,
             schemaJson: schemaJsonText(input.schema),
+            ...(input.initiator === undefined ? {} : { initiator: input.initiator }),
             ...(input.interrupt === undefined ? {} : { interrupt: input.interrupt }),
         },
         ...(input.signal === undefined ? {} : { signal: input.signal }),
@@ -214,7 +218,12 @@ export async function requestForwardedFleetTell(input) {
     const response = await requestBodyCommand({
         directory: input.directory,
         command: fleetRequestProtocol("akuma.tell"),
-        value: { action: "akuma.tell", target: input.target, body: input.body },
+        value: {
+            action: "akuma.tell",
+            target: input.target,
+            body: input.body,
+            ...(input.initiator === undefined ? {} : { initiator: input.initiator }),
+        },
         ...(input.signal === undefined ? {} : { signal: input.signal }),
     });
     return forwardedFleetCommandResult(response, "akuma.tell");

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

@@ -77,6 +77,7 @@ export type TurnStartFact = Readonly<{
     sequence: number;
     bodySequence: number;
     startedAt: string;
+    initiator?: string;
     schemaJson?: string;
 }>;
 export type TurnEndFact = Readonly<{
@@ -111,6 +112,7 @@ export type TellFact = Readonly<{
     sequence: number;
     id: string;
     body: string;
+    initiator?: string;
     schemaJson?: string;
     recordedAt: string;
     state: "pending" | "told";

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

@@ -77,6 +77,7 @@ export declare function beginTurn(paths: AkumaPaths, input: Readonly<{
     startedAt: string;
     call?: string;
     schemaJson?: string;
+    initiator?: string;
 }>): Promise<TurnStartFact>;
 export declare function bindTellsToTurn(paths: AkumaPaths, input: Readonly<{
     turnSequence: number;

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

@@ -74,7 +74,10 @@ export async function readLifeSnapshot(paths) {
     }
 }
 function sameTellInput(existing, tell) {
-    return (existing.body === tell.body && existing.recordedAt === tell.recordedAt && existing.schemaJson === tell.schemaJson);
+    return (existing.body === tell.body &&
+        existing.recordedAt === tell.recordedAt &&
+        existing.schemaJson === tell.schemaJson &&
+        existing.initiator === tell.initiator);
 }
 export async function recordTell(paths, tell, options = {}) {
     return await withHeartTransaction(paths, (heart) => {

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

@@ -31,6 +31,7 @@ export type TurnRow = Readonly<{
     answer: string | null;
     answer_json: string | null;
     schema_json: string | null;
+    initiator: string | null;
     diagnostic: string | null;
     completed_at: string | null;
 }>;
@@ -107,6 +108,7 @@ export declare function insertTurnStartFact(database: DatabaseSync, input: Reado
     startedAt: string;
     call?: string;
     schemaJson?: string;
+    initiator?: string;
 }>): TurnStartFact;
 export declare function insertTurnEndFact(database: DatabaseSync, input: Omit<TurnEndFact, "sequence">): TurnEndFact;
 export declare function finishBodyFact(database: DatabaseSync, input: Readonly<{

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

@@ -72,6 +72,7 @@ export function decodeTurnRow(row) {
         bodySequence: row.body_sequence,
         startedAt: row.started_at,
         ...(row.schema_json === null || row.schema_json === undefined ? {} : { schemaJson: row.schema_json }),
+        ...(row.initiator == null ? {} : { initiator: row.initiator }),
     };
     if (row.outcome === null)
         return start;
@@ -192,8 +193,8 @@ export function markBodyHung(database, input) {
 export function insertTurnStartFact(database, input) {
     const sequence = Number(database.prepare("INSERT INTO timeline(kind) VALUES ('turn-start')").run().lastInsertRowid);
     database
-        .prepare("INSERT INTO turns(sequence, body_sequence, started_at, schema_json) VALUES (?, ?, ?, ?)")
-        .run(sequence, input.bodySequence, input.startedAt, input.schemaJson ?? null);
+        .prepare("INSERT INTO turns(sequence, body_sequence, started_at, schema_json, initiator) VALUES (?, ?, ?, ?, ?)")
+        .run(sequence, input.bodySequence, input.startedAt, input.schemaJson ?? null, input.initiator ?? null);
     if (input.call !== undefined) {
         const callSequence = Number(database.prepare("INSERT INTO timeline(kind) VALUES ('call')").run().lastInsertRowid);
         database
@@ -205,6 +206,7 @@ export function insertTurnStartFact(database, input) {
         sequence,
         bodySequence: input.bodySequence,
         startedAt: input.startedAt,
+        ...(input.initiator === undefined ? {} : { initiator: input.initiator }),
         ...(input.schemaJson === undefined ? {} : { schemaJson: input.schemaJson }),
     };
 }
@@ -286,21 +288,21 @@ export function killFactForBody(database, bodySequence) {
 export function lastAnsweredTurnFact(database) {
     const row = database
         .prepare(`SELECT sequence, body_sequence, started_at, end_sequence, outcome, history_id,
-    session_json, answer, answer_json, schema_json, diagnostic, completed_at FROM turns WHERE outcome = 'answered' ORDER BY end_sequence DESC LIMIT 1`)
+    session_json, answer, answer_json, schema_json, initiator, diagnostic, completed_at FROM turns WHERE outcome = 'answered' ORDER BY end_sequence DESC LIMIT 1`)
         .get();
     return row === undefined ? null : decodeTurnRow(row);
 }
 export function answeredTurnFact(database, turnSequence) {
     const row = database
         .prepare(`SELECT sequence, body_sequence, started_at, end_sequence, outcome, history_id,
-    session_json, answer, answer_json, schema_json, diagnostic, completed_at FROM turns WHERE outcome = 'answered' AND sequence = ?`)
+    session_json, answer, answer_json, schema_json, initiator, diagnostic, completed_at FROM turns WHERE outcome = 'answered' AND sequence = ?`)
         .get(turnSequence);
     return row === undefined ? null : decodeTurnRow(row);
 }
 export function turnFact(database, turnSequence) {
     const row = database
         .prepare(`SELECT sequence, body_sequence, started_at, end_sequence, outcome, history_id,
-    session_json, answer, answer_json, schema_json, diagnostic, completed_at FROM turns WHERE sequence = ?`)
+    session_json, answer, answer_json, schema_json, initiator, diagnostic, completed_at FROM turns WHERE sequence = ?`)
         .get(turnSequence);
     return row === undefined ? null : decodeTurnRow(row);
 }

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

@@ -2,5 +2,5 @@ import type { DatabaseSync } from "node:sqlite";
 export declare function assertHeartSchemaVersion(database: DatabaseSync): void;
 export declare function assertLeashSchemaVersion(database: DatabaseSync): void;
 export declare function heartSchemaIsCurrent(database: DatabaseSync): boolean;
-export declare const HEART_SCHEMA = "\n  CREATE TABLE IF NOT EXISTS akuma_schema (\n    singleton INTEGER PRIMARY KEY CHECK (singleton = 1),\n    version INTEGER NOT NULL CHECK (version = 28)\n  ) STRICT;\n  INSERT OR IGNORE INTO akuma_schema(singleton, version) VALUES (1, 28);\n  CREATE TABLE IF NOT EXISTS soul (\n    singleton INTEGER PRIMARY KEY CHECK (singleton = 1),\n    soul_json TEXT NOT NULL CHECK (json_valid(soul_json))\n  ) STRICT;\n  CREATE TABLE IF NOT EXISTS bodies (\n    sequence INTEGER PRIMARY KEY AUTOINCREMENT,\n    leash_taken_at TEXT NOT NULL,\n    hung_diagnostic TEXT,\n    hung_at TEXT,\n    end TEXT CHECK (end IN ('exited', 'broke-off', 'put-down')),\n    ended_at TEXT,\n    CHECK ((hung_diagnostic IS NULL AND hung_at IS NULL)\n      OR (hung_diagnostic IS NOT NULL AND hung_at IS NOT NULL))\n  ) STRICT;\n  CREATE TABLE IF NOT EXISTS sessions (\n    sequence INTEGER PRIMARY KEY AUTOINCREMENT,\n    provider TEXT NOT NULL,\n    coordinate_json TEXT NOT NULL CHECK (json_valid(coordinate_json)),\n    cwd TEXT NOT NULL,\n    options_json TEXT NOT NULL CHECK (json_valid(options_json)),\n    admitted_at TEXT NOT NULL\n  ) STRICT;\n  CREATE TABLE IF NOT EXISTS turns (\n    sequence INTEGER PRIMARY KEY REFERENCES timeline(sequence) ON DELETE CASCADE,\n    body_sequence INTEGER NOT NULL REFERENCES bodies(sequence),\n    started_at TEXT NOT NULL,\n    end_sequence INTEGER UNIQUE REFERENCES timeline(sequence) ON DELETE SET NULL,\n    outcome TEXT CHECK (outcome IN ('answered', 'failed', 'invalid-output')),\n    history_id TEXT UNIQUE,\n    session_json TEXT CHECK (session_json IS NULL OR json_valid(session_json)),\n    answer TEXT,\n    answer_json TEXT CHECK (answer_json IS NULL OR json_valid(answer_json)),\n    schema_json TEXT CHECK (schema_json IS NULL OR json_valid(schema_json)),\n    diagnostic TEXT,\n    completed_at TEXT,\n    CHECK (\n      (outcome = 'answered' AND session_json IS NOT NULL AND answer IS NOT NULL AND diagnostic IS NULL\n        AND ((schema_json IS NULL AND answer_json IS NULL) OR (schema_json IS NOT NULL AND answer_json IS NOT NULL)))\n      OR (outcome = 'failed' AND history_id IS NULL AND session_json IS NULL AND answer IS NULL\n        AND answer_json IS NULL AND diagnostic IS NOT NULL)\n      OR (outcome = 'invalid-output' AND answer IS NOT NULL AND answer_json IS NULL\n        AND diagnostic IS NOT NULL AND schema_json IS NOT NULL)\n      OR (outcome IS NULL AND end_sequence IS NULL AND history_id IS NULL AND session_json IS NULL\n        AND answer IS NULL AND answer_json IS NULL AND diagnostic IS NULL AND completed_at IS NULL)\n    )\n  ) STRICT;\n  CREATE TABLE IF NOT EXISTS timeline (\n    sequence INTEGER PRIMARY KEY AUTOINCREMENT,\n    kind TEXT NOT NULL CHECK (kind IN ('turn-start', 'call', 'activity', 'tell', 'turn-end'))\n  ) STRICT;\n  CREATE TABLE IF NOT EXISTS activity_retention (\n    singleton INTEGER PRIMARY KEY CHECK (singleton = 1),\n    checked_sequence INTEGER NOT NULL\n  ) STRICT;\n  INSERT OR IGNORE INTO activity_retention(singleton, checked_sequence) VALUES (1, 0);\n  CREATE TABLE IF NOT EXISTS calls (\n    sequence INTEGER PRIMARY KEY REFERENCES timeline(sequence) ON DELETE CASCADE,\n    turn_sequence INTEGER NOT NULL REFERENCES turns(sequence) ON DELETE CASCADE,\n    body TEXT NOT NULL,\n    at TEXT NOT NULL\n  ) STRICT;\n  CREATE TABLE IF NOT EXISTS activity (\n    sequence INTEGER PRIMARY KEY REFERENCES timeline(sequence) ON DELETE CASCADE,\n    turn_sequence INTEGER NOT NULL REFERENCES turns(sequence) ON DELETE CASCADE,\n    event_json TEXT NOT NULL CHECK (json_valid(event_json)),\n    at TEXT NOT NULL\n  ) STRICT;\n  CREATE TABLE IF NOT EXISTS tells (\n    id TEXT PRIMARY KEY,\n    sequence INTEGER NOT NULL UNIQUE REFERENCES timeline(sequence) ON DELETE CASCADE,\n    body TEXT NOT NULL,\n    schema_json TEXT CHECK (schema_json IS NULL OR json_valid(schema_json)),\n    recorded_at TEXT NOT NULL\n  ) STRICT;\n  CREATE TABLE IF NOT EXISTS tell_bindings (\n    sequence INTEGER PRIMARY KEY AUTOINCREMENT,\n    tell_id TEXT NOT NULL REFERENCES tells(id) ON DELETE CASCADE,\n    turn_sequence INTEGER NOT NULL REFERENCES turns(sequence) ON DELETE CASCADE,\n    bound_at TEXT NOT NULL,\n    UNIQUE (tell_id, turn_sequence)\n  ) STRICT;\n  CREATE TABLE IF NOT EXISTS tell_deliveries (\n    sequence INTEGER PRIMARY KEY AUTOINCREMENT,\n    tell_id TEXT NOT NULL REFERENCES tells(id) ON DELETE CASCADE,\n    route TEXT NOT NULL CHECK (route IN ('launch', 'live')),\n    turn_sequence INTEGER NOT NULL REFERENCES turns(sequence) ON DELETE CASCADE,\n    fence TEXT NOT NULL,\n    receipt TEXT CHECK (receipt IN ('unavailable', 'required')),\n    delivered_at TEXT NOT NULL,\n    CHECK ((route = 'launch' AND receipt IS NULL) OR (route = 'live' AND receipt IS NOT NULL)),\n    UNIQUE (tell_id, turn_sequence, fence)\n  ) STRICT;\n  CREATE TABLE IF NOT EXISTS tell_receipts (\n    sequence INTEGER PRIMARY KEY AUTOINCREMENT,\n    evidence TEXT NOT NULL CHECK (evidence IN ('exact', 'fence')),\n    tell_id TEXT REFERENCES tells(id) ON DELETE CASCADE,\n    turn_sequence INTEGER REFERENCES turns(sequence) ON DELETE CASCADE,\n    fence TEXT,\n    kind TEXT NOT NULL,\n    received_at TEXT NOT NULL,\n    CHECK (\n      (evidence = 'exact' AND tell_id IS NOT NULL AND turn_sequence IS NULL AND fence IS NULL)\n      OR (evidence = 'fence' AND tell_id IS NULL AND turn_sequence IS NOT NULL AND fence IS NOT NULL)\n    )\n  ) STRICT;\n  CREATE UNIQUE INDEX IF NOT EXISTS tell_receipts_exact\n    ON tell_receipts(tell_id, kind);\n  CREATE UNIQUE INDEX IF NOT EXISTS tell_receipts_fence\n    ON tell_receipts(turn_sequence, fence, kind);\n  CREATE TABLE IF NOT EXISTS tell_dispositions (\n    body_sequence INTEGER PRIMARY KEY REFERENCES bodies(sequence),\n    decided_at TEXT NOT NULL,\n    resolved_at TEXT\n  ) STRICT;\n  CREATE TABLE IF NOT EXISTS tell_disposition_members (\n    body_sequence INTEGER NOT NULL REFERENCES tell_dispositions(body_sequence) ON DELETE CASCADE,\n    tell_id TEXT NOT NULL REFERENCES tells(id),\n    PRIMARY KEY (body_sequence, tell_id)\n  ) STRICT;\n  CREATE INDEX IF NOT EXISTS calls_by_turn ON calls(turn_sequence);\n  CREATE INDEX IF NOT EXISTS activity_by_turn ON activity(turn_sequence);\n  CREATE INDEX IF NOT EXISTS tell_bindings_by_turn ON tell_bindings(turn_sequence);\n  CREATE INDEX IF NOT EXISTS tell_deliveries_by_turn ON tell_deliveries(turn_sequence);\n  CREATE INDEX IF NOT EXISTS tell_disposition_members_by_tell ON tell_disposition_members(tell_id);\n  CREATE TABLE IF NOT EXISTS requests (\n    sequence INTEGER PRIMARY KEY AUTOINCREMENT,\n    id TEXT NOT NULL UNIQUE,\n    requester TEXT NOT NULL,\n    action TEXT NOT NULL,\n    payload_json TEXT NOT NULL CHECK (json_valid(payload_json)),\n    admitted_at TEXT NOT NULL,\n    state TEXT NOT NULL CHECK (state IN ('admitted', 'reserved', 'begun', 'served', 'refused', 'voided', 'unproven')),\n    child TEXT,\n    service_json TEXT CHECK (service_json IS NULL OR json_valid(service_json)),\n    diagnostic TEXT,\n    evidence TEXT,\n    CHECK (\n      (state = 'admitted' AND child IS NULL AND service_json IS NULL AND diagnostic IS NULL AND evidence IS NULL)\n      OR (state = 'reserved' AND child IS NOT NULL AND service_json IS NULL\n        AND diagnostic IS NULL AND evidence IS NULL)\n      OR (state = 'begun' AND child IS NULL AND service_json IS NULL AND diagnostic IS NULL AND evidence IS NULL)\n      OR (state = 'served'\n        AND ((child IS NOT NULL AND service_json IS NULL)\n          OR (child IS NULL AND service_json IS NOT NULL))\n        AND diagnostic IS NULL AND evidence IS NULL)\n      OR (state = 'refused' AND child IS NULL AND service_json IS NULL AND diagnostic IS NOT NULL AND evidence IS NULL)\n      OR (state = 'voided' AND child IS NULL AND service_json IS NULL AND diagnostic IS NULL AND evidence IS NOT NULL)\n      OR (state = 'unproven' AND child IS NULL AND service_json IS NULL AND diagnostic IS NULL AND evidence IS NOT NULL)\n    )\n  ) STRICT;\n  CREATE TABLE IF NOT EXISTS control (\n    kind TEXT PRIMARY KEY CHECK (kind IN ('stop', 'pause')),\n    value_json TEXT NOT NULL CHECK (json_valid(value_json)),\n    at TEXT NOT NULL\n  ) STRICT;\n  CREATE TABLE IF NOT EXISTS kills (\n    sequence INTEGER PRIMARY KEY AUTOINCREMENT,\n    body_sequence INTEGER NOT NULL UNIQUE REFERENCES bodies(sequence),\n    evidence TEXT NOT NULL CHECK (evidence = 'killed'),\n    at TEXT NOT NULL\n  ) STRICT;\n";
+export declare const HEART_SCHEMA = "\n  CREATE TABLE IF NOT EXISTS akuma_schema (\n    singleton INTEGER PRIMARY KEY CHECK (singleton = 1),\n    version INTEGER NOT NULL CHECK (version = 29)\n  ) STRICT;\n  INSERT OR IGNORE INTO akuma_schema(singleton, version) VALUES (1, 29);\n  CREATE TABLE IF NOT EXISTS soul (\n    singleton INTEGER PRIMARY KEY CHECK (singleton = 1),\n    soul_json TEXT NOT NULL CHECK (json_valid(soul_json))\n  ) STRICT;\n  CREATE TABLE IF NOT EXISTS bodies (\n    sequence INTEGER PRIMARY KEY AUTOINCREMENT,\n    leash_taken_at TEXT NOT NULL,\n    hung_diagnostic TEXT,\n    hung_at TEXT,\n    end TEXT CHECK (end IN ('exited', 'broke-off', 'put-down')),\n    ended_at TEXT,\n    CHECK ((hung_diagnostic IS NULL AND hung_at IS NULL)\n      OR (hung_diagnostic IS NOT NULL AND hung_at IS NOT NULL))\n  ) STRICT;\n  CREATE TABLE IF NOT EXISTS sessions (\n    sequence INTEGER PRIMARY KEY AUTOINCREMENT,\n    provider TEXT NOT NULL,\n    coordinate_json TEXT NOT NULL CHECK (json_valid(coordinate_json)),\n    cwd TEXT NOT NULL,\n    options_json TEXT NOT NULL CHECK (json_valid(options_json)),\n    admitted_at TEXT NOT NULL\n  ) STRICT;\n  CREATE TABLE IF NOT EXISTS turns (\n    sequence INTEGER PRIMARY KEY REFERENCES timeline(sequence) ON DELETE CASCADE,\n    body_sequence INTEGER NOT NULL REFERENCES bodies(sequence),\n    started_at TEXT NOT NULL,\n    initiator TEXT,\n    end_sequence INTEGER UNIQUE REFERENCES timeline(sequence) ON DELETE SET NULL,\n    outcome TEXT CHECK (outcome IN ('answered', 'failed', 'invalid-output')),\n    history_id TEXT UNIQUE,\n    session_json TEXT CHECK (session_json IS NULL OR json_valid(session_json)),\n    answer TEXT,\n    answer_json TEXT CHECK (answer_json IS NULL OR json_valid(answer_json)),\n    schema_json TEXT CHECK (schema_json IS NULL OR json_valid(schema_json)),\n    diagnostic TEXT,\n    completed_at TEXT,\n    CHECK (\n      (outcome = 'answered' AND session_json IS NOT NULL AND answer IS NOT NULL AND diagnostic IS NULL\n        AND ((schema_json IS NULL AND answer_json IS NULL) OR (schema_json IS NOT NULL AND answer_json IS NOT NULL)))\n      OR (outcome = 'failed' AND history_id IS NULL AND session_json IS NULL AND answer IS NULL\n        AND answer_json IS NULL AND diagnostic IS NOT NULL)\n      OR (outcome = 'invalid-output' AND answer IS NOT NULL AND answer_json IS NULL\n        AND diagnostic IS NOT NULL AND schema_json IS NOT NULL)\n      OR (outcome IS NULL AND end_sequence IS NULL AND history_id IS NULL AND session_json IS NULL\n        AND answer IS NULL AND answer_json IS NULL AND diagnostic IS NULL AND completed_at IS NULL)\n    )\n  ) STRICT;\n  CREATE TABLE IF NOT EXISTS timeline (\n    sequence INTEGER PRIMARY KEY AUTOINCREMENT,\n    kind TEXT NOT NULL CHECK (kind IN ('turn-start', 'call', 'activity', 'tell', 'turn-end'))\n  ) STRICT;\n  CREATE TABLE IF NOT EXISTS activity_retention (\n    singleton INTEGER PRIMARY KEY CHECK (singleton = 1),\n    checked_sequence INTEGER NOT NULL\n  ) STRICT;\n  INSERT OR IGNORE INTO activity_retention(singleton, checked_sequence) VALUES (1, 0);\n  CREATE TABLE IF NOT EXISTS calls (\n    sequence INTEGER PRIMARY KEY REFERENCES timeline(sequence) ON DELETE CASCADE,\n    turn_sequence INTEGER NOT NULL REFERENCES turns(sequence) ON DELETE CASCADE,\n    body TEXT NOT NULL,\n    at TEXT NOT NULL\n  ) STRICT;\n  CREATE TABLE IF NOT EXISTS activity (\n    sequence INTEGER PRIMARY KEY REFERENCES timeline(sequence) ON DELETE CASCADE,\n    turn_sequence INTEGER NOT NULL REFERENCES turns(sequence) ON DELETE CASCADE,\n    event_json TEXT NOT NULL CHECK (json_valid(event_json)),\n    at TEXT NOT NULL\n  ) STRICT;\n  CREATE TABLE IF NOT EXISTS tells (\n    id TEXT PRIMARY KEY,\n    sequence INTEGER NOT NULL UNIQUE REFERENCES timeline(sequence) ON DELETE CASCADE,\n    body TEXT NOT NULL,\n    initiator TEXT,\n    schema_json TEXT CHECK (schema_json IS NULL OR json_valid(schema_json)),\n    recorded_at TEXT NOT NULL\n  ) STRICT;\n  CREATE TABLE IF NOT EXISTS tell_bindings (\n    sequence INTEGER PRIMARY KEY AUTOINCREMENT,\n    tell_id TEXT NOT NULL REFERENCES tells(id) ON DELETE CASCADE,\n    turn_sequence INTEGER NOT NULL REFERENCES turns(sequence) ON DELETE CASCADE,\n    bound_at TEXT NOT NULL,\n    UNIQUE (tell_id, turn_sequence)\n  ) STRICT;\n  CREATE TABLE IF NOT EXISTS tell_deliveries (\n    sequence INTEGER PRIMARY KEY AUTOINCREMENT,\n    tell_id TEXT NOT NULL REFERENCES tells(id) ON DELETE CASCADE,\n    route TEXT NOT NULL CHECK (route IN ('launch', 'live')),\n    turn_sequence INTEGER NOT NULL REFERENCES turns(sequence) ON DELETE CASCADE,\n    fence TEXT NOT NULL,\n    receipt TEXT CHECK (receipt IN ('unavailable', 'required')),\n    delivered_at TEXT NOT NULL,\n    CHECK ((route = 'launch' AND receipt IS NULL) OR (route = 'live' AND receipt IS NOT NULL)),\n    UNIQUE (tell_id, turn_sequence, fence)\n  ) STRICT;\n  CREATE TABLE IF NOT EXISTS tell_receipts (\n    sequence INTEGER PRIMARY KEY AUTOINCREMENT,\n    evidence TEXT NOT NULL CHECK (evidence IN ('exact', 'fence')),\n    tell_id TEXT REFERENCES tells(id) ON DELETE CASCADE,\n    turn_sequence INTEGER REFERENCES turns(sequence) ON DELETE CASCADE,\n    fence TEXT,\n    kind TEXT NOT NULL,\n    received_at TEXT NOT NULL,\n    CHECK (\n      (evidence = 'exact' AND tell_id IS NOT NULL AND turn_sequence IS NULL AND fence IS NULL)\n      OR (evidence = 'fence' AND tell_id IS NULL AND turn_sequence IS NOT NULL AND fence IS NOT NULL)\n    )\n  ) STRICT;\n  CREATE UNIQUE INDEX IF NOT EXISTS tell_receipts_exact\n    ON tell_receipts(tell_id, kind);\n  CREATE UNIQUE INDEX IF NOT EXISTS tell_receipts_fence\n    ON tell_receipts(turn_sequence, fence, kind);\n  CREATE TABLE IF NOT EXISTS tell_dispositions (\n    body_sequence INTEGER PRIMARY KEY REFERENCES bodies(sequence),\n    decided_at TEXT NOT NULL,\n    resolved_at TEXT\n  ) STRICT;\n  CREATE TABLE IF NOT EXISTS tell_disposition_members (\n    body_sequence INTEGER NOT NULL REFERENCES tell_dispositions(body_sequence) ON DELETE CASCADE,\n    tell_id TEXT NOT NULL REFERENCES tells(id),\n    PRIMARY KEY (body_sequence, tell_id)\n  ) STRICT;\n  CREATE INDEX IF NOT EXISTS calls_by_turn ON calls(turn_sequence);\n  CREATE INDEX IF NOT EXISTS activity_by_turn ON activity(turn_sequence);\n  CREATE INDEX IF NOT EXISTS tell_bindings_by_turn ON tell_bindings(turn_sequence);\n  CREATE INDEX IF NOT EXISTS tell_deliveries_by_turn ON tell_deliveries(turn_sequence);\n  CREATE INDEX IF NOT EXISTS tell_disposition_members_by_tell ON tell_disposition_members(tell_id);\n  CREATE TABLE IF NOT EXISTS requests (\n    sequence INTEGER PRIMARY KEY AUTOINCREMENT,\n    id TEXT NOT NULL UNIQUE,\n    requester TEXT NOT NULL,\n    action TEXT NOT NULL,\n    payload_json TEXT NOT NULL CHECK (json_valid(payload_json)),\n    admitted_at TEXT NOT NULL,\n    state TEXT NOT NULL CHECK (state IN ('admitted', 'reserved', 'begun', 'served', 'refused', 'voided', 'unproven')),\n    child TEXT,\n    service_json TEXT CHECK (service_json IS NULL OR json_valid(service_json)),\n    diagnostic TEXT,\n    evidence TEXT,\n    CHECK (\n      (state = 'admitted' AND child IS NULL AND service_json IS NULL AND diagnostic IS NULL AND evidence IS NULL)\n      OR (state = 'reserved' AND child IS NOT NULL AND service_json IS NULL\n        AND diagnostic IS NULL AND evidence IS NULL)\n      OR (state = 'begun' AND child IS NULL AND service_json IS NULL AND diagnostic IS NULL AND evidence IS NULL)\n      OR (state = 'served'\n        AND ((child IS NOT NULL AND service_json IS NULL)\n          OR (child IS NULL AND service_json IS NOT NULL))\n        AND diagnostic IS NULL AND evidence IS NULL)\n      OR (state = 'refused' AND child IS NULL AND service_json IS NULL AND diagnostic IS NOT NULL AND evidence IS NULL)\n      OR (state = 'voided' AND child IS NULL AND service_json IS NULL AND diagnostic IS NULL AND evidence IS NOT NULL)\n      OR (state = 'unproven' AND child IS NULL AND service_json IS NULL AND diagnostic IS NULL AND evidence IS NOT NULL)\n    )\n  ) STRICT;\n  CREATE TABLE IF NOT EXISTS control (\n    kind TEXT PRIMARY KEY CHECK (kind IN ('stop', 'pause')),\n    value_json TEXT NOT NULL CHECK (json_valid(value_json)),\n    at TEXT NOT NULL\n  ) STRICT;\n  CREATE TABLE IF NOT EXISTS kills (\n    sequence INTEGER PRIMARY KEY AUTOINCREMENT,\n    body_sequence INTEGER NOT NULL UNIQUE REFERENCES bodies(sequence),\n    evidence TEXT NOT NULL CHECK (evidence = 'killed'),\n    at TEXT NOT NULL\n  ) STRICT;\n";
 export declare const LEASH_SCHEMA = "\n  PRAGMA journal_mode=DELETE;\n  CREATE TABLE IF NOT EXISTS leash_schema (\n    singleton INTEGER PRIMARY KEY CHECK (singleton = 1),\n    version INTEGER NOT NULL CHECK (version = 4)\n  ) STRICT;\n  INSERT OR IGNORE INTO leash_schema(singleton, version) VALUES (1, 4);\n  CREATE TABLE IF NOT EXISTS seal (\n    singleton INTEGER PRIMARY KEY CHECK (singleton = 1),\n    evidence TEXT NOT NULL,\n    at TEXT NOT NULL\n  ) STRICT;\n";

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

@@ -1,4 +1,4 @@
-const HEART_SCHEMA_VERSION = 28;
+const HEART_SCHEMA_VERSION = 29;
 const LEASH_SCHEMA_VERSION = 4;
 function assertSchemaVersion(database, table, expected) {
     const row = database.prepare(`SELECT version FROM ${table} WHERE singleton = 1`).get();
@@ -52,6 +52,7 @@ export const HEART_SCHEMA = `
     sequence INTEGER PRIMARY KEY REFERENCES timeline(sequence) ON DELETE CASCADE,
     body_sequence INTEGER NOT NULL REFERENCES bodies(sequence),
     started_at TEXT NOT NULL,
+    initiator TEXT,
     end_sequence INTEGER UNIQUE REFERENCES timeline(sequence) ON DELETE SET NULL,
     outcome TEXT CHECK (outcome IN ('answered', 'failed', 'invalid-output')),
     history_id TEXT UNIQUE,
@@ -97,6 +98,7 @@ export const HEART_SCHEMA = `
     id TEXT PRIMARY KEY,
     sequence INTEGER NOT NULL UNIQUE REFERENCES timeline(sequence) ON DELETE CASCADE,
     body TEXT NOT NULL,
+    initiator TEXT,
     schema_json TEXT CHECK (schema_json IS NULL OR json_valid(schema_json)),
     recorded_at TEXT NOT NULL
   ) STRICT;

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

@@ -52,6 +52,7 @@ function decodeTellRows(database, rows) {
         sequence: row.sequence,
         id: row.id,
         body: row.body,
+        ...(row.initiator === null ? {} : { initiator: row.initiator }),
         ...(row.schema_json === null ? {} : { schemaJson: row.schema_json }),
         state: row.state,
         recordedAt: row.recorded_at,
@@ -63,7 +64,7 @@ export function tellFactsAtSequences(database, sequences) {
     if (sequences.length === 0)
         return [];
     const rows = database
-        .prepare(`SELECT sequence, id, body, schema_json, recorded_at, ${tellStateSql} AS state
+        .prepare(`SELECT sequence, id, body, initiator, schema_json, recorded_at, ${tellStateSql} AS state
     FROM tells WHERE sequence IN (SELECT value FROM json_each(?)) ORDER BY sequence`)
         .all(JSON.stringify(sequences));
     return decodeTellRows(database, rows);
@@ -74,13 +75,13 @@ export function hasPendingTell(database) {
 export function insertTellFact(database, tell) {
     const sequence = Number(database.prepare("INSERT INTO timeline(kind) VALUES ('tell')").run().lastInsertRowid);
     database
-        .prepare("INSERT INTO tells(id, sequence, body, schema_json, recorded_at) VALUES (?, ?, ?, ?, ?)")
-        .run(tell.id, sequence, tell.body, tell.schemaJson ?? null, tell.recordedAt);
+        .prepare("INSERT INTO tells(id, sequence, body, initiator, schema_json, recorded_at) VALUES (?, ?, ?, ?, ?, ?)")
+        .run(tell.id, sequence, tell.body, tell.initiator ?? null, tell.schemaJson ?? null, tell.recordedAt);
     return sequence;
 }
 export function tellFact(database, id) {
     const row = database
-        .prepare(`SELECT sequence, id, body, schema_json, recorded_at, ${tellStateSql} AS state
+        .prepare(`SELECT sequence, id, body, initiator, schema_json, recorded_at, ${tellStateSql} AS state
     FROM tells WHERE id = ?`)
         .get(id);
     return row === undefined ? null : decodeTellRows(database, [row])[0];
@@ -119,7 +120,7 @@ export function tellIdsForFence(database, turnSequence, fence) {
 }
 export function pendingTellFacts(database) {
     const rows = database
-        .prepare(`SELECT sequence, id, body, schema_json, recorded_at, ${tellStateSql} AS state FROM tells
+        .prepare(`SELECT sequence, id, body, initiator, schema_json, recorded_at, ${tellStateSql} AS state FROM tells
     WHERE ${tellStateSql} = 'pending' ORDER BY sequence`)
         .all();
     return decodeTellRows(database, rows);