@astrosheep/keiyaku 2.9.12 → 4.0.0

package/build/telemetry/logger.js

@@ -1,48 +0,0 @@
-import { appendDebugLog, shouldEmitProgressLogs } from "./debug-log.js";
-function shouldWriteToStderr(progressOnly) {
-    return progressOnly ? shouldEmitProgressLogs() : true;
-}
-function writeStderr(level, message) {
-    if (level === "warn") {
-        console.warn(message);
-        return;
-    }
-    console.error(message);
-}
-function log(level, message, options = {}) {
-    const { cwd, section, progressOnly = false, mirrorToDebugLog = true } = options;
-    if (shouldWriteToStderr(progressOnly)) {
-        writeStderr(level, message);
-    }
-    if (mirrorToDebugLog) {
-        appendDebugLog(message, { cwd, section });
-    }
-}
-function stringifyUnknown(error) {
-    if (error instanceof Error) {
-        return error.stack || error.message;
-    }
-    if (typeof error === "string")
-        return error;
-    try {
-        return JSON.stringify(error);
-    }
-    catch {
-        return String(error);
-    }
-}
-export function formatErrorWithCause(message, error) {
-    return `${message} ${stringifyUnknown(error)}`;
-}
-export function logInfo(message, options = {}) {
-    log("info", message, options);
-}
-export function logWarn(message, options = {}) {
-    log("warn", message, options);
-}
-export function logError(message, options = {}) {
-    log("error", message, options);
-}
-export function logErrorWithCause(message, error, options = {}) {
-    logError(formatErrorWithCause(message, error), options);
-}

package/skills/keiyaku/SKILL.md

@@ -1,46 +0,0 @@
----
-name: keiyaku
-description: Use when working in a Keiyaku repository — contract-style coding where changes run on isolated branches and nothing lands without your sign-off.
-allowed-tools: Bash(keiyaku *)
----
-
-# Keiyaku
-
-CLI for contract-style coding in git repos. The mind model, Chainsaw Man rules: you make a **contract** to get work done, you can **call a devil** (akuma) to do it, and words mean nothing — only the commits left behind count. Nothing merges to main without your sign-off.
-
-## Mind model
-
-Three kinds of objects:
-
-- **task** — a planning note in the repo. No branch, no execution. → `keiyaku-task` skill
-- **contract** — a unit of work with its own branch + worktree. Born by `bind`, dies by `claim` (merged) or `forfeit` (abandoned). Who works inside it — you, an akuma, anyone — is not keiyaku's business; only the result is. → `keiyaku-workflow` skill
-- **akuma / projection** — a callable worker and its live run. `call` starts one, `wait` watches it, `tell` sends more instructions. → `keiyaku-akuma` skill
-
-## Quick start
-
-```bash
-keiyaku task add "fix the flaky pump test"   # write the idea down          → k-3f9a21c4b0d2
-keiyaku bind --task k-3f9a21c4b0d2           # start it: branch + worktree
-cd .keiyaku/wt/<place>                       # work here yourself, or call an Akuma
-keiyaku call <akuma> "fix it"                # worker leaves reviewed source as a dirty tree
-# host coordinator reviews, then git -C <worktree> add/commit accepted paths
-keiyaku status                               # is anything stuck? what's next?
-keiyaku petition - <<'EOF'                   # done: seal + settle; the oath is required
-## Oath
-I fixed the flaky test; suite is green.
-EOF
-# passes → merged to main; a gate fails → keep working, petition again
-```
-
-That's the whole loop. Skip the task when the work needs no planning:
-`keiyaku bind --title TEXT --context TEXT --objective TEXT --design TEXT --scope GLOB --criteria TEXT [--verification COMMAND]` (or the same settled document through `keiyaku bind -` — `bind --help` shows the shape).
-
-## Getting oriented
-
-```bash
-keiyaku status             # the whole board: contracts, running work, ready tasks
-keiyaku guide              # long-form mechanics
-keiyaku <command> --help   # exact syntax — never guess flags or stdin formats
-```
-
-`status` is where you go when you lose track of anything: projection ids, contract state, what's ready.

package/skills/keiyaku-akuma/SKILL.md

@@ -1,96 +0,0 @@
----
-name: keiyaku-akuma
-description: Use whenever a request mentions an Akuma, akuma, devil, demon, or 恶魔 and the work may involve calling, watching, telling, killing, or reviving one; covers Keiyaku Akuma profiles, projections, artifacts, lifecycle control, and rejoin operations.
-allowed-tools: Bash(keiyaku *)
----
-
-# Keiyaku Akuma
-
-Running devils. Contract lifecycle = `keiyaku-workflow` skill.
-
-## Core ideas
-
-- **profile** — callable configuration: frontmatter selects provider/model;
-  Markdown body gives instructions. Project overrides user, which overrides builtin.
-- **projection** (`name/8hex`) — one live run of a devil. This is the id for `wait` / `tell` / `kill`.
-- **artifact** (`rsp_…`) — what a finished run left behind. This is the id for `revive`.
-
-Rule of thumb: continue the same conversation with its projection id. Use an
-artifact id with `revive` only when deliberately starting a new projection;
-failed/dead state alone is not a reason to revive.
-
-## Projection aliases
-
-When a lane will be supervised repeatedly, assign a short stable alias at call
-time and use it as the operator coordination handle:
-
-```bash
-keiyaku call worker-akuma --alias release-lane --detach "implement the brief"
-keiyaku wait release-lane --timeout 10m
-keiyaku tell release-lane "run the focused checks before handoff"
-keiyaku kill release-lane
-```
-
-Aliases are per selected projection ledger, not projection identity. Keep the
-full `name/8hex` ID in durable records and exact recovery. Reusing an alias
-word atomically moves only that per-ledger ref to the new projection; it does
-not stop, mutate, or delete the prior projection. Its old full ID remains
-addressable. `revive` starts a new projection and does not inherit an alias.
-
-## Common usage
-
-```bash
-keiyaku akuma ls                              # who's callable
-keiyaku akuma show NAME                       # resolved profile + live projections
-keiyaku call NAME "do the thing"              # run in foreground until it finishes
-keiyaku call NAME --wait 10m "do the thing"   # bounded: after 10m you get a snapshot, it keeps running
-keiyaku call NAME -d "do the thing"           # short for --detach; note the projection id
-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>                        # request a stop; returns an acceptance receipt
-keiyaku kill <proj-id> --wait 5m               # request a stop, then observe the result for 5m
-keiyaku status                                # forgot an id? it's on the board
-```
-
-## Configuration
-
-```text
-<repo>/.keiyaku/akuma/<name>.md          project profile
-<KEIYAKU_HOME>/akuma/<name>.md           user profile (normally ~/.keiyaku)
-```
-
-Use `keiyaku akuma show NAME` to inspect the resolved source and configuration.
-
-## Expectations
-
-- 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.
-- `kill` returns an acceptance receipt; it does not include the final result.
-  Use `kill --wait DURATION` when you need to observe the ordinary final result.
-  `DURATION` is required. A timeout ends observation only and does not undo the
-  stop request.
-- 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
-
-- `--incognito` — no artifact written, no revive possible (call)
-- `--effort LEVEL` — provider effort override; needs a model set (call, revive, tell)
-- `--repo DIR` — override repository inference only when the contract ledger
-  lives in a different repository.

package/skills/keiyaku-task/SKILL.md

@@ -1,84 +0,0 @@
----
-name: keiyaku-task
-description: Use when planning work in a Keiyaku repo — add tasks, wire dependencies, track what's ready, promote a task into a contract.
-allowed-tools: Bash(keiyaku *)
----
-
-# Keiyaku Task
-
-Planning notes that live in the repo. Executing them is `keiyaku-workflow` (`bind --task`).
-
-## Core ideas
-
-A task is a tracked planning fact, not a worker or execution. Its immutable ID
-is a normalized title slug with a numeric collision suffix when needed. It has
-priority 0–3 (0 highest), optional body, and no branch of its own.
-
-```
-open ⇄ in_progress → done | drop
-```
-
-**Ready** = open + every `needs` dependency satisfied. `needs` only orders
-tasks; binding is what turns ready planning facts into one executable contract.
-
-## Common usage
-
-```bash
-keiyaku task add - < task.md                      # literal - reads the task body from stdin
-keiyaku task add "title" --pri 1 --needs k-aaa  # priority + dependency at birth
-keiyaku task ls                                 # all nonterminal tasks
-keiyaku task ls --filter state=ready --sort priority,modified
-keiyaku task show k-xxxx                        # full detail and parent-children tree
-keiyaku task start k-xxxx                       # mark in_progress (start ≠ execute)
-keiyaku task stop k-xxxx                        # back to open
-keiyaku task done k-xxxx
-keiyaku task drop k-xxxx                        # won't do; kept in history, not deleted
-keiyaku task update k-xxxx --pri 0              # also --title, --body TEXT|-, --needs,
-                                                #   --drop-needs — see --help
-keiyaku task doctor                             # check board integrity
-```
-
-## Atomic reorganization
-
-Use `task compose` when the final tree and its complete outgoing relation sets
-need review as one operation. Pass the compact sketch through stdin and check
-it before applying it:
-
-```bash
-keiyaku task compose --check - <<'EOF'
-+ Project grouping
-  @parser needs=@types
-  @renderer relates=
-@release parent=
-EOF
-keiyaku task compose - < composition.md
-```
-
-An indented line assigns its parent. A top-level `@reference` keeps its parent;
-`parent=` explicitly clears it. `needs=`, `supersedes=`, and `relates=` replace
-only their named complete relation sets, and an explicit empty assignment clears
-that set. Omit a relation to preserve it. Use the command help for the current
-sketch grammar and receipt fields; this skill does not redefine task policy.
-
-## Dependencies
-
-`--needs` stores the forward edge; `blocks` on the other task is derived automatically. Cycles are rejected at write time. Use needs to express "don't start B before A lands" — nothing more.
-
-## Promoting to a contract
-
-```bash
-keiyaku bind --task fix-parser
-keiyaku bind --task fix-parser --task fix-parser-help - < contract.md
-```
-
-Only ready tasks bind. Multi-bind only when the tasks describe one delivery
-intent, share a coherent write surface, and should settle together; otherwise
-keep separate contracts and express order with task `needs` or contract
-`--after`. The first task supplies title/objective defaults; provide a partial
-bind document for every remaining resolved section. Final bind admission always
-requires Title, Context, Objective, Design & Approach, Scope, and Criteria; Verification
-is optional.
-
-## Gotcha
-
-Task files are ordinary tracked files: checking out another branch shows *that branch's* board. Don't panic when states differ across branches — you're reading a different branch's truth, and the old one is still in git.

package/skills/keiyaku-workflow/SKILL.md

@@ -1,151 +0,0 @@
----
-name: keiyaku-workflow
-description: Use when driving a Keiyaku contract — bind isolated work, use arc/renew mid-flight, audit a candidate, petition to settle, or forfeit.
-allowed-tools: Bash(keiyaku *)
----
-
-# Keiyaku Workflow
-
-## Mindset
-
-- One contract carries one delivery intent through one ledger, branch, and
-  linked worktree.
-- Scope is the expected write set for this delivery, not code ownership or a
-  permission boundary.
-- Criteria state what must be true. Verification supplies executable evidence.
-- Implementation happens in the linked worktree. Commit accepted bytes before
-  `arc`, `renew`, or `petition`.
-- An arc is a coherent chapter of the same delivery. It keeps the contract,
-  worktree, branch, and final settlement.
-- `audit` is the primary integrated review of one pinned candidate; `petition`
-  asks to settle that candidate.
-
-```text
-bound -> active -> petitioned -> claimed | forfeited
-```
-
-## Choosing Scope
-
-Scope names the files this contract is currently expected to write. Use exact
-repository-relative paths when known, a one-component wildcard for unknown
-files in one directory, and a recursive wildcard only when the Objective calls
-for changing the whole subtree.
-
-## Scope
-~~~
-src/pump.ts
-~~~
-
-Scope overlap means contracts may write the same paths; it does not prove their
-changes conflict or forbid parallel work. If intents are independent, proceed
-in parallel and use `--after` to order settlement; use `--exclusive` only when
-concurrent work is unsafe.
-
-Amend is cheap. Broad Scope consumes parallel coordination and weakens audit
-signal, so broader patterns need a reason while narrower terms do not.
-
-## Bind
-
-Bind when one implementation journey is decided: motivating facts, owning
-modules, inputs and outputs, consequences, failure behavior, invariants,
-forbidden expansion, write set, acceptance criteria, and decisive checks.
-Use a task only when planning or dependencies need a durable place.
-
-```bash
-keiyaku bind - < contract.md
-keiyaku bind --task TASK_ID - < contract.md
-```
-
-The contract document carries `Title`, `Context`, `Objective`, `Design & Approach`,
-`Scope`, `Criteria`, and optional `Verification`. Add newly expected exact paths
-with `amend`; do not pre-authorize a broad tree for convenience.
-
-## Select The Contract
-
-Use `-C DIR` to select the effective directory. A contract worktree carries its
-contract identity:
-
-```bash
-keiyaku -C .keiyaku/wt/cloud audit
-keiyaku -C .keiyaku/wt/cloud log
-```
-
-From a repository hub, name the contract with `--contract ADDR` or `@ADDR`:
-
-```bash
-keiyaku -C /work/keiyaku --contract repair-status.01K... audit
-```
-
-`bind -C DIR` creates a new contract in the selected repository. Full contract
-ID is durable identity; slug and place are convenience addresses.
-
-## Drive The Work
-
-```bash
-keiyaku arc - < arc.md
-keiyaku renew
-keiyaku amend - < amendment.md
-keiyaku log
-keiyaku status
-```
-
-- `arc` seals one coherent chapter and opens the next. It is not a child
-  contract or a parallel worktree.
-- `renew` rebases onto an advanced target. Re-run verification after it.
-- `amend` records a changed intent, invariant, Scope, Criteria, or Verification
-  before implementation relies on that change.
-
-Scope changes are ordered terms. Use `--append-scope` for a simple addition or
-one `Scope Append` block for an ordered delta:
-
-## Scope Append
-~~~
-src/new-owner.ts
-!src/retired/**
-~~~
-
-Later `!pattern` terms narrow earlier matches. Do not mix the block with
-`--append-scope` flags.
-
-After an explicit arc seal, commit any new work and open the next arc before
-`renew` or `petition`.
-
-## Review
-
-Review the complete candidate against the contract and repository law on every
-round. Findings identify a contract hole, missing owner or invariant, execution
-slip, test gap, or provider failure. Correct the governing model when the owner,
-flow, commit point, failure outcomes, obsolete paths, or proof matrix is wrong;
-use `amend` when the contract must change.
-
-Ask reviewers for material findings with file references and root-cause
-direction. Reviewers do not modify files or amend the contract. Keep related
-findings open until the corrected candidate and focused boundary evidence have
-been reviewed again.
-
-## Settle
-
-Commit, renew if stale, then run `audit` first. Audit already combines the
-candidate diff, Scope, Criteria, Verification, and delivery context.
-
-If the evidence is sufficient, petition. Otherwise, run only the check needed
-for a specific gap. `not configured` is not itself a failure. Audit exit 0 means
-a report was produced, not that the candidate passed.
-
-```bash
-keiyaku audit
-keiyaku petition - <<'EOF'
-## Oath
-I completed the contract and verified the submitted candidate.
-EOF
-```
-
-A passing petition claims into the target. A failed gate leaves the contract
-available for correction. End a superseded delivery explicitly:
-
-```bash
-keiyaku forfeit --reason "superseded by CONTRACT"
-```
-
-Forfeit preserves history and removes the contract worktree. There is no
-separate `claim` command.