@astrosheep/keiyaku 4.0.2 → 4.0.4

package/build/integrations/marketplace/plugins/keiyaku/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "keiyaku",
-  "version": "0.1.0+codex.20260815181541",
+  "version": "0.1.0+codex.20260818034655",
   "description": "Use the Keiyaku contract, task, and Akuma CLI.",
   "author": { "name": "Keiyaku" },
   "skills": "./skills/"

package/build/integrations/marketplace/plugins/keiyaku/.codex-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "keiyaku",
-  "version": "0.1.0+codex.20260815181541",
+  "version": "0.1.0+codex.20260818034655",
   "description": "Use the Keiyaku contract, task, and Akuma CLI.",
   "author": {
     "name": "Keiyaku"

package/build/integrations/marketplace/plugins/keiyaku/package.json

@@ -1,6 +1,6 @@
 {
   "name": "keiyaku-harness",
-  "version": "0.1.0+codex.20260815181541",
+  "version": "0.1.0+codex.20260818034655",
   "type": "module",
   "main": "./opencode.js",
   "keywords": ["pi-package"],

package/build/integrations/marketplace/plugins/keiyaku/skills/keiyaku/SKILL.md

@@ -31,7 +31,7 @@ keiyaku -C <repo> review [<contract>|@<contract>] --satisfied
 ```
 
 ```bash
-keiyaku -C <cwd> call <akuma-name> [--contract <kei/...>] [--alias @name] [--wait <duration> | -d | --detach] [--json] (<prompt> | -)
+keiyaku -C <cwd> call <akuma-name> [--contract <kei/...>] [--alias @name] [--allowed <product.action>]... [--wait <duration> | -d | --detach] [--json] (<prompt> | -)
 keiyaku -C <repo> wait <akuma-selector>... [--any | --all]
 keiyaku -C <repo> tell <aku/...|@alias> (<prompt> | -)
 ```

package/build/integrations/marketplace/plugins/keiyaku/skills/keiyaku-akuma/SKILL.md

@@ -13,7 +13,7 @@ is accepted; the identity underneath never changes.
 ## Start One
 
 ```bash
-keiyaku -C <cwd> call <akuma-name> [--alias @name] [--wait <duration> | -d | --detach] [--json] (<prompt> | -)
+keiyaku -C <cwd> call <akuma-name> [--alias @name] [--allowed <product.action>]... [--wait <duration> | -d | --detach] [--json] (<prompt> | -)
 ```
 
 Give the worker's initial prompt as one argument (quote it when it contains

package/build/integrations/marketplace/plugins/keiyaku/skills/keiyaku-bind/SKILL.md

@@ -102,6 +102,11 @@ Decidable without consulting you.>
 KEIYAKU
 ~~~~
 
+Use separate fences for checks that need separate timeouts or results. Fences
+run top-to-bottom, and later fences may use earlier outputs. Put setup/build
+before its consumers; use `&&` in one fence only when the consumer must stop
+if setup fails.
+
 Each declaration may set an individual timeout in its fence info string, using
 an explicit duration unit such as `bash timeout=5m`. Omit it for an unbounded
 declaration; there is no Verification-wide timeout.

package/build/integrations/marketplace/plugins/keiyaku/skills/keiyaku-task/SKILL.md

@@ -1,6 +1,8 @@
 ---
 name: keiyaku-task
-description: "Use when planning work in a Keiyaku v4 repo: add tasks, wire dependencies, inspect readiness, and track lifecycle."
+description: >-
+  Use when recording, decomposing, or tracking a complex task, typically
+  involving three or more steps.
 ---
 
 # Keiyaku Task

package/build/integrations/marketplace/plugins/keiyaku/skills/keiyaku-workflow/SKILL.md

@@ -165,19 +165,20 @@ old Contract onto a different delivery.
 
 ## Audit Before Delivery
 
-Audit is how you see a delivery before it exists:
+Audit is an evidence window for a prospective delivery:
 
 ```bash
 keiyaku audit <contract> --diff
 ```
 
-Audit answers three already-adjudicated questions: candidate, Verification,
-and target. It uses the same candidate preparation as deliver, shows the
-prospective identity and optional requested diff, and runs declared
-Verification against that candidate. A terminal run records ordinary
-subject-bound `verified` testimony; it does not record a delivery or request
-placement. Read those three answers instead of trusting a worker's completion
-report.
+It aggregates facts from the same candidate preparation used by `deliver`:
+the prospective candidate and integration identities, the requested diff, the
+declared Verification commands and their observed results, and the target
+placement observation. A terminal run may record subject-bound `verified`
+testimony for those observed commands; it does not deliver, request placement,
+satisfy a review gate, or decide whether the candidate should land. The
+coordinator judges the returned facts; a worker's completion report is not a
+substitute for them.
 
 ## Deliver
 

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

@@ -3,6 +3,7 @@ import { type AkuId } from "./identity.js";
 import { type ActivityHistory, type ActivitySnapshot } from "./projection.js";
 import { type Settings } from "../settings.js";
 import type { WorldRoot } from "../world.js";
+import { type AllowedAction } from "./allowed.js";
 export type AkumaListRow = Readonly<{
     id: AkuId;
     archetype: string;
@@ -36,6 +37,22 @@ export type AkumaList = Readonly<{
 export type AkumaListInput = Readonly<{
     archetype?: string;
 }>;
+export type AkumaCallExecution = Readonly<{
+    cwd: string;
+    source: "input" | "caller" | "process" | "world";
+}>;
+declare const CALL_EXECUTION: unique symbol;
+declare const CALL_WITH_CONTEXT: unique symbol;
+export type AkumaCallInput = Readonly<{
+    archetype: string;
+    body: string;
+    cwd?: string;
+    allowed?: readonly AllowedAction[];
+}>;
+type AkumaCallContext = Readonly<{
+    initiatorCwd?: string;
+    cwdCanonical?: true;
+}>;
 export type TellResult = Readonly<{
     admission: Readonly<{
         tellId: string;
@@ -76,8 +93,7 @@ export declare class AkumaNotBornError extends Error {
     readonly kind = "akuma-not-born";
     constructor(id: AkuId);
 }
-/** Package-internal action observation; it uses the same snapshot selector as status. */
-export declare function readActionFeedbackStatus(worldPath: WorldRoot, id: AkuId): Promise<AkumaStatus>;
+export declare function tellAkumaWithId(worldPath: WorldRoot, id: AkuId, body: string, tellId: string, recordedAt?: string): Promise<TellResult>;
 export type BudgetedStatusObservation = Readonly<{
     status: AkumaStatus;
     ordinarySelected: number;
@@ -86,10 +102,13 @@ export type BudgetedStatusObservation = Readonly<{
 export declare function readBudgetedStatus(worldPath: WorldRoot, id: AkuId, input: Readonly<{
     ordinaryBudget: number;
 }>): Promise<BudgetedStatusObservation>;
+/** Package-internal birth projection used by the composed Library call result. */
+export declare function readAkumaBirthCwd(worldPath: WorldRoot, id: AkuId): Promise<string>;
 export declare class AkumaHandle {
     readonly id: AkuId;
     private readonly worldPath;
-    constructor(id: AkuId, worldPath: WorldRoot);
+    readonly [CALL_EXECUTION]?: AkumaCallExecution;
+    constructor(id: AkuId, worldPath: WorldRoot, execution?: AkumaCallExecution);
     private get paths();
     status(): Promise<AkumaStatus>;
     history(input?: Readonly<{
@@ -108,26 +127,30 @@ export declare class AkumaHandle {
     kill(): Promise<KillEvidence>;
     lastAnswer(): Promise<LastAnswer>;
 }
+/** Package-internal provenance retained only by the handle returned from call. */
+export declare function akumaCallExecution(handle: AkumaHandle): AkumaCallExecution | undefined;
 export type LastAnswer = Readonly<{
     kind: "answer";
     answer: string;
 }> | Readonly<{
     kind: "no-answer";
 }>;
+type AkumaConfiguration = Readonly<{
+    home?: string;
+    settings?: Settings;
+}>;
 export declare class Akuma {
     private readonly path;
-    private readonly configuredSettings?;
+    private readonly configuration;
     private constructor();
-    static of(root: WorldRoot, settings?: Settings): Akuma;
-    private settings;
+    static of(root: WorldRoot, input?: AkumaConfiguration): Akuma;
     of(input: Readonly<{
         id: string;
     }>): AkumaHandle;
     listArchetypes(): Promise<readonly string[]>;
-    call(input: Readonly<{
-        archetype: string;
-        body: string;
-        cwd?: string;
-    }>): Promise<AkumaHandle>;
+    call(input: AkumaCallInput): Promise<AkumaHandle>;
+    [CALL_WITH_CONTEXT](input: AkumaCallInput, context: AkumaCallContext): Promise<AkumaHandle>;
     list(input?: AkumaListInput): Promise<AkumaList>;
 }
+/** Package-internal call path for a composition owner that already canonicalized cwd. */
+export declare function callAkumaWithContext(akuma: Akuma, input: AkumaCallInput, context: AkumaCallContext): Promise<AkumaHandle>;

package/build/src/akuma/akuma.js

@@ -1,8 +1,8 @@
 import { randomUUID } from "node:crypto";
-import { readdir } from "node:fs/promises";
+import { readdir, realpath, stat } from "node:fs/promises";
 import { resolve } from "node:path";
 import { CONTROL_RESPONSE_MS, spawnAkumaBody } from "./body.js";
-import { HeldAkumaLeash, activitySlice, life, lifeAt, probeLeash, readHeart, readLastAnsweredTurn, readForkPoint, readKill, readSeal, readSoul, recordTell, requestPause, requestStop, } from "./heart/index.js";
+import { HeldAkumaLeash, activitySlice, isHeartAbsent, life, lifeAt, probeLeash, readHeart, readLastAnsweredTurn, readForkPoint, readKill, readSeal, readSoul, recordTell, requestPause, requestStop, } from "./heart/index.js";
 import { akuIdFromDirectoryName, akumaPaths, akumaRunRoot, parseAkuId, pathsForAkuId, archetypeName, } from "./identity.js";
 import { ordinarySelectedCount, ordinarySnapshotBudget, projectTurns, selectActivitySnapshot, selectHistory, selectSnapshot, } from "./projection.js";
 import { listArchetypes as readArchetypes, loadArchetype } from "./archetype.js";
@@ -10,7 +10,22 @@ import { publishAkuma } from "./publication.js";
 import { resolveProviderExecution } from "./providers/index.js";
 import { injectedBodyRequests, requestBodyCall } from "./requests.js";
 import { settings as readSettings } from "../settings.js";
+import { decodeAllowedActions, } from "./allowed.js";
 const POLL_MS = 25;
+async function canonicalBirthCwd(input) {
+    const selected = resolve(input);
+    try {
+        const canonical = await realpath(selected);
+        if (!(await stat(canonical)).isDirectory())
+            throw new Error("not a directory");
+        return canonical;
+    }
+    catch {
+        throw new Error(`cwd is not an existing directory: ${input}`);
+    }
+}
+const CALL_EXECUTION = Symbol("akuma-call-execution");
+const CALL_WITH_CONTEXT = Symbol("akuma-call-with-context");
 export class AkumaNotBornError extends Error {
     id;
     kind = "akuma-not-born";
@@ -33,9 +48,8 @@ async function takeLeashUntil(paths, deadline) {
         await wait(POLL_MS);
     }
 }
-async function recordTellBody(paths, akuma, body) {
-    const id = randomUUID();
-    const admitted = await recordTell(paths, { kind: "tell", id, body, recordedAt: new Date().toISOString() });
+async function recordTellBody(paths, akuma, body, id = randomUUID(), recordedAt = new Date().toISOString()) {
+    const admitted = await recordTell(paths, { kind: "tell", id, body, recordedAt });
     if (admitted.kind === "not-born")
         throw new AkumaNotBornError(akuma);
     return { kind: "recorded", tellId: admitted.tell.id };
@@ -48,10 +62,34 @@ async function wakeTell(paths, tellId) {
     catch (error) {
         return {
             admission: { tellId, fact: "recorded" },
-            wake: { kind: "failed", diagnostic: error instanceof Error ? error.message : String(error) },
+            wake: { kind: "failed", diagnostic: diagnostic(error) },
         };
     }
 }
+export async function tellAkumaWithId(worldPath, id, body, tellId, recordedAt = new Date().toISOString()) {
+    const paths = pathsForAkuId(worldPath, id);
+    const recorded = await recordTellBody(paths, id, body, tellId, recordedAt);
+    return await wakeTell(paths, recorded.tellId);
+}
+function diagnostic(error) {
+    return error instanceof Error ? error.message : String(error);
+}
+async function fleetListRow(paths, expected) {
+    const snapshot = await readHeart(paths);
+    if (snapshot.soul !== null)
+        return await bornListRow(paths, expected, snapshot);
+    try {
+        if (await probeLeash(paths) === "held")
+            return { id: expected, life: "unborn" };
+        const seal = await readSeal(paths);
+        return seal === null ? { id: expected, life: "unborn" } : { id: expected, life: "stillborn", seal };
+    }
+    catch (error) {
+        if (isHeartAbsent(error))
+            return { id: expected, life: "unborn" };
+        throw error;
+    }
+}
 async function bornListRow(paths, expected, snapshot) {
     snapshot ??= await readHeart(paths);
     if (snapshot.soul === null)
@@ -81,7 +119,7 @@ async function bornStatus(paths, expected, budget) {
     const resumeUnsupported = current.life === "stranded"
         && snapshot.latestSession?.provider === snapshot.soul.provider.name
         && resolveProviderExecution(snapshot.soul.provider).adapter.resume === undefined;
-    const slice = await activitySlice(paths, { limit: Number.MAX_SAFE_INTEGER });
+    const slice = await activitySlice(paths);
     return {
         id: current.id,
         life: current.life,
@@ -92,10 +130,6 @@ async function bornStatus(paths, expected, budget) {
             : selectSnapshot(projectTurns(slice.rows), budget),
     };
 }
-/** Package-internal action observation; it uses the same snapshot selector as status. */
-export async function readActionFeedbackStatus(worldPath, id) {
-    return await bornStatus(pathsForAkuId(worldPath, id), id);
-}
 /** Package-internal budgeted observation; Fleet allocates, Akuma still selects. */
 export async function readBudgetedStatus(worldPath, id, input) {
     if (!Number.isSafeInteger(input.ordinaryBudget) || input.ordinaryBudget < 0) {
@@ -104,15 +138,22 @@ export async function readBudgetedStatus(worldPath, id, input) {
     const status = await bornStatus(pathsForAkuId(worldPath, id), id, ordinarySnapshotBudget(input.ordinaryBudget));
     return { status, ordinarySelected: ordinarySelectedCount(status.timeline) };
 }
-function diagnostic(error) {
-    return error instanceof Error ? error.message : String(error);
+/** Package-internal birth projection used by the composed Library call result. */
+export async function readAkumaBirthCwd(worldPath, id) {
+    const soul = await readSoul(pathsForAkuId(worldPath, id));
+    if (soul === null)
+        throw new AkumaNotBornError(id);
+    return soul.cwd;
 }
 export class AkumaHandle {
     id;
     worldPath;
-    constructor(id, worldPath) {
+    [CALL_EXECUTION];
+    constructor(id, worldPath, execution) {
         this.id = id;
         this.worldPath = worldPath;
+        if (execution !== undefined)
+            this[CALL_EXECUTION] = execution;
     }
     get paths() {
         return pathsForAkuId(this.worldPath, this.id);
@@ -133,11 +174,7 @@ export class AkumaHandle {
         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");
         }
-        const slice = await activitySlice(this.paths, {
-            ...(input.before === undefined ? {} : { before: input.before }),
-            ...(input.since === undefined ? {} : { since: input.since }),
-            limit: 5_000,
-        });
+        const slice = await activitySlice(this.paths);
         return selectHistory(projectTurns(slice.rows, {
             lowestRetained: slice.lowestRetained,
             highest: slice.highest,
@@ -254,6 +291,7 @@ export class AkumaHandle {
                         provider: source.provider,
                         options: source.options,
                         ...(source.readonly === undefined ? {} : { readonly: source.readonly }),
+                        allowed: source.allowed,
                         cwd: source.cwd,
                         origin: { kind: "fork", parent: this.id, at: input.at },
                         confinement: source.confinement,
@@ -264,7 +302,11 @@ export class AkumaHandle {
             return { kind: "forked", child: child.id };
         }
         catch (error) {
-            return { kind: "upstream-forked", childSession, diagnostic: diagnostic(error) };
+            return {
+                kind: "upstream-forked",
+                childSession,
+                diagnostic: diagnostic(error),
+            };
         }
     }
     async kill() {
@@ -309,52 +351,75 @@ export class AkumaHandle {
             : { kind: "no-answer" };
     }
 }
+/** Package-internal provenance retained only by the handle returned from call. */
+export function akumaCallExecution(handle) {
+    return handle[CALL_EXECUTION];
+}
 export class Akuma {
     path;
-    configuredSettings;
-    constructor(path, configuredSettings) {
+    configuration;
+    constructor(path, configuration) {
         this.path = path;
-        this.configuredSettings = configuredSettings;
+        this.configuration = configuration;
     }
-    static of(root, settings) {
+    static of(root, input = {}) {
         if (typeof root !== "string")
             throw new TypeError("Akuma.of root must be a WorldRoot");
-        return new Akuma(root, settings);
-    }
-    async settings() {
-        return this.configuredSettings ?? await readSettings({ root: this.path });
+        return new Akuma(root, input);
     }
     of(input) {
         return new AkumaHandle(parseAkuId(input.id).id, this.path);
     }
     async listArchetypes() {
-        return readArchetypes({ settings: await this.settings() });
+        return readArchetypes(this.configuration.home === undefined ? {} : { home: this.configuration.home });
     }
     async call(input) {
+        return await this[CALL_WITH_CONTEXT](input, { initiatorCwd: process.cwd() });
+    }
+    async [CALL_WITH_CONTEXT](input, context) {
         const name = archetypeName(input.archetype);
-        const archetype = await loadArchetype({ name, settings: await this.settings() });
-        const provider = archetype.adapter;
-        const cwd = resolve(input.cwd ?? this.path);
-        const recipe = Object.freeze({
+        const home = this.configuration.home === undefined ? {} : { home: this.configuration.home };
+        const settings = this.configuration.settings ?? await readSettings({ root: this.path, ...home });
+        const archetype = await loadArchetype({ name, ...home, settings });
+        const allowed = input.allowed === undefined
+            ? archetype.allowed
+            : decodeAllowedActions(input.allowed, "Akuma call allowed");
+        const requests = injectedBodyRequests();
+        const requestRecipe = Object.freeze({
             ...(archetype.description === undefined ? {} : { description: archetype.description }),
             provider: archetype.provider,
             options: archetype.options,
             ...(archetype.readonly === undefined ? {} : { readonly: archetype.readonly }),
-            confinement: provider.confinement({ cwd, options: archetype.options }),
+            allowed,
         });
-        const requests = injectedBodyRequests();
         if (requests !== null) {
+            const cwd = input.cwd === undefined
+                ? undefined
+                : context?.cwdCanonical === true ? input.cwd : await canonicalBirthCwd(input.cwd);
             const child = await requestBodyCall({
                 directory: requests,
                 id: randomUUID(),
                 world: this.path,
                 archetype: name,
                 body: input.body,
-                cwd,
-                recipe,
+                ...(cwd === undefined ? {} : { cwd }),
+                recipe: requestRecipe,
+            });
+            const bornCwd = await readAkumaBirthCwd(this.path, child);
+            return new AkumaHandle(child, this.path, {
+                cwd: bornCwd,
+                source: cwd === undefined ? "caller" : "input",
             });
-            return new AkumaHandle(child, this.path);
         }
+        const initiatorCwd = context.initiatorCwd;
+        const selectedCwd = input.cwd ?? initiatorCwd ?? this.path;
+        const cwd = input.cwd !== undefined && context?.cwdCanonical === true
+            ? input.cwd
+            : await canonicalBirthCwd(selectedCwd);
+        const recipe = Object.freeze({
+            ...requestRecipe,
+            confinement: archetype.adapter.confinement({ cwd, options: archetype.options }),
+        });
         const published = await publishAkuma({
             worldPath: this.path,
             archetype: archetype.name,
@@ -363,18 +428,17 @@ export class Akuma {
                 seed: {
                     id: allocated.id,
                     archetype: allocated.archetype,
-                    ...(archetype.description === undefined ? {} : { description: archetype.description }),
-                    provider: archetype.provider,
-                    options: archetype.options,
-                    ...(archetype.readonly === undefined ? {} : { readonly: archetype.readonly }),
+                    ...recipe,
                     cwd,
                     origin: { kind: "direct" },
-                    confinement: recipe.confinement,
                 },
                 initialBody: input.body,
             }),
         });
-        return new AkumaHandle(published.id, this.path);
+        return new AkumaHandle(published.id, this.path, {
+            cwd,
+            source: input.cwd !== undefined ? "input" : initiatorCwd === undefined ? "world" : "process",
+        });
     }
     async list(input = {}) {
         if (typeof input !== "object" || input === null || Array.isArray(input)) {
@@ -399,28 +463,20 @@ export class Akuma {
         }
         const rows = [];
         for (const name of names) {
+            let physical;
             try {
-                const physical = akuIdFromDirectoryName(name);
-                if (selected !== undefined && physical.archetype !== selected)
-                    continue;
-                const paths = akumaPaths({ runRoot, archetype: physical.archetype, suffix: physical.suffix });
-                const snapshot = await readHeart(paths);
-                if (snapshot.soul !== null) {
-                    rows.push(await bornListRow(paths, physical.id, snapshot));
-                    continue;
-                }
-                if (await probeLeash(paths) === "held") {
-                    rows.push({ id: physical.id, life: "unborn" });
-                    continue;
-                }
-                const seal = await readSeal(paths);
-                rows.push(seal === null
-                    ? { id: physical.id, life: "unborn" }
-                    : { id: physical.id, life: "stillborn", seal });
+                physical = akuIdFromDirectoryName(name);
             }
             catch {
                 continue;
             }
+            if (selected !== undefined && physical.archetype !== selected)
+                continue;
+            const paths = akumaPaths({ runRoot, archetype: physical.archetype, suffix: physical.suffix });
+            try {
+                rows.push(await fleetListRow(paths, physical.id));
+            }
+            catch { }
         }
         return {
             rows,
@@ -428,3 +484,7 @@ export class Akuma {
         };
     }
 }
+/** Package-internal call path for a composition owner that already canonicalized cwd. */
+export async function callAkumaWithContext(akuma, input, context) {
+    return await akuma[CALL_WITH_CONTEXT](input, context);
+}

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

@@ -0,0 +1,7 @@
+export declare const ALLOWED_ACTIONS: readonly ["akuma.call", "akuma.kill", "akuma.tell", "contract.deliver", "task.add", "task.addDocument", "task.compose", "task.done", "task.drop", "task.hold", "task.resume", "task.start", "task.stop", "task.update"];
+export type AllowedAction = (typeof ALLOWED_ACTIONS)[number];
+export type AllowedActions = readonly AllowedAction[];
+export declare function isAllowedAction(value: unknown): value is AllowedAction;
+export declare function decodeAllowedActions(value: unknown, label?: string): AllowedActions;
+export declare function effectiveAllowedActions(value: unknown): AllowedActions;
+export declare function clipAllowedActions(requested: AllowedActions, parent: AllowedActions): AllowedActions;

package/build/src/akuma/allowed.js

@@ -0,0 +1,40 @@
+export const ALLOWED_ACTIONS = Object.freeze([
+    "akuma.call",
+    "akuma.kill",
+    "akuma.tell",
+    "contract.deliver",
+    "task.add",
+    "task.addDocument",
+    "task.compose",
+    "task.done",
+    "task.drop",
+    "task.hold",
+    "task.resume",
+    "task.start",
+    "task.stop",
+    "task.update",
+]);
+const ALLOWED_ACTION_SET = new Set(ALLOWED_ACTIONS);
+export function isAllowedAction(value) {
+    return typeof value === "string" && ALLOWED_ACTION_SET.has(value);
+}
+export function decodeAllowedActions(value, label = "allowed") {
+    if (!Array.isArray(value))
+        throw new TypeError(`${label} must be an array`);
+    const seen = new Set();
+    for (const action of value) {
+        if (!isAllowedAction(action))
+            throw new TypeError(`${label} contains an unknown action: ${String(action)}`);
+        if (seen.has(action))
+            throw new TypeError(`${label} contains a duplicate action: ${action}`);
+        seen.add(action);
+    }
+    return Object.freeze([...seen].sort());
+}
+export function effectiveAllowedActions(value) {
+    return value === undefined ? ALLOWED_ACTIONS : decodeAllowedActions(value);
+}
+export function clipAllowedActions(requested, parent) {
+    const ceiling = new Set(parent);
+    return Object.freeze(requested.filter((action) => ceiling.has(action)));
+}

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

@@ -1,12 +1,14 @@
 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 AllowedActions } from "./allowed.js";
 type DecodedArchetype = Readonly<{
     name: string;
     path: string;
     provider: string;
     description?: string;
     options: ProviderOptions;
+    allowed: AllowedActions;
 }>;
 export type ArchetypeCatalogRow = Readonly<{
     name: string;
@@ -27,14 +29,15 @@ export declare class AkumaArchetypeError extends Error {
     readonly kind = "akuma-archetype";
     constructor(archetype: string, searched: readonly string[], reason: string, guidance?: string);
 }
-export declare function listArchetypes(input: Readonly<{
-    settings: Settings;
+export declare function listArchetypes(input?: Readonly<{
+    home?: string;
 }>): Promise<readonly string[]>;
-export declare function listArchetypeDefinitions(input: Readonly<{
-    settings: Settings;
+export declare function listArchetypeDefinitions(input?: Readonly<{
+    home?: string;
 }>): Promise<readonly ArchetypeCatalogRow[]>;
 export declare function loadArchetype(input: Readonly<{
     name: string;
+    home?: string;
     settings: Settings;
 }>): Promise<AdmittedArchetype>;
 export {};