@astrosheep/keiyaku 4.5.28 → 4.6.1

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<{
@@ -51,12 +61,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;
@@ -220,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<{
@@ -379,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<{
@@ -440,81 +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 { ReadonlyRestraint } from "./provider-recipe.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;
-    readonly?: true;
-    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,34 +1,19 @@
-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;
-    }
-});
-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(),
-]);
+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,
     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(),
 })
@@ -36,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

@@ -1,14 +1,15 @@
+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;
     path: string;
     provider: string;
     description?: string;
+    hidden?: boolean;
     options: ProviderOptions;
-    readonly?: true;
     allowed: AllowedActions;
 }>;
 export type ArchetypeCatalogRow = Readonly<{
@@ -19,9 +20,12 @@ 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;
+}>;
+/** One loaded archetype whose provider owner has decoded its execution but not yet admitted its options. */
+type PreparedArchetype = Omit<DecodedArchetype, "provider"> & Readonly<{
     provider: ProviderExecution;
-    readonly?: ReadonlyRestraint;
 }>;
 export declare class AkumaArchetypeError extends Error {
     readonly archetype: string;
@@ -35,12 +39,20 @@ 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>>;
+/** 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;
     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,12 +100,13 @@ 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))
+function archetypeBoolean(values, key) {
+    const value = values[key];
+    if (value === undefined)
         return undefined;
-    if (values.readonly !== true)
-        throw new TypeError("Akuma readonly must be true");
-    return true;
+    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);
@@ -126,14 +128,11 @@ 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 hidden = archetypeBoolean(values, "hidden");
     const allowedPresent = "allowed" in values;
     const allowed = allowedPresent ? decodeAllowedActions(values.allowed) : undefined;
     const systemPromptMode = archetypeEnum(values, "systemPromptMode", ["append", "replace"]);
@@ -142,10 +141,9 @@ function decodeArchetypeFields(values) {
         ...(provider === undefined ? {} : { provider }),
         ...(model === undefined ? {} : { model }),
         ...(effort === undefined ? {} : { effort }),
-        ...(readonly === undefined ? {} : { readonly }),
         ...(network === undefined ? {} : { network }),
-        ...(sandbox === undefined ? {} : { sandbox }),
         ...(description === undefined ? {} : { description }),
+        ...(hidden === undefined ? {} : { hidden }),
         ...(allowed === undefined ? {} : { allowed }),
         allowedPresent,
         ...(systemPromptMode === undefined ? {} : { systemPromptMode }),
@@ -164,11 +162,11 @@ 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 }),
             ...(fields.network === undefined ? {} : { network: fields.network }),
-            ...(fields.sandbox === undefined ? {} : { sandbox: fields.sandbox }),
             ...(systemPrompt.length === 0
                 ? {}
                 : {
@@ -176,7 +174,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,
     });
@@ -196,8 +193,9 @@ 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,
-        ...(local.readonly === true || base?.readonly === true ? { readonly: true } : {}),
         allowed,
     });
 }
@@ -242,14 +240,11 @@ 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 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)
@@ -260,7 +255,18 @@ 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);
+    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: limit === undefined ? visible : visible.slice(0, limit),
+        hasMore: limit === undefined ? false : visible.length > limit,
+    };
 }
 function record(value) {
     return value !== null && typeof value === "object" && !Array.isArray(value)
@@ -296,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",
@@ -314,10 +325,10 @@ function providerExecution(settings, name) {
         return decodeProviderRecipe({ name, ...builtin });
     throw new TypeError(`unknown provider ${name}`);
 }
-async function admitArchetype(archetype, settings, callReadonly) {
+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)
@@ -326,25 +337,32 @@ 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) {
+/** 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, input.readonly);
+    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));
 }