@astrosheep/keiyaku 4.6.7 → 4.6.8

package/README.md

@@ -186,6 +186,8 @@ lists every recognized namespace.
 npm install -g @astrosheep/keiyaku
 ```
 
+Pi loads the extension from the package source and invokes the `keiyaku` CLI from `PATH`, so Pi users must have that command installed and available in the host environment.
+
 Node ≥ 22.19. Product law lives in [`docs/`](docs/README.md).
 
 ## Source builds
@@ -194,8 +196,10 @@ Host integration sources live in `plugins/pi`, `plugins/claude`, `plugins/codex`
 and `plugins/opencode`. Shared skills live in `skills/`; the build copies them
 into each host package so native installations are self-contained. The separate
 `plugins/square` workspace is Keiyaku's internal Square observer, not a coding
-harness plugin. Installation recipes and Pi package metadata select the built
-assets under `build/plugins` and `build/skills`.
+harness plugin. Installation recipes and harness package metadata select the built
+assets under `build/plugins` and `build/skills`, except the Pi package metadata,
+which selects the source extension and `skills/` so a source checkout is loadable
+without a build.
 
 Building from source also builds the Windows launcher with Zig 0.14.1 or later. Install
 that system tool separately and make `zig` available on `PATH`, or set

package/build/plugins/pi/keiyaku.ts

@@ -1,13 +1,8 @@
-import { existsSync } from "node:fs";
-import { dirname, resolve } from "node:path";
-import { fileURLToPath } from "node:url";
 import type { ExtensionAPI, Theme } from "@earendil-works/pi-coding-agent";
 
 type ExecResult = Readonly<{ stdout: string; stderr: string; code: number }>;
 
 async function runStatus(pi: ExtensionAPI): Promise<ExecResult> {
-  const bundledCli = resolve(dirname(fileURLToPath(import.meta.url)), "../../src/cli/index.js");
-  if (existsSync(bundledCli)) return await pi.exec(process.execPath, [bundledCli, "status"]);
   return await pi.exec("keiyaku", ["status"]);
 }
 

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

@@ -1,3 +1,4 @@
+import { type AkumaCaller } from "./caller.js";
 import type { Settings } from "../settings.js";
 import type { WorldRoot } from "../world.js";
 import { type AllowedAction } from "./allowed.js";
@@ -17,6 +18,7 @@ export type AkumaCallInput = Readonly<{
     allowed?: readonly AllowedAction[];
     schema?: Schema<unknown>;
     initiator?: string;
+    caller?: AkumaCaller;
     signal?: AbortSignal;
 }>;
 type AkumaCallContext = Readonly<{

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

@@ -1,3 +1,4 @@
+import { decodeAkumaCaller } from "./caller.js";
 import { randomUUID } from "node:crypto";
 import { settings as readSettings } from "../settings.js";
 import { readAkumaBirthCwd } from "./akuma-observe.js";
@@ -7,7 +8,7 @@ import { AkumaArchetypeError, loadPreparedArchetype } from "./archetype.js";
 import { spawnAkumaBody } from "./body.js";
 import { canonicalBirthCwd } from "./call-input.js";
 import { requestForwardedAkumaCall } from "./call-request.js";
-import { archetypeName } from "./identity.js";
+import { validateAkumaName } from "../identity/normalize.js";
 import { PreparedCallAdmissionError, executePreparedCall } from "./publication.js";
 import { executionChannel } from "./requests.js";
 async function admitBodyRequest(input) {
@@ -24,6 +25,8 @@ async function admitBodyRequest(input) {
         ...(input.call.initialTell === undefined ? {} : { initialTell: input.call.initialTell }),
         ...(cwd === undefined ? {} : { cwd }),
         recipe: input.recipe,
+        ...(input.call.initiator === undefined ? {} : { birthInitiator: input.call.initiator }),
+        ...(input.call.contractId === undefined ? {} : { contractId: input.call.contractId }),
         ...(input.call.signal === undefined ? {} : { signal: input.call.signal }),
     });
     const bornCwd = await readAkumaBirthCwd(input.path, response.id);
@@ -50,6 +53,7 @@ async function admitDirect(input) {
         result = await executePreparedCall({
             archetype: input.archetype.name,
             cwd,
+            ...(input.call.caller === undefined ? {} : { caller: input.call.caller }),
             ...(input.call.initialTell === undefined ? {} : { initialTell: input.call.initialTell }),
             ...(input.call.signal === undefined ? {} : { signal: input.call.signal }),
             custody: {
@@ -59,6 +63,7 @@ async function admitDirect(input) {
                 spawn: async (launch) => await spawnAkumaBody({
                     paths: launch.paths,
                     seed: launch.seed,
+                    ...(input.call.initiator === undefined ? {} : { birthInitiator: input.call.initiator }),
                     ...(input.call.contractId === undefined ? {} : { completion: { contractId: input.call.contractId } }),
                 }),
                 admitInitialTell: async ({ id, initialTell, signal }) => await new AkumaOwner(id, input.path).admitInitialTell(initialTell, {
@@ -93,7 +98,8 @@ async function admitDirect(input) {
  * then invoke the P3 prepared-call executor under local or request custody.
  */
 export async function admitAkumaCall(path, configuration, input, context) {
-    const name = archetypeName(input.archetype);
+    decodeAkumaCaller(input.caller);
+    const name = validateAkumaName(input.archetype);
     const home = configuration.home === undefined ? {} : { home: configuration.home };
     const settings = configuration.settings ?? (await readSettings({ root: path, ...home }));
     const archetype = await loadPreparedArchetype({ name, project: path, ...home, settings });

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

@@ -1,3 +1,4 @@
+import type { AkumaCaller } from "./caller.js";
 import type { Settings } from "../settings.js";
 import type { WorldRoot } from "../world.js";
 import { type InterruptReceipt } from "./akuma-owner.js";
@@ -24,12 +25,21 @@ export type AkumaHistoryOptions = Readonly<{
 export type AkumaSignalOptions = Readonly<{
     signal?: AbortSignal;
 }>;
+/** Observes only plugin diagnostics produced in this host, never remote Body logs. */
+export type AkumaHostOptions = Readonly<{
+    reportDiagnostic?: (message: string) => void;
+}>;
+/** Capture the observer capability, not the caller's mutable options object. */
+export declare function captureAkumaHostDiagnostic(host: AkumaHostOptions | undefined): AkumaHostOptions["reportDiagnostic"];
 export type AkumaBirthInput = Readonly<{
     root: WorldRoot;
     cwd?: string;
     home?: string;
     settings?: Settings;
     allowed?: readonly AllowedAction[];
+    caller?: AkumaCaller;
+    initiator?: string;
+    host?: AkumaHostOptions;
 }>;
 export type AkumaTellOptions = AkumaSignalOptions & Readonly<{
     interrupt?: boolean;
@@ -43,10 +53,11 @@ export type { AkumaAskResult, AkumaTellResult, InterruptReceipt, KillEvidence };
 export declare class Akuma {
     readonly id: AkuId;
     private readonly root;
+    private readonly reportDiagnostic;
     private constructor();
     private owner;
     static birth(archetype: string, input: AkumaBirthInput): Promise<Akuma>;
-    static select(root: WorldRoot, selector: string): Akuma;
+    static select(root: WorldRoot, selector: string, host?: AkumaHostOptions): Akuma;
     tell(text: string, options?: AkumaTellOptions): Promise<AkumaTellResult>;
     ask(text: string, options?: AkumaAskOptions<string>): Promise<AkumaAskResult<string>>;
     ask<T>(text: string, options: AkumaAskOptions<T> & Readonly<{

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

@@ -1,4 +1,4 @@
-import { outcomePluginObserver } from "../plugin/akuma-signals.js";
+import { outcomePluginObserver, stderrPluginDiagnostic } from "../plugin/akuma-signals.js";
 import { abortable } from "./abort.js";
 import { admitAkumaCall } from "./akuma-call.js";
 import { defaultWaitComplete } from "./akuma-observe.js";
@@ -6,6 +6,20 @@ import { AkumaOwner } from "./akuma-owner.js";
 import { decodeAskObservation, executeAskAkuma, executeTellAkuma } from "./akuma-selection-execution.js";
 import { parseAkuId } from "./identity.js";
 import { schemaFromStandard, schemaJsonText } from "./schema.js";
+/** Capture the observer capability, not the caller's mutable options object. */
+export function captureAkumaHostDiagnostic(host) {
+    if (host === undefined)
+        return undefined;
+    if (typeof host !== "object" || host === null || Array.isArray(host))
+        throw new TypeError("Akuma host options must be an object");
+    const unknown = Object.keys(host).find((key) => key !== "reportDiagnostic");
+    if (unknown !== undefined)
+        throw new TypeError(`Akuma host options has unknown field: ${unknown}`);
+    const reportDiagnostic = host.reportDiagnostic;
+    if (reportDiagnostic !== undefined && typeof reportDiagnostic !== "function")
+        throw new TypeError("Akuma host reportDiagnostic must be a function");
+    return reportDiagnostic;
+}
 function signalOption(value) {
     if (value === undefined)
         return undefined;
@@ -16,13 +30,15 @@ function signalOption(value) {
 export class Akuma {
     id;
     root;
-    constructor(id, root) {
+    reportDiagnostic;
+    constructor(id, root, reportDiagnostic) {
         this.id = id;
         this.root = root;
+        this.reportDiagnostic = reportDiagnostic;
         Object.freeze(this);
     }
     owner(observing = false) {
-        return new AkumaOwner(this.id, this.root, observing ? outcomePluginObserver({ world: this.root, reportDiagnostic: console.error }) : undefined);
+        return new AkumaOwner(this.id, this.root, observing ? outcomePluginObserver({ world: this.root, reportDiagnostic: this.reportDiagnostic }) : undefined);
     }
     static async birth(archetype, input) {
         if (typeof input !== "object" || input === null || Array.isArray(input)) {
@@ -30,6 +46,7 @@ export class Akuma {
         }
         if (typeof input.root !== "string")
             throw new TypeError("Akuma birth root must be a WorldRoot");
+        const reportDiagnostic = captureAkumaHostDiagnostic(input.host) ?? stderrPluginDiagnostic;
         const admitted = await admitAkumaCall(input.root, {
             ...(input.home === undefined ? {} : { home: input.home }),
             ...(input.settings === undefined ? {} : { settings: input.settings }),
@@ -37,15 +54,18 @@ export class Akuma {
             archetype,
             ...(input.cwd === undefined ? {} : { cwd: input.cwd }),
             ...(input.allowed === undefined ? {} : { allowed: input.allowed }),
+            ...(input.caller === undefined ? {} : { caller: input.caller }),
+            ...(input.initiator === undefined ? {} : { initiator: input.initiator }),
         }, {});
         if (admitted.failure !== undefined)
             throw admitted.failure;
-        return new Akuma(admitted.id, input.root);
+        return new Akuma(admitted.id, input.root, reportDiagnostic);
     }
-    static select(root, selector) {
+    static select(root, selector, host) {
         if (typeof root !== "string")
             throw new TypeError("Akuma.select root must be a WorldRoot");
-        return new Akuma(parseAkuId(selector).id, root);
+        const reportDiagnostic = captureAkumaHostDiagnostic(host) ?? stderrPluginDiagnostic;
+        return new Akuma(parseAkuId(selector).id, root, reportDiagnostic);
     }
     async tell(text, options = {}) {
         if (typeof text !== "string")
@@ -85,7 +105,7 @@ export class Akuma {
         const result = await executeAskAkuma({
             path: this.root,
             id: this.id,
-            outcomeObserved: outcomePluginObserver({ world: this.root, reportDiagnostic: console.error }),
+            outcomeObserved: outcomePluginObserver({ world: this.root, reportDiagnostic: this.reportDiagnostic }),
             body: text,
             ...(options.timeoutMs === undefined ? {} : { timeoutMs: options.timeoutMs }),
             ...(schema === undefined ? {} : { schemaJson: schemaJsonText(schema) }),

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";
@@ -124,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,3 +1,4 @@
+import { type AkumaCaller } from "./caller.js";
 import type { WorldRoot } from "../world.js";
 import { type OutcomeObserver, type LiveStatusObservation, type WaitReason } from "./akuma-observe.js";
 import type { AkumaStatus } from "./akuma.js";
@@ -147,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,3 +1,4 @@
+import { decodeAkumaCaller } from "./caller.js";
 import { randomUUID } from "node:crypto";
 import { AkumaNotBornError, AkumaProviderError } from "./akuma-errors.js";
 import { bornLiveStatus, bornStatus, defaultWaitComplete, observeOutcomeRows, observeStatusOutcome, waitForObservation, } from "./akuma-observe.js";
@@ -319,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);
@@ -366,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 }),
                     });
                 },
             });

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<{