@astrosheep/keiyaku 4.5.28 → 4.5.29

package/build/src/akuma/akuma-handle.d.ts

@@ -1,3 +1,4 @@
+import { type CallInitialTell, type CallInitialTellAdmission } from "./call-initial-tell.js";
 import { type TellResult, type TellWakeRuntime } from "./body.js";
 import { HeldAkumaLeash, type KillEvidence, type TellFact, type TurnOutcome } from "./heart/index.js";
 import { type AkuId, type AkumaPaths } from "./identity.js";
@@ -18,6 +19,7 @@ export type TellAdmission = Readonly<{
     tell: TellFact;
     wake: Promise<TellResult>;
 }>;
+export type InitialTellAdmission = CallInitialTellAdmission;
 export type InterruptAdmission = Readonly<{
     kind: "unavailable";
     evidence: "hung" | "untidy" | "unavailable";
@@ -53,6 +55,10 @@ export declare class AkumaHandle {
         timeoutMs?: number;
         signal?: AbortSignal;
     }>): Promise<AkumaStatus>;
+    admitInitialTell(initialTell: CallInitialTell, options?: Readonly<{
+        signal?: AbortSignal;
+        runtime?: TellWakeRuntime;
+    }>): Promise<InitialTellAdmission>;
     tell(body: string, tellId?: string, recordedAt?: string, runtime?: TellWakeRuntime, options?: Readonly<{
         schemaJson?: string;
         initiator?: string;
@@ -82,6 +88,7 @@ export declare class AkumaHandle {
     }>): Promise<Readonly<{
         reason: WaitReason;
         outcome: TurnOutcome | null;
+        completedAt: string | null;
     }>>;
     private boundTellOutcome;
     interrupt(body: string, options?: Readonly<{

package/build/src/akuma/akuma-handle.js

@@ -1,4 +1,5 @@
 import { randomUUID } from "node:crypto";
+import { admitCallInitialTell } from "./call-initial-tell.js";
 import { handoffPendingTells, wakeRecordedTell } from "./body.js";
 import { HeldAkumaLeash, activitySlice, readForkPoint, readHeart, readKill, readLastAnsweredTurn, readSoul, readTell, readTurn, recordTell, requestPause, requestStop, projectTell, } from "./heart/index.js";
 import { acquireLeash } from "./control.js";
@@ -150,6 +151,15 @@ export class AkumaHandle {
     async wait(predicate = defaultWaitComplete, options = {}) {
         return (await this.waitReceipt(predicate, options)).status;
     }
+    async admitInitialTell(initialTell, options = {}) {
+        return await admitCallInitialTell({
+            world: this.worldPath,
+            id: this.id,
+            initialTell,
+            ...(options.signal === undefined ? {} : { signal: options.signal }),
+            wake: (tell) => wakeRecordedTell(this.paths, tell.id, options.runtime, options.signal),
+        });
+    }
     async tell(body, tellId = randomUUID(), recordedAt = new Date().toISOString(), runtime, options = {}) {
         const admitted = await this.admitTell(body, tellId, recordedAt, runtime, options);
         if (admitted.kind === "not-born")
@@ -212,17 +222,21 @@ export class AkumaHandle {
                 if (options.observe !== undefined) {
                     await options.observe(await bornLiveStatus(this.paths, this.id, { aperture: "monitoring", admittedTellId: tellId }));
                 }
-                return { outcome, terminalWithoutTurn: tell.state === "told" && tell.binding === undefined };
+                return { ...outcome, terminalWithoutTurn: tell.state === "told" && tell.binding === undefined };
             },
             complete: (observed) => observed.outcome !== null || observed.terminalWithoutTurn,
         });
-        return { reason: waited.reason, outcome: waited.value.outcome };
+        return {
+            reason: waited.reason,
+            outcome: waited.value.outcome,
+            completedAt: waited.value.completedAt,
+        };
     }
     async boundTellOutcome(tell) {
         if (tell.binding === undefined)
-            return null;
-        const turn = await readTurn(this.paths, tell.binding.turnSequence);
-        return turn?.end?.outcome ?? null;
+            return { outcome: null, completedAt: null };
+        const end = (await readTurn(this.paths, tell.binding.turnSequence))?.end;
+        return { outcome: end?.outcome ?? null, completedAt: end?.completedAt ?? null };
     }
     async interrupt(body, options = {}) {
         const admitted = await this.admitInterrupt(body, options);
@@ -331,7 +345,6 @@ export class AkumaHandle {
                             ...(source.description === undefined ? {} : { description: source.description }),
                             provider: source.provider,
                             options: source.options,
-                            ...(source.readonly === undefined ? {} : { readonly: source.readonly }),
                             allowed: source.allowed,
                             cwd: source.cwd,
                             origin: { kind: "fork", parent: this.id, at: input.at },

package/build/src/akuma/akuma-instance.d.ts

@@ -28,7 +28,6 @@ export type AkumaBirthInput = Readonly<{
     cwd?: string;
     home?: string;
     settings?: Settings;
-    readonly?: true;
     allowed?: readonly AllowedAction[];
 }>;
 export type AkumaTellOptions<T> = Readonly<{

package/build/src/akuma/akuma-instance.js

@@ -1,5 +1,5 @@
 import { randomUUID } from "node:crypto";
-import { callReadonly, canonicalBirthCwd } from "./call-input.js";
+import { canonicalBirthCwd } from "./call-input.js";
 import { spawnAkumaBody } from "./body.js";
 import { decodeAllowedActions, unionAllowedActions } from "./allowed.js";
 import { AkumaDecodeError, AkumaProviderError } from "./akuma-errors.js";
@@ -98,8 +98,7 @@ export class Akuma {
         const name = archetype;
         const home = input.home === undefined ? {} : { home: input.home };
         const settings = input.settings ?? (await readSettings({ root: input.root, ...home }));
-        const readonly = callReadonly(input.readonly, "Akuma birth readonly must be true");
-        const loaded = await loadArchetype({ name, project: input.root, ...home, settings, ...readonly });
+        const loaded = await loadArchetype({ name, project: input.root, ...home, settings });
         const allowed = input.allowed === undefined
             ? loaded.allowed
             : unionAllowedActions(loaded.allowed, decodeAllowedActions(input.allowed, "Akuma birth allowed"));
@@ -115,7 +114,6 @@ export class Akuma {
                     ...(loaded.description === undefined ? {} : { description: loaded.description }),
                     provider: loaded.provider,
                     options: loaded.options,
-                    ...(loaded.readonly === undefined ? {} : { readonly: loaded.readonly }),
                     allowed,
                     cwd,
                     origin: { kind: "direct" },

package/build/src/akuma/akuma-observe.js

@@ -77,7 +77,6 @@ export async function bornLiveStatus(paths, expected, input) {
             life: currentLife,
             cwd: soul.cwd,
             allowed: soul.allowed,
-            ...(soul.readonly === undefined ? {} : { readonly: soul.readonly }),
             ...(resumeUnsupported ? { strandedReason: "resume-unsupported" } : {}),
             timeline: selected.snapshot,
         },

package/build/src/akuma/akuma-product.d.ts

@@ -1,6 +1,6 @@
 import { AkumaHandle } from "./akuma-handle.js";
 import type { AkumaCallContext, AkumaCallInput, AkumaCompleteList, AkumaConfiguration, AkumaList, AkumaListInput } from "./akuma.js";
-import { CALL_WITH_CONTEXT } from "./akuma-product-symbols.js";
+import type { CallInitialTell } from "./call-initial-tell.js";
 import type { WorldRoot } from "../world.js";
 import type { BodyLaunch } from "./body.js";
 import type { AllocatedAkuma } from "./identity.js";
@@ -9,6 +9,7 @@ type BornExecution = Readonly<{
     cwd: string;
     source: "input" | "caller" | "process" | "world";
 }>;
+export type InitialCallTell = CallInitialTell;
 export type BornAkumaCall = Readonly<{
     kind: "born";
     allocated: AllocatedAkuma;
@@ -20,9 +21,6 @@ export type BornAkumaCall = Readonly<{
             kind: "direct";
         };
     }>;
-    initialBody?: string;
-    initiator?: string;
-    initialSchemaJson?: string;
     execution: BornExecution;
 }>;
 export type RequestedAkumaCall = Readonly<{
@@ -32,8 +30,8 @@ export type RequestedAkumaCall = Readonly<{
     execution: BornExecution;
 }>;
 export type AkumaBornCall = BornAkumaCall | RequestedAkumaCall;
-type AkumaCallLaunchInput = Omit<AkumaCallInput, "body"> & Readonly<{
-    body?: string;
+type AkumaCallLaunchInput = Omit<AkumaCallInput, "body" | "schema"> & Readonly<{
+    initialTell: InitialCallTell;
 }>;
 export declare const PAGE_POOL_SIZE = 16;
 export declare function boundedMap<Value, Result>(values: readonly Value[], mapper: (value: Value) => Promise<Result>): Promise<readonly Result[]>;
@@ -46,12 +44,10 @@ declare class AkumaProduct {
         id: string;
     }>): AkumaHandle;
     listArchetypes(): Promise<readonly string[]>;
-    invoke(input: AkumaCallLaunchInput): Promise<AkumaHandle>;
     admit(input: AkumaCallLaunchInput, context: AkumaCallContext): Promise<AkumaBornCall>;
     publish(born: AkumaBornCall, completion?: Readonly<{
         contractId?: string;
     }>, signal?: AbortSignal): Promise<AkumaHandle>;
-    [CALL_WITH_CONTEXT](input: AkumaCallLaunchInput, context: AkumaCallContext): Promise<AkumaHandle>;
     listComplete(input?: Readonly<{
         archetype?: string;
     }>): Promise<AkumaCompleteList>;

package/build/src/akuma/akuma-product.js

@@ -2,8 +2,7 @@ import { randomUUID } from "node:crypto";
 import { readdir, stat } from "node:fs/promises";
 import { boundedListLimit, projectBoundedList } from "../bounded-list.js";
 import { AkumaHandle } from "./akuma-handle.js";
-import { CALL_WITH_CONTEXT } from "./akuma-product-symbols.js";
-import { callReadonly, canonicalBirthCwd } from "./call-input.js";
+import { canonicalBirthCwd } from "./call-input.js";
 import { fleetListRow, readAkumaBirthCwd } from "./akuma-observe.js";
 import { akuIdFromDirectoryName, akumaPaths, akumaRunRoot, archetypeName, parseAkuId } from "./identity.js";
 import { loadArchetype, listArchetypes as readArchetypes } from "./archetype.js";
@@ -13,7 +12,6 @@ import { requestForwardedAkumaCall } from "./call-request.js";
 import { executionChannel } from "./requests.js";
 import { decodeAllowedActions, unionAllowedActions } from "./allowed.js";
 import { settings as readSettings } from "../settings.js";
-import { schemaJsonText } from "./schema.js";
 async function admitBodyRequest(input) {
     const cwd = input.call.cwd === undefined
         ? undefined
@@ -25,8 +23,7 @@ async function admitBodyRequest(input) {
         id: randomUUID(),
         world: input.path,
         archetype: input.name,
-        ...(input.call.body === undefined ? {} : { body: input.call.body }),
-        ...(input.call.initiator === undefined ? {} : { initiator: input.call.initiator }),
+        initialTell: input.call.initialTell,
         ...(cwd === undefined ? {} : { cwd }),
         recipe: input.recipe,
         ...(input.call.signal === undefined ? {} : { signal: input.call.signal }),
@@ -60,9 +57,6 @@ async function admitDirect(input) {
             cwd,
             origin: { kind: "direct" },
         },
-        ...(input.call.body === undefined ? {} : { initialBody: input.call.body }),
-        ...(input.call.initiator === undefined ? {} : { initiator: input.call.initiator }),
-        ...(input.call.schema === undefined ? {} : { initialSchemaJson: schemaJsonText(input.call.schema) }),
         execution: {
             cwd,
             source: input.call.cwd !== undefined ? "input" : initiatorCwd === undefined ? "world" : "process",
@@ -183,15 +177,11 @@ class AkumaProduct {
             ...(this.configuration.home === undefined ? {} : { home: this.configuration.home }),
         });
     }
-    async invoke(input) {
-        return await this[CALL_WITH_CONTEXT](input, { initiatorCwd: process.cwd() });
-    }
     async admit(input, context) {
-        const readonly = callReadonly(input.readonly);
         const name = archetypeName(input.archetype);
         const home = this.configuration.home === undefined ? {} : { home: this.configuration.home };
         const settings = this.configuration.settings ?? (await readSettings({ root: this.path, ...home }));
-        const archetype = await loadArchetype({ name, project: this.path, ...home, settings, ...readonly });
+        const archetype = await loadArchetype({ name, project: this.path, ...home, settings });
         const allowed = input.allowed === undefined
             ? archetype.allowed
             : unionAllowedActions(archetype.allowed, decodeAllowedActions(input.allowed, "Akuma call allowed"));
@@ -200,7 +190,6 @@ class AkumaProduct {
             ...(archetype.description === undefined ? {} : { description: archetype.description }),
             provider: archetype.provider,
             options: archetype.options,
-            ...(archetype.readonly === undefined ? {} : { readonly: archetype.readonly }),
             allowed,
         });
         if (execution.kind === "body-request")
@@ -217,9 +206,6 @@ class AkumaProduct {
             launch: async (allocated) => await spawnAkumaBody({
                 paths: allocated.paths,
                 seed: born.seed,
-                ...(born.initialBody === undefined ? {} : { initialBody: born.initialBody }),
-                ...(born.initiator === undefined ? {} : { initiator: born.initiator }),
-                ...(born.initialSchemaJson === undefined ? {} : { initialSchemaJson: born.initialSchemaJson }),
                 ...(Object.keys(completion).length === 0 ? {} : { completion }),
             }),
         });
@@ -228,9 +214,6 @@ class AkumaProduct {
             source: born.execution.source,
         });
     }
-    async [CALL_WITH_CONTEXT](input, context) {
-        return await this.publish(await this.admit(input, context));
-    }
     async listComplete(input = {}) {
         if (typeof input !== "object" || input === null || Array.isArray(input))
             throw new TypeError("Akuma complete list input must be an object");

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

@@ -51,12 +51,6 @@ export declare const akumaStatusSchema: z.ZodObject<{
         "contract.deliver": "contract.deliver";
         "contract.review": "contract.review";
     }>>, z.ZodTransform<import("./allowed.js").AllowedActions, ("task.add" | "task.addDocument" | "task.compose" | "task.done" | "task.drop" | "task.hold" | "task.resume" | "task.start" | "task.stop" | "task.update" | "akuma.call" | "akuma.kill" | "akuma.tell" | "contract.audit" | "contract.deliver" | "contract.review")[]>>;
-    readonly: z.ZodOptional<z.ZodUnion<readonly [z.ZodObject<{
-        enforcement: z.ZodLiteral<"native">;
-    }, z.core.$strict>, z.ZodObject<{
-        enforcement: z.ZodLiteral<"none">;
-        diagnostic: z.ZodString;
-    }, z.core.$strict>]>>;
     timeline: z.ZodUnion<readonly [z.ZodObject<{
         reportedChanges: z.ZodReadonly<z.ZodArray<z.ZodObject<{
             sequence: z.ZodNumber;
@@ -442,7 +436,6 @@ export type AkumaStatus = z.infer<typeof akumaStatusSchema>;
 export declare function parseAkumaStatus(value: unknown): AkumaStatus;
 export { defaultWaitComplete } from "./akuma-observe.js";
 export { withoutReportedChanges } from "./projection.js";
-export type { ReadonlyRestraint } from "./provider-recipe.js";
 export type * from "./projection.js";
 export type UnbornAkumaListRow = Readonly<{
     id: AkuId;
@@ -469,7 +462,6 @@ export type AkumaCallInput = Readonly<{
     archetype: string;
     body: string;
     cwd?: string;
-    readonly?: true;
     allowed?: readonly AllowedAction[];
     schema?: Schema<unknown>;
     initiator?: string;

package/build/src/akuma/akuma.js

@@ -18,17 +18,12 @@ export const akumaIdSchema = z.string().transform((value, context) => {
         return z.NEVER;
     }
 });
-const readonlySchema = z.union([
-    z.object({ enforcement: z.literal("native") }).strict(),
-    z.object({ enforcement: z.literal("none"), diagnostic: z.string().refine((value) => value.trim() !== "") }).strict(),
-]);
 export const akumaStatusSchema = z
     .object({
     id: akumaIdSchema,
     life: z.enum(["running", "asleep", "stranded", "hung", "untidy", "killed"]),
     cwd: z.string().optional(),
     allowed: allowedActionsSchema,
-    readonly: readonlySchema.optional(),
     timeline: activitySnapshotSchema,
     strandedReason: z.literal("resume-unsupported").optional(),
 })

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

@@ -1,6 +1,7 @@
+import { type BoundedList } from "../bounded-list.js";
 import type { Settings } from "../settings.js";
 import type { ProviderAdapter } from "./provider.js";
-import { type ProviderExecution, type ProviderOptions, type ReadonlyRestraint } from "./provider-recipe.js";
+import { type ProviderExecution, type ProviderOptions } from "./provider-recipe.js";
 import { type AllowedActions } from "./allowed.js";
 type DecodedArchetype = Readonly<{
     name: string;
@@ -8,7 +9,6 @@ type DecodedArchetype = Readonly<{
     provider: string;
     description?: string;
     options: ProviderOptions;
-    readonly?: true;
     allowed: AllowedActions;
 }>;
 export type ArchetypeCatalogRow = Readonly<{
@@ -19,9 +19,8 @@ export type ArchetypeCatalogRow = Readonly<{
 type ArchetypeDefinition = DecodedArchetype & Readonly<{
     adapter: ProviderAdapter;
 }>;
-type AdmittedArchetype = Omit<ArchetypeDefinition, "provider" | "readonly"> & Readonly<{
+type AdmittedArchetype = Omit<ArchetypeDefinition, "provider"> & Readonly<{
     provider: ProviderExecution;
-    readonly?: ReadonlyRestraint;
 }>;
 export declare class AkumaArchetypeError extends Error {
     readonly archetype: string;
@@ -35,12 +34,13 @@ type ArchetypeCoordinates = Readonly<{
     home?: string;
 }>;
 export declare function listArchetypes(input?: ArchetypeCoordinates): Promise<readonly string[]>;
-export declare function listArchetypeDefinitions(input?: ArchetypeCoordinates): Promise<readonly ArchetypeCatalogRow[]>;
+export declare function listArchetypeDefinitions(input?: ArchetypeCoordinates & Readonly<{
+    limit?: number;
+}>): Promise<BoundedList<ArchetypeCatalogRow>>;
 export declare function loadArchetype(input: Readonly<{
     name: string;
     project?: string;
     home?: string;
     settings: Settings;
-    readonly?: true;
 }>): Promise<AdmittedArchetype>;
 export {};

package/build/src/akuma/archetype.js

@@ -2,6 +2,7 @@ import { readFile, readdir } from "node:fs/promises";
 import { homedir } from "node:os";
 import { join } from "node:path";
 import { parseDocument } from "yaml";
+import { boundedListLimit } from "../bounded-list.js";
 import { archetypeName } from "./identity.js";
 import { decodeProviderOptions, decodeProviderRecipe, } from "./provider-recipe.js";
 import { resolveProviderExecution } from "./providers/index.js";
@@ -99,13 +100,6 @@ function archetypeEnum(values, key, allowed) {
         throw new TypeError(`Akuma ${key} must be one of ${allowed.join(", ")}`);
     return value;
 }
-function archetypeReadonly(values) {
-    if (!("readonly" in values))
-        return undefined;
-    if (values.readonly !== true)
-        throw new TypeError("Akuma readonly must be true");
-    return true;
-}
 function parseArchetypeFrontmatter(markdown) {
     const lines = markdown.split(/\r?\n/u);
     if (lines[0]?.trim() !== "---")
@@ -126,13 +120,9 @@ function decodeArchetypeFields(values) {
     const provider = archetypeField(values, "provider");
     const baseValue = archetypeField(values, "base");
     const base = baseValue === undefined ? undefined : archetypeName(baseValue);
-    if ("access" in values)
-        throw new TypeError("Akuma access is not supported; use readonly: true");
     const model = archetypeField(values, "model");
     const effort = archetypeField(values, "effort");
-    const readonly = archetypeReadonly(values);
     const network = archetypeEnum(values, "network", ["disabled", "enabled"]);
-    const sandbox = archetypeEnum(values, "sandbox", ["full-access"]);
     const description = archetypeField(values, "description");
     const allowedPresent = "allowed" in values;
     const allowed = allowedPresent ? decodeAllowedActions(values.allowed) : undefined;
@@ -142,9 +132,7 @@ function decodeArchetypeFields(values) {
         ...(provider === undefined ? {} : { provider }),
         ...(model === undefined ? {} : { model }),
         ...(effort === undefined ? {} : { effort }),
-        ...(readonly === undefined ? {} : { readonly }),
         ...(network === undefined ? {} : { network }),
-        ...(sandbox === undefined ? {} : { sandbox }),
         ...(description === undefined ? {} : { description }),
         ...(allowed === undefined ? {} : { allowed }),
         allowedPresent,
@@ -168,7 +156,6 @@ function decodeArchetype(name, path, markdown) {
             ...(fields.model === undefined ? {} : { model: fields.model }),
             ...(fields.effort === undefined ? {} : { effort: fields.effort }),
             ...(fields.network === undefined ? {} : { network: fields.network }),
-            ...(fields.sandbox === undefined ? {} : { sandbox: fields.sandbox }),
             ...(systemPrompt.length === 0
                 ? {}
                 : {
@@ -176,7 +163,6 @@ function decodeArchetype(name, path, markdown) {
                     systemPromptMode: fields.systemPromptMode ?? "append",
                 }),
         }),
-        ...(fields.readonly === undefined ? {} : { readonly: fields.readonly }),
         ...(fields.allowed === undefined ? {} : { allowed: fields.allowed }),
         allowedPresent: fields.allowedPresent,
     });
@@ -197,7 +183,6 @@ function mergeArchetype(base, local) {
                 : { description: base.description }
             : { description: local.description }),
         options,
-        ...(local.readonly === true || base?.readonly === true ? { readonly: true } : {}),
         allowed,
     });
 }
@@ -242,7 +227,15 @@ async function resolveArchetype(name, input, source, chain = []) {
 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 settled = await Promise.allSettled((await archetypePaths(input)).map(async ({ name, path }) => {
+    const limit = input.limit === undefined ? undefined : boundedListLimit(input.limit);
+    const all = await archetypePaths(input);
+    const selected = limit === undefined
+        ? { paths: all, hasMore: false }
+        : (() => {
+            const paths = all.slice(0, limit + 1);
+            return { paths: paths.slice(0, limit), hasMore: paths.length > limit };
+        })();
+    const settled = await Promise.allSettled(selected.paths.map(async ({ name, path }) => {
         try {
             const definition = await resolveArchetype(name, input, undefined);
             return Object.freeze({
@@ -260,7 +253,10 @@ export async function listArchetypeDefinitions(input = {}) {
     const firstInvalid = settled.find((result) => result.status === "rejected");
     if (firstInvalid !== undefined)
         throw firstInvalid.reason;
-    return settled.map((result) => result.value);
+    return {
+        rows: settled.map((result) => result.value),
+        hasMore: selected.hasMore,
+    };
 }
 function record(value) {
     return value !== null && typeof value === "object" && !Array.isArray(value)
@@ -314,7 +310,7 @@ function providerExecution(settings, name) {
         return decodeProviderRecipe({ name, ...builtin });
     throw new TypeError(`unknown provider ${name}`);
 }
-async function admitArchetype(archetype, settings, callReadonly) {
+async function admitArchetype(archetype, settings) {
     let selected;
     try {
         selected = await resolveProviderExecution(providerExecution(settings, archetype.provider));
@@ -326,25 +322,19 @@ async function admitArchetype(archetype, settings, callReadonly) {
     }
     const execution = selected.execution;
     const adapter = selected.adapter;
-    const effectiveReadonly = archetype.readonly === true || callReadonly === true;
-    const admission = adapter.admitOptions({
-        ...archetype.options,
-        ...(effectiveReadonly ? { readonly: true } : {}),
-    });
+    const admission = adapter.admitOptions(archetype.options);
     if (admission.kind === "refused") {
         throw new AkumaArchetypeError(archetype.name, [archetype.path], `is unsupported: ${admission.diagnostic}`);
     }
-    const { readonly: _readonly, ...definition } = archetype;
     return Object.freeze({
-        ...definition,
+        ...archetype,
         provider: execution,
         adapter,
         options: admission.options,
-        ...(admission.readonly === undefined ? {} : { readonly: admission.readonly }),
     });
 }
 export async function loadArchetype(input) {
     const name = archetypeName(input.name);
     const definition = await resolveArchetype(name, input, undefined);
-    return await admitArchetype(definition, input.settings, input.readonly);
+    return await admitArchetype(definition, input.settings);
 }

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

@@ -1,10 +1,12 @@
 import type { AkumaCallRequestChildLaunch } from "./call-request.js";
-import { type SessionFact, type Soul, type TellRow } from "./heart/index.js";
+import { type SessionFact, type Soul } from "./heart/index.js";
 import { type AkumaPaths } from "./identity.js";
+import { type TellResult } from "./call-initial-tell.js";
+export type { TellResult, TellWake } from "./call-initial-tell.js";
 import { type WorldRoot } from "../world.js";
 import type { ProviderAdapter } from "./provider.js";
 import type { ErasedRequestCommand } from "./request-wire.js";
-import { type OwnedProcess, type RunLogReference } from "../runtime/proc/run.js";
+import { type OwnedProcess } from "../runtime/proc/run.js";
 export declare const LEASH_HELD_EXIT = 75;
 export { CONTROL_RESPONSE_MS } from "./body-supervisor.js";
 export type BodyLaunch = Readonly<{
@@ -19,30 +21,6 @@ export type BodyLaunch = Readonly<{
         contractId?: string;
     }>;
 }>;
-export type TellWake = Readonly<{
-    kind: "told";
-}> | Readonly<{
-    kind: "pursuing";
-    bodySequence: number;
-}> | Readonly<{
-    kind: "held";
-}> | Readonly<{
-    kind: "failed";
-    diagnostic: string;
-    child?: Readonly<{
-        code: number | null;
-        signal: string | null;
-        log: RunLogReference;
-    }>;
-}>;
-export type TellResult = Readonly<{
-    admission: Readonly<{
-        tellId: string;
-        fact: "recorded";
-    }>;
-    row: TellRow;
-    wake: TellWake;
-}>;
 export type TellWakeRuntime = Readonly<{
     spawn(paths: AkumaPaths): Promise<OwnedProcess>;
     schedule?(milliseconds: number, signal: AbortSignal): Promise<void>;

package/build/src/akuma/body.js

@@ -5,13 +5,14 @@ import { abortable, abortableDelay } from "./abort.js";
 import { BodySupervisor } from "./body-supervisor.js";
 import { driveTurn, turnRecipe } from "./turn-drive.js";
 import { HeldAkumaLeash, breakBody, decidePendingTellDisposition, drainPendingTells, endTurn, failOpenBoundTurns, finishBodyIfIdle, heartExists, isHeartAbsent, probeLeash, projectTell, readHeart, readLatestTurnForBody, readOpenBoundTurns, readOpenPendingTellDisposition, readTell, readTurn, readNonterminalRequests, resolvePendingTellDisposition, } from "./heart/index.js";
-import { worldRootForAkumaPaths } from "./identity.js";
+import { 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 { World } from "../world.js";
 import { resolveProviderExecution } from "./providers/index.js";
 import { clearBodyRequestTransport, settleBodyRequests } from "./request-serve.js";
-import { spawnDetachedProcess, } from "../runtime/proc/run.js";
+import { spawnDetachedProcess } from "../runtime/proc/run.js";
 const LEASH_RETRY_MS = 100;
 const WAKE_REREAD_MS = 100;
 export const LEASH_HELD_EXIT = 75;
@@ -344,6 +345,20 @@ function bodyEndEmitter(launch, soul) {
         }
     })();
 }
+async function admitInitialCallTell(runtime, input) {
+    const paths = pathsForAkuId(runtime.world, input.id);
+    return await admitCallInitialTell({
+        world: runtime.world,
+        id: input.id,
+        initialTell: input.initialTell,
+        signal: input.signal,
+        now: runtime.now,
+        wake: async (tell) => await wakeRecordedTell(paths, tell.id, {
+            spawn: async (tellPaths) => await (runtime.spawnBody ?? spawnAkumaBody)({ paths: tellPaths, refuseIfHeld: true }),
+            schedule: abortableDelay,
+        }, input.signal),
+    });
+}
 async function runBodyTurns(input) {
     const { launch, soul, adapter, bodySequence, supervisor, runtime, turnOutcome } = input;
     let initial = launch.initialBody;
@@ -371,6 +386,7 @@ async function runBodyTurns(input) {
             bodySequence,
             supervisor,
             runtimeSpawn: runtime.spawnChild ?? spawnAkumaBody,
+            admitInitialTell: async (admission) => await admitInitialCallTell(runtime, admission),
             body: initial ?? "",
             ...(initial === undefined ? {} : { call: initial }),
             ...(launch.initiator === undefined ? {} : { initiator: launch.initiator }),

package/build/src/akuma/call-initial-tell.d.ts

@@ -0,0 +1,55 @@
+import { type TellFact, type TellRow } from "./heart/index.js";
+import { type AkuId } from "./identity.js";
+import type { WorldRoot } from "../world.js";
+export type CallInitialTell = Readonly<{
+    tellId: string;
+    body: string;
+    schemaJson?: string;
+    initiator?: string;
+}>;
+export type TellWake = Readonly<{
+    kind: "told";
+}> | Readonly<{
+    kind: "pursuing";
+    bodySequence: number;
+}> | Readonly<{
+    kind: "held";
+}> | Readonly<{
+    kind: "failed";
+    diagnostic: string;
+    child?: Readonly<{
+        code: number | null;
+        signal: string | null;
+        log: Readonly<{
+            path: string;
+            from: number;
+            to: number;
+        }>;
+    }>;
+}>;
+export type TellResult = Readonly<{
+    admission: Readonly<{
+        tellId: string;
+        fact: "recorded";
+    }>;
+    row: TellRow;
+    wake: TellWake;
+}>;
+export type CallInitialTellAdmission = Readonly<{
+    kind: "admitted";
+    tell: TellFact;
+    wake: Promise<TellResult>;
+}> | Readonly<{
+    kind: "not-born";
+}> | Readonly<{
+    kind: "birth-failed";
+    diagnostic: string;
+}>;
+export declare function admitCallInitialTell(input: Readonly<{
+    world: WorldRoot;
+    id: AkuId;
+    initialTell: CallInitialTell;
+    signal?: AbortSignal;
+    now?: () => string;
+    wake(tell: TellFact): Promise<TellResult>;
+}>): Promise<CallInitialTellAdmission>;