@astrosheep/keiyaku 4.6.6 → 4.6.8

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

@@ -1,3 +1,4 @@
+import { projectAkumaBirth } from "./caller.js";
 import { readStatusFacts, createStatusFactReader, readLifeSnapshot, HeldAkumaLeash, isHeartAbsent, life, lifeAt, probeLeash, readHeart, readSeal, readSoul, } from "./heart/index.js";
 import { pathsForAkuId } from "./identity.js";
 import { ordinarySnapshotBudget, projectTurns, selectHistory, selectSnapshot, } from "./projection.js";
@@ -59,6 +60,18 @@ async function bornObservation(paths, expected, read, snapshot) {
         claim?.release();
     }
 }
+export async function observeOutcomeRows(id, rows, observer) {
+    if (observer === undefined)
+        return;
+    const historyIds = rows.flatMap((row) => (row.kind === "outcome" ? [row.outcome.historyId] : []));
+    if (historyIds.length > 0)
+        await observer(id, historyIds);
+}
+export async function observeStatusOutcome(status, observer) {
+    const snapshot = status.timeline;
+    if (snapshot.kind === "idle" && snapshot.outcome !== undefined)
+        await observer?.(status.id, [snapshot.outcome.outcome.historyId]);
+}
 function snapshotSelection(input) {
     return {
         aperture: input.aperture,
@@ -112,6 +125,7 @@ export async function bornLiveStatus(paths, expected, input, signal, readProject
     return {
         status: {
             id: soul.id,
+            birth: projectAkumaBirth(soul),
             life: currentLife,
             cwd: soul.cwd,
             allowed: soul.allowed,

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

@@ -1,5 +1,6 @@
+import { type AkumaCaller } from "./caller.js";
 import type { WorldRoot } from "../world.js";
-import { type LiveStatusObservation, type WaitReason } from "./akuma-observe.js";
+import { type OutcomeObserver, type LiveStatusObservation, type WaitReason } from "./akuma-observe.js";
 import type { AkumaStatus } from "./akuma.js";
 import { type TellResult, type TellWakeRuntime } from "./body.js";
 import { type CallInitialTell, type CallInitialTellAdmission } from "./call-initial-tell.js";
@@ -68,7 +69,8 @@ export declare function killAkumaWithRecovery(paths: AkumaPaths, recover?: (path
 export declare class AkumaOwner {
     readonly id: AkuId;
     private readonly worldPath;
-    constructor(id: AkuId, worldPath: WorldRoot);
+    private readonly outcomeObserved?;
+    constructor(id: AkuId, worldPath: WorldRoot, outcomeObserved?: OutcomeObserver | undefined);
     private get paths();
     private projectHistoryTurns;
     private exactHistory;
@@ -146,6 +148,8 @@ export declare class AkumaOwner {
     }>): Promise<InterruptAdmission>;
     fork(input: Readonly<{
         at: string;
+        caller?: AkumaCaller;
+        initiator?: string;
     }>): Promise<ForkReceipt>;
     kill(options?: Readonly<{
         signal?: AbortSignal;

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

@@ -1,6 +1,7 @@
+import { decodeAkumaCaller } from "./caller.js";
 import { randomUUID } from "node:crypto";
 import { AkumaNotBornError, AkumaProviderError } from "./akuma-errors.js";
-import { bornLiveStatus, bornStatus, defaultWaitComplete, waitForObservation, } from "./akuma-observe.js";
+import { bornLiveStatus, bornStatus, defaultWaitComplete, observeOutcomeRows, observeStatusOutcome, waitForObservation, } from "./akuma-observe.js";
 import { executeWaitAkuma } from "./akuma-wait.js";
 import { handoffPendingTells, spawnAkumaBody, wakeRecordedTell, } from "./body.js";
 import { admitCallInitialTell } from "./call-initial-tell.js";
@@ -88,9 +89,11 @@ export async function killAkumaWithRecovery(paths, recover, signal) {
 export class AkumaOwner {
     id;
     worldPath;
-    constructor(id, worldPath) {
+    outcomeObserved;
+    constructor(id, worldPath, outcomeObserved) {
         this.id = id;
         this.worldPath = worldPath;
+        this.outcomeObserved = outcomeObserved;
     }
     get paths() {
         return pathsForAkuId(this.worldPath, this.id);
@@ -109,11 +112,17 @@ export class AkumaOwner {
         return selectExactHistory((await this.projectHistoryTurns()).rows, input.id);
     }
     async status() {
-        return (await bornStatus(this.paths, this.id, { aperture: "monitoring" })).status;
+        const { status } = await bornStatus(this.paths, this.id, { aperture: "monitoring" });
+        await observeStatusOutcome(status, this.outcomeObserved);
+        return status;
     }
     async history(input = {}) {
-        if (input.id !== undefined)
-            return this.exactHistory(input);
+        if (input.id !== undefined) {
+            const exact = await this.exactHistory(input);
+            if (exact.kind === "exact")
+                await this.outcomeObserved?.(this.id, [exact.outcome.outcome.historyId]);
+            return exact;
+        }
         if (input.before !== undefined && input.since !== undefined) {
             throw new TypeError("Akuma history before and since are mutually exclusive");
         }
@@ -129,11 +138,13 @@ export class AkumaOwner {
         if (!Number.isSafeInteger(limit) || limit <= 0 || limit > 5_000) {
             throw new TypeError("Akuma history limit must be a positive safe integer no greater than 5000");
         }
-        return selectHistory(await this.projectHistoryTurns(), {
+        const history = selectHistory(await this.projectHistoryTurns(), {
             ...(input.before === undefined ? {} : { before: input.before }),
             ...(input.since === undefined ? {} : { since: input.since }),
             limit,
         });
+        await observeOutcomeRows(this.id, history.rows, this.outcomeObserved);
+        return history;
     }
     async waitReceipt(predicate = defaultWaitComplete, options = {}) {
         if (options.timeoutMs !== undefined && (!Number.isFinite(options.timeoutMs) || options.timeoutMs < 0)) {
@@ -143,6 +154,7 @@ export class AkumaOwner {
             path: this.worldPath,
             ids: [this.id],
             completion: "all",
+            ...(this.outcomeObserved === undefined ? {} : { outcomeObserved: this.outcomeObserved }),
             ...(options.timeoutMs === undefined ? {} : { timeoutMs: options.timeoutMs }),
             ...(options.signal === undefined ? {} : { signal: options.signal }),
             ...(predicate === defaultWaitComplete ? {} : { predicate }),
@@ -220,6 +232,8 @@ export class AkumaOwner {
                 if (tell === null)
                     throw new AkumaProviderError(`recorded Tell ${tellId} is missing from Heart`);
                 const outcome = await this.boundTellOutcome(tell);
+                if (outcome.historyId !== undefined)
+                    await this.outcomeObserved?.(this.id, [outcome.historyId]);
                 if (options.observe !== undefined) {
                     await options.observe(await bornLiveStatus(this.paths, this.id, { aperture: "monitoring", admittedTellId: tellId }));
                 }
@@ -237,7 +251,11 @@ export class AkumaOwner {
         if (tell.binding === undefined)
             return { outcome: null, completedAt: null };
         const end = (await readTurn(this.paths, tell.binding.turnSequence))?.end;
-        return { outcome: end?.outcome ?? null, completedAt: end?.completedAt ?? null };
+        return {
+            outcome: end?.outcome ?? null,
+            completedAt: end?.completedAt ?? null,
+            ...(end === undefined ? {} : { historyId: `turn/${tell.binding.turnSequence}` }),
+        };
     }
     async interrupt(body, options = {}) {
         const admitted = await this.admitInterrupt(body, options);
@@ -302,6 +320,7 @@ export class AkumaOwner {
         };
     }
     async fork(input) {
+        const caller = decodeAkumaCaller(input.caller);
         const source = await readSoul(this.paths);
         if (source === null)
             throw new AkumaNotBornError(this.id);
@@ -349,8 +368,10 @@ export class AkumaOwner {
                             allowed: source.allowed,
                             cwd: source.cwd,
                             origin: { kind: "fork", parent: this.id, at: input.at },
+                            ...(caller === undefined ? {} : { caller }),
                         },
                         birthSession,
+                        ...(input.initiator === undefined ? {} : { birthInitiator: input.initiator }),
                     });
                 },
             });
@@ -369,9 +390,10 @@ export class AkumaOwner {
     }
     async lastAnswer() {
         const turn = await readLastAnsweredTurn(this.paths);
-        return turn?.end?.outcome.kind === "answered"
-            ? { kind: "answer", answer: turn.end.outcome.answer }
-            : { kind: "no-answer" };
+        if (turn?.end?.outcome.kind !== "answered")
+            return { kind: "no-answer" };
+        await this.outcomeObserved?.(this.id, [`turn/${turn.sequence}`]);
+        return { kind: "answer", answer: turn.end.outcome.answer };
     }
 }
 /* ---------------------------------------------------------------------------

package/build/src/akuma/akuma-selection-execution.d.ts

@@ -1,5 +1,5 @@
 import type { WorldRoot } from "../world.js";
-import type { LiveStatusObservation } from "./akuma-observe.js";
+import type { LiveStatusObservation, OutcomeObserver } from "./akuma-observe.js";
 import type { AkumaStatus } from "./akuma.js";
 import type { TellResult } from "./body.js";
 import type { Schema } from "./schema.js";
@@ -18,6 +18,7 @@ type TellExecutionInput = Readonly<{
     signal?: AbortSignal;
     interrupt?: boolean;
     onObserve?: AskObserver;
+    outcomeObserved?: OutcomeObserver;
 }>;
 export declare function executeTellAkuma(input: TellExecutionInput): Promise<AkumaTellResult>;
 export declare function decodeAskObservation<T>(observation: AkumaAskObservation, schema: Schema<T>): AkumaAskObservation<T>;
@@ -37,6 +38,7 @@ export declare function observeAdmittedAskAkuma(input: Readonly<{
      */
     receipt?: TellResult;
     onObserve?: AskObserver;
+    outcomeObserved?: OutcomeObserver;
 }>): Promise<AkumaAskResult>;
 export declare function executeAskAkuma(input: TellExecutionInput & Readonly<{
     timeoutMs?: number;

package/build/src/akuma/akuma-selection-execution.js

@@ -64,7 +64,7 @@ export function decodeAskObservation(observation, schema) {
     }
 }
 export async function observeAdmittedAskAkuma(input) {
-    const owner = new AkumaOwner(input.id, input.path);
+    const owner = new AkumaOwner(input.id, input.path, input.outcomeObserved);
     const tell = input.receipt ?? (await owner.admittedReceipt(input.tellId));
     await input.onObserve?.admitted?.(tell, input.id);
     let settled;
@@ -118,6 +118,7 @@ export async function executeAskAkuma(input) {
         wake: admission.wake,
         ...(input.signal === undefined ? {} : { signal: input.signal }),
         ...(input.onObserve === undefined ? {} : { onObserve: input.onObserve }),
+        ...(input.outcomeObserved === undefined ? {} : { outcomeObserved: input.outcomeObserved }),
     });
 }
 export async function executeKillAkuma(input) {

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

@@ -1,6 +1,6 @@
 import type { AkumaAlias } from "../identity/selector.js";
 import type { WorldRoot } from "../world.js";
-import { type WaitReason } from "./akuma-observe.js";
+import { type OutcomeObserver, type WaitReason } from "./akuma-observe.js";
 import type { AkumaStatus } from "./akuma.js";
 import type { DispatchAssociation } from "./dispatch-association.js";
 import type { ActivityRow } from "./projection.js";
@@ -33,6 +33,7 @@ type WaitExecutionInput = Readonly<{
     signal?: AbortSignal;
     /** Internal custom completion judge over the full final observation where supplied. */
     predicate?: (status: AkumaStatus) => boolean;
+    outcomeObserved?: OutcomeObserver;
     /** Resolves one Akuma's identity facts; consulted once per Akuma a viewer first sees. */
     identity?: (id: AkumaStatus["id"]) => Promise<WaitIdentityFacts>;
     /** The selected set in the caller's order; a viewer's head and scoreboard follow it. */

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

@@ -1,5 +1,5 @@
 import { AkumaNotBornError } from "./akuma-errors.js";
-import { createLiveStatusReader, defaultWaitComplete, readLiveStatus, readWaitComplete, waitForObservation, } from "./akuma-observe.js";
+import { createLiveStatusReader, defaultWaitComplete, readLiveStatus, readWaitComplete, observeOutcomeRows, observeStatusOutcome, waitForObservation, } from "./akuma-observe.js";
 import { pathsForAkuId } from "./identity.js";
 const SHARED_ORDINARY_BUDGET = 30;
 async function observeWaitRound(path, ids, signal, readers) {
@@ -88,6 +88,9 @@ export async function executeWaitAkuma(input) {
             input.onSelected(ordered.map((id) => ({ id, ...facts.get(id) })));
         }
         const observeRound = async (round) => {
+            await Promise.all(round.observations.map(({ status, rows }) => input.observe === undefined
+                ? observeStatusOutcome(status, input.outcomeObserved)
+                : observeOutcomeRows(status.id, rows, input.outcomeObserved)));
             if (input.observe === undefined)
                 return;
             const observed = [];

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

@@ -3,7 +3,7 @@ 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";
+import { type AkuId, type AkumaPaths } from "./identity.js";
 export type AkumaListRow = Readonly<{
     id: AkuId;
     archetype: string;
@@ -34,6 +34,30 @@ export type AkumaListInput = Readonly<{
 }>;
 export declare const akumaStatusSchema: z.ZodObject<{
     id: z.ZodPipe<z.ZodString, z.ZodTransform<AkuId, string>>;
+    birth: 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<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">;
+        caller: z.ZodUnion<readonly [z.ZodDiscriminatedUnion<[z.ZodObject<{
+            kind: z.ZodLiteral<"akuma">;
+            world: z.ZodCustom<WorldRoot, WorldRoot>;
+            akuId: z.ZodPipe<z.ZodString, z.ZodTransform<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>;
     life: z.ZodEnum<{
         killed: "killed";
         hung: "hung";
@@ -441,10 +465,16 @@ export declare const akumaStatusSchema: z.ZodObject<{
     strandedReason: z.ZodOptional<z.ZodLiteral<"resume-unsupported">>;
 }, z.core.$strict>;
 export type AkumaStatus = z.infer<typeof akumaStatusSchema>;
-export declare function parseAkumaStatus(value: unknown): AkumaStatus;
-export declare function listAkumaArchetypes(path: WorldRoot, input?: Readonly<{
-    home?: string;
-}>): Promise<readonly string[]>;
+/** One recognized Akuma directory under this World's run root. */
+export type KnownAkuma = Readonly<{
+    id: AkuId;
+    paths: AkumaPaths;
+}>;
+/** Enumerate the recognized Akuma directories under this World's run root. */
+export declare function knownAkuma(path: WorldRoot, selected?: string): Promise<Readonly<{
+    runRoot: string;
+    rows: readonly KnownAkuma[];
+}>>;
 /**
  * The bounded recent-activity roster: native membership, semantic order and
  * observed extent. World Alias context is attached by the upper composition.

package/build/src/akuma/akuma.js

@@ -1,16 +1,18 @@
+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(),
     allowed: allowedActionsSchema,
@@ -18,12 +20,6 @@ export const akumaStatusSchema = z
     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 +55,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 +77,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 +107,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/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.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<{
@@ -93,6 +95,7 @@ type BodyRuntime = Readonly<{
     world: WorldRoot;
     externalCommands: Readonly<Record<string, ErasedRequestCommand>>;
 }>;
+export declare function recordPluginDiagnostic(paths: AkumaPaths, occurrence: string, error: unknown): Promise<void>;
 export declare function bodyProcessInput(launch: BodyLaunch, bodyModuleUrl?: string): Promise<{
     argv: string[];
     cwd: string;