@astrosheep/keiyaku 4.5.7 → 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", "keiyaku-babysit"]
-  .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,16 +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`.
-- A long-running multi-lane goal needs coordination; see `keiyaku-babysit`.
+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,...>`
@@ -32,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

@@ -3,112 +3,51 @@ 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
+# Keiyaku Babysit
 
-A goal big enough to babysit is a room full of wards: kei in delivery,
-Akuma working, reviews pending, a caller owing a decision, an external
-dependency due someday. Each lane advances on its own once set moving;
-each calls for you when it chooses; a lane left waiting on you holds up
-the lanes behind it. There is one of you. The hard part is where your
-next ten minutes go.
-
-## You did not hand it off. You booked yourself.
-
-Handing a lane to a worker felt lighter, didn't it. What you actually
-did was schedule your own future: a question to answer, a return to
-verify, a review to start, a delivery to make — all arriving when the
-lane is ready, never when you are. While absorbed anywhere, every lane
-reaching such a moment stops dead and waits, billing the goal by the
-minute. Price attention by delay cost, not work importance: the
-two-minute answer an Akuma is stalled on outranks an hour of brilliant
-work in your hands, because your hour happens later and the stall does
-not un-happen. Yes, even though your work is more interesting.
-
-## The sweep
-
-Several lanes calling at once? How flattering. Take them in order of
-what your delay costs, never the order you prefer:
-
-1. Unblock anyone stopped and waiting on you: a question, hand-off, or
-   review only you can start. It will take minutes; it has cost hours.
-2. Verify returns, starting with the one other lanes build on. An
-   unverified return cannot close its lane, and every lane treating it
-   as settled builds on your unchecked assumption. If two returns can
-   interact, read both before settling either.
-3. Tell lanes what changed. A settled result that invalidates a running
-   lane's premise gets relayed before your own work; silence manufactures
-   rework.
-4. Then, and only then, your own lane. It survived waiting.
-
-Sweep at the seams: before a long stretch, when a lane returns something
-material, and when you hand a new lane out. Not on a timer. A quiet lane
-is not a content lane: quiet is working, stuck, or waiting on you, and
-you cannot tell which from your chair. Go look; reading progress into
-silence is astrology, not babysitting.
-
-## Productive absorption
-
-Neglect does not have to look like thrashing on a dead end. Real neglect
-looks like you, deeply satisfied, making excellent progress on one ward
-while the room goes unswept: an Akuma holding a one-line question for
-two hours, a finished return nobody dares build on because you never
-checked it, a caller decision request composed in your head and sent
-nowhere. The test is not "am I being productive" — you are. Is any
-lane's due care older than the work in your hands?
+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.
 
-## The critical path decides ties
+## Lanes At Any Grain
 
-Two lanes call, both claims valid? Serve the critical path. Hand out
-critical-path work first, too: the side lane is tempting because it is
-easier to specify, and easy-to-specify is how goals die surrounded by
-finished side quests. Re-derive the path after every settled result; a
-delivered kei or fresh blocker can promote a background lane.
+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.
 
-## Only you can see the whole room
+## Attention
 
-Task records dependencies between tasks; nothing records that an Akuma
-waits on your answer, a review waits on a worktree, or the caller owes a
-lane a decision. That wait-graph lives in exactly one place: your head.
-It is what the sweep walks. When it outgrows your head — it will — park
-the waits in task notes. The map may degrade to paper, never to memory
-you merely trust. Wards answer at different speeds — Akuma in minutes,
-reviewers in hours, callers and external dependencies in geological
-time — so ask the slow ones when the question is knowable, not urgent.
-Shape a caller request as a decision with evidence, not a pile of raw
-results.
+**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.
 
-## Release a blocked lane, keep the goal
+**Critical path.** The lane the most other lanes wait on gets attention first,
+regardless of which lane is loudest.
 
-Lane blocked beyond your reach? Write the blocker into its task where
-the next sweep will see it, and release the lane. Hovering beside a
-blocker you cannot move is decoration, not diligence. The note makes
-releasing different from abandoning. Exception: a blocker gating the
-critical path with nothing else runnable is the job — press on it, split
-it into its own task or kei, or take it to the caller now.
+**Wait graph.** Know who waits on whom before deciding where to look; a cycle
+in that graph is the emergency, everything else is schedule.
 
-## Tired babysitters skip the checking
+**Blocked lanes.** A blocked lane outranks every healthy one — unblock before
+you optimize.
 
-Under load you cut verification depth first: diffs skimmed, gates
-assumed, "done" believed because the worker sounded confident. The
-goal's quality becomes the shabbiest check you accepted while busy.
-For a risky return, delegate an independent review: minutes spent, bar
-kept. Accepting it unread is free today and costs a later lane its
-premise.
+**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, with the existing verbs
+**Steer early.** The cheapest steer is before divergence compounds: ask the
+question at the first doubt, not at delivery.
 
-Evidence changed the delivery? Amend the kei. Evidence obsoleted it?
-Abandon and bind a new one. Discovery deserves its own lane? Make it a
-task. Now, not "after this stretch": every lane keeps spending against
-the old contract until you speak.
+**Lightest lane.** Keep each lane as light as it can be; do not babysit what
+does not move without you.
 
-## Boundaries
+## What Babysitting Never Owns
 
-Babysitting is a method, not a role: no new identity, permission, ledger,
-status, id, lifecycle, fixed cadence, numeric threshold, or mandatory
-Task+kei+Akuma bundle. Task is optional planning and dependency memory;
-each kei stays one bounded delivery; Akuma is one ward among the
-entities you watch, not the definition of the job. Commands live with
-their owners — keiyaku-task, keiyaku-bind, keiyaku-workflow,
-keiyaku-akuma — this skill says when to reach for them, never how they
-work.
+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.