@astrosheep/keiyaku 2.9.13 → 4.0.1

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,97 +0,0 @@
----
-name: keiyaku-akuma
-description: Use whenever a request mentions an Akuma, akuma, devil, demon, or 恶魔 and the work may involve calling, waiting, telling, killing, or forking one; covers Keiyaku Akuma profiles, projections, artifacts, lifecycle control, and fork lineage.
-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 retained finished run left behind. This is the id for `fork`.
-
-Rule of thumb: continue the same conversation with its projection id. Use an
-artifact id with `fork` only when deliberately starting a new projection;
-failed/terminal state alone is not a reason to fork.
-
-## 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. `fork` 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 deadline 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>                        # observe one retained or active projection
-keiyaku wait <proj-id> --timeout 5m           # deadline snapshot; timeout does not stop it
-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 fork rsp_XXXX "continue..."           # new run continuing from a retained 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
-
-- `tell` succeeds only after durable acceptance for the addressed projection.
-  Its receipt never claims provider consumption. `tell --wait DURATION` then
-  performs the ordinary bounded wait and returns that response and exit status.
-- `tell --interrupt` records tell acceptance and interruption intent; provider
-  stop/successor adoption remain asynchronous. An idle or terminal wake failure
-  preserves the accepted tell and reports its typed wake failure.
-- `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 the admitted-set deadline snapshot and
-  exits 124. It changes no lifecycle state; observe again with `wait` anytime.
-- `wait` is repeatable: a terminal view re-renders durable terminal facts,
-  including the typed final answer and real artifact lineage when retained.
-- 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 fork possible (call)
-- `--effort LEVEL` — provider effort override; needs a model set (call, fork, tell)
-- `--repo DIR` — override repository inference only when the contract ledger
-  lives in a different repository.

package/skills/keiyaku-task/SKILL.md

@@ -1,118 +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 - <<'EOF'                       # canonical stdin task document
----
-title: Parse task documents
-pri: 1
-needs:
-  - task-model
----
-Keep parser and model validation together.
-EOF
-keiyaku task add "title" --pri 1 --needs k-aaa  # concise title plus creation flags
-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
-keiyaku task ls --contract hades                # inspect one commissioned workspace from the hub
-```
-
-## 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 - <<'EOF'
-# Fix parser
-
-## Context
-Valid input is rejected.
-
-## Objective
-Accept valid input.
-
-## Design & Approach
-Correct the parser at its existing boundary.
-
-## Scope
-~~~
-src/parser.ts
-~~~
-
-## Criteria
-- Valid input parses.
-EOF
-```
-
-For a multi-task delivery, repeat `--task TASK_ID` on the same bind.
-
-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.
-
-When a task operation targets a commissioned workspace from the hub, use
-`--contract <place|slug|full-id>`. It resolves the ledger-owned materialized
-checkout and follows its normal task authority; do not use a physical
-`.keiyaku/wt/...` path as the commission identity.

package/skills/keiyaku-workflow/SKILL.md

@@ -1,191 +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 stage of the same delivery. It keeps the contract,
-  worktree, branch, Scope, and final settlement; it is not independently
-  claimable.
-- `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.
-
-## Choose Topology
-
-Use arcs only when successive stages share one delivery, acceptance boundary,
-ownership, and final settlement. Scope overlap alone does not choose topology.
-Base drift calls for `renew`, not an arc. `arc --append-scope` adds to the
-cumulative contract Scope; it does not create arc-local Scope enforcement.
-
-Use separate tasks and contracts for independently deliverable work, distinct
-acceptance or ownership, or a slice that must wait on another contract. Record
-external ordering with task needs or `--after`; do not keep an otherwise
-claimable slice open merely to wait.
-
-One contract can migrate a storage format with an arc for the writer and a
-later arc for the reader, then settle once. A parent task for an API migration
-can instead track producer and consumer child contracts with separate owners
-and acceptance, ordered by a task need or `--after`.
-
-## Bind
-
-Bind a Keiyaku only after its motivating facts and design are clear. When they
-are not, complete the necessary investigation first; that investigation may
-itself be a prerequisite Keiyaku.
-Use a task only when planning or dependencies need a durable place.
-
-```bash
-keiyaku bind - <<'EOF'
-# Fix parser
-
-## Context
-Valid input is rejected.
-
-## Objective
-Accept valid input.
-
-## Design & Approach
-Correct the parser at its existing boundary.
-
-## Scope
-~~~
-src/parser.ts
-~~~
-
-## Criteria
-- Valid input parses.
-EOF
-```
-
-The H1 is the Title. The H2 sections are `Context`, `Objective`,
-`Design & Approach`, `Scope`, `Criteria`, and optional `Verification`. Use
-`bind --task TASK_ID -` to bind a ready task with the same document shape. 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, then use `renew --audit` when the delivery may be stale; it performs
-the ordinary delivery rewrite first and audits the resulting fresh candidate.
-Use `audit` directly when no renewal is needed. 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.