@astrosheep/keiyaku 4.6.7 → 4.6.9

package/build/src/akuma/akuma.js

@@ -1,29 +1,27 @@
+import { akumaBirthSchema } from "./caller.js";
 import { readdir, stat } from "node:fs/promises";
 import { z } from "zod";
 import { boundedListLimit, projectBoundedList } from "../bounded-list.js";
 import { rosterListRow } from "./akuma-observe.js";
 import { AkumaOwner } from "./akuma-owner.js";
 import { allowedActionsSchema } from "./allowed.js";
-import { listArchetypes as readArchetypes } from "./archetype.js";
-import { akuIdFromDirectoryName, akumaIdSchema, akumaPaths, akumaRunRoot, archetypeName, } from "./identity.js";
+import { akuIdFromDirectoryName, akumaIdSchema, akumaPaths, akumaRunRoot, } from "./identity.js";
+import { validateAkumaName } from "../identity/normalize.js";
 import { activitySnapshotSchema } from "./projection.js";
 import { PAGE_POOL_SIZE, boundedMap } from "./read-pool.js";
 export const akumaStatusSchema = z
     .object({
     id: akumaIdSchema,
+    birth: akumaBirthSchema,
     life: z.enum(["running", "asleep", "stranded", "hung", "untidy", "killed"]),
     cwd: z.string().optional(),
+    provider: z.string().optional(),
+    model: z.string().optional(),
     allowed: allowedActionsSchema,
     timeline: activitySnapshotSchema,
     strandedReason: z.literal("resume-unsupported").optional(),
 })
     .strict();
-export function parseAkumaStatus(value) {
-    return akumaStatusSchema.parse(value);
-}
-export async function listAkumaArchetypes(path, input = {}) {
-    return readArchetypes({ project: path, ...(input.home === undefined ? {} : { home: input.home }) });
-}
 function activityAt(row) {
     if (!("lifeAt" in row))
         return null;
@@ -59,7 +57,8 @@ async function mtimeBound(paths) {
     };
     return Math.max(await read(paths.heart), await read(`${paths.heart}-wal`));
 }
-async function knownAkuma(path, selected) {
+/** Enumerate the recognized Akuma directories under this World's run root. */
+export async function knownAkuma(path, selected) {
     const runRoot = akumaRunRoot(path);
     let names;
     try {
@@ -80,6 +79,7 @@ async function knownAkuma(path, selected) {
             physical = akuIdFromDirectoryName(name);
         }
         catch {
+            // The run root can contain bytes not produced by Keiyaku. Preserve them.
             continue;
         }
         if (selected !== undefined && physical.archetype !== selected)
@@ -109,7 +109,7 @@ function rosterArchetype(input, allowLimit) {
     const unknown = Object.keys(input).find((key) => !allowed.includes(key));
     if (unknown !== undefined)
         throw new TypeError(`Akuma list input has unknown field: ${unknown}`);
-    return input.archetype === undefined ? undefined : archetypeName(input.archetype);
+    return input.archetype === undefined ? undefined : validateAkumaName(input.archetype);
 }
 /**
  * The bounded recent-activity roster: native membership, semantic order and

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

@@ -1,5 +1,5 @@
 import { z } from "zod";
-export declare const ALLOWED_ACTIONS: readonly ["akuma.call", "akuma.kill", "akuma.tell", "contract.audit", "contract.deliver", "contract.review", "task.add", "task.addDocument", "task.compose", "task.done", "task.drop", "task.hold", "task.resume", "task.start", "task.stop", "task.update"];
+export declare const ALLOWED_ACTIONS: readonly ["akuma.call", "akuma.kill", "akuma.tell", "contract.audit", "contract.deliver", "contract.review", "debt.add", "debt.addDocument", "debt.done", "debt.drop", "debt.update"];
 export type AllowedAction = (typeof ALLOWED_ACTIONS)[number];
 export type AllowedActions = readonly AllowedAction[];
 export declare const DEFAULT_ALLOWED_ACTIONS: AllowedActions;
@@ -7,23 +7,18 @@ export declare function isAllowedAction(value: unknown): value is AllowedAction;
 export declare function decodeAllowedActions(value: unknown, label?: string): AllowedActions;
 /** Public codecs retain the Soul's canonical, duplicate-free action membership. */
 export declare const allowedActionsSchema: z.ZodPipe<z.ZodArray<z.ZodEnum<{
-    "task.add": "task.add";
-    "task.addDocument": "task.addDocument";
-    "task.compose": "task.compose";
-    "task.done": "task.done";
-    "task.drop": "task.drop";
-    "task.hold": "task.hold";
-    "task.resume": "task.resume";
-    "task.start": "task.start";
-    "task.stop": "task.stop";
-    "task.update": "task.update";
+    "debt.add": "debt.add";
+    "debt.addDocument": "debt.addDocument";
+    "debt.done": "debt.done";
+    "debt.drop": "debt.drop";
+    "debt.update": "debt.update";
     "akuma.call": "akuma.call";
     "akuma.kill": "akuma.kill";
     "akuma.tell": "akuma.tell";
     "contract.audit": "contract.audit";
     "contract.deliver": "contract.deliver";
     "contract.review": "contract.review";
-}>>, z.ZodTransform<AllowedActions, ("task.add" | "task.addDocument" | "task.compose" | "task.done" | "task.drop" | "task.hold" | "task.resume" | "task.start" | "task.stop" | "task.update" | "akuma.call" | "akuma.kill" | "akuma.tell" | "contract.audit" | "contract.deliver" | "contract.review")[]>>;
+}>>, z.ZodTransform<AllowedActions, ("debt.add" | "debt.addDocument" | "debt.done" | "debt.drop" | "debt.update" | "akuma.call" | "akuma.kill" | "akuma.tell" | "contract.audit" | "contract.deliver" | "contract.review")[]>>;
 export declare function historicalAllowedActions(value: unknown): AllowedActions;
 export declare function unionAllowedActions(base: AllowedActions, additions: AllowedActions): AllowedActions;
 export declare function clipAllowedActions(requested: AllowedActions, parent: AllowedActions): AllowedActions;

package/build/src/akuma/allowed.js

@@ -1,4 +1,4 @@
-import { TASK_MUTATION_ACTIONS } from "../task/mutation.js";
+import { DEBT_MUTATION_ACTIONS } from "../debt/mutation.js";
 import { z } from "zod";
 const AKUMA_MUTATION_ACTIONS = Object.freeze(["akuma.call", "akuma.kill", "akuma.tell"]);
 export const ALLOWED_ACTIONS = Object.freeze([
@@ -6,13 +6,13 @@ export const ALLOWED_ACTIONS = Object.freeze([
     "contract.audit",
     "contract.deliver",
     "contract.review",
-    ...TASK_MUTATION_ACTIONS,
+    ...DEBT_MUTATION_ACTIONS,
 ]);
 export const DEFAULT_ALLOWED_ACTIONS = Object.freeze([
     ...AKUMA_MUTATION_ACTIONS,
     "contract.audit",
     "contract.deliver",
-    ...TASK_MUTATION_ACTIONS,
+    ...DEBT_MUTATION_ACTIONS,
 ]);
 const ALLOWED_ACTION_SET = new Set(ALLOWED_ACTIONS);
 export function isAllowedAction(value) {
@@ -42,7 +42,16 @@ export const allowedActionsSchema = z.array(z.enum(ALLOWED_ACTIONS)).transform((
     }
 });
 export function historicalAllowedActions(value) {
-    return value === undefined ? ALLOWED_ACTIONS : decodeAllowedActions(value);
+    if (value === undefined)
+        return ALLOWED_ACTIONS;
+    if (!Array.isArray(value))
+        return decodeAllowedActions(value);
+    // Persisted permissions retain the same surviving capabilities after rename;
+    // removed planning/progress operations confer no replacement permission.
+    const retired = new Set(["task.compose", "task.start", "task.stop", "task.hold", "task.resume"]);
+    return decodeAllowedActions(value
+        .filter((action) => !retired.has(action))
+        .map((action) => typeof action === "string" && action.startsWith("task.") ? `debt.${action.slice("task.".length)}` : action));
 }
 export function unionAllowedActions(base, additions) {
     const merged = new Set(base);

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

@@ -1,6 +1,5 @@
 import { type BoundedList } from "../bounded-list.js";
 import type { Settings } from "../settings.js";
-import type { ProviderAdapter } from "./provider.js";
 import { type ProviderExecution, type ProviderOptions } from "./provider-recipe.js";
 import { type AllowedActions } from "./allowed.js";
 type DecodedArchetype = Readonly<{
@@ -17,11 +16,12 @@ export type ArchetypeCatalogRow = Readonly<{
     model?: string;
     description?: string;
 }>;
-type ArchetypeDefinition = DecodedArchetype & Readonly<{
-    adapter: ProviderAdapter;
-}>;
-type AdmittedArchetype = Omit<ArchetypeDefinition, "provider"> & Readonly<{
-    provider: ProviderExecution;
+export type ArchetypeCatalog = BoundedList<ArchetypeCatalogRow>;
+/** One closed catalogue request: omitted project means no project scope, never ambient discovery. */
+export type ArchetypeCatalogInput = Readonly<{
+    project?: string;
+    home?: string;
+    limit?: number;
 }>;
 /** One loaded archetype whose provider owner has decoded its execution but not yet admitted its options. */
 type PreparedArchetype = Omit<DecodedArchetype, "provider"> & Readonly<{
@@ -39,9 +39,7 @@ type ArchetypeCoordinates = Readonly<{
     home?: string;
 }>;
 export declare function listArchetypes(input?: ArchetypeCoordinates): Promise<readonly string[]>;
-export declare function listArchetypeDefinitions(input?: ArchetypeCoordinates & Readonly<{
-    limit?: number;
-}>): Promise<BoundedList<ArchetypeCatalogRow>>;
+export declare function listArchetypeDefinitions(input?: ArchetypeCatalogInput): Promise<ArchetypeCatalog>;
 /** Resolve one archetype and decode its provider execution, leaving option admission to the caller. */
 export declare function loadPreparedArchetype(input: Readonly<{
     name: string;
@@ -49,10 +47,4 @@ export declare function loadPreparedArchetype(input: Readonly<{
     home?: string;
     settings: Settings;
 }>): Promise<PreparedArchetype>;
-export declare function loadArchetype(input: Readonly<{
-    name: string;
-    project?: string;
-    home?: string;
-    settings: Settings;
-}>): Promise<AdmittedArchetype>;
 export {};

package/build/src/akuma/archetype.js

@@ -1,11 +1,10 @@
 import { readFile, readdir } from "node:fs/promises";
 import { homedir } from "node:os";
-import { join } from "node:path";
+import { isAbsolute, join } from "node:path";
 import { parseDocument } from "yaml";
 import { boundedListLimit } from "../bounded-list.js";
-import { archetypeName } from "./identity.js";
+import { validateAkumaName } from "../identity/normalize.js";
 import { decodeProviderOptions, decodeProviderRecipe, } from "./provider-recipe.js";
-import { resolveProviderExecution } from "./providers/index.js";
 import { DEFAULT_ALLOWED_ACTIONS, decodeAllowedActions } from "./allowed.js";
 export class AkumaArchetypeError extends Error {
     archetype;
@@ -37,7 +36,7 @@ async function pathsInDirectory(directory) {
                 return [];
             const name = entry.name.slice(0, -3);
             try {
-                return [{ name: archetypeName(name), path: join(directory, entry.name) }];
+                return [{ name: validateAkumaName(name), path: join(directory, entry.name) }];
             }
             catch {
                 return [];
@@ -127,7 +126,7 @@ function parseArchetypeFrontmatter(markdown) {
 function decodeArchetypeFields(values) {
     const provider = archetypeField(values, "provider");
     const baseValue = archetypeField(values, "base");
-    const base = baseValue === undefined ? undefined : archetypeName(baseValue);
+    const base = baseValue === undefined ? undefined : validateAkumaName(baseValue);
     const model = archetypeField(values, "model");
     const effort = archetypeField(values, "effort");
     const network = archetypeEnum(values, "network", ["disabled", "enabled"]);
@@ -237,14 +236,41 @@ async function resolveArchetype(name, input, source, chain = []) {
     const missingChain = chain.length === 0 ? chain : [...chain, name];
     throw archetypeError(name, searched, "was not found", missingChain, chain.length === 0 ? "use `keiyaku ls aku/` to list available Akuma" : undefined);
 }
+function catalogueCoordinate(value, field) {
+    if (value === undefined)
+        return undefined;
+    if (typeof value !== "string" || value.trim().length === 0) {
+        throw new TypeError(`Akuma catalogue ${field} must be a nonblank string`);
+    }
+    if (!isAbsolute(value))
+        throw new TypeError(`Akuma catalogue ${field} must be absolute: ${value}`);
+    return value;
+}
+/** Malformed caller input fails here, before any filesystem observation. */
+function catalogueInput(value) {
+    if (value === null || typeof value !== "object" || Array.isArray(value)) {
+        throw new TypeError("Akuma catalogue input must be an object");
+    }
+    const input = value;
+    const unknown = Object.keys(input).find((key) => !["project", "home", "limit"].includes(key));
+    if (unknown !== undefined)
+        throw new TypeError(`Akuma catalogue input has unknown field: ${unknown}`);
+    const project = catalogueCoordinate(input.project, "project");
+    const home = catalogueCoordinate(input.home, "home");
+    return {
+        ...(project === undefined ? {} : { project }),
+        ...(home === undefined ? {} : { home }),
+        ...(input.limit === undefined ? {} : { limit: boundedListLimit(input.limit) }),
+    };
+}
 export async function listArchetypeDefinitions(input = {}) {
     // Reads still run concurrently, but the reported failure is the first invalid
     // definition in catalog byte order, not whichever read happened to finish first.
-    const limit = input.limit === undefined ? undefined : boundedListLimit(input.limit);
-    const all = await archetypePaths(input);
+    const { limit, ...coordinates } = catalogueInput(input);
+    const all = await archetypePaths(coordinates);
     const settled = await Promise.allSettled(all.map(async ({ name, path }) => {
         try {
-            return await resolveArchetype(name, input, undefined);
+            return await resolveArchetype(name, coordinates, undefined);
         }
         catch (error) {
             if (error instanceof AkumaArchetypeError)
@@ -307,6 +333,7 @@ const BUILTIN_EXECUTIONS = {
         executable: "kimi",
         config: { argvBefore: ["acp"], argvAfter: [], modelConfigId: "model", effortConfigId: "thinking" },
     },
+    paseo: { kind: "paseo" },
     pi: { kind: "pi" },
     "grok-build": {
         kind: "grok-build",
@@ -325,32 +352,9 @@ function providerExecution(settings, name) {
         return decodeProviderRecipe({ name, ...builtin });
     throw new TypeError(`unknown provider ${name}`);
 }
-async function admitArchetype(archetype) {
-    let selected;
-    try {
-        selected = await resolveProviderExecution(archetype.provider);
-    }
-    catch (error) {
-        if (error instanceof TypeError)
-            throw new AkumaArchetypeError(archetype.name, [archetype.path], `uses ${error.message}`);
-        throw error;
-    }
-    const execution = selected.execution;
-    const adapter = selected.adapter;
-    const admission = adapter.admitOptions(archetype.options);
-    if (admission.kind === "refused") {
-        throw new AkumaArchetypeError(archetype.name, [archetype.path], `is unsupported: ${admission.diagnostic}`);
-    }
-    return Object.freeze({
-        ...archetype,
-        provider: execution,
-        adapter,
-        options: admission.options,
-    });
-}
 /** Resolve one archetype and decode its provider execution, leaving option admission to the caller. */
 export async function loadPreparedArchetype(input) {
-    const name = archetypeName(input.name);
+    const name = validateAkumaName(input.name);
     const definition = await resolveArchetype(name, input, undefined);
     let provider;
     try {
@@ -363,6 +367,3 @@ export async function loadPreparedArchetype(input) {
     }
     return Object.freeze({ ...definition, provider });
 }
-export async function loadArchetype(input) {
-    return await admitArchetype(await loadPreparedArchetype(input));
-}

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

@@ -1,10 +1,11 @@
-import { type HeartSnapshot, type HeldAkumaLeash } from "./heart/index.js";
+import { type BodyControlSnapshot, type HeldAkumaLeash } from "./heart/index.js";
 import type { AkumaPaths } from "./identity.js";
 export declare const CONTROL_RESPONSE_MS = 1000;
 export declare class BodySupervisor {
     private readonly paths;
     private readonly bodySequence;
     private readonly leash;
+    private readonly reader;
     readonly signal: AbortSignal;
     private readonly controller;
     private readonly finished;
@@ -15,12 +16,11 @@ export declare class BodySupervisor {
     private constructor();
     static open(paths: AkumaPaths, bodySequence: number, leash: HeldAkumaLeash): Promise<BodySupervisor>;
     get reason(): "control" | "heart-gone" | undefined;
-    current(): HeartSnapshot;
+    current(): BodyControlSnapshot;
     recordHung(diagnostic: string, at: string): Promise<void>;
-    refresh(): Promise<HeartSnapshot>;
-    next(after: HeartSnapshot): Promise<HeartSnapshot>;
+    refresh(): Promise<BodyControlSnapshot>;
+    next(after: BodyControlSnapshot): Promise<BodyControlSnapshot>;
     cancel(reason: "control" | "heart-gone"): void;
     close(): Promise<void>;
-    private publish;
     private observe;
 }

package/build/src/akuma/body-supervisor.js

@@ -1,11 +1,13 @@
 import { abortableDelay } from "./abort.js";
-import { heartExists, readHeart } from "./heart/index.js";
+import { isDeepStrictEqual } from "node:util";
+import { createBodyHeartReader } from "./heart/index.js";
 const BODY_CONTROL_OBSERVATION_MS = 100;
 export const CONTROL_RESPONSE_MS = 1_000;
 export class BodySupervisor {
     paths;
     bodySequence;
     leash;
+    reader;
     signal;
     controller = new AbortController();
     finished = new AbortController();
@@ -13,16 +15,18 @@ export class BodySupervisor {
     waiter;
     observation;
     stopping;
-    constructor(paths, bodySequence, leash, observation) {
+    constructor(paths, bodySequence, leash, reader, observation) {
         this.paths = paths;
         this.bodySequence = bodySequence;
         this.leash = leash;
+        this.reader = reader;
         this.signal = this.controller.signal;
         this.observation = observation;
         this.observer = this.observe();
     }
     static async open(paths, bodySequence, leash) {
-        return new BodySupervisor(paths, bodySequence, leash, await readHeart(paths));
+        const reader = createBodyHeartReader(paths);
+        return new BodySupervisor(paths, bodySequence, leash, reader, await reader.read());
     }
     get reason() {
         return this.stopping;
@@ -34,7 +38,12 @@ export class BodySupervisor {
         await this.leash.recordBodyHung(this.paths, { sequence: this.bodySequence, diagnostic, at });
     }
     async refresh() {
-        this.publish(await readHeart(this.paths));
+        const snapshot = await this.reader.read();
+        if (!isDeepStrictEqual(snapshot, this.observation)) {
+            this.observation = snapshot;
+            this.waiter?.(snapshot);
+            this.waiter = undefined;
+        }
         return this.observation;
     }
     next(after) {
@@ -54,18 +63,18 @@ export class BodySupervisor {
     }
     async close() {
         this.finished.abort();
-        await this.observer;
-        this.waiter = undefined;
-    }
-    publish(snapshot) {
-        this.observation = snapshot;
-        this.waiter?.(snapshot);
-        this.waiter = undefined;
+        try {
+            await this.observer;
+        }
+        finally {
+            this.reader.clear();
+            this.waiter = undefined;
+        }
     }
     async observe() {
         for (;;) {
             const snapshot = this.observation;
-            if (!(await heartExists(this.paths)))
+            if (snapshot.soul === null)
                 return this.cancel("heart-gone");
             if (snapshot.stop?.bodySequence === this.bodySequence || snapshot.pause?.bodySequence === this.bodySequence) {
                 return this.cancel("control");
@@ -76,14 +85,7 @@ export class BodySupervisor {
             catch {
                 return;
             }
-            try {
-                await this.refresh();
-            }
-            catch (error) {
-                if (await heartExists(this.paths))
-                    throw error;
-                return this.cancel("heart-gone");
-            }
+            await this.refresh();
         }
     }
 }

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

@@ -25,6 +25,7 @@ export declare const bodyLaunchSchema: z.ZodObject<{
         options: import("./provider-recipe.js").ProviderOptions;
         cwd: string;
         origin: import("./heart/facts.js").AkumaOrigin;
+        caller?: import("./caller.js").AkumaCaller;
         allowed: import("./allowed.js").AllowedActions;
         createdAt: string;
     }>, "createdAt">, unknown>>>;
@@ -55,11 +56,11 @@ export declare const bodyLaunchSchema: 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;
@@ -69,12 +70,13 @@ export declare const bodyLaunchSchema: 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>>;
     initialBody: z.ZodOptional<z.ZodString>;
     initiator: z.ZodOptional<z.ZodString>;
+    birthInitiator: z.ZodOptional<z.ZodString>;
     initialSchemaJson: z.ZodOptional<z.ZodString>;
     refuseIfHeld: z.ZodOptional<z.ZodBoolean>;
     completion: z.ZodOptional<z.ZodObject<{

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