@astrosheep/keiyaku 4.0.0 → 4.0.1

package/README.md

@@ -1,16 +1,9 @@
-# Keiyaku v4
+# Keiyaku
 
-Keiyaku v4 is a clean implementation of an agent-facing contract workflow.
+Keiyaku is an agent-facing contract workflow.
 
 The first milestone is intentionally narrow: a Git-backed facts kernel with
 per-contract append-only journals, Git-tree evidence, atomic path-set CAS,
 and tests that prove clone and garbage-collection durability.
 
 No v3 runtime code is wired into this repository.
-
-## Install
-
-```sh
-npm install -g @astrosheep/keiyaku
-keiyaku --help
-```

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

@@ -1,7 +1,7 @@
 {
   "name": "keiyaku",
-  "version": "0.1.0",
-  "description": "Use the Keiyaku v4 contract, task, and Akuma CLI.",
+  "version": "0.1.0+codex.20260813114301",
+  "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,7 +1,7 @@
 {
   "name": "keiyaku",
-  "version": "0.1.0",
-  "description": "Use the Keiyaku v4 contract, task, and Akuma CLI.",
+  "version": "0.1.0+codex.20260813114301",
+  "description": "Use the Keiyaku contract, task, and Akuma CLI.",
   "author": {
     "name": "Keiyaku"
   },
@@ -9,10 +9,10 @@
   "interface": {
     "displayName": "Keiyaku",
     "shortDescription": "Use Keiyaku in Codex.",
-    "longDescription": "Keiyaku adds the v4 agent-facing workflow CLI.",
+    "longDescription": "Keiyaku adds the agent-facing workflow CLI.",
     "developerName": "Keiyaku",
     "category": "Productivity",
     "capabilities": [],
-    "defaultPrompt": "Use Keiyaku v4 to coordinate this work."
+    "defaultPrompt": "Use Keiyaku to coordinate this work."
   }
 }

package/build/integrations/marketplace/plugins/keiyaku/opencode.js

@@ -1,11 +1,11 @@
 import { readFile } from "node:fs/promises";
 import { fileURLToPath } from "node:url";
 
-const skills = ["keiyaku", "keiyaku-task", "keiyaku-workflow", "keiyaku-akuma"]
+const skills = ["keiyaku", "keiyaku-task", "keiyaku-bind", "keiyaku-workflow", "keiyaku-akuma"]
   .map((name) => fileURLToPath(new URL(`./skills/${name}/SKILL.md`, import.meta.url)));
 
 export default {
-  id: "keiyaku-v4",
+  id: "keiyaku",
   server: async () => ({
     config: async (config) => {
       const instructions = config.instructions ?? (config.instructions = []);

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

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

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

@@ -11,24 +11,32 @@ read `<command> --help` before using flags.
 ## Model
 
 - `task` is planning; see `keiyaku-task`.
-- A Contract is delivery authority; see `keiyaku-workflow`.
+- A Contract is delivery authority; see `keiyaku-bind` to author and bind one,
+  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.
+
 ## Quick Start
 
 ```bash
 keiyaku -C <repo> task add "title"
 keiyaku -C <repo> task start <task-id>
-keiyaku -C <repo> bind -
+keiyaku -C <repo> bind [--task <task-id>] -
 keiyaku -C <repo> status
 keiyaku -C <repo> deliver [<contract>|@<contract>]
 keiyaku -C <repo> review [<contract>|@<contract>] --satisfied
 ```
 
 ```bash
-keiyaku -C <repo> call <akuma> [--contract <kei/...>] [--alias @name] [--workdir <path>] [--wait [--timeout <duration>] | -d | --detach] [--json] -
+keiyaku -C <cwd> call <akuma> [--contract <kei/...>] [--alias @name] [--wait [--timeout <duration>] | -d | --detach] [--json] -
 keiyaku -C <repo> wait <aku/...>
 keiyaku -C <repo> tell <aku/...> -
 ```
 
+`-C` is the invocation and Akuma execution cwd. Add `--repo <path>` only when
+a Contract or Dispatch reader must use a different Git repository.
+
 Use text by default; add `--json` when a script needs structured output.

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

@@ -11,22 +11,25 @@ An Akuma is a durable callable worker projection. Its complete id is
 ## Choose A Verb
 
 ```bash
-keiyaku -C <repo> call <akuma> [--contract <kei/...>] [--alias @name] [--workdir <path>] [--wait [--timeout <duration>] | -d | --detach] [--json] -
+keiyaku -C <cwd> call <akuma> [--contract <kei/...>] [--alias @name] [--wait [--timeout <duration>] | -d | --detach] [--json] -
 keiyaku -C <repo> wait <aku/...> [--timeout <duration>]
 keiyaku -C <repo> tell <aku/...> -
-keiyaku -C <repo> interrupt <aku/...> -
+keiyaku -C <repo> tell <aku/...> --interrupt -
 keiyaku -C <repo> history <aku/...>
 keiyaku -C <repo> fork <aku/...> --at <historyId>
 keiyaku -C <repo> kill <aku/...>
 ```
 
 `call` starts from an Archetype, requires a final stdin body, and waits up to
-five minutes by default. Use `-d` or `--detach` to return after birth. `tell` continues
+five minutes by default. Its execution cwd is exactly `-C` (or the process cwd
+when omitted). Use `--repo <path>` only with a Contract or Dispatch reader that
+must use a different Git repository. Use `-d` or `--detach` to return after birth. `tell` continues
 the same projection, including after it has answered. `fork` starts a child
 from one exact retained answered-turn coordinate and leaves the source alone.
-`interrupt` puts down the current body synchronously, then records the tell;
-it is not terminal kill. `kill` records death and returns typed physical
-evidence.
+`tell --interrupt` puts down the current Body synchronously, then records the
+Tell for its successor. `kill` stops the current Body while preserving the
+Akuma's Heart, session, history, pending Tells, and Body Requests; a later Tell
+wakes the same Akuma.
 
 ## Observe
 

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

@@ -0,0 +1,94 @@
+---
+name: keiyaku-bind
+description: Author and bind one Keiyaku delivery Contract. Use when deciding whether a bounded delivery is ready for Contract terms, writing those terms for an implementer, binding an existing Task with `bind --task`, choosing bind inputs, or interpreting the bind receipt and worktree handoff.
+---
+
+# Keiyaku Bind
+
+Use bind when the work is a delivery decision rather than an investigation.
+The objective and delivery boundary should be clear, the expected write surface
+should be truthful, and every criterion should be decidable without inventing
+taste at review time. Investigate first when a plausible unresolved fact could
+change the objective, governing design, criteria, or delivery boundary.
+
+## Author The Terms
+
+Write for the implementer and reviewer. Include facts they cannot safely
+recover locally: the owner, boundary, data-flow direction, commit point, single
+authority, and forbidden parallel shapes. Leave ordinary helper names and
+equivalent local control flow to the implementation.
+
+A design statement earns its place when a test-green candidate could violate
+it. A criterion names one observable condition that can accept or reject the
+candidate. Keep the Region truthful and no broader than the intended write
+surface.
+
+Start from this complete shape:
+
+~~~markdown
+# <delivery name>
+
+## Context
+<established facts that frame the decision>
+
+## Objective
+<one observable delivery outcome>
+
+## Design
+<ownership, boundaries, and constraints a test-green candidate could violate>
+
+## Region
+```
+<expected write surface>
+```
+
+## Criteria
+### <criterion title>
+<one decidable acceptance condition>
+
+## Verification
+```bash
+<optional executable check>
+```
+~~~
+
+Use an H1 title and the H2 sections shown above. `Verification` is optional.
+When a declaration needs a limit, put an explicit duration such as
+`bash timeout=5m` in its fence info string; omit it for an unbounded declaration.
+Keep extra rationale and investigation logs out of the Contract.
+
+## Bind
+
+Inspect the actual command surface before choosing inputs:
+
+```bash
+keiyaku -C <repo> bind --help
+```
+
+Bind the complete document through stdin. A Task is optional: a Contract is
+complete delivery authority on its own, and ordinary bounded delivery does not
+require creating planning state first. Use `--task` only when an existing Task
+already carries real scheduling, dependency, or coordination value and this
+Contract is specifically its delivery:
+
+```bash
+keiyaku -C <repo> bind - < CONTRACT.md
+keiyaku -C <repo> bind --task <task/...> - < CONTRACT.md
+```
+
+Do not create a Task merely to make `bind --task` available or to mirror the
+Contract objective. That adds a second lifecycle with no planning reader.
+
+Use `bind --help` as the installed command authority for optional target,
+workspace, prerequisite, gate-set, actor, and JSON inputs. Do not guess flags
+from an older installation or repository checkout.
+
+## Read The Receipt
+
+Treat the receipt as the handoff. Keep the complete `kei/...` identity, work in
+the reported managed worktree when one was created, and retain the target and
+gate facts it reports. A waiting receipt means prerequisites remain; it is not
+a second authoring workflow. A post-admission lag does not erase the admitted
+Contract; read the typed facts, effects, and lag before acting.
+
+Continue the delivery with `keiyaku-workflow`.

package/build/integrations/marketplace/plugins/keiyaku/skills/keiyaku-bind/agents/openai.yaml

@@ -0,0 +1,4 @@
+interface:
+  display_name: "Keiyaku Bind"
+  short_description: "Author and bind a delivery Contract."
+  default_prompt: "Use $keiyaku-bind to author and bind this delivery."

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

@@ -7,7 +7,13 @@ description: "Use when planning work in a Keiyaku v4 repo: add tasks, wire depen
 
 Task is a directory-context planning product. It is separate from Contract
 delivery and Akuma execution. A task records intent; `start` does not execute
-it and no task command binds a Contract.
+it and no task command binds a Contract. Task use is optional: create one only
+when planning needs a durable reader such as priority, dependencies, readiness,
+or coordination across deliveries. Do not create one as boilerplate before
+binding a Contract. Contract `bind --task <task/...>` optionally associates an
+existing Task through Settlement-owned TaskHolder: claim settles the current
+held Task to `done`, and abandon releases it. Task Markdown carries no Contract
+field.
 
 ## Lifecycle
 
@@ -55,8 +61,37 @@ keiyaku task update <task-id> --title <text>
 keiyaku task namespace [<namespace>]
 ```
 
-Use `--json` on any command when a script must inspect the typed result. Use
-`task compose -` for one atomic tree/graph edit; read its command help for the
-composition grammar. Relations are explicit facts: `needs` orders work,
-`parent` groups it, `supersedes` navigates replacement, and `relates` does not
-affect readiness.
+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.
+
+## Batch Create Or Modify
+
+Use `task compose -` to create and modify multiple Tasks in one planning
+document:
+
+```bash
+keiyaku task compose - <<'EOF'
+ns=feature
++ Parent pri=0
+Parent body.
+  + Child needs=@task/existing
+@task/existing pri=1 relates+=@task/other
+Replacement body.
+EOF
+```
+
+- Optional first line `ns=<segment/...>` selects the allocation namespace;
+  `ns=` selects root.
+- `+ <title>` creates a Task. `@task/<id>` modifies an existing Task.
+- Two spaces of indentation assign the preceding shallower Task as `parent`.
+- Inline assignments are `pri=`, `parent=`, `needs=`, `supersedes=`, and
+  `relates=`. Relation values are comma-separated `@task/...` references.
+- `=` replaces or clears a field. `+=` appends only to `needs`, `supersedes`,
+  or `relates`.
+- Prose after a node replaces its body; bare `body=` clears it. Prefix body
+  lines beginning with `+ `, `@task/`, or `\` with one `\`.
+
+Compose does not change Task lifecycle state. Each changed Task is admitted
+independently; an incomplete result returns a canonical draft for the remaining
+batch.

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

@@ -5,68 +5,185 @@ description: Use when authoring, binding, delivering, reviewing, amending, audit
 
 # Keiyaku Workflow
 
-A Contract is one delivery authority. Its document is ordinary input until
-`bind` admits it; the bound Contract owns its coordinates, terms, prerequisite
-snapshot, candidate, reviews, gates, and terminal decision. Task planning and
-Akuma execution remain separate products.
+A Contract turns one bounded delivery into acceptable terms: write what done
+means, bind it, work in the worktree the receipt names, and deliver. When
+every declared gate is current, the result lands on the target ref. This is
+the whole trip from current work to `claimed`.
 
-## Lifecycle
+## How The Delivery Moves
 
 ```text
-bind -> waiting | bound -> pending delivery -> claimed
-                                      \-> abandoned
+contract document -> bind -> work in the Contract worktree -> deliver
+                             -> review gates -> placement -> claimed
+                                                      \-> abandoned
 ```
 
-`claimed` and `abandoned` are terminal. A prerequisite `after` list is ordered
-and immutable after `bound`; `amend` can replace terms and change prerequisites
-only before they are consumed. `deliver` tenders current worktree bytes.
-`review --satisfied` records testimony and requests placement; placement claims
-only when every declared gate is current. `review --unsatisfied` records
-judgment without claiming. `audit` observes and never places.
+The lifecycle is `waiting -> bound -> pending-delivery -> claimed | abandoned`;
+the last two are terminal. `--after` prerequisites hold a Contract at
+`waiting`; it becomes `bound` automatically once they are satisfied. You never
+push it through states by hand: `deliver` and satisfied reviews request
+placement, and placement claims when the gates allow it.
 
 ## Bind
 
-Write one canonical Contract document to stdin and bind it:
+Use `keiyaku-bind` to decide readiness, author one bounded Contract, choose
+bind inputs, and read the receipt. Continue here from that receipt.
+
+## Work In The Contract Worktree
+
+Change and test code in the worktree the bind receipt names. `deliver` accepts
+a clean worktree by default. You may commit first, or explicitly include all
+non-ignored staged, unstaged, and untracked final bytes with
+`deliver --include-dirty`. Check where you are at any point:
 
 ```bash
-keiyaku bind -
-keiyaku bind --target <ref> -
-keiyaku bind --here -
-keiyaku bind --after <kei/...> --gates <name> -
+keiyaku status [<contract>|@<contract>]
 ```
 
-The document owns the delivery objective, design, scope, criteria, and optional
-verification declaration. Use the exact `bind --help` grammar; do not invent
-identity or timestamps. A successful receipt is the source of the complete
-Contract coordinate and any managed worktree facts.
+`status` shows the lifecycle state, the candidate, and one mark per gate: `✓`
+current satisfied, `!` current unsatisfied, `?` stale because the patch or
+document changed after the evidence, and `○` missing.
+
+## Commission A Contract
+
+When another agent will fulfill or review the Contract, the commissioning
+harness must pass one explicit seat and one exact worktree. `--contract` or an
+equivalent association identifies the Contract; it does not appoint a seat.
+Never ask the worker to infer either value.
+
+Use this minimum handoff in the dispatch body, regardless of harness:
+
+```text
+Contract: kei/...
+Seat: Deliverer | Reviewer
+Worktree: /absolute/path/from-the-bind-receipt
+Read first:
+- .keiyaku/KEIYAKU.md
+- <owner documents governing this delivery>
+- <source files named or selected from the Contract Region for this work>
+Objective:
+<bounded assignment>
+```
+
+Every `Read first` path is relative to `Worktree` unless it is absolute. The
+worker starts by reading `.keiyaku/KEIYAKU.md` in that worktree, confirms its
+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.
+
+A `Deliverer` implements and verifies the terms, keeps all work in `Worktree`,
+and reports the candidate, checks run, and unmet terms. A `Reviewer` reads the
+same worktree and Contract, judges the current candidate with direct evidence,
+and does not modify it. If `Seat`, `Worktree`, or the required reading list is
+missing or contradictory, the worker stops and asks the caller instead of
+guessing.
 
-## Work And Acceptance
+## Arcs For Large Deliveries
+
+When one Contract carries several coherent chunks, record each chunk as an arc
+before moving to the next:
 
 ```bash
-keiyaku status [<contract>|@<contract>]
-keiyaku amend [<contract>|@<contract>] -
-keiyaku arc [<contract>|@<contract>] -
-keiyaku deliver [<contract>|@<contract>]
-keiyaku review [<contract>|@<contract>] --satisfied
-keiyaku review [<contract>|@<contract>] --unsatisfied
-keiyaku audit [<contract>|@<contract>] [--show-diff-body]
-keiyaku reconcile [<contract>|@<contract>]
+keiyaku arc <contract> -
+```
+
+The stdin body is the arc's Markdown; see `arc --help` for its shape. Arcs
+narrate one delivery; they do not split acceptance. Work that needs its own
+independent acceptance is a new Contract, not an arc.
+
+## Amend Or Start Over
+
+Use `amend` when a discovery during the same delivery changes terms but the
+original Objective, Design, and acceptance boundary still truthfully describe
+the result:
+
+```bash
+keiyaku amend <contract> -
 ```
 
-Use complete `kei/...` IDs or `@...` managed-worktree references. Omitted
-selectors are contextual only when the CLI reports exactly one active
-worktree contract. `amend` reads amendment operations, `arc` reads arc
-Markdown, and both require their final `-`; `deliver`, `review`, `audit`, and
-`reconcile` do not read an unselected stdin body. `review --summary <text>` is
-opaque testimony and is mutually exclusive with review stdin.
+See `amend --help` for the operation grammar. If the objective or boundary
+itself changed, `abandon` with a note and bind a new Contract; do not steer an
+old Contract onto a different delivery.
+
+## Deliver
+
+```bash
+keiyaku deliver <contract>
+```
+
+`deliver` tenders the clean `HEAD`, runs the declared `Verification`, records
+the candidate, and requests placement. If the workspace is dirty, the refusal
+lists staged, unstaged, and untracked paths, a short statistic, and the
+`--include-dirty` option. Use that option only when the complete current
+workspace is the intended delivery; dirty submodule internals cannot be
+included. Read the receipt:
+
+- When every gate is current, the receipt shows placement and `claimed`; the
+  delivery is done.
+- When a gate is not current, the receipt shows the recorded candidate and the
+  placement stop. This is not a failed delivery. The Contract stays
+  `pending-delivery` while you complete the gates.
+
+Verification declarations may set an individual timeout in the fence info
+string, using an explicit duration unit such as `bash timeout=5m`. Omit the
+attribute for an unbounded declaration; there is no Verification-wide timeout.
+
+## Review Gates
+
+A `reviewed` gate wants a recorded judgment of the current patch:
+
+```bash
+keiyaku review <contract> --satisfied --summary "<conclusion>"
+keiyaku review <contract> --unsatisfied --summary "<finding>"
+```
+
+Have an independent reviewer read the exact Contract worktree first; the
+`review` command records the gate-visible verdict. `--satisfied` requests
+placement. If the same patch is already delivered and the other gates are
+current, the receipt shows `claimed`. Review works before or after deliver.
+When the reviewed projection includes ordinary dirty workspace bytes, the
+review receipt discloses those paths and stats; delivery still needs
+`deliver --include-dirty` before those bytes become the candidate.
+
+Fixing findings changes the patch, which turns earlier evidence stale (`?` in
+`status`): review the current patch again. Record `--unsatisfied` only when the
+negative judgment should remain in Contract history.
+
+## Target Placement
+
+Placement follows the Git mental model you already have:
+
+- Delivering from a managed worktree to a checked-out target behaves like a
+  merge. Non-overlapping staged, unstaged, and untracked files in that checkout
+  are preserved. A staged path refuses only when Git cannot carry it through
+  the predecessor-to-candidate merge; overlapping worktree changes and
+  colliding untracked files also refuse. The receipt lists the exact paths.
+  The deliver or review you just ran still counts: the recorded candidate and
+  any `✓ reviewed` verdict are kept, but nothing claims and nothing moves.
+  The target ref, its checkout, and your bytes stay exactly where they were,
+  and the Contract stays `pending-delivery`.
+- A `--here` Contract behaves like a commit with gates: it lands on the current
+  branch and cannot deliver to a foreign checked-out target.
+
+After a refusal, handle the listed paths, then `deliver` again or record a
+satisfied review; either command requests placement again.
+
+## Observe, Recover, Or End
+
+```bash
+keiyaku audit <contract> [--show-diff-body]   # report only; never places
+keiyaku reconcile <contract>                  # finish accepted lagging effects
+keiyaku abandon <contract> --note "<why>"     # terminal; target untouched
+```
 
-## Terminal Choice
+`audit` is one aggregate read of the document, candidate diff, Verification,
+gates, and target status. `reconcile` completes physical effects of already
+accepted placements; it does not retry an ordinary placement refusal.
+`abandon` ends the Contract and never touches the target.
 
-`abandon [<contract>|@<contract>] [--note <text>]` writes the terminal
-abandoned fact and does not touch a target ref. There is no `petition`, `claim`,
-`forfeit`, `renew`, or `bind --task` command in v4. A successful placement
-produces the claimed terminal state; inspect the typed result and decide what
-to do next.
+## Routine Output
 
-Use default text output for routine observation. Add `--json` when a script
-needs the public result without renderer-specific text.
+Use default text output for normal operation and `--json` only when a script
+needs the public result. Use the complete `kei/...` ID, or `@...` inside a
+managed worktree. When a flag or stdin form is unclear, read that command's
+`--help` instead of guessing.

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

@@ -1,7 +1,8 @@
 import { type AkumaLife, type CollarProbe, type KillEvidence, type ResumeCoordinate, type Soul } from "./heart/index.js";
 import { type AkuId } from "./identity.js";
-import { type ActivityHistory, type ActivitySnapshot } from "./activity.js";
+import { type ActivityHistory, type ActivitySnapshot } from "./projection.js";
 import { type Settings } from "../settings.js";
+import type { WorldRoot } from "../world.js";
 export type AkumaListRow = Readonly<{
     id: AkuId;
     archetype: string;
@@ -11,14 +12,14 @@ export type AkumaListRow = Readonly<{
     confinement: Soul["confinement"];
     pending: readonly string[];
 }>;
-export type AkumaStatus = AkumaListRow & Readonly<{
-    answer?: string;
-    answerHistoryId?: string;
-    failure?: string;
-    outcomeAt?: string;
-    activity: ActivitySnapshot;
+export type AkumaStatus = Readonly<{
+    id: AkuId;
+    life: AkumaLife;
+    collar: CollarProbe;
+    timeline: ActivitySnapshot;
+    strandedReason?: "resume-unsupported";
 }>;
-export type { ActivityHistory, ActivityRow, ActivitySnapshot } from "./activity.js";
+export type { ActivityHistory, ActivityRow, ActivitySnapshot, ActivitySnapshotEntry } from "./projection.js";
 export type UnbornAkumaListRow = Readonly<{
     id: AkuId;
     life: "unborn" | "stillborn";
@@ -31,25 +32,26 @@ export type AkumaList = Readonly<{
     rows: readonly (AkumaListRow | UnbornAkumaListRow)[];
     searched: readonly string[];
 }>;
-export type TellReceipt = Readonly<{
-    id: string;
-    state: "recorded";
+export type AkumaListInput = Readonly<{
+    archetype?: string;
+}>;
+export type TellResult = Readonly<{
+    admission: Readonly<{
+        tellId: string;
+        fact: "recorded";
+    }>;
     wake: "spawned" | Readonly<{
         kind: "failed";
         diagnostic: string;
     }>;
 }>;
 export type InterruptReceipt = Readonly<{
-    kind: "dead";
-}> | Readonly<{
     kind: "unstoppable";
     evidence: "no-collar" | "collar-unverifiable" | "unavailable" | "alive-after-sigkill" | "leash-held-after-put-down";
 }> | Readonly<{
     kind: "interrupted";
     putDown: "was-idle" | "self-aborted" | "collar";
-    tell: TellReceipt | Readonly<{
-        kind: "refused-dead";
-    }>;
+    tell: TellResult;
 }>;
 export type ForkReceipt = Readonly<{
     kind: "forked";
@@ -73,10 +75,12 @@ export declare class AkumaNotBornError extends Error {
     readonly kind = "akuma-not-born";
     constructor(id: AkuId);
 }
+/** Package-internal compact observation for action feedback. */
+export declare function readActionFeedbackStatus(worldPath: WorldRoot, id: AkuId): AkumaStatus;
 export declare class AkumaHandle {
     readonly id: AkuId;
     private readonly worldPath;
-    constructor(id: AkuId, worldPath: string);
+    constructor(id: AkuId, worldPath: WorldRoot);
     private get paths();
     status(): AkumaStatus;
     history(input?: Readonly<{
@@ -87,22 +91,26 @@ export declare class AkumaHandle {
     wait(predicate?: (status: AkumaStatus) => boolean, options?: Readonly<{
         timeoutMs?: number;
     }>): Promise<AkumaStatus>;
-    tell(body: string): Promise<TellReceipt>;
+    tell(body: string): Promise<TellResult>;
     interrupt(body: string): Promise<InterruptReceipt>;
     fork(input: Readonly<{
         at: string;
     }>): Promise<ForkReceipt>;
     kill(): Promise<KillEvidence>;
-    lastAnswer(): string;
+    lastAnswer(): LastAnswer;
 }
+export type LastAnswer = Readonly<{
+    kind: "answer";
+    answer: string;
+}> | Readonly<{
+    kind: "no-answer";
+}>;
 export declare class Akuma {
     private readonly path;
-    private readonly settings;
+    private readonly configuredSettings?;
     private constructor();
-    static at(input: Readonly<{
-        path: string;
-        settings?: Settings;
-    }>): Akuma;
+    static of(root: WorldRoot, settings?: Settings): Akuma;
+    private settings;
     of(input: Readonly<{
         id: string;
     }>): AkumaHandle;
@@ -112,5 +120,5 @@ export declare class Akuma {
         body: string;
         cwd?: string;
     }>): Promise<AkumaHandle>;
-    list(): AkumaList;
+    list(input?: AkumaListInput): AkumaList;
 }