@astrosheep/keiyaku 2.9.5 → 2.9.7

package/build/core/task/task-git-store.js

@@ -105,6 +105,29 @@ export async function locateTaskBoard(cwd, runGitProbe = defaultRunGit) {
 function taskDirectory(board) {
     return path.join(board.root, ".keiyaku", "tasks");
 }
+const TASK_HISTORY_FORMAT = "%aI%x00%an%x00%s";
+function taskHistoryPath(taskId) {
+    return `.keiyaku/tasks/${taskId}.md`;
+}
+function parseTaskHistory(output) {
+    const fields = output.split("\0");
+    if (fields.at(-1) !== "") {
+        throw new FlowError("INTERNAL_STATE", "task history returned an incomplete record");
+    }
+    fields.pop();
+    if (fields.length % 3 !== 0) {
+        throw new FlowError("INTERNAL_STATE", "task history returned an incomplete record");
+    }
+    const entries = [];
+    for (let index = 0; index < fields.length; index += 3) {
+        entries.push({
+            timestamp: fields[index],
+            actor: fields[index + 1],
+            subject: fields[index + 2],
+        });
+    }
+    return entries;
+}
 function assertKeiyakuDirectory(board) {
     const keiyakuDirectory = path.join(board.root, ".keiyaku");
     const stat = lstatIfPresent(keiyakuDirectory);
@@ -201,6 +224,33 @@ export async function inspectTaskLock(cwd) {
         closeQuietly(database);
     }
 }
+/** Read the current hub branch's task-specific Git history without acquiring the task lock. */
+export async function readTaskHistory(cwd, taskId, deps = {}) {
+    if (!isTaskId(taskId)) {
+        throw new FlowError("INVALID_TARGET", `task history requires a canonical task id: ${taskId}`);
+    }
+    const board = await locateTaskBoard(cwd, deps.runGit);
+    if (board.mode !== "git") {
+        throw new FlowError("NOT_GIT_REPO", "task history is available only in a Git repository");
+    }
+    const result = await (deps.runGit ?? defaultRunGit)(board.root, [
+        "log",
+        "-z",
+        "--topo-order",
+        "--reverse",
+        `--format=${TASK_HISTORY_FORMAT}`,
+        "--",
+        taskHistoryPath(taskId),
+    ]);
+    if (result.error) {
+        throw new FlowError("INTERNAL_STATE", `cannot read task history: ${result.error.message}`, { cause: result.error });
+    }
+    if (result.status !== 0) {
+        const detail = result.stderr.trim() || `exit ${String(result.status)}`;
+        throw new FlowError("INTERNAL_STATE", `cannot read task history: ${detail}`);
+    }
+    return parseTaskHistory(result.stdout);
+}
 export function atomicReplaceTaskFile(filePath, text, _deps) {
     const directory = path.dirname(filePath);
     fs.mkdirSync(directory, { recursive: true });

package/build/generated/version.js

@@ -1,3 +1,3 @@
 // Generated into build output by scripts/build.mjs
-export const VERSION = "2.9.5";
-export const GIT_HASH = "ade1510";
+export const VERSION = "2.9.7";
+export const GIT_HASH = "e0169c3";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@astrosheep/keiyaku",
-  "version": "2.9.5",
+  "version": "2.9.7",
   "description": "CLI for running iterative keiyaku workflows with Codex subagents.",
   "license": "MIT",
   "type": "module",

package/skills/keiyaku-akuma/SKILL.md

@@ -30,6 +30,8 @@ keiyaku call NAME --detach "do the thing"     # fire and forget; note the projec
 keiyaku call NAME - < prompt.md               # long prompt: literal `-` reads stdin
 keiyaku wait <proj-id>                        # join a running one; prints its activity
 keiyaku wait <proj-id> --timeout 5m           # peek for 5m; timeout = snapshot, not death
+keiyaku wait <proj-a> <proj-b> --any          # return when the first member finishes
+keiyaku wait <proj-a> <proj-b> --all          # return when every member finishes
 keiyaku tell <proj-id> [--wait DURATION] <BODY|-> # optionally tell, then bounded-join
 keiyaku revive rsp_XXXX "continue..."         # new run continuing from a record
 keiyaku kill <proj-id>                        # stop it; record survives, revive still works
@@ -50,10 +52,18 @@ Use `keiyaku akuma view NAME` to inspect the resolved source and configuration.
 - Omit tell's bracketed `--wait DURATION` option for silent success: exit 0,
   zero output. Supply it to perform the ordinary bounded join after acceptance.
   Silence **is** the receipt — do not re-send. Effects show up in `wait`/`status`.
+- `tell --interrupt` is intentionally destructive. On an active runner, silent
+  success means the tell and interrupt intent are durable; provider stop and
+  successor wake continue asynchronously under the same projection id. Idle or
+  terminal state uses ordinary tell plus wake and reports its typed wake error.
 - Body is required for `call`/`tell`. Literal `-` selects stdin; unselected
   piped bytes are ignored and cannot change an argv body.
 - A `--wait`/`--timeout` expiry prints a live snapshot and exits 0 — the run continues; rejoin with `wait` anytime.
 - `wait` is repeatable: on a finished run it shows the final transcript again.
+- Supervise multiple projections with one plural `wait`. Choose `--any` to
+  handle the first terminal member and refill its lane; choose `--all` only for
+  final batch convergence. Keep foreground waits blocking; if bounded, use one
+  operationally meaningful timeout instead of repeated short-timeout polling.
 
 ## Occasional flags
 

package/skills/keiyaku-workflow/SKILL.md

@@ -22,6 +22,32 @@ Lifecycle:
 bound → active → petitioned → claimed | forfeited
 ```
 
+## Before Bind
+
+`bind` begins implementation from a settled executable contract.
+
+Before binding, complete the fact and decision work needed to state the delivery:
+
+- reproduce or otherwise establish the motivating fact;
+- read the registered authority and locate the current owning modules;
+- settle inputs, outputs, state consequences, failure behavior, invariants, and
+  forbidden expansion;
+- declare one coherent ownership region and account for known write overlap and
+  delivery dependencies;
+- write checks that prove the critical success path, the highest-risk rejection,
+  and the relevant durability, concurrency, or recovery boundary.
+
+Use tasks, fact scans, and bare read-only exploration while gathering evidence
+and settling decisions. Task `ready` reports that its dependencies are
+satisfied; the coordinator promotes it after establishing semantic contract
+readiness. Bind when Objective, Scope, and Checks describe one complete
+implementation journey and contain every product or architecture decision the
+worker needs.
+
+After bind, the worker implements and verifies that contract. `amend` records
+new evidence or a change of intent that genuinely emerges during implementation
+or review, then implementation continues from the updated contract.
+
 ## The default flow
 
 ```bash
@@ -51,8 +77,9 @@ EOF
 # The oath is required (OATH_MISSING otherwise) and checked for presence, not content.
 ```
 
-A task is optional planning, not a prerequisite. Bind directly for new work;
-use `--task` only when promoting existing tracked planning into this contract.
+A task is optional planning, not a prerequisite. Bind settled new work directly;
+use `--task` when promoting existing tracked planning after the same readiness
+judgment.
 
 That's the whole small case: bind → worker dirty-tree handoff → host review/commit → petition.
 
@@ -62,11 +89,57 @@ contracts/worktrees; it does not replace `needs` or contract `--after` ordering.
 
 `audit` is read-only and never invokes an Akuma or settles the contract. Exit 0
 means it constructed the report, not that the candidate is acceptable. Use
-`--diff-budget BYTES` for bounded output and `--json` for complete typed facts.
+`--diff-budget BYTES` when bounded diff evidence is useful.
 
 Commissioned workers never write Git metadata. The host alone reviews and
 commits accepted bytes before `arc`, `renew`, or `petition`.
 
+Dispatch rule: every time a dispatcher sends a worker, whether through
+`keiyaku call` or any other agent tool, the prompt must explicitly tell that
+worker to read the worktree-root `.keiyaku/KEIYAKU.md` first and follow its
+objective, scope, and checks. The file is the contract-body carrier; do not
+copy its rendered body into a dispatch prompt.
+
+## Review findings
+
+Review findings are evidence for diagnosis, not a queue of local patches. Before
+changing code, classify each finding as a contract hole, missing invariant or
+owner, execution slip, test gap, or provider/capability failure. A second
+finding in the same transition, a race that crosses module owners, or a finding
+that contradicts the contract is a root-cause signal: stop symptom patching,
+record the governing invariant and ownership correction with `amend`, and
+refactor the boundary before sending another tell or accepting another diff.
+
+A default review dispatch is:
+
+> First read the worktree-root `.keiyaku/KEIYAKU.md`. Review the candidate end
+> to end against the contract and repository law. On every review round, treat
+> the current candidate as a new complete implementation: reassess its overall
+> coherence and regression risks rather than checking only whether prior
+> findings were patched. Report material findings first. For each problem,
+> explain the underlying cause and recommend a root-cause correction direction,
+> not a patch-sized edit. If the evidence is insufficient, state what remains
+> unknown. Do not modify files or Git metadata.
+
+Add candidate-specific evidence only when it helps the reviewer judge coverage;
+do not copy the contract body or seed an expected defect. Reviewer suggestions
+inform the coordinator's judgment but do not amend the contract. The
+coordinator owns the final diagnosis; a worker may implement a settled
+correction but may not invent a new state machine or compatibility rule.
+
+Do not claim a contract while related findings remain unresolved merely because
+each individual test or patch passes. Re-run the focused interleaving or
+boundary evidence and an independent review against the corrected ownership
+model. Repeated tells that only add guards to the same disputed path are not
+progress; if the contract cannot express the required invariant, amend or
+forfeit and bind a coherent replacement.
+
+After a worker fixes review findings, prefer telling the same review projection
+to re-check those findings and the corrected candidate. Start a fresh reviewer
+only when the earlier projection is unavailable or incompatible, its context is
+no longer trustworthy, or a genuinely fresh independent perspective is useful.
+This is an efficiency preference, not an acceptance gate.
+
 ## Mid-flight commands (use when needed, skip otherwise)
 
 ```bash
@@ -88,20 +161,22 @@ keiyaku log                  # this contract's history
 Clarify the owned documentation surface.
 
 ## Scope Append
-```
+~~~
 docs/**
 !docs/generated/**
-```
+~~~
 ````
 
 `Scope Append` appends ordered raw gitignore-subset lines in one column-zero
-backtick fence; `Scope Add` and Markdown bullets are rejected. A later
+tilde fence; direct input also accepts a matching backtick fence. `Scope Add`
+and Markdown bullets are rejected. A later
 `!pattern` can narrow earlier scope. Use `--append-scope PATTERN` when a
 lifecycle operation discovers one durable term.
 
 Gotchas:
 - `-C DIR` selects the effective working directory; repository discovery starts there.
-- Base drift blocks petition — if main moved, `renew` first; petition tells you.
+- Base drift blocks ordinary petition. `petition --renew` runs the same renew
+  first and settles only after that renew succeeds; it never auto-opens an arc.
 - After an explicit `arc` seals, new loose commits need another `arc` before `renew`/`petition` accept them.
 - Not in the worktree? Address a contract with `--contract ADDR` (place, slug, or full id) or the `keiyaku @addr <verb>` prefix.