@astrosheep/keiyaku 4.0.5 → 4.1.0

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

@@ -1,6 +1,6 @@
 {
   "name": "keiyaku",
-  "version": "0.1.0+codex.20260819092206",
+  "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.20260819092206",
+  "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.20260819092206",
+  "version": "0.1.0+codex.20260819155641",
   "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] [--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
@@ -196,11 +197,16 @@ 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

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

@@ -10,6 +10,7 @@ export type AkumaListRow = Readonly<{
     description?: string;
     life: AkumaLife;
     lifeAt: string | null;
+    lastActivityAt: string | null;
     pending: readonly string[];
 }>;
 export type AkumaStatus = Readonly<{
@@ -46,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,6 +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),
+        lastActivityAt: snapshot.lastActivityAt,
         pending: snapshot.pending.map((tell) => tell.id),
     };
 }
@@ -117,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,
@@ -218,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);
@@ -253,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);
@@ -375,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");

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

@@ -96,7 +96,11 @@ function decodeArchetype(name, path, markdown) {
     const network = archetypeEnum(values, "network", ["disabled", "enabled"]);
     const description = archetypeField(values, "description");
     const allowed = effectiveAllowedActions(values.allowed);
+    const systemPromptMode = archetypeEnum(values, "systemPromptMode", ["append", "replace"]);
     const systemPrompt = lines.slice(closing + 1).join("\n");
+    if (systemPromptMode !== undefined && systemPrompt.length === 0) {
+        throw new TypeError("Akuma systemPromptMode requires a nonempty Markdown body");
+    }
     return Object.freeze({
         name,
         path,
@@ -105,10 +109,13 @@ function decodeArchetype(name, path, markdown) {
         options: decodeProviderOptions({
             ...(model === undefined ? {} : { model }),
             ...(effort === undefined ? {} : { effort }),
-            ...(readonly === undefined ? {} : { readonly }),
             ...(network === undefined ? {} : { network }),
-            ...(systemPrompt.length === 0 ? {} : { systemPrompt }),
+            ...(systemPrompt.length === 0 ? {} : {
+                systemPrompt,
+                systemPromptMode: systemPromptMode ?? "append",
+            }),
         }),
+        ...(readonly === undefined ? {} : { readonly }),
         allowed,
     });
 }
@@ -184,10 +191,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 +203,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 +235,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";
+}>>;