@astrosheep/keiyaku 4.5.29 → 4.6.2

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

@@ -1,17 +1,9 @@
-import { type AkumaLife, type KillEvidence, type ResumeCoordinate } from "./heart/index.js";
-export type { KillEvidence };
-import { type AkuId } from "./identity.js";
-import type { Settings } from "../settings.js";
-import type { WorldRoot } from "../world.js";
-import { type AllowedAction } from "./allowed.js";
-import type { ExecutionContext } from "./requests.js";
 import { z } from "zod";
-import type { BoundedList } from "../bounded-list.js";
-import type { Schema } from "./schema.js";
-import { killAkumaWithRecovery } from "./akuma-handle.js";
-import type { TellResult } from "./body.js";
-export { killAkumaWithRecovery };
-export declare const POLL_MS = 100;
+import { type BoundedList } from "../bounded-list.js";
+import type { AkumaAlias } from "../identity/selector.js";
+import type { WorldRoot } from "../world.js";
+import type { AkumaLife } from "./heart/index.js";
+import { type AkuId } from "./identity.js";
 export type AkumaListRow = Readonly<{
     id: AkuId;
     archetype: string;
@@ -20,8 +12,26 @@ export type AkumaListRow = Readonly<{
     lifeAt: string | null;
     lastActivityAt: string | null;
     pending: readonly string[];
+    aliases: readonly AkumaAlias[];
+}>;
+export type UnbornAkumaListRow = Readonly<{
+    id: AkuId;
+    life: "unborn" | "stillborn";
+    aliases: readonly AkumaAlias[];
+    seal?: Readonly<{
+        evidence: string;
+        at: string;
+    }>;
+}>;
+export type AkumaList = BoundedList<AkumaListRow | UnbornAkumaListRow> & Readonly<{
+    observedAt: string;
+    searched: readonly string[];
+}>;
+export type AkumaCompleteList = Omit<AkumaList, "hasMore">;
+export type AkumaListInput = Readonly<{
+    archetype?: string;
+    limit?: number;
 }>;
-export declare const akumaIdSchema: z.ZodPipe<z.ZodString, z.ZodTransform<AkuId, string>>;
 export declare const akumaStatusSchema: z.ZodObject<{
     id: z.ZodPipe<z.ZodString, z.ZodTransform<AkuId, string>>;
     life: z.ZodEnum<{
@@ -214,7 +224,6 @@ export declare const akumaStatusSchema: z.ZodObject<{
                 sequence: z.ZodNumber;
                 turnSequence: z.ZodNumber;
                 at: z.ZodString;
-                completedAt: z.ZodOptional<z.ZodString>;
                 durationMs: z.ZodOptional<z.ZodNumber>;
                 name: z.ZodString;
                 call: z.ZodUnion<readonly [z.ZodObject<{
@@ -373,7 +382,6 @@ export declare const akumaStatusSchema: z.ZodObject<{
                 sequence: z.ZodNumber;
                 turnSequence: z.ZodNumber;
                 at: z.ZodString;
-                completedAt: z.ZodOptional<z.ZodString>;
                 durationMs: z.ZodOptional<z.ZodNumber>;
                 name: z.ZodString;
                 call: z.ZodUnion<readonly [z.ZodObject<{
@@ -434,79 +442,17 @@ export declare const akumaStatusSchema: z.ZodObject<{
 }, z.core.$strict>;
 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 * from "./projection.js";
-export type UnbornAkumaListRow = Readonly<{
-    id: AkuId;
-    life: "unborn" | "stillborn";
-    seal?: Readonly<{
-        evidence: string;
-        at: string;
-    }>;
-}>;
-export type AkumaList = BoundedList<AkumaListRow | UnbornAkumaListRow> & Readonly<{
-    observedAt: string;
-    searched: readonly string[];
-}>;
-export type AkumaCompleteList = Omit<AkumaList, "hasMore">;
-export type AkumaListInput = Readonly<{
-    archetype?: string;
-    limit?: number;
-}>;
-export type AkumaCallExecution = Readonly<{
-    cwd: string;
-    source: "input" | "caller" | "process" | "world";
-}>;
-export type AkumaCallInput = Readonly<{
-    archetype: string;
-    body: string;
-    cwd?: string;
-    allowed?: readonly AllowedAction[];
-    schema?: Schema<unknown>;
-    initiator?: string;
-    signal?: AbortSignal;
-}>;
-export type AkumaCallContext = Readonly<{
-    initiatorCwd?: string;
-    cwdCanonical?: true;
-}>;
-export type { TellResult, TellWake } from "./body.js";
-export type InterruptReceipt = Readonly<{
-    kind: "unavailable";
-    evidence: "hung" | "untidy" | "unavailable";
-}> | Readonly<{
-    kind: "interrupted";
-    putDown: "was-idle" | "self-aborted";
-    tell: TellResult;
-}>;
-export type ForkReceipt = Readonly<{
-    kind: "forked";
-    child: AkuId;
-}> | Readonly<{
-    kind: "provider-cannot-fork";
-    provider: string;
-}> | Readonly<{
-    kind: "unknown-history";
-    at: string;
-}> | Readonly<{
-    kind: "fork-failed";
-    diagnostic: string;
-}> | Readonly<{
-    kind: "upstream-forked";
-    childSession: ResumeCoordinate;
-    diagnostic: string;
-}>;
-export { AkumaNotBornError } from "./akuma-errors.js";
-export declare function wait(milliseconds: number): Promise<void>;
-export { bornStatus, fleetListRow, readAkumaBirthCwd, readBudgetedStatus, type BudgetedStatusObservation, } from "./akuma-observe.js";
-export type AkumaConfiguration = Readonly<{
+export declare function listAkumaArchetypes(path: WorldRoot, input?: Readonly<{
     home?: string;
-    settings?: Settings;
-    execution?: ExecutionContext;
-}>;
-/** Internal catalog observation for composition owners. */
-export declare function readAkumaCatalog(path: WorldRoot, input?: AkumaListInput): Promise<AkumaList>;
+}>): Promise<readonly string[]>;
+/**
+ * The bounded recent-activity roster: native membership, semantic order and
+ * observed extent. World Alias context is attached by the upper composition.
+ */
+export declare function readAkumaRoster(path: WorldRoot, input?: AkumaListInput): Promise<AkumaList>;
+/** The complete native roster for callers whose semantics require a frozen set. */
+export declare function readAkumaCompleteRoster(path: WorldRoot, input?: Readonly<{
+    archetype?: string;
+}>): Promise<AkumaCompleteList>;
 /** Internal timeline observation for composition owners. */
 export declare function readAkumaTimeline(path: WorldRoot, id: AkuId): Promise<AkumaStatus["timeline"]>;
-export { AkumaBusyError, AkumaDecodeError, AkumaProviderError } from "./akuma-errors.js";

package/build/src/akuma/akuma.js

@@ -1,23 +1,13 @@
-import { parseAkuId } from "./identity.js";
-import { activitySnapshotSchema } from "./projection.js";
-import { allowedActionsSchema } from "./allowed.js";
+import { readdir, stat } from "node:fs/promises";
 import { z } from "zod";
-import { createAkumaProduct } from "./akuma-product.js";
-import { killAkumaWithRecovery } from "./akuma-handle.js";
-export { killAkumaWithRecovery };
-export const POLL_MS = 100;
-export const akumaIdSchema = z.string().transform((value, context) => {
-    try {
-        const id = parseAkuId(value).id;
-        if (id !== value)
-            throw new Error("not canonical");
-        return id;
-    }
-    catch {
-        context.addIssue({ code: "custom", message: "expected canonical AkuId" });
-        return z.NEVER;
-    }
-});
+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 { activitySnapshotSchema } from "./projection.js";
+import { PAGE_POOL_SIZE, boundedMap } from "./read-pool.js";
 export const akumaStatusSchema = z
     .object({
     id: akumaIdSchema,
@@ -31,19 +21,147 @@ export const akumaStatusSchema = z
 export function parseAkumaStatus(value) {
     return akumaStatusSchema.parse(value);
 }
-export { defaultWaitComplete } from "./akuma-observe.js";
-export { withoutReportedChanges } from "./projection.js";
-export { AkumaNotBornError } from "./akuma-errors.js";
-export function wait(milliseconds) {
-    return new Promise((resolve) => setTimeout(resolve, milliseconds));
+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;
+    if (row.lifeAt === null)
+        return row.lastActivityAt;
+    if (row.lastActivityAt === null)
+        return row.lifeAt;
+    return row.lifeAt > row.lastActivityAt ? row.lifeAt : row.lastActivityAt;
+}
+function compareActivity(left, right) {
+    if (left === right)
+        return 0;
+    if (left === null)
+        return 1;
+    if (right === null)
+        return -1;
+    return left > right ? -1 : 1;
+}
+function compareRows(left, right) {
+    const activity = compareActivity(activityAt(left), activityAt(right));
+    if (activity !== 0)
+        return activity;
+    return left.id < right.id ? -1 : left.id > right.id ? 1 : 0;
+}
+async function mtimeBound(paths) {
+    const read = async (path) => {
+        try {
+            return (await stat(path)).mtimeMs;
+        }
+        catch (error) {
+            return error.code === "ENOENT" ? 0 : Number.POSITIVE_INFINITY;
+        }
+    };
+    return Math.max(await read(paths.heart), await read(`${paths.heart}-wal`));
+}
+async function knownAkuma(path, selected) {
+    const runRoot = akumaRunRoot(path);
+    let names;
+    try {
+        names = (await readdir(runRoot, { withFileTypes: true }))
+            .filter((entry) => entry.isDirectory())
+            .map((entry) => entry.name)
+            .sort();
+    }
+    catch (error) {
+        if (error.code === "ENOENT")
+            return { runRoot, rows: [] };
+        throw error;
+    }
+    const rows = [];
+    for (const name of names) {
+        let physical;
+        try {
+            physical = akuIdFromDirectoryName(name);
+        }
+        catch {
+            continue;
+        }
+        if (selected !== undefined && physical.archetype !== selected)
+            continue;
+        rows.push({
+            id: physical.id,
+            paths: akumaPaths({ runRoot, archetype: physical.archetype, suffix: physical.suffix }),
+        });
+    }
+    return { runRoot, rows };
+}
+async function readableRows(rows) {
+    const loaded = await boundedMap(rows, async ({ id, paths }) => {
+        try {
+            return await rosterListRow(paths, id);
+        }
+        catch {
+            return null;
+        }
+    });
+    return [...loaded].filter((row) => row !== null);
+}
+function rosterArchetype(input, allowLimit) {
+    if (typeof input !== "object" || input === null || Array.isArray(input))
+        throw new TypeError("Akuma list input must be an object");
+    const allowed = allowLimit ? ["archetype", "limit"] : ["archetype"];
+    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);
+}
+/**
+ * The bounded recent-activity roster: native membership, semantic order and
+ * observed extent. World Alias context is attached by the upper composition.
+ */
+export async function readAkumaRoster(path, input = {}) {
+    const selected = rosterArchetype(input, true);
+    const limit = boundedListLimit(input.limit);
+    const observedAt = new Date().toISOString();
+    const known = await knownAkuma(path, selected);
+    const candidatesWithBounds = await boundedMap(known.rows, async (row) => ({
+        ...row,
+        bound: await mtimeBound(row.paths),
+    }));
+    const candidates = [...candidatesWithBounds].sort((left, right) => right.bound - left.bound);
+    const readable = [];
+    let cursor = 0;
+    while (cursor < candidates.length) {
+        const batch = candidates.slice(cursor, cursor + PAGE_POOL_SIZE);
+        readable.push(...(await readableRows(batch)));
+        cursor += batch.length;
+        const ranked = readable.sort(compareRows);
+        const lookahead = ranked[limit];
+        const activity = lookahead === undefined ? null : activityAt(lookahead);
+        const unreadBound = candidates[cursor]?.bound;
+        if (lookahead !== undefined &&
+            activity !== null &&
+            unreadBound !== undefined &&
+            Number.isFinite(unreadBound) &&
+            Number.isFinite(Date.parse(activity)) &&
+            unreadBound < Date.parse(activity)) {
+            break;
+        }
+    }
+    const ranked = readable.sort(compareRows);
+    return {
+        observedAt,
+        searched: [known.runRoot],
+        ...projectBoundedList(ranked, limit),
+    };
 }
-export { bornStatus, fleetListRow, readAkumaBirthCwd, readBudgetedStatus, } from "./akuma-observe.js";
-/** Internal catalog observation for composition owners. */
-export async function readAkumaCatalog(path, input = {}) {
-    return await createAkumaProduct(path).list(input);
+/** The complete native roster for callers whose semantics require a frozen set. */
+export async function readAkumaCompleteRoster(path, input = {}) {
+    const selected = rosterArchetype(input, false);
+    const known = await knownAkuma(path, selected);
+    return {
+        observedAt: new Date().toISOString(),
+        rows: [...(await readableRows(known.rows))].sort(compareRows),
+        searched: [known.runRoot],
+    };
 }
 /** Internal timeline observation for composition owners. */
 export async function readAkumaTimeline(path, id) {
-    return (await createAkumaProduct(path).selectHandle({ id }).status()).timeline;
+    return (await new AkumaOwner(id, path).status()).timeline;
 }
-export { AkumaBusyError, AkumaDecodeError, AkumaProviderError } from "./akuma-errors.js";

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

@@ -8,6 +8,7 @@ type DecodedArchetype = Readonly<{
     path: string;
     provider: string;
     description?: string;
+    hidden?: boolean;
     options: ProviderOptions;
     allowed: AllowedActions;
 }>;
@@ -22,6 +23,10 @@ type ArchetypeDefinition = DecodedArchetype & Readonly<{
 type AdmittedArchetype = Omit<ArchetypeDefinition, "provider"> & Readonly<{
     provider: ProviderExecution;
 }>;
+/** One loaded archetype whose provider owner has decoded its execution but not yet admitted its options. */
+type PreparedArchetype = Omit<DecodedArchetype, "provider"> & Readonly<{
+    provider: ProviderExecution;
+}>;
 export declare class AkumaArchetypeError extends Error {
     readonly archetype: string;
     readonly searched: readonly string[];
@@ -37,6 +42,13 @@ export declare function listArchetypes(input?: ArchetypeCoordinates): Promise<re
 export declare function listArchetypeDefinitions(input?: ArchetypeCoordinates & Readonly<{
     limit?: number;
 }>): Promise<BoundedList<ArchetypeCatalogRow>>;
+/** Resolve one archetype and decode its provider execution, leaving option admission to the caller. */
+export declare function loadPreparedArchetype(input: Readonly<{
+    name: string;
+    project?: string;
+    home?: string;
+    settings: Settings;
+}>): Promise<PreparedArchetype>;
 export declare function loadArchetype(input: Readonly<{
     name: string;
     project?: string;

package/build/src/akuma/archetype.js

@@ -100,6 +100,14 @@ function archetypeEnum(values, key, allowed) {
         throw new TypeError(`Akuma ${key} must be one of ${allowed.join(", ")}`);
     return value;
 }
+function archetypeBoolean(values, key) {
+    const value = values[key];
+    if (value === undefined)
+        return undefined;
+    if (typeof value !== "boolean")
+        throw new TypeError(`Akuma ${key} must be a boolean`);
+    return value;
+}
 function parseArchetypeFrontmatter(markdown) {
     const lines = markdown.split(/\r?\n/u);
     if (lines[0]?.trim() !== "---")
@@ -124,6 +132,7 @@ function decodeArchetypeFields(values) {
     const effort = archetypeField(values, "effort");
     const network = archetypeEnum(values, "network", ["disabled", "enabled"]);
     const description = archetypeField(values, "description");
+    const hidden = archetypeBoolean(values, "hidden");
     const allowedPresent = "allowed" in values;
     const allowed = allowedPresent ? decodeAllowedActions(values.allowed) : undefined;
     const systemPromptMode = archetypeEnum(values, "systemPromptMode", ["append", "replace"]);
@@ -134,6 +143,7 @@ function decodeArchetypeFields(values) {
         ...(effort === undefined ? {} : { effort }),
         ...(network === undefined ? {} : { network }),
         ...(description === undefined ? {} : { description }),
+        ...(hidden === undefined ? {} : { hidden }),
         ...(allowed === undefined ? {} : { allowed }),
         allowedPresent,
         ...(systemPromptMode === undefined ? {} : { systemPromptMode }),
@@ -152,6 +162,7 @@ function decodeArchetype(name, path, markdown) {
         ...(fields.base === undefined ? {} : { base: fields.base }),
         ...(fields.provider === undefined ? {} : { provider: fields.provider }),
         ...(fields.description === undefined ? {} : { description: fields.description }),
+        ...(fields.hidden === undefined ? {} : { hidden: fields.hidden }),
         options: decodeProviderOptions({
             ...(fields.model === undefined ? {} : { model: fields.model }),
             ...(fields.effort === undefined ? {} : { effort: fields.effort }),
@@ -182,6 +193,8 @@ function mergeArchetype(base, local) {
                 ? {}
                 : { description: base.description }
             : { description: local.description }),
+        // Hiddenness is the file's own catalogue visibility; it never flows through base.
+        ...(local.hidden === true ? { hidden: true } : {}),
         options,
         allowed,
     });
@@ -229,20 +242,9 @@ export async function listArchetypeDefinitions(input = {}) {
     // 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 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 }) => {
+    const settled = await Promise.allSettled(all.map(async ({ name, path }) => {
         try {
-            const definition = await resolveArchetype(name, input, undefined);
-            return Object.freeze({
-                name: definition.name,
-                ...(definition.options.model === undefined ? {} : { model: definition.options.model }),
-                ...(definition.description === undefined ? {} : { description: definition.description }),
-            });
+            return await resolveArchetype(name, input, undefined);
         }
         catch (error) {
             if (error instanceof AkumaArchetypeError)
@@ -253,9 +255,17 @@ export async function listArchetypeDefinitions(input = {}) {
     const firstInvalid = settled.find((result) => result.status === "rejected");
     if (firstInvalid !== undefined)
         throw firstInvalid.reason;
+    const visible = settled
+        .map((result) => result.value)
+        .filter((definition) => definition.hidden !== true)
+        .map((definition) => Object.freeze({
+        name: definition.name,
+        ...(definition.options.model === undefined ? {} : { model: definition.options.model }),
+        ...(definition.description === undefined ? {} : { description: definition.description }),
+    }));
     return {
-        rows: settled.map((result) => result.value),
-        hasMore: selected.hasMore,
+        rows: limit === undefined ? visible : visible.slice(0, limit),
+        hasMore: limit === undefined ? false : visible.length > limit,
     };
 }
 function record(value) {
@@ -292,6 +302,11 @@ const BUILTIN_EXECUTIONS = {
     claude: { kind: "claude-agent-sdk" },
     "codex-app-server": { kind: "codex-app-server" },
     "opencode-sdk": { kind: "opencode-sdk" },
+    kimi: {
+        kind: "acp",
+        executable: "kimi",
+        config: { argvBefore: ["acp"], argvAfter: [], modelConfigId: "model", effortConfigId: "thinking" },
+    },
     pi: { kind: "pi" },
     "grok-build": {
         kind: "grok-build",
@@ -310,10 +325,10 @@ function providerExecution(settings, name) {
         return decodeProviderRecipe({ name, ...builtin });
     throw new TypeError(`unknown provider ${name}`);
 }
-async function admitArchetype(archetype, settings) {
+async function admitArchetype(archetype) {
     let selected;
     try {
-        selected = await resolveProviderExecution(providerExecution(settings, archetype.provider));
+        selected = await resolveProviderExecution(archetype.provider);
     }
     catch (error) {
         if (error instanceof TypeError)
@@ -333,8 +348,21 @@ async function admitArchetype(archetype, settings) {
         options: admission.options,
     });
 }
-export async function loadArchetype(input) {
+/** 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 definition = await resolveArchetype(name, input, undefined);
-    return await admitArchetype(definition, input.settings);
+    let provider;
+    try {
+        provider = providerExecution(input.settings, definition.provider);
+    }
+    catch (error) {
+        if (error instanceof TypeError)
+            throw new AkumaArchetypeError(definition.name, [definition.path], `uses ${error.message}`);
+        throw error;
+    }
+    return Object.freeze({ ...definition, provider });
+}
+export async function loadArchetype(input) {
+    return await admitArchetype(await loadPreparedArchetype(input));
 }

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

@@ -1,5 +1,5 @@
+import { z } from "zod";
 import type { AkumaCallRequestChildLaunch } from "./call-request.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";
@@ -9,18 +9,79 @@ import type { ErasedRequestCommand } from "./request-wire.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<{
-    paths: AkumaPaths;
-    seed?: Omit<Soul, "createdAt">;
-    birthSession?: Omit<SessionFact, "sequence">;
-    initialBody?: string;
-    initiator?: string;
-    initialSchemaJson?: string;
-    refuseIfHeld?: boolean;
-    completion?: Readonly<{
-        contractId?: string;
-    }>;
-}>;
+export declare const bodyLaunchSchema: z.ZodObject<{
+    paths: z.ZodObject<{
+        directory: z.ZodString;
+        heart: z.ZodString;
+        leash: z.ZodString;
+        log: z.ZodString;
+        requests: z.ZodString;
+    }, z.core.$strict>;
+    seed: z.ZodOptional<z.ZodPipe<z.ZodUnknown, z.ZodTransform<Omit<Readonly<{
+        id: import("./identity.js").AkuId;
+        archetype: string;
+        description?: string;
+        provider: import("./provider-recipe.js").ProviderExecution;
+        options: import("./provider-recipe.js").ProviderOptions;
+        cwd: string;
+        origin: import("./heart/facts.js").AkumaOrigin;
+        allowed: import("./allowed.js").AllowedActions;
+        createdAt: string;
+    }>, "createdAt">, unknown>>>;
+    birthSession: z.ZodOptional<z.ZodObject<{
+        provider: z.ZodString;
+        coordinate: z.ZodUnion<readonly [z.ZodPipe<z.ZodObject<{
+            sessionFile: z.ZodString;
+            sessionId: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>, z.ZodTransform<{
+            sessionFile: string;
+            sessionId?: never;
+        } | {
+            sessionFile: string;
+            sessionId: string;
+        }, {
+            sessionFile: string;
+            sessionId?: string | undefined;
+        }>>, z.ZodObject<{
+            sessionId: z.ZodString;
+        }, z.core.$strict>]>;
+        cwd: z.ZodString;
+        options: z.ZodPipe<z.ZodObject<{
+            model: z.ZodOptional<z.ZodString>;
+            effort: z.ZodOptional<z.ZodString>;
+            network: z.ZodOptional<z.ZodEnum<{
+                disabled: "disabled";
+                enabled: "enabled";
+            }>>;
+            systemPrompt: z.ZodOptional<z.ZodString>;
+            systemPromptMode: z.ZodOptional<z.ZodEnum<{
+                append: "append";
+                replace: "replace";
+            }>>;
+        }, z.core.$strip>, z.ZodTransform<Readonly<{
+            systemPromptMode?: "append" | "replace";
+            systemPrompt?: string;
+            network?: "disabled" | "enabled";
+            effort?: string;
+            model?: string;
+        }>, {
+            model?: string | undefined;
+            effort?: string | undefined;
+            network?: "disabled" | "enabled" | undefined;
+            systemPrompt?: string | undefined;
+            systemPromptMode?: "append" | "replace" | undefined;
+        }>>;
+        admittedAt: z.ZodString;
+    }, z.core.$strict>>;
+    initialBody: z.ZodOptional<z.ZodString>;
+    initiator: z.ZodOptional<z.ZodString>;
+    initialSchemaJson: z.ZodOptional<z.ZodString>;
+    refuseIfHeld: z.ZodOptional<z.ZodBoolean>;
+    completion: z.ZodOptional<z.ZodObject<{
+        contractId: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export type BodyLaunch = z.infer<typeof bodyLaunchSchema>;
 export type TellWakeRuntime = Readonly<{
     spawn(paths: AkumaPaths): Promise<OwnedProcess>;
     schedule?(milliseconds: number, signal: AbortSignal): Promise<void>;
@@ -32,28 +93,7 @@ type BodyRuntime = Readonly<{
     world: WorldRoot;
     externalCommands: Readonly<Record<string, ErasedRequestCommand>>;
 }>;
-type RuntimeEnvironment = Readonly<{
-    /** The current process executable, preferred only while it is a different live value. */
-    current?: string;
-    /** The present PATH used to resolve the recorded executable basename. */
-    path?: string | undefined;
-    exists?: (path: string) => boolean | Promise<boolean>;
-}>;
-/** One Body launch's runtime input: the runtime recorded for it and its resolution environment. */
-export type BodyLaunchRuntime = Readonly<{
-    recorded?: string;
-    environment?: RuntimeEnvironment;
-}>;
-/**
- * Resolve the runtime executable a Body spawn will use. The path recorded for
- * this process's birth wins while it exists. Once it is gone, wake re-resolves
- * the runtime before any spawn can fail: the current process executable while
- * that is a different live value, then the recorded executable basename on the
- * present PATH. An unresolvable runtime refuses with the stale record, the
- * failed re-resolution, and the kill-and-call-fresh remedy.
- */
-export declare function resolveRuntimeExecutable(recorded?: string, environment?: RuntimeEnvironment): Promise<string>;
-export declare function bodyProcessInput(launch: BodyLaunch, bodyModuleUrl?: string, runtime?: BodyLaunchRuntime): Promise<{
+export declare function bodyProcessInput(launch: BodyLaunch, bodyModuleUrl?: string): Promise<{
     argv: string[];
     cwd: string;
     env: Record<string, string>;
@@ -61,6 +101,6 @@ export declare function bodyProcessInput(launch: BodyLaunch, bodyModuleUrl?: str
 }>;
 export declare function handoffPendingTells(paths: AkumaPaths, spawn?: (launch: BodyLaunch) => Promise<OwnedProcess>): Promise<void>;
 export declare function driveAkumaBody(launch: BodyLaunch, adapter?: ProviderAdapter, runtimeInput?: Partial<BodyRuntime>): Promise<"held" | void>;
-export declare function spawnAkumaBody(launch: BodyLaunch, runtime?: BodyLaunchRuntime): Promise<OwnedProcess>;
+export declare function spawnAkumaBody(launch: BodyLaunch): Promise<OwnedProcess>;
 export declare function runAkumaBody(launch: BodyLaunch, world: WorldRoot, externalCommands: Readonly<Record<string, ErasedRequestCommand>>): Promise<"held" | void>;
 export declare function wakeRecordedTell(paths: AkumaPaths, tellId: string, runtime?: TellWakeRuntime, signal?: AbortSignal): Promise<TellResult>;