@astrosheep/keiyaku 4.6.6 → 4.6.8

package/build/src/akuma/body.js

@@ -1,3 +1,4 @@
+import { projectAkumaBirth } from "./caller.js";
 import { z } from "zod";
 import { decodeSoulSeed } from "./heart/soul.js";
 import { sessionAdmissionSchema } from "./heart/rows.js";
@@ -10,7 +11,7 @@ import { HeldAkumaLeash, breakBody, decidePendingTellDisposition, drainPendingTe
 import { akumaPathsSchema, pathsForAkuId, worldRootForAkumaPaths } from "./identity.js";
 import { admitCallInitialTell, } from "./call-initial-tell.js";
 import { akumaExecutionEnvironment } from "./providers/execution-environment.js";
-import { pluginRuntime } from "../plugin/runtime.js";
+import { emitPluginSignal } from "../plugin/akuma-signals.js";
 import { World } from "../world.js";
 import { resolveProviderExecution } from "./providers/index.js";
 import { clearBodyRequestTransport, settleBodyRequests } from "./request-serve.js";
@@ -35,6 +36,7 @@ export const bodyLaunchSchema = z
     birthSession: sessionAdmissionSchema.optional(),
     initialBody: z.string().optional(),
     initiator: z.string().optional(),
+    birthInitiator: z.string().optional(),
     initialSchemaJson: z.string().optional(),
     refuseIfHeld: z.boolean().optional(),
     completion: z.object({ contractId: z.string().optional() }).strict().optional(),
@@ -74,17 +76,18 @@ async function takeLeash(paths, refuseIfHeld = false) {
 async function bornSoul(launch, leash, now) {
     const before = await readHeart(launch.paths);
     if (before.soul !== null)
-        return before.soul;
+        return { soul: before.soul, created: false };
     if (launch.seed === undefined)
         throw new Error("Akuma wake has no born soul");
     const candidate = { ...launch.seed, createdAt: now };
-    if ((await leash.birth(launch.paths, candidate, launch.birthSession)) === "sealed")
+    const result = await leash.birth(launch.paths, candidate, launch.birthSession);
+    if (result === "sealed")
         return null;
     const born = (await readHeart(launch.paths)).soul;
     if (born === null || born.id !== candidate.id) {
         throw new Error("Akuma birth identity does not match its directory");
     }
-    return born;
+    return { soul: born, created: result === "born" };
 }
 async function launchCwd(launch) {
     if (launch.seed !== undefined)
@@ -156,7 +159,7 @@ function boundedDiagnostic(error) {
     const text = diagnostic(error);
     return text.length <= 500 ? text : `${text.slice(0, 500)}...`;
 }
-async function recordPluginDiagnostic(paths, occurrence, error) {
+export async function recordPluginDiagnostic(paths, occurrence, error) {
     try {
         await appendFile(paths.log, `plugin ${occurrence} failed: ${boundedDiagnostic(error)}\n`);
     }
@@ -233,14 +236,18 @@ export async function bodyProcessInput(launch, bodyModuleUrl = import.meta.url)
     return {
         argv: source ? [executable, "--import", import.meta.resolve("tsx"), entry, encoded] : [executable, entry, encoded],
         cwd: await launchCwd(launch),
-        env: akumaExecutionEnvironment(process.env, { KEIYAKU_ACTOR_ID: actorId }),
+        env: akumaExecutionEnvironment(process.env, {
+            KEIYAKU_ACTOR_ID: actorId,
+            KEIYAKU_ACTOR_WORLD: worldRootForAkumaPaths(launch.paths),
+        }),
         log: launch.paths.log,
     };
 }
 async function prepareBodyExecution(launch, leash, runtime, adapter) {
-    const soul = await bornSoul(launch, leash, runtime.now());
-    if (soul === null)
+    const birth = await bornSoul(launch, leash, runtime.now());
+    if (birth === null)
         return null;
+    const { soul } = birth;
     if (launch.seed === undefined && launch.initialBody === undefined) {
         const [heart, requests] = await Promise.all([readHeart(launch.paths), readNonterminalRequests(launch.paths)]);
         if (heart.pending.length === 0 && requests.length === 0)
@@ -249,7 +256,7 @@ async function prepareBodyExecution(launch, leash, runtime, adapter) {
     const selected = adapter ?? (await resolveProviderExecution(soul.provider)).adapter;
     if (!(await prepareBodyStart(launch.paths, leash)))
         return null;
-    return { soul, adapter: selected };
+    return { ...birth, adapter: selected };
 }
 async function runPreparedBody(input) {
     let pendingTellDisposition;
@@ -306,8 +313,7 @@ async function recoverBodyRequests(input) {
     }
     return false;
 }
-function turnOutcomeEmitter(launch, soul) {
-    let plugins;
+function turnOutcomeEmitter(launch, soul, world) {
     const reportDiagnostic = (message) => {
         void recordPluginDiagnostic(launch.paths, "turn outcome", message);
     };
@@ -318,11 +324,7 @@ function turnOutcomeEmitter(launch, soul) {
                 if (turn === null)
                     throw new Error(`Committed Turn ${turnSequence} is missing from Heart`);
                 const participants = await readTurnParticipants(launch.paths, turnSequence);
-                plugins ??= pluginRuntime({
-                    world: await World.at(worldRootForAkumaPaths(launch.paths)),
-                    reportDiagnostic,
-                });
-                await (await plugins).emit({
+                await emitPluginSignal({ world, reportDiagnostic }, {
                     kind: "akuma.turn-outcome",
                     akumaId: soul.id,
                     bodySequence: turn.bodySequence,
@@ -333,7 +335,7 @@ function turnOutcomeEmitter(launch, soul) {
                         ? { kind: "answered", text: outcome.answer }
                         : { kind: "failed", reason: outcome.diagnostic },
                     ...(launch.completion?.contractId === undefined ? {} : { contractId: launch.completion.contractId }),
-                }, reportDiagnostic);
+                });
             }
             catch (error) {
                 await recordPluginDiagnostic(launch.paths, "turn outcome", error);
@@ -341,22 +343,16 @@ function turnOutcomeEmitter(launch, soul) {
         },
     };
 }
-function bodyEndEmitter(launch, soul) {
-    let plugins;
+function bodyEndEmitter(launch, soul, world) {
     const reportDiagnostic = (message) => {
         void recordPluginDiagnostic(launch.paths, "body end", message);
     };
-    return (bodySequence, end, diagnostic) => (async () => {
+    return async (bodySequence, end, diagnostic) => {
         try {
             const latestTurn = await readLatestTurnForBody(launch.paths, bodySequence);
             const initiator = latestTurn?.initiator;
             const participants = latestTurn === null ? [] : await readTurnParticipants(launch.paths, latestTurn.sequence);
-            plugins ??= pluginRuntime({
-                world: await World.at(worldRootForAkumaPaths(launch.paths)),
-                reportDiagnostic,
-            });
-            const runtime = await plugins;
-            await runtime.emit({
+            await emitPluginSignal({ world, reportDiagnostic }, {
                 kind: "akuma.body-ended",
                 akumaId: soul.id,
                 bodySequence,
@@ -365,12 +361,12 @@ function bodyEndEmitter(launch, soul) {
                 ...(participants.length === 0 ? {} : { participants }),
                 ...(diagnostic === undefined ? {} : { diagnostic }),
                 ...(launch.completion?.contractId === undefined ? {} : { contractId: launch.completion.contractId }),
-            }, reportDiagnostic);
+            });
         }
         catch (error) {
             await recordPluginDiagnostic(launch.paths, "body end", error);
         }
-    })();
+    };
 }
 async function admitInitialCallTell(runtime, input) {
     const paths = pathsForAkuId(runtime.world, input.id);
@@ -575,10 +571,25 @@ export async function driveAkumaBody(launch, adapter, runtimeInput = {}) {
         const prepared = await prepareBodyExecution(launch, leash, runtime, adapter);
         if (prepared === null)
             return;
-        emitBodyEnd = bodyEndEmitter(launch, prepared.soul);
-        emitTurnOutcome = turnOutcomeEmitter(launch, prepared.soul);
+        emitBodyEnd = bodyEndEmitter(launch, prepared.soul, world);
+        emitTurnOutcome = turnOutcomeEmitter(launch, prepared.soul, world);
         const body = await leash.recordBody(launch.paths, { leashTakenAt: runtime.now() });
         bodySequence = body.sequence;
+        if (prepared.created) {
+            await emitPluginSignal({
+                world,
+                reportDiagnostic: (message) => {
+                    void recordPluginDiagnostic(launch.paths, "birth", message);
+                },
+            }, {
+                kind: "akuma.born",
+                akumaId: prepared.soul.id,
+                bodySequence: body.sequence,
+                ...projectAkumaBirth(prepared.soul),
+                ...(launch.birthInitiator === undefined ? {} : { initiator: launch.birthInitiator }),
+                ...(launch.completion?.contractId === undefined ? {} : { contractId: launch.completion.contractId }),
+            });
+        }
         const supervisor = await BodySupervisor.open(launch.paths, body.sequence, leash);
         pendingTellDisposition = await runPreparedBody({
             launch,

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

@@ -33,6 +33,7 @@ declare const akumaCallRecipeSchema: z.ZodObject<{
             "codex-app-server": "codex-app-server";
             "grok-build": "grok-build";
             "opencode-sdk": "opencode-sdk";
+            paseo: "paseo";
             pi: "pi";
         }>;
         executable: z.ZodOptional<z.ZodString>;
@@ -43,10 +44,10 @@ declare const akumaCallRecipeSchema: z.ZodObject<{
         config?: Readonly<Record<string, unknown>>;
         executable?: string;
         name: string;
-        kind: "acp" | "claude-agent-sdk" | "codex-app-server" | "grok-build" | "opencode-sdk" | "pi";
+        kind: "acp" | "claude-agent-sdk" | "codex-app-server" | "grok-build" | "opencode-sdk" | "paseo" | "pi";
     }>, {
         name: string;
-        kind: "acp" | "claude-agent-sdk" | "codex-app-server" | "grok-build" | "opencode-sdk" | "pi";
+        kind: "acp" | "claude-agent-sdk" | "codex-app-server" | "grok-build" | "opencode-sdk" | "paseo" | "pi";
         executable?: string | undefined;
         config?: Record<string, unknown> | undefined;
         env?: Record<string, string> | undefined;
@@ -60,11 +61,11 @@ declare const akumaCallRecipeSchema: z.ZodObject<{
         }>>;
         systemPrompt: z.ZodOptional<z.ZodString>;
         systemPromptMode: z.ZodOptional<z.ZodEnum<{
-            append: "append";
             replace: "replace";
+            append: "append";
         }>>;
     }, z.core.$strip>, z.ZodTransform<Readonly<{
-        systemPromptMode?: "append" | "replace";
+        systemPromptMode?: "replace" | "append";
         systemPrompt?: string;
         network?: "disabled" | "enabled";
         effort?: string;
@@ -74,7 +75,7 @@ declare const akumaCallRecipeSchema: z.ZodObject<{
         effort?: string | undefined;
         network?: "disabled" | "enabled" | undefined;
         systemPrompt?: string | undefined;
-        systemPromptMode?: "append" | "replace" | undefined;
+        systemPromptMode?: "replace" | "append" | undefined;
     }>>;
 }, z.core.$strict>;
 declare const akumaCallPayloadSchema: z.ZodObject<{
@@ -86,6 +87,8 @@ declare const akumaCallPayloadSchema: z.ZodObject<{
         schemaJson: z.ZodOptional<z.ZodString>;
         initiator: z.ZodOptional<z.ZodString>;
     }, z.core.$strict>>;
+    birthInitiator: z.ZodOptional<z.ZodString>;
+    contractId: z.ZodOptional<z.ZodString>;
     cwd: z.ZodOptional<z.ZodString>;
     recipe: z.ZodObject<{
         description: z.ZodOptional<z.ZodString>;
@@ -115,6 +118,7 @@ declare const akumaCallPayloadSchema: z.ZodObject<{
                 "codex-app-server": "codex-app-server";
                 "grok-build": "grok-build";
                 "opencode-sdk": "opencode-sdk";
+                paseo: "paseo";
                 pi: "pi";
             }>;
             executable: z.ZodOptional<z.ZodString>;
@@ -125,10 +129,10 @@ declare const akumaCallPayloadSchema: z.ZodObject<{
             config?: Readonly<Record<string, unknown>>;
             executable?: string;
             name: string;
-            kind: "acp" | "claude-agent-sdk" | "codex-app-server" | "grok-build" | "opencode-sdk" | "pi";
+            kind: "acp" | "claude-agent-sdk" | "codex-app-server" | "grok-build" | "opencode-sdk" | "paseo" | "pi";
         }>, {
             name: string;
-            kind: "acp" | "claude-agent-sdk" | "codex-app-server" | "grok-build" | "opencode-sdk" | "pi";
+            kind: "acp" | "claude-agent-sdk" | "codex-app-server" | "grok-build" | "opencode-sdk" | "paseo" | "pi";
             executable?: string | undefined;
             config?: Record<string, unknown> | undefined;
             env?: Record<string, string> | undefined;
@@ -142,11 +146,11 @@ declare const akumaCallPayloadSchema: z.ZodObject<{
             }>>;
             systemPrompt: z.ZodOptional<z.ZodString>;
             systemPromptMode: z.ZodOptional<z.ZodEnum<{
-                append: "append";
                 replace: "replace";
+                append: "append";
             }>>;
         }, z.core.$strip>, z.ZodTransform<Readonly<{
-            systemPromptMode?: "append" | "replace";
+            systemPromptMode?: "replace" | "append";
             systemPrompt?: string;
             network?: "disabled" | "enabled";
             effort?: string;
@@ -156,7 +160,7 @@ declare const akumaCallPayloadSchema: z.ZodObject<{
             effort?: string | undefined;
             network?: "disabled" | "enabled" | undefined;
             systemPrompt?: string | undefined;
-            systemPromptMode?: "append" | "replace" | undefined;
+            systemPromptMode?: "replace" | "append" | undefined;
         }>>;
     }, z.core.$strict>;
 }, z.core.$strict>;
@@ -167,6 +171,10 @@ export type AkumaCallRequest = z.infer<typeof akumaCallPayloadSchema> & Readonly
 export type AkumaCallRequestChildLaunch = Readonly<{
     paths: AkumaPaths;
     seed: Omit<Soul, "createdAt">;
+    birthInitiator?: string;
+    completion?: Readonly<{
+        contractId?: string;
+    }>;
 }>;
 export type InitialTellAdmissionRequest = Readonly<{
     id: AkuId;

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

@@ -1,7 +1,8 @@
 import { isAbsolute, resolve } from "node:path";
 import { allowedActionsSchema } from "./allowed.js";
 import { refuseRequest, reserveRequest } from "./heart/index.js";
-import { archetypeName, akumaIdSchema } from "./identity.js";
+import { validateAkumaName } from "../identity/normalize.js";
+import { akumaIdSchema } from "./identity.js";
 import { callDiagnostic, executePreparedCall } from "./publication.js";
 import { tellResultSchema } from "./call-initial-tell.js";
 import { providerOptionsSchema, providerRecipeSchema } from "./provider-recipe.js";
@@ -11,7 +12,7 @@ import { z } from "zod";
 const absolutePathSchema = z.string().refine((value) => isAbsolute(value) && resolve(value) === value);
 const archetypeSchema = z.string().transform((value, context) => {
     try {
-        return archetypeName(value);
+        return validateAkumaName(value);
     }
     catch {
         context.addIssue({ code: "custom", message: "expected Akuma name" });
@@ -39,6 +40,8 @@ const akumaCallPayloadSchema = z
     world: absolutePathSchema,
     archetype: archetypeSchema,
     initialTell: initialTellSchema.optional(),
+    birthInitiator: z.string().optional(),
+    contractId: z.string().optional(),
     cwd: absolutePathSchema.optional(),
     recipe: akumaCallRecipeSchema,
 })
@@ -95,7 +98,11 @@ async function executeAkumaCall(request, facts, capabilities) {
             refuse: async (diagnostic) => {
                 await refuseRequest(paths, facts.id, diagnostic);
             },
-            spawn,
+            spawn: async (launch) => await spawn({
+                ...launch,
+                ...(request.birthInitiator === undefined ? {} : { birthInitiator: request.birthInitiator }),
+                ...(request.contractId === undefined ? {} : { completion: { contractId: request.contractId } }),
+            }),
             admitInitialTell,
         },
     });

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

@@ -0,0 +1,39 @@
+import { z } from "zod";
+import type { WorldRoot } from "../world.js";
+import { type Soul } from "./heart/facts.js";
+export declare const akumaCallerSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    kind: z.ZodLiteral<"akuma">;
+    world: z.ZodCustom<WorldRoot, WorldRoot>;
+    akuId: z.ZodPipe<z.ZodString, z.ZodTransform<import("./identity.js").AkuId, string>>;
+}, z.core.$strict>, z.ZodObject<{
+    kind: z.ZodLiteral<"external">;
+    integration: z.ZodString;
+    id: z.ZodString;
+}, z.core.$strict>], "kind">;
+export type AkumaCaller = z.infer<typeof akumaCallerSchema>;
+export declare const akumaBirthSchema: z.ZodObject<{
+    origin: z.ZodDiscriminatedUnion<[z.ZodObject<{
+        kind: z.ZodLiteral<"direct">;
+    }, z.core.$strip>, z.ZodObject<{
+        kind: z.ZodLiteral<"request">;
+        parent: z.ZodPipe<z.ZodString, z.ZodTransform<import("./identity.js").AkuId, string>>;
+        requestId: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+        kind: z.ZodLiteral<"fork">;
+        parent: z.ZodPipe<z.ZodString, z.ZodTransform<import("./identity.js").AkuId, string>>;
+        at: z.ZodString;
+    }, z.core.$strip>], "kind">;
+    caller: z.ZodUnion<readonly [z.ZodDiscriminatedUnion<[z.ZodObject<{
+        kind: z.ZodLiteral<"akuma">;
+        world: z.ZodCustom<WorldRoot, WorldRoot>;
+        akuId: z.ZodPipe<z.ZodString, z.ZodTransform<import("./identity.js").AkuId, string>>;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"external">;
+        integration: z.ZodString;
+        id: z.ZodString;
+    }, z.core.$strict>], "kind">, z.ZodObject<{
+        kind: z.ZodLiteral<"unknown">;
+    }, z.core.$strict>]>;
+}, z.core.$strict>;
+export declare function projectAkumaBirth(soul: Soul): z.infer<typeof akumaBirthSchema>;
+export declare function decodeAkumaCaller(value: unknown): AkumaCaller | undefined;

package/build/src/akuma/caller.js

@@ -0,0 +1,36 @@
+import { isAbsolute, resolve } from "node:path";
+import { z } from "zod";
+import { akumaIdSchema } from "./identity.js";
+import { akumaOriginSchema } from "./heart/facts.js";
+// Stored attribution is a coordinate, not a live World capability or lookup.
+const callerWorldSchema = z.custom((value) => typeof value === "string" && isAbsolute(value) && resolve(value) === value, "caller world must be an absolute normalized path");
+export const akumaCallerSchema = z.discriminatedUnion("kind", [
+    z.object({ kind: z.literal("akuma"), world: callerWorldSchema, akuId: akumaIdSchema }).strict(),
+    z
+        .object({
+        kind: z.literal("external"),
+        integration: z.string().regex(/^[a-z][a-z0-9._-]{0,63}$/u),
+        id: z
+            .string()
+            .max(512)
+            .refine((value) => value.trim().length > 0 && !/[\u0000-\u001f\u007f-\u009f]/u.test(value), "external caller id must be nonblank and contain no control characters"),
+    })
+        .strict(),
+]);
+export const akumaBirthSchema = z
+    .object({
+    origin: akumaOriginSchema,
+    caller: z.union([akumaCallerSchema, z.object({ kind: z.literal("unknown") }).strict()]),
+})
+    .strict();
+export function projectAkumaBirth(soul) {
+    return { origin: soul.origin, caller: soul.caller ?? { kind: "unknown" } };
+}
+export function decodeAkumaCaller(value) {
+    if (value === undefined)
+        return undefined;
+    const parsed = akumaCallerSchema.safeParse(value);
+    if (!parsed.success)
+        throw new TypeError(`Invalid Akuma caller: ${parsed.error.message}`);
+    return parsed.data;
+}

package/build/src/akuma/dispatch-association.d.ts

@@ -10,4 +10,3 @@ export declare const dispatchAssociationSchema: z.ZodUnion<readonly [z.ZodObject
 }, z.core.$strict>]>;
 export type DispatchAssociation = z.infer<typeof dispatchAssociationSchema>;
 export declare const NO_DISPATCH_ASSOCIATION: DispatchAssociation;
-export declare function parseDispatchAssociation(value: unknown): DispatchAssociation;

package/build/src/akuma/dispatch-association.js

@@ -6,6 +6,3 @@ export const dispatchAssociationSchema = z.union([
     z.object({ kind: z.literal("failed"), diagnostic: z.string() }).strict(),
 ]);
 export const NO_DISPATCH_ASSOCIATION = { kind: "none" };
-export function parseDispatchAssociation(value) {
-    return dispatchAssociationSchema.parse(value);
-}

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

@@ -1,4 +1,6 @@
-import type { AkuId } from "../identity.js";
+import type { AkumaCaller } from "../caller.js";
+import { z } from "zod";
+import { type AkuId } from "../identity.js";
 import type { ResumeCoordinate } from "../coordinate.js";
 import type { ProviderExecution, ProviderOptions } from "../provider-recipe.js";
 import type { AllowedActions } from "../allowed.js";
@@ -6,17 +8,18 @@ export type { ResumeCoordinate } from "../coordinate.js";
 export declare class HeartAuthorityCorruptionError extends Error {
     constructor(message: string, options?: ErrorOptions);
 }
-export type AkumaOrigin = Readonly<{
-    kind: "direct";
-}> | Readonly<{
-    kind: "request";
-    parent: AkuId;
-    requestId: string;
-}> | Readonly<{
-    kind: "fork";
-    parent: AkuId;
-    at: string;
-}>;
+export declare const akumaOriginSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    kind: z.ZodLiteral<"direct">;
+}, z.core.$strip>, z.ZodObject<{
+    kind: z.ZodLiteral<"request">;
+    parent: z.ZodPipe<z.ZodString, z.ZodTransform<AkuId, string>>;
+    requestId: z.ZodString;
+}, z.core.$strip>, z.ZodObject<{
+    kind: z.ZodLiteral<"fork">;
+    parent: z.ZodPipe<z.ZodString, z.ZodTransform<AkuId, string>>;
+    at: z.ZodString;
+}, z.core.$strip>], "kind">;
+export type AkumaOrigin = z.infer<typeof akumaOriginSchema>;
 export type Soul = Readonly<{
     id: AkuId;
     archetype: string;
@@ -25,6 +28,7 @@ export type Soul = Readonly<{
     options: ProviderOptions;
     cwd: string;
     origin: AkumaOrigin;
+    caller?: AkumaCaller;
     allowed: AllowedActions;
     createdAt: string;
 }>;

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

@@ -1,9 +1,17 @@
+import { z } from "zod";
+import { akumaIdSchema } from "../identity.js";
 export class HeartAuthorityCorruptionError extends Error {
     constructor(message, options) {
         super(message, options);
         this.name = "HeartAuthorityCorruptionError";
     }
 }
+const originText = z.string().refine((value) => value.trim().length > 0);
+export const akumaOriginSchema = z.discriminatedUnion("kind", [
+    z.object({ kind: z.literal("direct") }),
+    z.object({ kind: z.literal("request"), parent: akumaIdSchema, requestId: originText }),
+    z.object({ kind: z.literal("fork"), parent: akumaIdSchema, at: originText }),
+]);
 export function projectTell(fact) {
     return {
         kind: "tell",

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

@@ -1,14 +1,12 @@
 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";
-export type { CallFact } from "./facts.js";
-import type { ActivityFact } from "./rows.js";
 import type { AgentEvent } from "./activity-schema.js";
 import { type StatusFactInput, type ActivityFactSlice } from "./timeline.js";
 export { HeartAbsentError, HeldAkumaLeash, classifyHeartSchema, initializeHeart, isHeartAbsent, probeLeash, } from "./storage.js";
 export { admitRequest, beginRequest, isRequestInputConflict, readNonterminalRequests, readRequest, refuseRequest, reserveRequest, serveRequest, serveUpstreamRequest, unproveRequest, voidRequest, } from "./request-authority.js";
 export { AkumaBusyError, life, lifeAt, projectTell } from "./facts.js";
 export { drainPendingTells } from "./tells.js";
-export type { AkumaLife, AkumaOrigin, BodyEnd, BodyFact, HeartSnapshot, ForkPoint, KillEvidence, KillFact, LeashProbe, PauseFact, RequestFact, RequestInput, RequestRecipe, SealFact, SessionFact, Soul, StopFact, TellBinding, TellFact, TellRow, TellDelivery, TellDeliveryInput, TellReceiptInput, TurnEndFact, TurnFact, TurnOutcome, TurnStartFact, } from "./facts.js";
+export type { AkumaLife, AkumaOrigin, BodyEnd, HeartSnapshot, KillEvidence, RequestFact, SessionFact, Soul, TellFact, TurnEndFact, TurnOutcome, } from "./facts.js";
 export type { ResumeCoordinate } from "../coordinate.js";
 export declare function readSoul(paths: AkumaPaths): Promise<Soul | null>;
 export declare function heartExists(paths: AkumaPaths): Promise<boolean>;
@@ -19,8 +17,7 @@ export declare function appendActivity(paths: AkumaPaths, input: Readonly<{
     event: AgentEvent;
     at: string;
 }>): Promise<number>;
-export type ActivitySlice = ActivityFactSlice;
-export type { ActivityFact };
+type ActivitySlice = ActivityFactSlice;
 export type { TimelineFact } from "./timeline.js";
 export declare function activitySlice(paths: AkumaPaths): Promise<ActivitySlice>;
 export declare function readStatusFacts(paths: AkumaPaths, input: StatusFactInput, signal?: AbortSignal): Promise<ActivitySlice["rows"]>;
@@ -74,8 +71,6 @@ export declare function requestPause(paths: AkumaPaths, at: string, signal?: Abo
     kind: "requested";
     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">;

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

@@ -1,8 +1,8 @@
 import { parsePublicHistoryId } from "../identity.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, insertTellFact, insertTellReceiptFact, insertUndeliveredTellReceipts, latestOpenTellDisposition, openBoundTurns, openTellDispositionIds, pendingTellFacts, hasPendingTell, resolveTellDispositionSnapshot, tellDispositionResolved, tellFact, tellIdsForFence, turnParticipants, } from "./tells.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, withHeartTransaction, withReadOnlyHeart } from "./storage.js";
+import { isHeartAbsent, readSealFromLeash, recordPendingTell, withHeartTransaction, withReadOnlyHeart, } from "./storage.js";
 import { soulFact } from "./soul.js";
 import { AkumaBusyError, HeartAuthorityCorruptionError } from "./facts.js";
 export { HeartAbsentError, HeldAkumaLeash, classifyHeartSchema, initializeHeart, isHeartAbsent, probeLeash, } from "./storage.js";
@@ -138,9 +138,7 @@ export async function recordTell(paths, tell, options = {}) {
         const running = body !== null && body.end === undefined && body.hung === undefined;
         if (tell.schemaJson !== undefined && running && options.interrupt !== true)
             throw new AkumaBusyError();
-        const sequence = insertTellFact(heart, tell);
-        pruneActivityFacts(heart, ACTIVITY_LIMIT);
-        return { kind: "recorded", tell: { sequence, ...tell, state: "pending", deliveries: [] } };
+        return recordPendingTell(heart, tell);
     });
 }
 export async function readTell(paths, id) {
@@ -256,18 +254,6 @@ export async function requestPause(paths, at, signal) {
         return { kind: "requested", body };
     }, signal);
 }
-export async function stopRequested(paths, bodySequence) {
-    return await withReadOnlyHeart(paths, (heart) => {
-        const target = stopFact(heart);
-        return target !== null && (bodySequence === undefined || target.bodySequence === bodySequence);
-    });
-}
-export async function pauseRequested(paths, bodySequence) {
-    return await withReadOnlyHeart(paths, (heart) => {
-        const target = pauseFact(heart);
-        return target !== null && (bodySequence === undefined || target.bodySequence === bodySequence);
-    });
-}
 export async function breakBody(paths, input) {
     await withHeartTransaction(paths, (heart) => endBodyFact(heart, input));
 }

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

@@ -41,11 +41,11 @@ export declare const sessionAdmissionSchema: z.ZodObject<{
         }>>;
         systemPrompt: z.ZodOptional<z.ZodString>;
         systemPromptMode: z.ZodOptional<z.ZodEnum<{
-            append: "append";
             replace: "replace";
+            append: "append";
         }>>;
     }, z.core.$strip>, z.ZodTransform<Readonly<{
-        systemPromptMode?: "append" | "replace";
+        systemPromptMode?: "replace" | "append";
         systemPrompt?: string;
         network?: "disabled" | "enabled";
         effort?: string;
@@ -55,7 +55,7 @@ export declare const sessionAdmissionSchema: z.ZodObject<{
         effort?: string | undefined;
         network?: "disabled" | "enabled" | undefined;
         systemPrompt?: string | undefined;
-        systemPromptMode?: "append" | "replace" | undefined;
+        systemPromptMode?: "replace" | "append" | undefined;
     }>>;
     admittedAt: z.ZodString;
 }, z.core.$strict>;

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

@@ -1,5 +1,5 @@
 import type { DatabaseSync } from "node:sqlite";
-import type { Soul, SoulRow } from "./facts.js";
+import { type Soul, type SoulRow } from "./facts.js";
 export declare function decodeSoulSeed(value: unknown): Omit<Soul, "createdAt">;
 export declare function decodeSoul(value: unknown): Soul;
 export declare function encodeSoul(soul: Soul): string;

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

@@ -1,5 +1,7 @@
+import { decodeAkumaCaller } from "../caller.js";
 import { parseAkuId } from "../identity.js";
 import { decodeProviderOptions, decodeProviderRecipe } from "../provider-recipe.js";
+import { akumaOriginSchema } from "./facts.js";
 import { historicalAllowedActions } from "../allowed.js";
 function record(value) {
     return value !== null && typeof value === "object" && !Array.isArray(value)
@@ -20,29 +22,6 @@ function soulAkuIdentity(value, what) {
         throw new Error(`Akuma soul ${what} is not an Akuma identity coordinate`, { cause: error });
     }
 }
-function decodeOrigin(value) {
-    const origin = record(value);
-    if (origin === null)
-        throw new Error("Akuma soul origin must be an object");
-    if (origin.kind === "direct") {
-        return { kind: "direct" };
-    }
-    if (origin.kind === "request") {
-        return {
-            kind: "request",
-            parent: soulAkuIdentity(origin.parent, "request parent").id,
-            requestId: nonblank(origin.requestId, "request requestId"),
-        };
-    }
-    if (origin.kind === "fork") {
-        return {
-            kind: "fork",
-            parent: soulAkuIdentity(origin.parent, "fork parent").id,
-            at: nonblank(origin.at, "fork at"),
-        };
-    }
-    throw new Error("Akuma soul origin must be direct, request, or fork");
-}
 export function decodeSoulSeed(value) {
     const soul = record(value);
     if (soul === null)
@@ -55,6 +34,7 @@ export function decodeSoulSeed(value) {
     const description = soul.description === undefined ? undefined : nonblank(soul.description, "description");
     const provider = decodeProviderRecipe(soul.provider);
     const options = decodeProviderOptions(soul.options);
+    const caller = decodeAkumaCaller(soul.caller);
     return {
         id,
         archetype,
@@ -62,7 +42,8 @@ export function decodeSoulSeed(value) {
         provider,
         options,
         cwd: nonblank(soul.cwd, "cwd"),
-        origin: decodeOrigin(soul.origin),
+        origin: akumaOriginSchema.parse(soul.origin),
+        ...(caller === undefined ? {} : { caller }),
         allowed: historicalAllowedActions(soul.allowed),
     };
 }