@astrosheep/keiyaku 4.5.18 → 4.5.20

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

@@ -36,15 +36,22 @@ keiyaku -C <repo> review [<contract>|@<contract>] --satisfied
 ```
 
 ```bash
-keiyaku -C <cwd> call <akuma-name> [--contract <kei/...>] [--alias @name] [--allowed <product.action>]... [--schema <file>] [--wait <duration> | -d | --detach] [--json] (<prompt> | -)
+keiyaku -C <cwd> call <akuma-name> [--contract <kei/...>] [--workdir <path>] [--alias @name] [--allowed <product.action>]... [--schema <file>] [--wait <duration> | -d | --detach] (<prompt> | -)
 keiyaku -C <repo> wait <akuma-selector>... [--any | --all]
 keiyaku -C <repo> tell <aku/...|@alias> (<prompt> | -)
 ```
 
-`-C` is the invocation and Akuma execution cwd. Add `--repo <path>` only when
-a Contract or Dispatch reader must use a different Git repository.
+`-C` selects the invocation cwd and therefore the World. `--repo <path>` only
+selects the Contract repository; it never retargets that World. `call
+--workdir <path>` selects execution cwd (relative to the effective invocation
+cwd). Without it, a Contract call uses its appointed worktree and an
+unassociated call uses the invocation cwd.
 
 Repeated `--allowed` values add actions to the selected Akuma's defaults. A
 nested call can use only actions permitted by its direct parent Soul.
 
-Use text by default; add `--json` when a script needs structured output.
+`deliver`, `review`, and `audit` may take time after their leading admission.
+Their witnessed progress is ephemeral stderr output; stdout remains one final
+text or JSON result. Ctrl-C asks the owned operation to stop and waits for its
+truthful final receipt, so it is not evidence that an already admitted action
+was rolled back.

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

@@ -15,7 +15,7 @@ is accepted; the identity underneath never changes.
 ## Start One
 
 ```bash
-keiyaku -C <cwd> call <akuma-name> [--alias @name] [--allowed <product.action>]... [--schema <file>] [--wait <duration> | -d | --detach] [--json] (<prompt> | -)
+keiyaku -C <cwd> call <akuma-name> [--workdir <path>] [--alias @name] [--allowed <product.action>]... [--schema <file>] [--wait <duration> | -d | --detach] (<prompt> | -)
 ```
 
 Give the worker's initial prompt as one argument (quote it when it contains
@@ -28,20 +28,30 @@ exclusive. Decide up front whether you will stay:
   work outlives your attention; come back with `wait`.
 
 `--alias @name` assigns that world-local selector to the born Akuma. If the
-Alias already points elsewhere, it moves to the born Akuma. The worker's
-execution cwd is exactly `-C <path>`, or your own cwd when `-C` is omitted.
+Alias already points elsewhere, it moves to the born Akuma. `-C` selects the
+invocation World; `--workdir <path>` selects the worker execution cwd relative
+to that invocation directory. Without `--workdir`, an unassociated call uses
+the invocation cwd, while a `--contract` call uses its appointed worktree.
 
-Repeated `--allowed` values add actions to the selected Akuma's defaults. A
-nested call can use only actions permitted by its direct parent Soul.
+Repeated `--allowed` values add actions to the selected Akuma's defaults; they
+never narrow them. An omitted Archetype default permits the complete action
+vocabulary, while an explicit empty default permits none. A nested call can use
+only actions permitted by its direct parent Soul. Use `status <aku/...|@alias>`
+to inspect the born worker's frozen effective actions.
 
 ## Akuma Names
 
-An Akuma name selects a Markdown file at `~/.keiyaku/akuma/<name>.md`; pass
-the filename without `.md` as `<akuma-name>`. Its frontmatter selects the
-provider and may declare `model`, `effort`, `readonly`, `network`, and
-`description`; the body is an optional system prompt, and an empty body keeps
-the harness default. If none grants the permissions and stance the work needs,
-add a new Akuma name. A born Akuma keeps its selected defaults for its lifetime.
+An Akuma name selects a reusable worker configuration, not an individual worker.
+Calling the same name multiple times creates independent workers with distinct
+AkuIds. Choose different names for different capabilities, not merely to run
+work in parallel.
+
+Each name fixes its own capability stance — provider, model, permissions —
+and a born Akuma keeps those selected defaults for its lifetime. `keiyaku ls
+aku/` lists the available names with their providers and descriptions. If none
+grants the permissions and stance the work needs, add a new Akuma name;
+`keiyaku settings --help` says where Akuma definitions live and what they may
+declare.
 
 ## Commission And Steer
 
@@ -64,6 +74,13 @@ including nested calls, which stay under this Soul's ceiling — and state the
 loop as the question. Steering that delegation afterwards goes to the holder,
 not around it.
 
+When that whole-loop worker must operate in the main repository rather than its
+Contract worktree, make that execution choice explicit:
+
+```bash
+keiyaku -C <repo> call worker --contract <kei/...> --workdir <repo> --allowed contract.deliver -d "Own this Contract loop."
+```
+
 ## Watch
 
 ```bash
@@ -78,9 +95,11 @@ a mode. When observing multiple Akuma, prefer one plural wait over separate
 waits and choose exactly one mode:
 
 ```bash
-keiyaku -C <cwd> wait @worker-a --timeout 5m
-keiyaku -C <cwd> wait @worker-a @worker-b --all --timeout 5m
-keiyaku -C <cwd> wait @worker-a @worker-b --any --timeout 5m
+keiyaku -C <cwd> call worker --alias @projection -d "Inspect the projection."
+keiyaku -C <cwd> call worker --alias @host-boundary -d "Inspect the host boundary."
+keiyaku -C <cwd> wait @projection --timeout 5m
+keiyaku -C <cwd> wait @projection @host-boundary --all --timeout 5m
+keiyaku -C <cwd> wait @projection @host-boundary --any --timeout 5m
 ```
 
 `--all` waits until every selected Akuma stops running. `--any` returns when the

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

@@ -62,7 +62,6 @@ keiyaku task update <task-id> --title <text>
 keiyaku task context [<namespace>]
 ```
 
-Use `--json` on any command when a script must inspect the typed result.
 Relations are explicit facts: `needs` orders work, `parent` groups it,
 `supersedes` navigates replacement, and `relates` does not affect readiness.
 `task start` accepts one or more complete TaskIds. A single ID keeps the

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

@@ -8,17 +8,13 @@ import { resolveProviderExecution } from "./providers/index.js";
 import { publishAkuma } from "./publication.js";
 import { spawnAkumaBody } from "./body.js";
 import { AkumaNotBornError } from "./akuma-errors.js";
-import { bornStatus } from "./akuma-observe.js";
+import { bornStatus, defaultWaitComplete, readWaitComplete } from "./akuma-observe.js";
 const CALL_EXECUTION = Symbol("akuma-call-execution");
 const POLL_MS = 100;
 const wait = (milliseconds) => new Promise((resolve) => setTimeout(resolve, milliseconds));
 function diagnostic(error) {
     return error instanceof Error ? error.message : String(error);
 }
-function defaultWaitComplete(status) {
-    return (status.life !== "running" &&
-        !status.timeline.entries.some((entry) => entry.kind === "row" && entry.row.kind === "tell" && entry.row.state === "pending"));
-}
 async function takeLeashUntilSignal(paths, bodySequence, signal, unbounded = false) {
     const leash = await acquireLeash(paths, {
         bodySequence,
@@ -35,7 +31,7 @@ async function takeLeashUntilSignal(paths, bodySequence, signal, unbounded = fal
     return { kind: "unavailable", evidence: "unavailable" };
 }
 export async function settleAkumaKill(paths, signal, retainLeash = false) {
-    const request = await requestStop(paths, new Date().toISOString());
+    const request = await requestStop(paths, new Date().toISOString(), signal);
     if (request.kind !== "requested") {
         if (!retainLeash)
             return { evidence: request.kind };
@@ -141,9 +137,13 @@ export class AkumaHandle {
         }
         const deadline = options.timeoutMs === undefined ? undefined : performance.now() + options.timeoutMs;
         for (;;) {
-            const status = await this.status();
-            if (predicate(status) || (deadline !== undefined && performance.now() >= deadline))
-                return status;
+            if (predicate !== defaultWaitComplete ||
+                (deadline !== undefined && performance.now() >= deadline) ||
+                (await readWaitComplete(this.worldPath, this.id))) {
+                const status = await this.status();
+                if (predicate(status) || (deadline !== undefined && performance.now() >= deadline))
+                    return status;
+            }
             await wait(deadline === undefined ? POLL_MS : Math.min(POLL_MS, Math.max(0, deadline - performance.now())));
         }
     }
@@ -160,7 +160,7 @@ export class AkumaHandle {
         return await wakeRecordedTell(this.paths, admitted.tell.id, runtime);
     }
     async interrupt(body, options = {}) {
-        const request = await requestPause(this.paths, new Date().toISOString());
+        const request = await requestPause(this.paths, new Date().toISOString(), options.signal);
         if (request.kind === "not-born") {
             throw new AkumaNotBornError(this.id);
         }

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

@@ -17,5 +17,7 @@ export declare function readBudgetedStatus(worldPath: WorldRoot, id: AkuId, inpu
     ordinaryBudget?: number;
     admittedTellId?: string;
 }>): Promise<BudgetedStatusObservation>;
+export declare function defaultWaitComplete(status: AkumaStatus): boolean;
+export declare function readWaitComplete(worldPath: WorldRoot, id: AkuId): Promise<boolean>;
 export declare function readAkumaBirthCwd(worldPath: WorldRoot, id: AkuId): Promise<string>;
 export { selectHistory, type ActivityHistory, type ActivitySnapshot };

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

@@ -1,12 +1,22 @@
-import { activitySlice, HeldAkumaLeash, isHeartAbsent, life, lifeAt, probeLeash, readHeart, readSeal, readSoul, } from "./heart/index.js";
+import { readStatusFacts, 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";
 import { resolveProviderExecution } from "./providers/index.js";
 import { AkumaNotBornError } from "./akuma-errors.js";
 export async function fleetListRow(paths, expected) {
     const snapshot = await readHeart(paths);
-    if (snapshot.soul !== null)
-        return (await bornObservation(paths, expected, snapshot)).row;
+    if (snapshot.soul !== null) {
+        const observed = await bornObservation(paths, expected, () => readHeart(paths), snapshot);
+        return {
+            id: observed.soul.id,
+            archetype: observed.soul.archetype,
+            ...(observed.soul.description === undefined ? {} : { description: observed.soul.description }),
+            life: observed.currentLife,
+            lifeAt: lifeAt(observed.currentLife, observed.snapshot.latestBody, observed.snapshot.latestKill, observed.soul.createdAt),
+            lastActivityAt: observed.snapshot.lastActivityAt,
+            pending: observed.snapshot.pending.map((tell) => tell.id),
+        };
+    }
     try {
         if ((await probeLeash(paths)) === "held")
             return { id: expected, life: "unborn" };
@@ -19,8 +29,8 @@ export async function fleetListRow(paths, expected) {
         throw error;
     }
 }
-async function bornObservation(paths, expected, snapshot) {
-    snapshot ??= await readHeart(paths);
+async function bornObservation(paths, expected, read, snapshot) {
+    snapshot ??= await read();
     if (snapshot.soul === null)
         throw new AkumaNotBornError(expected);
     const claim = await HeldAkumaLeash.try(paths);
@@ -28,7 +38,7 @@ async function bornObservation(paths, expected, snapshot) {
         // A Body may finish after the first read. Refresh under the free seat so
         // neither its release nor a successor can manufacture an untidy observation.
         if (claim !== null)
-            snapshot = await readHeart(paths);
+            snapshot = await read();
         const soul = snapshot.soul;
         if (soul === null)
             throw new AkumaNotBornError(expected);
@@ -39,19 +49,7 @@ async function bornObservation(paths, expected, snapshot) {
             body: snapshot.latestBody,
             kill: snapshot.latestKill,
         });
-        return {
-            snapshot,
-            soul,
-            row: {
-                id: soul.id,
-                archetype: soul.archetype,
-                ...(soul.description === undefined ? {} : { description: soul.description }),
-                life: currentLife,
-                lifeAt: lifeAt(currentLife, snapshot.latestBody, snapshot.latestKill, soul.createdAt),
-                lastActivityAt: snapshot.lastActivityAt,
-                pending: snapshot.pending.map((tell) => tell.id),
-            },
-        };
+        return { snapshot, soul, currentLife };
     }
     finally {
         claim?.release();
@@ -60,20 +58,21 @@ async function bornObservation(paths, expected, snapshot) {
 export async function bornStatus(paths, expected, input) {
     if (input.ordinaryBudget !== undefined && (!Number.isSafeInteger(input.ordinaryBudget) || input.ordinaryBudget < 0))
         throw new TypeError("ordinary budget must be a nonnegative safe integer");
-    const { snapshot, soul, row: current } = await bornObservation(paths, expected);
-    const resumeUnsupported = current.life === "stranded" &&
+    const { snapshot, soul, currentLife } = await bornObservation(paths, expected, () => readLifeSnapshot(paths));
+    const resumeUnsupported = currentLife === "stranded" &&
         snapshot.latestSession?.provider === soul.provider.name &&
         (await resolveProviderExecution(soul.provider)).adapter.resume === undefined;
-    const slice = await activitySlice(paths);
-    const selected = selectSnapshot(projectTurns(slice.rows), {
+    const facts = await readStatusFacts(paths, input);
+    const selected = selectSnapshot(projectTurns(facts), {
         aperture: input.aperture,
         budget: ordinarySnapshotBudget(input.ordinaryBudget),
         ...(input.admittedTellId === undefined ? {} : { admittedTellId: input.admittedTellId }),
     });
     return {
         status: {
-            id: current.id,
-            life: current.life,
+            id: soul.id,
+            life: currentLife,
+            allowed: soul.allowed,
             ...(soul.readonly === undefined ? {} : { readonly: soul.readonly }),
             ...(resumeUnsupported ? { strandedReason: "resume-unsupported" } : {}),
             timeline: selected.snapshot,
@@ -84,6 +83,17 @@ export async function bornStatus(paths, expected, input) {
 export async function readBudgetedStatus(worldPath, id, input) {
     return await bornStatus(pathsForAkuId(worldPath, id), id, input);
 }
+function complete(life, pending) {
+    return life !== "running" && !pending;
+}
+export function defaultWaitComplete(status) {
+    return complete(status.life, status.timeline.entries.some((entry) => entry.kind === "row" && entry.row.kind === "tell" && entry.row.state === "pending"));
+}
+export async function readWaitComplete(worldPath, id) {
+    const paths = pathsForAkuId(worldPath, id);
+    const observed = await bornObservation(paths, id, () => readLifeSnapshot(paths));
+    return complete(observed.currentLife, observed.snapshot.hasPendingTell);
+}
 export async function readAkumaBirthCwd(worldPath, id) {
     const soul = await readSoul(pathsForAkuId(worldPath, id));
     if (soul === null)

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

@@ -22,6 +22,7 @@ export type BornAkumaCall = Readonly<{
     }>;
     initialBody?: string;
     initialSchemaJson?: string;
+    awaitAsleep?: true;
     execution: BornExecution;
 }>;
 export type RequestedAkumaCall = Readonly<{

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

@@ -26,6 +26,7 @@ async function admitBodyRequest(input) {
         world: input.path,
         archetype: input.name,
         ...(input.call.body === undefined ? {} : { body: input.call.body }),
+        ...(input.call.schema === undefined ? {} : { awaitAsleep: true }),
         ...(cwd === undefined ? {} : { cwd }),
         recipe: input.recipe,
     });
@@ -56,6 +57,7 @@ async function admitDirect(input) {
         },
         ...(input.call.body === undefined ? {} : { initialBody: input.call.body }),
         ...(input.call.schema === undefined ? {} : { initialSchemaJson: schemaJsonText(input.call.schema) }),
+        ...(input.call.schema === undefined ? {} : { awaitAsleep: true }),
         execution: {
             cwd,
             source: input.call.cwd !== undefined ? "input" : initiatorCwd === undefined ? "world" : "process",
@@ -206,6 +208,7 @@ class AkumaProduct {
         }
         const published = await launchAkuma({
             allocated: born.allocated,
+            ...(born.awaitAsleep === undefined ? {} : { awaitAsleep: born.awaitAsleep }),
             launch: async (allocated) => await spawnAkumaBody({
                 paths: allocated.paths,
                 seed: born.seed,

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

@@ -3,7 +3,7 @@ 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 AllowedAction } from "./allowed.js";
 import type { ExecutionContext } from "./requests.js";
 import { z } from "zod";
 import type { BoundedList } from "../bounded-list.js";
@@ -32,6 +32,24 @@ export declare const akumaStatusSchema: z.ZodObject<{
         asleep: "asleep";
         stranded: "stranded";
     }>;
+    allowed: z.ZodPipe<z.ZodArray<z.ZodEnum<{
+        "task.add": "task.add";
+        "task.addDocument": "task.addDocument";
+        "task.compose": "task.compose";
+        "task.done": "task.done";
+        "task.drop": "task.drop";
+        "task.hold": "task.hold";
+        "task.resume": "task.resume";
+        "task.start": "task.start";
+        "task.stop": "task.stop";
+        "task.update": "task.update";
+        "akuma.call": "akuma.call";
+        "akuma.kill": "akuma.kill";
+        "akuma.tell": "akuma.tell";
+        "contract.audit": "contract.audit";
+        "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<{
@@ -408,8 +426,7 @@ export declare const akumaStatusSchema: z.ZodObject<{
 }, z.core.$strict>;
 export type AkumaStatus = z.infer<typeof akumaStatusSchema>;
 export declare function parseAkumaStatus(value: unknown): AkumaStatus;
-/** The default completion judgment over one complete status snapshot. */
-export declare function defaultWaitComplete(status: AkumaStatus): boolean;
+export { defaultWaitComplete } from "./akuma-observe.js";
 export type { ReadonlyRestraint } from "./provider-recipe.js";
 export type * from "./projection.js";
 export type UnbornAkumaListRow = Readonly<{

package/build/src/akuma/akuma.js

@@ -1,5 +1,6 @@
 import { parseAkuId } from "./identity.js";
 import { activitySnapshotSchema } from "./projection.js";
+import { allowedActionsSchema } from "./allowed.js";
 import { z } from "zod";
 import { createAkumaProduct } from "./akuma-product.js";
 import { killAkumaWithRecovery } from "./akuma-handle.js";
@@ -25,6 +26,7 @@ export const akumaStatusSchema = z
     .object({
     id: akumaIdSchema,
     life: z.enum(["running", "asleep", "stranded", "hung", "untidy", "killed"]),
+    allowed: allowedActionsSchema,
     readonly: readonlySchema.optional(),
     timeline: activitySnapshotSchema,
     strandedReason: z.literal("resume-unsupported").optional(),
@@ -33,11 +35,7 @@ export const akumaStatusSchema = z
 export function parseAkumaStatus(value) {
     return akumaStatusSchema.parse(value);
 }
-/** The default completion judgment over one complete status snapshot. */
-export function defaultWaitComplete(status) {
-    return (status.life !== "running" &&
-        !status.timeline.entries.some((entry) => entry.kind === "row" && entry.row.kind === "tell" && entry.row.state === "pending"));
-}
+export { defaultWaitComplete } from "./akuma-observe.js";
 export { AkumaNotBornError } from "./akuma-errors.js";
 export function wait(milliseconds) {
     return new Promise((resolve) => setTimeout(resolve, milliseconds));

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

@@ -1,8 +1,28 @@
+import { z } from "zod";
 export declare const ALLOWED_ACTIONS: readonly ["akuma.call", "akuma.kill", "akuma.tell", "contract.audit", "contract.deliver", "contract.review", "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;
+/** Public codecs retain the Soul's canonical, duplicate-free action membership. */
+export declare const allowedActionsSchema: z.ZodPipe<z.ZodArray<z.ZodEnum<{
+    "task.add": "task.add";
+    "task.addDocument": "task.addDocument";
+    "task.compose": "task.compose";
+    "task.done": "task.done";
+    "task.drop": "task.drop";
+    "task.hold": "task.hold";
+    "task.resume": "task.resume";
+    "task.start": "task.start";
+    "task.stop": "task.stop";
+    "task.update": "task.update";
+    "akuma.call": "akuma.call";
+    "akuma.kill": "akuma.kill";
+    "akuma.tell": "akuma.tell";
+    "contract.audit": "contract.audit";
+    "contract.deliver": "contract.deliver";
+    "contract.review": "contract.review";
+}>>, z.ZodTransform<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")[]>>;
 export declare function effectiveAllowedActions(value: unknown): AllowedActions;
 export declare function unionAllowedActions(base: AllowedActions, additions: AllowedActions): AllowedActions;
 export declare function clipAllowedActions(requested: AllowedActions, parent: AllowedActions): AllowedActions;

package/build/src/akuma/allowed.js

@@ -1,4 +1,5 @@
 import { TASK_MUTATION_ACTIONS } from "../task/mutation.js";
+import { z } from "zod";
 export const ALLOWED_ACTIONS = Object.freeze([
     "akuma.call",
     "akuma.kill",
@@ -25,6 +26,16 @@ export function decodeAllowedActions(value, label = "allowed") {
     }
     return Object.freeze([...seen].sort());
 }
+/** Public codecs retain the Soul's canonical, duplicate-free action membership. */
+export const allowedActionsSchema = z.array(z.enum(ALLOWED_ACTIONS)).transform((value, context) => {
+    try {
+        return decodeAllowedActions(value);
+    }
+    catch (error) {
+        context.addIssue({ code: "custom", message: error instanceof Error ? error.message : String(error) });
+        return z.NEVER;
+    }
+});
 export function effectiveAllowedActions(value) {
     return value === undefined ? ALLOWED_ACTIONS : decodeAllowedActions(value);
 }

package/build/src/akuma/archetype.js

@@ -132,6 +132,7 @@ function decodeArchetypeFields(values) {
     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 allowedPresent = "allowed" in values;
     const allowed = allowedPresent ? effectiveAllowedActions(values.allowed) : undefined;
@@ -143,6 +144,7 @@ function decodeArchetypeFields(values) {
         ...(effort === undefined ? {} : { effort }),
         ...(readonly === undefined ? {} : { readonly }),
         ...(network === undefined ? {} : { network }),
+        ...(sandbox === undefined ? {} : { sandbox }),
         ...(description === undefined ? {} : { description }),
         ...(allowed === undefined ? {} : { allowed }),
         allowedPresent,
@@ -166,6 +168,7 @@ function decodeArchetype(name, path, markdown) {
             ...(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
                 ? {}
                 : {

package/build/src/akuma/body.js

@@ -3,7 +3,7 @@ import { fileURLToPath } from "node:url";
 import { abortableDelay } from "./abort.js";
 import { BodySupervisor } from "./body-supervisor.js";
 import { driveTurn, turnRecipe } from "./turn-drive.js";
-import { HeldAkumaLeash, breakBody, decidePendingTellDisposition, drainPendingTells, endTurn, failOpenBoundTurns, finishBodyIfIdle, heartExists, isHeartAbsent, probeLeash, projectTell, provePendingTellDispositionCustody, readHeart, readOpenBoundTurns, readOpenPendingTellDisposition, readTell, readTurn, readNonterminalRequests, recordUndeliveredPendingTells, resolvePendingTellDisposition, } from "./heart/index.js";
+import { HeldAkumaLeash, breakBody, decidePendingTellDisposition, drainPendingTells, endTurn, failOpenBoundTurns, finishBodyIfIdle, heartExists, isHeartAbsent, probeLeash, projectTell, readHeart, readOpenBoundTurns, readOpenPendingTellDisposition, readTell, readTurn, readNonterminalRequests, resolvePendingTellDisposition, } from "./heart/index.js";
 import { worldRootForAkumaPaths } from "./identity.js";
 import { pluginRuntime } from "../plugin/runtime.js";
 import { World } from "../world.js";
@@ -231,13 +231,11 @@ async function recoverBodyRequests(input) {
 }
 function turnOutcomeEmitter(launch, soul) {
     let plugins;
-    const pending = new Set();
     const reportDiagnostic = (message) => {
         void recordPluginDiagnostic(launch.paths, "turn outcome", message);
     };
-    const emit = (turnSequence, outcome) => {
-        let delivery;
-        delivery = (async () => {
+    return {
+        async emit(turnSequence, outcome) {
             try {
                 plugins ??= pluginRuntime({
                     world: await World.at(worldRootForAkumaPaths(launch.paths)),
@@ -256,17 +254,8 @@ function turnOutcomeEmitter(launch, soul) {
             catch (error) {
                 await recordPluginDiagnostic(launch.paths, "turn outcome", error);
             }
-        })().finally(() => pending.delete(delivery));
-        pending.add(delivery);
-        return delivery;
-    };
-    const drain = async () => {
-        while (pending.size > 0)
-            await Promise.all([...pending]);
-        if (plugins !== undefined)
-            await (await plugins).drain("akuma.turn-outcome");
+        },
     };
-    return { emit, drain };
 }
 function bodyEndEmitter(launch, soul) {
     let plugins;
@@ -288,7 +277,6 @@ function bodyEndEmitter(launch, soul) {
                 ...(diagnostic === undefined ? {} : { diagnostic }),
                 ...(launch.completion?.contractId === undefined ? {} : { contractId: launch.completion.contractId }),
             }, reportDiagnostic);
-            await (await plugins).drain("akuma.body-ended");
         }
         catch (error) {
             await recordPluginDiagnostic(launch.paths, "body end", error);
@@ -346,7 +334,7 @@ async function runBodyTurns(input) {
             return;
         }
         const outcome = await persistTurn(launch.paths, result.turnSequence, result, runtime.now());
-        void turnOutcome.emit(result.turnSequence, outcome);
+        await turnOutcome.emit(result.turnSequence, outcome);
         if (outcome.outcome === "failed") {
             await failOpenBoundTurnsIfPresent(launch.paths, bodySequence, outcome.diagnostic, runtime.now());
             await breakBody(launch.paths, { sequence: bodySequence, end: "broke-off", at: runtime.now() });
@@ -369,15 +357,10 @@ async function settleUndeliveredDisposition(paths, disposition, error) {
     if (!(await heartExists(paths)))
         return;
     const at = new Date().toISOString();
-    await recordUndeliveredPendingTells(paths, at, disposition.tellIds);
-    await resolvePendingTellDisposition(paths, disposition.bodySequence, at);
+    await resolvePendingTellDisposition(paths, disposition.bodySequence, at, "undelivered");
 }
 async function consumeProvenDisposition(paths, disposition) {
-    const proof = await provePendingTellDispositionCustody(paths, disposition);
-    if (proof.kind !== "proven")
-        return false;
-    await resolvePendingTellDisposition(paths, disposition.bodySequence, new Date().toISOString());
-    return true;
+    return await resolvePendingTellDisposition(paths, disposition.bodySequence, new Date().toISOString());
 }
 /**
  * Wait for Heart custody proof of the frozen Tell-id snapshot, or for the
@@ -386,7 +369,7 @@ async function consumeProvenDisposition(paths, disposition) {
  */
 async function awaitDispositionCustody(paths, disposition, child, schedule) {
     for (;;) {
-        if ((await provePendingTellDispositionCustody(paths, disposition)).kind === "proven") {
+        if (await consumeProvenDisposition(paths, disposition)) {
             child.release();
             return { kind: "proven" };
         }
@@ -405,7 +388,7 @@ async function awaitDispositionCustody(paths, disposition, child, schedule) {
             continue;
         timerController.abort();
         await timer.catch(() => undefined);
-        if ((await provePendingTellDispositionCustody(paths, disposition)).kind === "proven") {
+        if (await consumeProvenDisposition(paths, disposition)) {
             child.release();
             return { kind: "proven" };
         }
@@ -417,10 +400,8 @@ async function resolveDecidedPendingTellDisposition(paths, disposition, spawn) {
         if (await consumeProvenDisposition(paths, disposition))
             return;
         const wake = await awaitDispositionCustody(paths, disposition, await spawn({ paths, refuseIfHeld: true }), abortableDelay);
-        if (wake.kind === "proven") {
-            await resolvePendingTellDisposition(paths, disposition.bodySequence, new Date().toISOString());
+        if (wake.kind === "proven")
             return;
-        }
         // Predecessor still holds the leash: leave the Heart disposition open.
         if (wake.kind === "held")
             return;
@@ -515,19 +496,13 @@ export async function driveAkumaBody(launch, adapter, runtimeInput = {}) {
             await resolveDecidedPendingTellDisposition(launch.paths, finished.decided, runtime.spawnBody ?? spawnAkumaBody);
         if (finished.notification !== undefined)
             await finished.notification;
-        void emitTurnOutcome?.drain();
     }
 }
 export async function spawnAkumaBody(launch) {
     return await spawnDetachedProcess(await bodyProcessInput(launch));
 }
 export async function runAkumaBody(launch, world, externalCommands) {
-    try {
-        return await driveAkumaBody(launch, undefined, { world, externalCommands });
-    }
-    finally {
-        await (await pluginRuntime({ world })).drain();
-    }
+    return await driveAkumaBody(launch, undefined, { world, externalCommands });
 }
 const DIRECT_TELL_WAKE = {
     spawn: async (paths) => await spawnAkumaBody({ paths, refuseIfHeld: true }),

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

@@ -19,6 +19,7 @@ declare const akumaCallRecipeSchema: z.ZodObject<{
         effort?: string;
         readonly?: true;
         network?: "disabled" | "enabled";
+        sandbox?: "full-access";
         systemPrompt?: string;
         systemPromptMode?: import("./provider-recipe.js").SystemPromptMode;
     }>, unknown>>;
@@ -28,6 +29,7 @@ declare const akumaCallPayloadSchema: z.ZodObject<{
     world: z.ZodString;
     archetype: z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>;
     body: z.ZodOptional<z.ZodString>;
+    awaitAsleep: z.ZodOptional<z.ZodLiteral<true>>;
     cwd: z.ZodOptional<z.ZodString>;
     recipe: z.ZodObject<{
         description: z.ZodOptional<z.ZodString>;
@@ -44,6 +46,7 @@ declare const akumaCallPayloadSchema: z.ZodObject<{
             effort?: string;
             readonly?: true;
             network?: "disabled" | "enabled";
+            sandbox?: "full-access";
             systemPrompt?: string;
             systemPromptMode?: import("./provider-recipe.js").SystemPromptMode;
         }>, unknown>>;