@astrosheep/keiyaku 4.0.4 → 4.0.6

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

@@ -1,6 +1,6 @@
 {
   "name": "keiyaku",
-  "version": "0.1.0+codex.20260818034655",
+  "version": "0.1.0+codex.20260819155641",
   "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.20260818034655",
+  "version": "0.1.0+codex.20260819155641",
   "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.20260818034655",
+  "version": "0.1.0+codex.20260819155641",
   "type": "module",
   "main": "./opencode.js",
   "keywords": ["pi-package"],

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

@@ -15,9 +15,9 @@ read `<command> --help` before using flags.
   then `keiyaku-workflow` for the remaining lifecycle.
 - An Akuma is a callable worker; see `keiyaku-akuma`.
 
-Settings owns named gate sets. Omitting `--gates` selects `gates.default`, or
-freezes an empty gate list when that entry is absent. `--gates <name>` selects
-one configured set; it does not add a literal gate word.
+Settings owns named gate bundles. Omitting `--gates` selects `gates.default`,
+or freezes `["reviewed"]` when that entry is absent. `--gates <name,...>`
+selects configured bundles in order; it does not add literal gate words.
 
 ## Quick Start
 
@@ -31,7 +31,7 @@ keiyaku -C <repo> review [<contract>|@<contract>] --satisfied
 ```
 
 ```bash
-keiyaku -C <cwd> call <akuma-name> [--contract <kei/...>] [--alias @name] [--allowed <product.action>]... [--wait <duration> | -d | --detach] [--json] (<prompt> | -)
+keiyaku -C <cwd> call <akuma-name> [--contract <kei/...>] [--alias @name] [--readonly] [--allowed <product.action>]... [--wait <duration> | -d | --detach] (<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] [--allowed <product.action>]... [--wait <duration> | -d | --detach] [--json] (<prompt> | -)
+keiyaku -C <cwd> call <akuma-name> [--alias @name] [--readonly] [--allowed <product.action>]... [--wait <duration> | -d | --detach] (<prompt> | -)
 ```
 
 Give the worker's initial prompt as one argument (quote it when it contains
@@ -44,14 +44,22 @@ outgrows its Archetype mid-life.
 keiyaku status                            # deep fleet observation
 keiyaku status <aku/...|@alias>           # one worker's snapshot
 keiyaku ls aku/                           # shallow catalog; also aku/<archetype>/ and "aku/*/*"
-keiyaku wait <selector>... [--any | --all] [--timeout <duration>] [--json]
+keiyaku wait <selector>... [--any | --all] [--timeout <duration>]
 ```
 
-`wait` accepts complete ids, aliases, and Akuma globs, resolved once into a
-stable deduplicated set. One member needs no mode; two or more require exactly
-one of `--any` or `--all`. A timeout returns the current real snapshot — never
-a fabricated timeout state — and `--any` leaves the unfinished members
-running.
+`wait` accepts complete ids, aliases, and Akuma globs. Wait on one Akuma without
+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
+```
+
+`--all` waits until every selected Akuma stops running. `--any` returns when the
+first one stops and leaves the others alone. When the timeout expires, `wait`
+returns their current status without stopping them.
 
 ## Steer
 

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

@@ -66,9 +66,11 @@ reader would otherwise re-derive wrongly. Never narrative. If Objective and
 Design read the same without a sentence here, delete it.>
 
 ## Objective
-<One observable end-state, judged done/not-done without reading Design.
-If "and" joins independently acceptable outcomes, bind two Contracts. A
-single outcome may still require several arcs during fulfillment.>
+<One end-state you could watch happen, named at the level of intent and goal
+— above implementation detail, above spec recital. If "and" joins two
+outcomes that would each stand alone, bind two Contracts. Even an outcome
+that cannot split into two may still need arcs to organize its
+fulfillment.>
 
 ## Design
 <The closed decisions. A statement belongs here exactly when a test-green

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

@@ -85,7 +85,8 @@ Read first:
 - <owner documents governing this delivery>
 - <source files named or selected from the Contract Region for this work>
 Objective:
-<bounded assignment>
+<the assignment's high-level intent and goal — not implementation detail,
+not a restatement of the Contract terms>
 ```
 
 Every `Read first` path is relative to `Worktree` unless it is absolute. The
@@ -94,6 +95,12 @@ frontmatter names `Contract`, then reads the listed owner documents and source
 files before acting. Do not substitute a generic repository tour for the files
 that actually govern the assignment.
 
+Contract association, available forwarded actions, and the brief are
+independent inputs. When a Reviewer should record its own verdict, include
+`--allowed contract.review` and say in the brief to record `--satisfied` on
+pass or `--unsatisfied` on failure. When a Deliverer should tender its completed
+candidate, include `--allowed contract.deliver` and say so in the brief.
+
 A `Deliverer` implements and verifies the terms in `Worktree`. Commission a
 `Reviewer` after delivery. The reviewer inspects the complete current Contract
 worktree snapshot, not a worker report or named candidate commit, and does not
@@ -182,14 +189,24 @@ substitute for them.
 
 ## Deliver
 
+When the brief assigns delivery to the Deliverer, include `--allowed
+contract.deliver`; require it to run the command below after verification and
+return the receipt. Otherwise the coordinator runs it after accepting the
+candidate.
+
 Deliver when the worktree content is the candidate you intend to land:
 
 ```bash
-keiyaku deliver <contract>
+keiyaku deliver <contract> --include-dirty
 ```
 
-`deliver` freshly tenders the clean `HEAD`, records the candidate, and requests
-placement. When a current audit attestation names the identical integration
+This example includes all non-ignored staged, unstaged, and untracked bytes in
+the candidate. Use `--include-dirty` only when the complete current workspace
+is the intended delivery; otherwise commit the intended bytes and run
+`keiyaku deliver <contract>`.
+
+`deliver` freshly tenders the candidate, records it, and requests placement.
+When a current audit attestation names the identical integration
 snapshot and Verification segment, deliver reuses it; otherwise it runs the
 declarations. Worktree, target, policy, document, Verification, or
 snapshot-producing option changes prevent reuse. If the workspace is dirty, the refusal
@@ -217,6 +234,9 @@ keiyaku review <contract> --unsatisfied --summary "<finding>"
 ```
 
 Have an independent reviewer inspect the delivered Contract worktree snapshot.
+If it should record the verdict itself, dispatch it with `--allowed
+contract.review` and state both verdicts in the brief. Otherwise its answer is
+review input for the coordinator to record.
 The `review` command records the verdict. `--satisfied` requests placement; if
 the other gates are current, the receipt shows `claimed`.
 

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

@@ -10,7 +10,7 @@ export type AkumaListRow = Readonly<{
     description?: string;
     life: AkumaLife;
     lifeAt: string | null;
-    confinement: Soul["confinement"];
+    lastActivityAt: string | null;
     pending: readonly string[];
 }>;
 export type AkumaStatus = Readonly<{
@@ -47,6 +47,7 @@ export type AkumaCallInput = Readonly<{
     archetype: string;
     body: string;
     cwd?: string;
+    readonly?: true;
     allowed?: readonly AllowedAction[];
 }>;
 type AkumaCallContext = Readonly<{

package/build/src/akuma/akuma.js

@@ -24,6 +24,13 @@ async function canonicalBirthCwd(input) {
         throw new Error(`cwd is not an existing directory: ${input}`);
     }
 }
+function callReadonly(value) {
+    if (value === undefined)
+        return {};
+    if (value !== true)
+        throw new TypeError("Akuma call readonly must be true");
+    return { readonly: true };
+}
 const CALL_EXECUTION = Symbol("akuma-call-execution");
 const CALL_WITH_CONTEXT = Symbol("akuma-call-with-context");
 export class AkumaNotBornError extends Error {
@@ -107,7 +114,7 @@ async function bornListRow(paths, expected, snapshot) {
         ...(snapshot.soul.description === undefined ? {} : { description: snapshot.soul.description }),
         life: currentLife,
         lifeAt: lifeAt(currentLife, snapshot.latestBody, snapshot.latestKill, snapshot.soul.createdAt),
-        confinement: snapshot.soul.confinement,
+        lastActivityAt: snapshot.lastActivityAt,
         pending: snapshot.pending.map((tell) => tell.id),
     };
 }
@@ -118,7 +125,7 @@ async function bornStatus(paths, expected, budget) {
     const current = await bornListRow(paths, expected, snapshot);
     const resumeUnsupported = current.life === "stranded"
         && snapshot.latestSession?.provider === snapshot.soul.provider.name
-        && resolveProviderExecution(snapshot.soul.provider).adapter.resume === undefined;
+        && (await resolveProviderExecution(snapshot.soul.provider)).adapter.resume === undefined;
     const slice = await activitySlice(paths);
     return {
         id: current.id,
@@ -219,6 +226,15 @@ export class AkumaHandle {
                     : "unavailable" };
         }
         const settledBody = (await readHeart(this.paths)).latestBody;
+        if (settledBody?.sequence === request.body.sequence && settledBody.hung !== undefined) {
+            try {
+                await leash.clearPause(this.paths);
+            }
+            finally {
+                leash.release();
+            }
+            return { kind: "unavailable", evidence: "hung" };
+        }
         if (settledBody?.sequence !== request.body.sequence || settledBody.end === undefined) {
             try {
                 await leash.clearPause(this.paths);
@@ -254,7 +270,7 @@ export class AkumaHandle {
             throw new AkumaNotBornError(this.id);
         if (source.id !== this.id)
             throw new Error("Akuma soul does not match its coordinate");
-        const adapter = resolveProviderExecution(source.provider).adapter;
+        const adapter = (await resolveProviderExecution(source.provider)).adapter;
         if (adapter.fork === undefined)
             return { kind: "provider-cannot-fork", provider: source.provider.name };
         const point = await readForkPoint(this.paths, input.at);
@@ -294,7 +310,6 @@ export class AkumaHandle {
                         allowed: source.allowed,
                         cwd: source.cwd,
                         origin: { kind: "fork", parent: this.id, at: input.at },
-                        confinement: source.confinement,
                     },
                     birthSession,
                 }),
@@ -377,10 +392,16 @@ export class Akuma {
         return await this[CALL_WITH_CONTEXT](input, { initiatorCwd: process.cwd() });
     }
     async [CALL_WITH_CONTEXT](input, context) {
+        const readonly = callReadonly(input.readonly);
         const name = archetypeName(input.archetype);
         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 archetype = await loadArchetype({
+            name,
+            ...home,
+            settings,
+            ...readonly,
+        });
         const allowed = input.allowed === undefined
             ? archetype.allowed
             : decodeAllowedActions(input.allowed, "Akuma call allowed");
@@ -416,10 +437,7 @@ export class Akuma {
         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 recipe = requestRecipe;
         const published = await publishAkuma({
             worldPath: this.path,
             archetype: archetype.name,

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

@@ -1,4 +1,4 @@
-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 declare const ALLOWED_ACTIONS: readonly ["akuma.call", "akuma.kill", "akuma.tell", "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;

package/build/src/akuma/allowed.js

@@ -1,18 +1,11 @@
+import { TASK_MUTATION_ACTIONS } from "../task/mutation.js";
 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",
+    "contract.review",
+    ...TASK_MUTATION_ACTIONS,
 ]);
 const ALLOWED_ACTION_SET = new Set(ALLOWED_ACTIONS);
 export function isAllowedAction(value) {

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

@@ -8,6 +8,7 @@ type DecodedArchetype = Readonly<{
     provider: string;
     description?: string;
     options: ProviderOptions;
+    readonly?: true;
     allowed: AllowedActions;
 }>;
 export type ArchetypeCatalogRow = Readonly<{
@@ -18,7 +19,7 @@ export type ArchetypeCatalogRow = Readonly<{
 type ArchetypeDefinition = DecodedArchetype & Readonly<{
     adapter: ProviderAdapter;
 }>;
-type AdmittedArchetype = Omit<ArchetypeDefinition, "provider"> & Readonly<{
+type AdmittedArchetype = Omit<ArchetypeDefinition, "provider" | "readonly"> & Readonly<{
     provider: ProviderExecution;
     readonly?: ReadonlyRestraint;
 }>;
@@ -39,5 +40,6 @@ export declare function loadArchetype(input: Readonly<{
     name: string;
     home?: string;
     settings: Settings;
+    readonly?: true;
 }>): Promise<AdmittedArchetype>;
 export {};

package/build/src/akuma/archetype.js

@@ -105,10 +105,10 @@ function decodeArchetype(name, path, markdown) {
         options: decodeProviderOptions({
             ...(model === undefined ? {} : { model }),
             ...(effort === undefined ? {} : { effort }),
-            ...(readonly === undefined ? {} : { readonly }),
             ...(network === undefined ? {} : { network }),
             ...(systemPrompt.length === 0 ? {} : { systemPrompt }),
         }),
+        ...(readonly === undefined ? {} : { readonly }),
         allowed,
     });
 }
@@ -184,10 +184,10 @@ function providerExecution(settings, name) {
         return decodeProviderRecipe({ name, ...builtin });
     throw new TypeError(`unknown provider ${name}`);
 }
-function admitArchetype(archetype, settings) {
+async function admitArchetype(archetype, settings, callReadonly) {
     let selected;
     try {
-        selected = resolveProviderExecution(providerExecution(settings, archetype.provider));
+        selected = await resolveProviderExecution(providerExecution(settings, archetype.provider));
     }
     catch (error) {
         if (error instanceof TypeError)
@@ -196,12 +196,17 @@ function admitArchetype(archetype, settings) {
     }
     const execution = selected.execution;
     const adapter = selected.adapter;
-    const admission = adapter.admitOptions(archetype.options);
+    const effectiveReadonly = archetype.readonly === true || callReadonly === true;
+    const admission = adapter.admitOptions({
+        ...archetype.options,
+        ...(effectiveReadonly ? { readonly: true } : {}),
+    });
     if (admission.kind === "refused") {
         throw new AkumaArchetypeError(archetype.name, [archetype.path], `is unsupported: ${admission.diagnostic}`);
     }
+    const { readonly: _readonly, ...definition } = archetype;
     return Object.freeze({
-        ...archetype,
+        ...definition,
         provider: execution,
         adapter,
         options: admission.options,
@@ -223,7 +228,7 @@ export async function loadArchetype(input) {
         throw new AkumaArchetypeError(name, [path], `could not be read: ${error instanceof Error ? error.message : String(error)}`);
     }
     try {
-        return admitArchetype(decodeArchetype(name, path, markdown), input.settings);
+        return await admitArchetype(decodeArchetype(name, path, markdown), input.settings, input.readonly);
     }
     catch (error) {
         if (error instanceof AkumaArchetypeError)

package/build/src/akuma/body-turn.d.ts

@@ -0,0 +1,64 @@
+import { type HeartSnapshot, type HeldAkumaLeash, type ResumeCoordinate, type Soul, type TellFact } from "./heart/index.js";
+import type { AkumaPaths } from "./identity.js";
+import { type ProviderAdapter, type TurnResult } from "./provider.js";
+import { type RequestChildLaunch, type UpstreamExecutionPort } from "./request-serve.js";
+export declare const CONTROL_RESPONSE_MS = 1000;
+export declare class BodySupervisor {
+    private readonly paths;
+    private readonly bodySequence;
+    private readonly leash;
+    readonly signal: AbortSignal;
+    private readonly controller;
+    private readonly finished;
+    private readonly observer;
+    private waiter;
+    private observation;
+    private stopping?;
+    private constructor();
+    static open(paths: AkumaPaths, bodySequence: number, leash: HeldAkumaLeash): Promise<BodySupervisor>;
+    get reason(): "control" | "heart-gone" | undefined;
+    current(): HeartSnapshot;
+    recordHung(diagnostic: string, at: string): Promise<void>;
+    refresh(): Promise<HeartSnapshot>;
+    next(after: HeartSnapshot): Promise<HeartSnapshot>;
+    cancel(reason: "control" | "heart-gone"): void;
+    close(): Promise<void>;
+    private publish;
+    private observe;
+}
+export declare function turnRecipe(paths: AkumaPaths, soul: Soul): Promise<Readonly<{
+    cwd: string;
+    options: Soul["options"];
+    session?: ResumeCoordinate;
+}>>;
+export type DrivenTurn = (Extract<TurnResult, {
+    kind: "answered";
+}> & Readonly<{
+    session?: ResumeCoordinate;
+}>) | Extract<TurnResult, {
+    kind: "failed";
+}>;
+export type DriveTurnInput = Readonly<{
+    paths: AkumaPaths;
+    soul: Soul;
+    adapter: ProviderAdapter;
+    bodySequence: number;
+    body: string;
+    call?: string;
+    launchTells: readonly TellFact[];
+    supervisor: BodySupervisor;
+    runtimeSpawn(launch: RequestChildLaunch): Promise<void>;
+    upstream?: UpstreamExecutionPort;
+    now(): string;
+}>;
+export declare function driveTurn(input: DriveTurnInput): Promise<(DrivenTurn & Readonly<{
+    turnSequence: number;
+}>) | Readonly<{
+    kind: "stopped";
+}> | Readonly<{
+    kind: "hung";
+}> | Readonly<{
+    kind: "handoff";
+}> | Readonly<{
+    kind: "resume-unsupported";
+}>>;