@astrosheep/keiyaku 4.5.6 → 4.5.8

package/README.md

@@ -139,3 +139,13 @@ npm install -g @astrosheep/keiyaku
 ```
 
 Node ≥ 22.19. Product law lives in [`docs/`](docs/README.md).
+
+## Source builds
+
+Building from source also builds the Windows launcher with Zig 0.14.1. Install
+that system tool separately and make `zig` available on `PATH`, or set
+`KEIYAKU_ZIG` to the selected executable. `npm ci` alone is not sufficient for
+the Windows launcher: use `npm ci --ignore-scripts --prefer-offline` followed by
+`npm run build` (or `npm test`). On non-Windows hosts, a missing or unusable
+Zig skips only the Windows launcher so the rest of `npm run build` and `npm test`
+can continue; Windows builds fail with an actionable diagnostic.

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

@@ -1,6 +1,6 @@
 {
   "name": "keiyaku",
-  "version": "0.1.1",
+  "version": "0.1.2",
   "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.1+codex.20260826070830",
+  "version": "0.1.2+codex.20260826070830",
   "description": "Use the Keiyaku contract, task, and Akuma CLI.",
   "author": {
     "name": "Keiyaku"

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

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

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

@@ -1,6 +1,6 @@
 {
   "name": "keiyaku-harness",
-  "version": "0.1.1",
+  "version": "0.1.2",
   "type": "module",
   "main": "./opencode.js",
   "keywords": [

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

@@ -5,15 +5,17 @@ description: Use the Keiyaku v4 CLI for contract delivery, task coordination, an
 
 # Keiyaku
 
-Use `keiyaku` as an agent-facing ledger. Keep decisions with the flagship;
-read `<command> --help` before using flags.
-
 ## Model
 
-- `task` is planning; see `keiyaku-task`.
-- 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`.
+Keiyaku is three independent pillars, not a bundle: **Task** remembers plans
+and dependencies, **Contract** makes acceptance standing and auditable,
+**Akuma** invokes capability. Use any one alone; combine them only when the
+work calls for it. Behind every Contract in flight there is one holder of its
+fulfillment loop — whoever turns intent into commissions and returns into
+decisions. The flagship holds it by default, and may hand a whole Contract's
+loop to one Aku in a single commission; the harness serves both styles
+equally. See `keiyaku-workflow` for the loop, `keiyaku-bind` for authoring,
+`keiyaku-akuma` for invocation.
 
 Settings owns named gate bundles. Omitting `--gates` selects `gates.default`,
 or freezes `["reviewed"]` when that entry is absent. `--gates <name,...>`
@@ -31,7 +33,7 @@ keiyaku -C <repo> review [<contract>|@<contract>] --satisfied
 ```
 
 ```bash
-keiyaku -C <cwd> call <akuma-name> [--contract <kei/...>] [--alias @name] [--readonly] [--allowed <product.action>]... [--wait <duration> | -d | --detach] (<prompt> | -)
+keiyaku -C <cwd> call <akuma-name> [--contract <kei/...>] [--alias @name] [--readonly] [--allowed <product.action>]... [--wait <duration> | -d | --detach] [--json] (<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] [--readonly] [--allowed <product.action>]... [--wait <duration> | -d | --detach] (<prompt> | -)
+keiyaku -C <cwd> call <akuma-name> [--alias @name] [--readonly] [--allowed <product.action>]... [--wait <duration> | -d | --detach] [--json] (<prompt> | -)
 ```
 
 Give the worker's initial prompt as one argument (quote it when it contains
@@ -41,6 +41,27 @@ prompt, and an empty body keeps the harness default. Write a new one when no
 existing file grants the permissions and stance the work needs; a worker never
 outgrows its Archetype mid-life.
 
+## Commission And Steer
+
+A call assembles a commission from independent inputs: the Archetype fixes
+capability stance for the identity's whole life; the `--contract` Dispatch
+associates standing terms; allowed actions set what the callee may do, always
+under the Archetype base 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.
+
 ## Watch
 
 ```bash

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

@@ -0,0 +1,53 @@
+---
+name: keiyaku-babysit
+description: Babysit a long-running multi-lane goal — a room of lanes that advance on their own, call for you on their schedule, and hold each other up while you are busy being productive.
+---
+
+# Keiyaku Babysit
+
+Babysitting is a method, not a role: no new identity, permission, ledger,
+status, id, or lifecycle. It is how whoever holds work in flight schedules
+their own attention across it.
+
+## Lanes At Any Grain
+
+A lane is anything you are answerable for that moves without you: a Worker on
+an Arc, a Reviewer mid-examination, a whole Contract whose fulfillment loop you
+handed to one Aku. Handing work down narrows a lane; it never empties it — you
+did not hand off your answerability, you booked yourself for the next question,
+the next verify, the next return. When a Contract's whole loop is delegated,
+your lane is the holder itself: watch the journaled record — bind, amends,
+testimony, placement — verify at the boundaries you kept, and steer through the
+holder, never past it. One delegated loop is one lane, however much moves
+inside it.
+
+## Attention
+
+**Sweep.** Pass over every lane at natural pause points instead of dwelling on
+one; depth goes where the sweep finds movement or silence that should not be
+there.
+
+**Critical path.** The lane the most other lanes wait on gets attention first,
+regardless of which lane is loudest.
+
+**Wait graph.** Know who waits on whom before deciding where to look; a cycle
+in that graph is the emergency, everything else is schedule.
+
+**Blocked lanes.** A blocked lane outranks every healthy one — unblock before
+you optimize.
+
+**Verify returns.** A return is not done because it arrived; it is done when
+checked against what was asked. Book the verify when you delegate, not after.
+
+**Steer early.** The cheapest steer is before divergence compounds: ask the
+question at the first doubt, not at delivery.
+
+**Lightest lane.** Keep each lane as light as it can be; do not babysit what
+does not move without you.
+
+## What Babysitting Never Owns
+
+Commands and semantics belong to task, bind, workflow, and akuma. Acceptance
+belongs to the Contract's journal and its Reviewer's testimony. The question
+belongs to whoever commissioned it. Babysitting decides only when you look and
+what you check next.

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

@@ -5,51 +5,22 @@ description: Author and bind one Keiyaku delivery Contract. Use when deciding wh
 
 # Keiyaku Bind
 
-A Contract records a decision that already exists; writing terms does not
-produce one. You supply **all high-level design and public-surface facts this
-Keiyaku creates or changes**, and **all** pseudocode where ordering matters.
-The worker is a cheap executor: every choice you leave open, it resolves —
-possibly the way you like least, discovered at review and billed at review
-prices.
-
-## Before You Bind
-
-Bind is the last step of an investigation, never the first step of an idea.
-
-- Design the delivery to the depth you could implement it yourself, against
-  the code as it is — not as you remember it. An unknown surfacing while
-  you design is the next investigation, not a detail for the worker.
-- Walk the implementation path once, end to end. A step you cannot walk is
-  an unresolved fact.
-- Observe active Contracts whose Regions intersect yours. Region overlap is a
-  prompt signal only; it does not by itself imply a logical conflict. The
-  caller decides autonomously whether to proceed in parallel or serialize.
-- A decision settled elsewhere binds only its explicit words; converting it
-  into concrete shape is your job, and a question it left open goes back to
-  its decider, never to the worker.
-- If the delivery must land documentation, you can draft its exact sentence
-  now. Cannot draft means unresolved design — "the worker will sort out the
-  docs" is a design gap in disguise.
-
-Split complex work wherever independently acceptable delivery boundaries
-exist. When a complex Keiyaku cannot be split without breaking one acceptance
-boundary, bind one Contract and plan its fulfillment as explicit arcs. Treat
-each arc as a chapter as in a work of literature, not as a task sequence.
-Commission one current chapter at a time; never hand the whole undifferentiated
-Contract to one Deliverer and trust it to finish everything in one pass.
-Continue with `keiyaku-workflow` for the arc document and command.
-
-Two tests close the gate:
-
-- **Substitution.** Two workers who never met each deliver test-green from
-  your terms. If any external reader could tell the deliveries apart, that
-  fact is undecided — decide it and write it.
-- **Rework.** For each blank: "if the worker picks what I like least, do I
-  demand rework?" Yes — write it. No — write nothing.
-
-Public — anything visible outside the diff — is always yours to pin.
-Private — helper names, decomposition, control flow — is the worker's;
-its freedom comes from your genuine indifference, not from omission.
+## What Bind Records
+
+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.
+
+## Author And Freedom
+
+The author pins every public, high-level fact: surfaces, semantics, persisted
+shapes, the observable acceptance boundary. Private decomposition, helper
+names, and 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.
 
 ## Author And Bind
 
@@ -125,11 +96,19 @@ do not create one just to mirror the Contract.
 
 ## Authority Order
 
-> Settled upstream decisions and their documentation → this Contract → worker
-> brief (zero authority) → review evidence (witnessed fact, never law).
+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.
+
+## One Boundary, One Contract
 
-Gaps flow upstream, never down: a design gap found by a worker or reviewer
-returns to you, never filled silently downstream.
+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.
 
 ## Read The Receipt
 

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

@@ -7,15 +7,13 @@ description: >-
 
 # Keiyaku Task
 
-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. 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.
+## What A Task Is Not
+
+A Task remembers a plan: what is intended, what depends on what, what was
+decided about sequence. It grants nothing — no acceptance, no permission, no
+scope, no fulfillment loop. Whoever holds a Contract's loop uses Tasks when the
+plan is worth remembering and skips them when it is not; nothing binds Tasks to
+Arcs, Contracts, or Akuma as a package.
 
 ## Lifecycle
 
@@ -42,7 +40,7 @@ keiyaku task ls --closed
 keiyaku task ls --all --world
 keiyaku task ready
 keiyaku task blocked
-keiyaku task tree <task-id> [--full]
+keiyaku task tree <task-id>
 keiyaku task doctor
 ```
 
@@ -53,19 +51,22 @@ commands require a complete TaskId and never infer namespace.
 ## Mutations
 
 ```bash
-keiyaku task start <task-id>
+keiyaku task start <task-id>...
 keiyaku task stop <task-id>
 keiyaku task hold <task-id>
 keiyaku task resume <task-id>
 keiyaku task done <task-id>...
 keiyaku task drop <task-id>... [--note <text>]
 keiyaku task update <task-id> --title <text>
-keiyaku task namespace [<namespace>]
+keiyaku task context [<namespace>]
 ```
 
 Use `--json` on any command when a script must inspect the typed result.
 Relations are explicit facts: `needs` orders work, `parent` groups it,
 `supersedes` navigates replacement, and `relates` does not affect readiness.
+`task start` accepts one or more complete TaskIds. A single ID keeps the
+single-mutation result; multiple IDs use the ordered batch result, continue
+after per-Task refusals, and preserve retry-over-refusal exit precedence.
 
 ## Batch Create Or Modify
 
@@ -78,6 +79,7 @@ ns=feature
 
 + Parent
 as = parent
+state = in_progress
 pri = 0
 body <<BODY
 Parent body.
@@ -90,6 +92,10 @@ EOF
 ```
 
 Use `--plan` to inspect aliases, admission order, and body byte previews without
-writing. Compose does not change Task lifecycle state. Each changed Task is
-admitted independently; an incomplete result returns a reusable draft for the
-remaining batch.
+writing. New `+ Title` nodes may declare `state = open|in_progress|on_hold|done|drop`
+as their initial state; omitted state is `open`. Existing `@task/...` nodes cannot
+declare state. Aliases are nonempty single-line tokens containing neither
+Unicode whitespace nor comma; references use `^alias`. Compose does not change
+the lifecycle state of pre-existing Tasks. Each changed Task is admitted
+independently; an incomplete result returns a reusable draft for the remaining
+batch and preserves each new node's declared state.