@astrosheep/keiyaku 4.5.27 → 4.5.28

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

@@ -1,6 +1,6 @@
 {
   "name": "keiyaku",
-  "version": "0.1.2",
+  "version": "4.5.28",
   "description": "Use the Keiyaku contract, task, and Akuma CLI.",
   "author": {
     "name": "Keiyaku"

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

@@ -1,6 +1,6 @@
 {
   "name": "keiyaku",
-  "version": "0.1.2+codex.20260905023250",
+  "version": "4.5.28+codex.20260905023250",
   "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.2",
+  "version": "4.5.28",
   "type": "module",
   "main": "./opencode.js",
   "keywords": [

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

@@ -36,7 +36,7 @@ keiyaku -C <repo> review [<contract>|@<contract>] --satisfied
 ```
 
 ```bash
-keiyaku -C <cwd> call <akuma-name> [--contract <kei/...>] [--workdir <path>] [--alias @name] [--allowed <product.action>]... [--schema <file>] [--wait <duration> | -d | --detach] (<prompt> | -)
+keiyaku -C <cwd> call <akuma-name> [--contract <kei/...>] [--workdir <path>] [--alias <name>] [--allowed <product.action>]... [--schema <file>] [--wait <duration>] (<prompt> | -)
 keiyaku -C <repo> wait <akuma-selector>... [--any | --all]
 keiyaku -C <repo> tell <aku/...|@alias> (<prompt> | -)
 ```
@@ -44,8 +44,8 @@ keiyaku -C <repo> tell <aku/...|@alias> (<prompt> | -)
 `-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.
+cwd). Without it, the call uses the invocation cwd; `--contract` associates a
+Contract without selecting an execution directory.
 
 Repeated `--allowed` values add actions to the selected Akuma's defaults. A
 nested call can use only actions permitted by its direct parent Soul.

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

@@ -1,206 +1,125 @@
 ---
 name: keiyaku-akuma
 description: >-
-  Calling an Akuma: delegating scouting, mechanical chores, or fanned-out
-  parallel work instead of doing it inline.
+  Calling an Akuma: delegate work to a new or existing worker, then observe,
+  guide, and collect the result.
 ---
 
 # Keiyaku Akuma
 
-An Akuma is a durable callable worker. Its complete identity is
-`aku/<akuma>/<hex8>` — keep it; it is how you address the same worker
-later. An Alias is a movable world-local selector usable wherever a direct id
-is accepted; the identity underneath never changes.
+Use Akumas to delegate work to another worker. `call` creates a new Akuma;
+`tell` gives an existing Akuma another prompt. Keep the complete AkuId, such
+as `aku/worker/1234abcd`, when you need to address the same worker later. An
+alias such as `@reviewer` is a shorter, world-local name.
 
-## Automated Orchestration
-
-For task-specific JavaScript orchestration with the public Akuma API, read
-[Automation With The Akuma API](references/automation.md). It covers structured
-answers, semantic ranking and tournaments, adversarial verification, learning
-from corrections, bounded parallelism, and failure/reconnection handling.
-Use it when the flagship should write and run a program for this task rather
-than coordinate every delegation in conversation. The examples are adaptable
-techniques, not a fixed workflow or a built-in workflow runtime.
-
-## Start One
+## Call a new Akuma
 
 ```bash
-keiyaku -C <cwd> call <akuma-name> [--workdir <path>] [--alias @name] [--allowed <product.action>]... [--schema <file>] [--wait <duration> | -d | --detach] (<prompt> | -)
+keiyaku -C <cwd> call <akuma-name> [--workdir <path>] [--alias <name>] [--allowed <product.action>]... [--schema <file>] [--wait <duration>] (<prompt> | -)
 ```
 
-Give the worker's initial prompt as one argument (quote it when it contains
-spaces), or use final `-` to read it from stdin. These forms are mutually
-exclusive. Decide up front whether you will stay:
-
-- The default observes up to five minutes and writes the complete answer when
-  it arrives inside that window. `--wait <duration>` replaces that window.
-- `-d` / `--detach` returns right after birth with the AkuId. Use it when the
-  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. `-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; they
-never narrow them. An omitted Archetype permits `akuma.*`, every `task.*`,
-`contract.audit`, and `contract.deliver`; `contract.review` requires an explicit
-Archetype or call-time grant. 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.
-
-## Answer Schemas
-
-For a schema-bearing call or tell through the public API, pass the schema
-directly — `{ schema: z.object({ claim: z.string() }) }` — importing `z` from
-the package root next to `Akuma`. Any Standard Schema v1 value works the same
-way, and the explicit `Schema.zod(...)` and `Schema.json(...)` forms remain
-available for callers who want them.
-
-Keep an answer contract inside simple JSON shape vocabulary: objects, arrays,
-strings, numbers, booleans, enums, literals, and optional or nullable fields.
-Do not attach `.max`, `.min`, `.regex`, `.refine`, `.transform`, or other
-constraint methods. The provider must satisfy the contract, and a fragile or
-unrepresentable constraint fails the loop after submission; the seam refuses
-such a schema at submission and names the offending keyword instead. Enforce
-bounds, formats, and cross-field rules in ordinary caller code after the answer
-arrives, and treat a full JSON Schema through `Schema.json(...)` as the explicit
-waiver a caller signs only when it owns that risk.
-
-## Akuma Names
-
-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. A name may
-also ask for full host access, which disables only its provider's native
-command sandbox and never grants extra operating-system permissions; it
-cannot combine with a readonly restriction or a disabled network. `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
-
-A call assembles a commission from independent inputs: the selected Akuma fixes
-capability stance for the identity's whole life; the `--contract` Dispatch
-associates standing terms; allowed actions set what the callee may do, subject
-to that Akuma's restrictions and the parent Soul's ceiling; the prompt carries
-the question. None of these implies another — association is not a seat, forwarded
-actions are not a seat, and no combination mints a role.
-
-The prompt and every later tell genuinely direct the callee's work: they choose
-the subject, scope, depth, risks, and deliverable of the round. They spend
-decisions already made and ask questions still open; they never change the
-Dispatch, the journal, or what counts as acceptance, and an expectation stated
-in a prompt is never evidence for the callee's own findings.
-
-A commission can be as large as a whole Contract's fulfillment loop: call one
-Aku with the Contract association, forward the actions the loop needs —
-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:
+The prompt is the new Akuma's first prompt. Give it as one argument, or use
+`-` to read stdin, never both. Calls are detached by default: they return the
+new identity after birth without waiting for the first answer. Use explicit
+`--wait <duration>` when this invocation should block while observing that
+initial work. `--wait` only bounds this command; it never stops the Akuma.
 
-```bash
-keiyaku -C <repo> call worker --contract <kei/...> --workdir <repo> --allowed contract.deliver -d "Own this Contract loop."
+Useful options:
+
+- `--alias <name>` assigns a reusable world-local `@name` selector; `--alias @name` is also accepted. An existing alias moves to this Akuma.
+- `--contract <kei/...>` associates the Akuma with a Contract; it never selects an execution directory.
+- `--workdir <path>` chooses its execution directory; without it the call uses the invocation cwd.
+- `--allowed <product.action>` adds actions subject to the Akuma's restrictions.
+- `--schema <file>` requests a structured answer described by a JSON Schema.
+
+The selected Akuma name is a reusable worker configuration, not an individual.
+Calling it again creates an independent Akuma. Use different names for
+capabilities, not merely for parallelism.
+
+## Public-library core example
+
+```ts
+const akuma = await Akuma.birth({ path, archetype: "worker" });
+const answer = await akuma.tell("Inspect the change");
+console.log(answer);
 ```
 
-## Watch
+## Commission Context
 
-```bash
-keiyaku status                            # deep fleet observation
-keiyaku status <aku/...|@alias>           # one worker's snapshot
-keiyaku ls aku/                           # shallow catalog; also aku/<akuma>/ and "aku/*/*"
-keiyaku wait <selector>... [--any | --all] [--timeout <duration>]
+`--contract` only records the association. It does not tell the Akuma the
+Contract or worktree. Put them in the prompt explicitly:
+
+```text
+Contract: <kei/...>
+Worktree: <exact path>
+This Arc: <what to do>
 ```
 
-`wait` accepts complete ids, aliases, and Akuma globs. Prefer one plural wait
-over separate waits. The default mode is any: the wait returns when any
-selected Akuma completes, and a member that already completed counts right
-away, so waiting again can return at once. Use `--all` to wait until every
-selected Akuma completes:
+`--contract` does not choose a worktree. Use `--workdir <path>` when needed.
+
+## Tell an existing Akuma
 
 ```bash
-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 --timeout 5m   # returns when either completes
-keiyaku -C <cwd> wait @projection @host-boundary --all --timeout 5m
+keiyaku tell <aku/...|@alias> [--interrupt] [--schema <file>] [--wait <duration>] (<prompt> | -)
 ```
 
-Omitted mode behaves as `--any` and leaves the others alone. When the timeout
-expires, `wait` returns their current status without stopping them.
+Use `tell` for the next instruction. Plain `tell` lets current work continue;
+`--interrupt` asks the current Body to yield before the new prompt is handled.
+Use `--wait <duration>` to wait for this Tell's answer. An admitted Tell is
+not withdrawn when the wait ends. Use `--schema` when the answer must follow a
+JSON Schema.
 
-## Steer
+## Observe work
 
 ```bash
-keiyaku tell <aku/...|@alias> (<prompt> | -)
-keiyaku tell <aku/...|@alias> --interrupt (<prompt> | -)
+keiyaku wait <selector>... [--any | --all] [--timeout <duration>]
 ```
 
-Give `tell` one prompt argument (quote it when it contains spaces) or final `-`
-for stdin, never both.
-`tell` continues the same worker: it steers a live Body in place, or — when
-none is running, including after an answer — records the message durably and
-wakes a successor. `tell --interrupt` puts down the current Body synchronously
-first, then hands the message to the successor; it is not a kill. Choose plain
-`tell` when the current attempt should finish with your guidance folded in;
-choose `--interrupt` when the current attempt itself is the problem.
+Use `wait` for one or more existing Akumas. The default is `--any`; use
+`--all` for every selected Akuma. `--timeout` limits observation and does not
+stop workers. A completed Akuma already counts, so repeating a wait can return
+immediately.
+
+The three waiting forms have distinct subjects:
+
+```text
+call --wait   create an Akuma and observe its initial work
+tell --wait   deliver a Tell and observe that Tell's answer
+wait          observe existing Akumas
+```
 
-## Take The Answer
+## Inspect and retrieve results
 
 ```bash
+keiyaku status                         # current Akuma fleet
+keiyaku status <aku/...|@alias>        # one Akuma, including its execution workdir
+keiyaku ls aku/                        # names available to call
+keiyaku ls aku/<akuma>/                # existing workers from one name
+keiyaku ls "aku/*/*"                   # existing workers across names
 keiyaku history <aku/...|@alias> --last
 keiyaku history <aku/...|@alias> --id <historyId>
 keiyaku history <aku/...|@alias> [--before <N> | --since <N>] [--limit <N>]
 ```
 
-`--last` writes exactly the complete answer bytes of the latest answered turn
-and says so plainly when no answer exists yet. Snapshot rows elsewhere may
-clip long text; the terminal answer from `call`/`wait` and the bytes from
-`--last` are never clipped — when you need the full result, take it from one
-of those. Every completed answered or failed outcome carries one Heart-owned
-public `historyId` shaped as `turn/<positive-safe-integer>` in `status`, `wait`,
-and history output. Use `--id` with that same value to read exactly one retained
-outcome: text writes the complete answer or diagnostic bytes without clipping
-or framing. Provider-native history coordinates remain private. A malformed or
-unknown ID is a typed nonzero refusal. `--id` is mutually exclusive with
-`--last`, `--before`, `--since`, and `--limit`.
+Use `history --last` for the latest complete answer. Use `--id` for one exact
+answered result named by a status, wait, or history result. Use the complete
+AkuId when an alias may move.
 
-Cursor reads page the activity timeline; `--before` and `--since` are exclusive
-sequence cursors. `--limit` defaults to 50 and accepts at most 5000 semantic
-rows.
-
-## Stop
+## Stop and branch
 
 ```bash
 keiyaku kill <selector>...
+keiyaku fork <aku/...|@alias> --at <historyId>
 ```
 
-`kill` accepts the same id, alias, and glob selectors as `wait`. It stops the
-current Body and records that it did; everything else survives — Heart,
-session, history, pending Tells, and Body Requests — so a later `tell` wakes
-the same worker where it left off. Killing pauses a worker; nothing is
-deleted.
-
-## Branch
+`kill` stops current work without deleting the Akuma or its history. `fork`
+creates a new Akuma from one exact retained answered history point; the source
+is unchanged, and providers that cannot fork report that refusal.
 
-```bash
-keiyaku fork <aku/...|@alias> --at <historyId> [--alias @name]
-```
+## JavaScript automation
 
-`fork` starts a child from one exact retained answered-turn coordinate and
-leaves the source untouched. It is a provider capability, not a guarantee:
-when the provider cannot fork from that turn, the command refuses rather than
-fabricating a fresh start. Pass the same public `historyId` exposed by status,
-wait, or history; Heart privately resolves the provider coordinate. The ID must
-name an answered outcome with a provider fork point. Failed outcomes are not
-forkable.
+For a task-specific JavaScript program that coordinates Akumas, read
+[Automation With The Akuma API](references/automation.md). `Akuma.birth`
+creates an Akuma without a prompt; call `tell` on the returned handle to give
+it its first prompt. Use `idle()` when a script must wait before sending
+another schema Tell, and keep AkuIds in the script's own results.

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

@@ -1,123 +1,198 @@
 ---
 name: keiyaku-bind
 description: >-
-  Use when deciding what must be in one Keiyaku Contract and how its work
-  is divided into Arcs, or when writing or binding that Contract.
+  Must read before binding a `kei` (Contract). Use when deciding what belongs
+  in one `kei`, how to divide its work, and how to write or run `bind`.
 ---
 
-# Keiyaku Bind
+# Before Binding A Keiyaku
 
-## What Bind Records
+Bind records a Contract whose objective, design, and acceptance boundary are
+settled. Do not use it to leave an open design for someone else to decide.
 
-Bind journals decisions that have already been made. The Contract author
-arrives with the public outcome decided: Objective, Design, Region, Criteria,
-Verification. A design gap discovered while authoring goes back to whoever
-owns the decision — it is never forwarded into the worktree for a worker to
-resolve.
+## 1. What Must Be Clear Before Binding
 
-## Author And Freedom
+Settle these facts first:
 
-The author pins every public, high-level fact: surfaces, semantics, persisted
-shapes, the observable acceptance boundary. Private decomposition, helper
-names, and equivalent control flow belong to the Deliverer — and that freedom
-comes from the author genuinely not caring, never from the author not deciding.
-Criteria are observable accept/reject observations a Reviewer can judge without
-asking the author anything further.
+- objective and intended outcome;
+- architecture and module boundaries;
+- detailed design and implementation approach;
+- public interfaces, behavior, data, and persistence;
+- ordering, concurrency, dependencies, and failure behavior;
+- acceptance conditions;
+- verification and required evidence;
+- the affected Region;
+- the one holder responsible for the `kei`.
 
-## Author And Bind
+The Design section is a detailed design document. It may contain subsections
+such as:
 
-`keiyaku -C <repo> bind --help` lists the options; only the heredoc is
-stdin. Each section states what it must contain:
+- Architecture: components, module boundaries, ownership, and connections;
+- Interfaces And Behavior: public surfaces, inputs, outputs, success, and
+  refusal behavior;
+- Data And Persistence: data shape, identity, lifecycle facts, and persistence;
+- Approach And Flow: implementation approach, dependencies, ordering,
+  concurrency, and failure handling;
+- Pseudocode: algorithms and control flow.
+
+Record every design decision the implementation must follow. Add other Design
+subsections when needed. Do not bind while the architecture, design, approach,
+or acceptance conditions are open.
+
+### Contract Shape
+
+- Bind separate `kei`s for outcomes that can be accepted independently.
+- Use an Arc for a chapter inside one `kei`; an Arc is not separately accepted.
+- Use a Task for decomposition or dependency memory that must outlive the
+  current conversation.
+
+A `kei` owns one independently acceptable outcome and its delivery lifecycle. A
+Task records decomposition or dependency memory; it may exist without a `kei`,
+and it does not create a second acceptance or lifecycle. Associate a `kei` with
+an existing Task only when that Task has real scheduling or dependency value.
+Do not create a Task just to mirror a `kei`.
+
+### Parallel Work
+
+Parallel work is the default.
+
+- Bind and advance independent `kei`s in parallel. Each has its own acceptance
+  boundary and holder.
+- Within one `kei`, run independent Tasks or Arc chapters in parallel whenever
+  their work can proceed independently. They converge on the one acceptance
+  boundary, which the holder owns.
+
+Region overlap is planning information. It does not prevent parallel work and
+is not a lock, ownership claim, exact diff, or dependency. Use `--after` only
+when one result must exist before another can proceed because of a real logical
+dependency. Do not add `--after` merely because work touches the same Region.
+
+## 2. Bind Syntax
+
+Read the command's help for the complete option grammar:
+
+```bash
+keiyaku -C <repo> bind --help
+```
+
+Inspect declared Regions when planning parallel work:
+
+```bash
+keiyaku -C <repo> region
+keiyaku -C <repo> region <kei/...>
+keiyaku -C <repo> region --path 'src/**' --path 'tests/**'
+```
+
+These list active Regions, read one Contract's Region, or show active Regions
+overlapping the supplied patterns. Overlap is coordination information only.
+
+Bind from stdin with a heredoc or a saved Markdown file:
 
 ~~~~bash
 keiyaku -C <repo> bind - <<'KEIYAKU'
-# <Delivery name — one decision, active voice; source of the kei/... identity>
+# <Delivery name>
 
 ## Context
-<Premises: coordinates of the governing decision or document, and facts a
-reader would otherwise re-derive wrongly. Never narrative. If Objective and
-Design read the same without a sentence here, delete it.>
+<Motivation, authority, baseline, and boundaries.>
 
 ## Objective
-<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.>
+<One observable, independently acceptable outcome.>
 
 ## Design
-<The closed decisions. A statement belongs here exactly when a test-green
-candidate could still violate it: existing owner modules and entry points,
-what is reused or changed, the implementation approach, critical ordering, the
-exact public surface — each type with its fields, each verb with its success,
-refusal, and error arms and their reason words; the persisted format; which way
-data flows and where it commits or refuses; which parallel shapes are
-forbidden. Unresolved architectural choices are settled before binding. Private
-helper names and equivalent control flow remain the Deliverer's freedom.>
-
-```text
-<pseudocode — only where ordering matters>
-```
+### Architecture
+<Components, module boundaries, ownership, and connections.>
+
+### Interfaces And Behavior
+<Public surfaces, inputs, outputs, success, and refusal behavior.>
+
+### Data And Persistence
+<Data shape, identity, lifecycle facts, and persistence decisions.>
+
+### Approach And Flow
+<Implementation approach, dependencies, ordering, concurrency, and failure.>
+
+### Pseudocode
+<Algorithms and control flow.>
 
 ## Region
-<one intended write pattern per line — the narrowest justified intended
-writes for this approach, not every potentially involved file. Planning evidence
-for overlap detection, never ownership or the exact diff. No broad directory
-fallback or redundant parent/child patterns; directory patterns end with `/`.
-Fenced lines, list items, and bare lines are equivalent and union.>
+<One repository-relative write pattern per nonblank line.>
 
 ## Criteria
-### <one observable condition>
-<One accept/reject observation with its method: run this, observe that.
-Decidable without consulting you.>
+### <observable acceptance condition>
+<How to observe pass or refusal.>
 
 ## Verification
-```bash timeout=<honest bound>
+```bash timeout=5m
 <commands runnable exactly as written>
 ```
 KEIYAKU
 ~~~~
 
-Use separate fences for checks that need separate timeouts or results. Fences
-run top-to-bottom, and later fences may use earlier outputs. Put setup/build
-before its consumers; use `&&` in one fence only when the consumer must stop
-if setup fails.
+Use the narrowest justified Region patterns for likely writes. A trailing `/`
+is directory shorthand for `/**`. Patterns may be fenced lines, list items, or
+bare lines; those forms are combined. Region patterns are planning evidence,
+not a prediction of the exact diff.
+
+Verification is optional. Each declaration is a closed bash, zsh, or pwsh
+fence containing commands runnable as written. Use separate fences when checks
+need different timeouts or results. Use an explicit timeout for bounded
+commands; `5m` is the normal baseline.
 
-Each declaration may set an individual timeout in its fence info string, using
-an explicit duration unit such as `bash timeout=5m`. Omit it for an unbounded
-declaration; there is no Verification-wide timeout.
+Verification runs against the exact integration snapshot in a clean disposable
+worktree for that attempt. It does not run in the author's worktree or the
+target checkout. If the Contract declares Verification, `deliver` runs it when
+no current `verified` attestation exists and otherwise reuses the current
+attestation. A newly run unsatisfied result stops that delivery. `audit` runs
+Verification for a prospective candidate. `--gates reviewed` requires review
+evidence; it does not select or suppress Verification. Selected gates are
+checked at placement.
 
-For a saved document:
+For an existing Task with real scheduling or dependency value:
 
 ```bash
-keiyaku -C <repo> bind - < CONTRACT.md
 keiyaku -C <repo> bind --task <task/...> - < CONTRACT.md
 ```
 
-Use `--task` only for an existing Task with scheduling or dependency value;
-do not create one just to mirror the Contract.
+For a real logical dependency between Contracts:
+
+```bash
+keiyaku -C <repo> bind --after <kei/...> - < CONTRACT.md
+```
+
+Gate selection is part of binding:
+
+```bash
+keiyaku -C <repo> bind --gates <name,...> - < CONTRACT.md
+keiyaku -C <repo> bind --gates "" - < CONTRACT.md
+keiyaku -C <repo> bind --gates reviewed - < CONTRACT.md
+```
+
+Omitting `--gates` uses `gates.default`, or `reviewed` when no default bundle
+exists. `--gates ""` selects no gates. Gates are named acceptance obligations,
+not work assignments.
 
-## Authority Order
+## 3. After Binding
 
-Settled upstream decisions and their documentation → this Contract → commission
-and brief (directs the current round's work and questions; never terms, never
-acceptance) → review evidence (witnessed fact, never law). The journaled terms
-are the standing acceptance floor. A brief or tell genuinely commands what this
-round works on and what evidence it gathers; anything that must survive beyond
-the round as a placement condition enters the journal through bind or amend, or
-it is not acceptance.
+Read the receipt as the handoff. Keep the complete `kei/...` identity and note:
 
-## One Boundary, One Contract
+- the holder;
+- the reported worktree, if one was created;
+- the target;
+- gates and prerequisites;
+- whether the `kei` is ready or waiting.
 
-One atomic acceptance boundary per Contract. Independent boundaries are
-separate Contracts; a boundary that cannot be split but is too large for one
-pass is chaptered with Arcs, and dispatch carries only the current Arc.
+If a worktree was created, work there. If the receipt is waiting, the stated
+prerequisites remain; do not bind a duplicate Contract.
 
-## Read The Receipt
+The holder now owns the lifecycle:
 
-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.
+1. Start the work directly or delegate Tasks, Arc chapters, Akumas, or seats.
+2. Run independent work in parallel and let it converge on the one acceptance
+   boundary.
+3. Prepare and deliver the candidate.
+4. Coordinate verification, review evidence, gates, and prerequisites.
+5. Continue until the `kei` is claimed, amend terms while keeping the same
+   objective and acceptance boundary, or abandon it when either has changed.
 
-Continue the delivery with `keiyaku-workflow`.
+Continue with `keiyaku-workflow` for this lifecycle. For Akuma invocation,
+telling, waiting, permissions, and history, read `keiyaku-akuma`.