@astrosheep/keiyaku 4.6.7 → 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";
@@ -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)
@@ -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;
@@ -568,6 +575,21 @@ export async function driveAkumaBody(launch, adapter, runtimeInput = {}) {
         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),
     };
 }

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

@@ -10,6 +10,11 @@ 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 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<{
+    kind: "recorded";
+    tell: TellFact;
+}>;
 export declare function initializeHeart(paths: AkumaPaths): Promise<void>;
 export declare class HeldAkumaLeash {
     private readonly database;

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

@@ -142,6 +142,12 @@ function finishTransaction(database, body) {
         throw error;
     }
 }
+/** Insert one already-admitted pending Tell into an already-open Heart transaction. */
+export function recordPendingTell(heart, tell) {
+    const sequence = insertTellFact(heart, tell);
+    pruneActivityFacts(heart, ACTIVITY_LIMIT);
+    return { kind: "recorded", tell: { sequence, ...tell, state: "pending", deliveries: [] } };
+}
 export async function initializeHeart(paths) {
     const heart = new DatabaseSync(paths.heart);
     try {
@@ -258,9 +264,7 @@ export class HeldAkumaLeash {
             deletePauseControl(heart);
             if (soulFact(heart) === null)
                 return { kind: "not-born" };
-            const sequence = insertTellFact(heart, tell);
-            pruneActivityFacts(heart, ACTIVITY_LIMIT);
-            return { kind: "recorded", tell: { sequence, ...tell, state: "pending", deliveries: [] } };
+            return recordPendingTell(heart, tell);
         });
     }
     release() {

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

@@ -18,7 +18,6 @@ export type AllocatedAkuma = Readonly<{
     suffix: string;
     paths: AkumaPaths;
 }>;
-export declare function archetypeName(value: string): string;
 export declare function akuId(input: Readonly<{
     archetype: string;
     suffix: string;

package/build/src/akuma/identity.js

@@ -22,9 +22,6 @@ export const akumaPathsSchema = z
     requests: pathText,
 })
     .strict();
-export function archetypeName(value) {
-    return validateAkumaName(value);
-}
 function suffixSegment(value) {
     if (!HEX8.test(value))
         throw new TypeError("Akuma suffix must be lower hex8");
@@ -33,7 +30,7 @@ function suffixSegment(value) {
 export function akuId(input) {
     return identityCoordinate({
         family: "aku",
-        segments: [archetypeName(input.archetype), suffixSegment(input.suffix)],
+        segments: [validateAkumaName(input.archetype), suffixSegment(input.suffix)],
     });
 }
 export function parseAkuId(value) {
@@ -94,7 +91,7 @@ export async function ensureAkumaRunRoot(worldRoot) {
     return runRoot;
 }
 export async function allocateAkumaDirectory(input) {
-    const archetype = archetypeName(input.archetype);
+    const archetype = validateAkumaName(input.archetype);
     const runRoot = await ensureAkumaRunRoot(input.worldRoot);
     for (;;) {
         const suffix = suffixSegment(input.draw?.() ?? randomBytes(4).toString("hex"));

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

@@ -1,7 +1,10 @@
-export type { WorldRoot } from "../world.js";
+export type { AkumaCaller } from "./caller.js";
+export type { AkumaOrigin } from "./heart/index.js";
+export { AkumaArchetypeError, listArchetypeDefinitions } from "./archetype.js";
+export type { ArchetypeCatalog, ArchetypeCatalogInput, ArchetypeCatalogRow } from "./archetype.js";
 export { AkumaBusyError, AkumaDecodeError, AkumaNotBornError, AkumaProviderError } from "./akuma-errors.js";
 export { Akuma } from "./akuma-instance.js";
-export type { AkumaAskOptions, AkumaBirthInput, AkumaHistoryOptions, AkumaIdleOptions, AkumaIdleResult, AkumaSignalOptions, AkumaTellOptions, } from "./akuma-instance.js";
+export type { AkumaAskOptions, AkumaBirthInput, AkumaHistoryOptions, AkumaHostOptions, AkumaIdleOptions, AkumaIdleResult, AkumaSignalOptions, AkumaTellOptions, } from "./akuma-instance.js";
 export type { InterruptReceipt } from "./akuma-owner.js";
 export type { AkumaStatus } from "./akuma.js";
 export { ALLOWED_ACTIONS } from "./allowed.js";

package/build/src/akuma/index.js

@@ -1,3 +1,4 @@
+export { AkumaArchetypeError, listArchetypeDefinitions } from "./archetype.js";
 export { AkumaBusyError, AkumaDecodeError, AkumaNotBornError, AkumaProviderError } from "./akuma-errors.js";
 export { Akuma } from "./akuma-instance.js";
 export { ALLOWED_ACTIONS } from "./allowed.js";