@astrosheep/keiyaku 1.0.1 → 2.8.0

package/build/core/verdict.js

@@ -1,7 +1,7 @@
 import { FlowError } from "../flow-error.js";
 import { claimContract } from "./claim.js";
 import { activeLedgerRef, appendWithRetry, readLedger } from "./ledger.js";
-import { dequeueContract, queuePositionFromEntries, readQueue } from "./queue.js";
+import { assertClaimQueueHead, queueMembership, readQueueReadModel } from "./queue_v2.js";
 import { deriveContractState } from "./status.js";
 function latestVerdict(entries) {
     for (let index = entries.length - 1; index >= 0; index -= 1) {
@@ -13,12 +13,6 @@ function latestVerdict(entries) {
     }
     return undefined;
 }
-async function assertQueueHead(cwd, contractId) {
-    const position = queuePositionFromEntries(await readQueue(cwd), contractId);
-    if (position !== 1) {
-        throw new FlowError("INTERNAL_STATE", `contract ${contractId} is not queue head; position=${position ?? "not queued"}`);
-    }
-}
 function assertPetitioned(contractId, entries) {
     const state = deriveContractState(entries);
     if (state.state !== "petitioned") {
@@ -32,13 +26,22 @@ export async function verdictContract(input) {
         throw new FlowError("INTERNAL_STATE", `contract ${input.contractId} not found or not active`);
     }
     assertPetitioned(input.contractId, current.entries);
-    await assertQueueHead(input.cwd, input.contractId);
+    // Rejected verdict is allowed for any petitioned ledger, including legacy and
+    // target mismatch, without a queue-head gate.
+    if (input.result === "approved") {
+        const model = await readQueueReadModel(input.cwd);
+        assertClaimQueueHead(model, input.contractId);
+    }
     const ref = activeLedgerRef(input.contractId);
     const appendResult = await appendWithRetry(input.cwd, ref, async (_head, entries) => {
         const existingVerdict = latestVerdict(entries);
         if (existingVerdict)
             return null;
         assertPetitioned(input.contractId, entries);
+        if (input.result === "approved") {
+            const model = await readQueueReadModel(input.cwd);
+            assertClaimQueueHead(model, input.contractId);
+        }
         const entry = {
             v: 1,
             kind: "verdict",
@@ -67,7 +70,7 @@ export async function verdictContract(input) {
         throw new FlowError("INTERNAL_STATE", `contract ${input.contractId} already has ${verdict.data.result} verdict`);
     }
     if (verdict.data.result === "rejected") {
-        await dequeueContract(input.cwd, { contractId: input.contractId, actor: input.actor, at });
+        // Rejected verdict naturally returns state to active and clears membership.
         return {
             contractId: input.contractId,
             result: "rejected",
@@ -76,21 +79,30 @@ export async function verdictContract(input) {
         };
     }
     const claimOnApproval = input.claimOnApproval ?? true;
-    const claimed = claimOnApproval
-        ? await claimContract({
+    if (claimOnApproval) {
+        const claimed = await claimContract({
             cwd: input.cwd,
             contractId: input.contractId,
             actor: "keiyaku",
             nowMs: input.nowMs,
             mergeDelivery: input.mergeDelivery,
             afterMerge: input.afterMerge,
-        })
-        : undefined;
+        });
+        return {
+            contractId: input.contractId,
+            result: "approved",
+            summary: verdict.data.summary,
+            claimed,
+            queuePosition: null,
+        };
+    }
+    // claimOnApproval false remains petitioned at target-local position 1.
+    const model = await readQueueReadModel(input.cwd);
+    const membership = queueMembership(model, input.contractId);
     return {
         contractId: input.contractId,
         result: "approved",
         summary: verdict.data.summary,
-        ...(claimed ? { claimed } : {}),
-        queuePosition: claimed ? null : 1,
+        queuePosition: membership?.position ?? 1,
     };
 }

package/build/core/worktree-bootstrap.js

@@ -0,0 +1,187 @@
+import { spawn as nodeSpawn } from "node:child_process";
+export const WORKTREE_BOOTSTRAP_STDERR_TAIL_BYTES = 2048;
+export const WORKTREE_BOOTSTRAP_KILL_GRACE_MS = 10_000;
+function defaultWait(ms) {
+    return new Promise((resolve) => {
+        const timer = setTimeout(resolve, ms);
+        timer.unref?.();
+    });
+}
+/** Retain the last 2048 UTF-8 bytes and decode lossily (partial leading code point → U+FFFD). */
+export function tailUtf8Bytes(bytes, maxBytes = WORKTREE_BOOTSTRAP_STDERR_TAIL_BYTES) {
+    const truncated = bytes.byteLength > maxBytes;
+    const slice = truncated ? bytes.subarray(bytes.byteLength - maxBytes) : bytes;
+    return { text: slice.toString("utf8"), truncated };
+}
+/**
+ * Rolling stderr accumulator: holds at most `maxBytes` across every chunk and
+ * remembers whether any earlier prefix was dropped. Never retains unbounded stderr.
+ */
+function createRollingByteTail(maxBytes = WORKTREE_BOOTSTRAP_STDERR_TAIL_BYTES) {
+    let tail = Buffer.alloc(0);
+    let truncated = false;
+    return {
+        append(chunk) {
+            const bytes = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
+            if (bytes.byteLength === 0)
+                return;
+            if (bytes.byteLength >= maxBytes) {
+                // Keep last maxBytes. Mark truncated only when this chunk itself exceeds
+                // maxBytes or when any already-retained prefix is displaced. Prior true sticks.
+                if (bytes.byteLength > maxBytes || tail.byteLength > 0) {
+                    truncated = true;
+                }
+                tail = Buffer.from(bytes.subarray(bytes.byteLength - maxBytes));
+                return;
+            }
+            const combinedLength = tail.byteLength + bytes.byteLength;
+            if (combinedLength <= maxBytes) {
+                const next = Buffer.allocUnsafe(combinedLength);
+                tail.copy(next, 0);
+                bytes.copy(next, tail.byteLength);
+                tail = next;
+                return;
+            }
+            truncated = true;
+            const keepFromTail = maxBytes - bytes.byteLength;
+            const next = Buffer.allocUnsafe(maxBytes);
+            tail.copy(next, 0, tail.byteLength - keepFromTail);
+            bytes.copy(next, keepFromTail);
+            tail = next;
+        },
+        snapshot() {
+            if (tail.byteLength === 0)
+                return { bytes: null, truncated: false };
+            return { bytes: tail, truncated };
+        },
+    };
+}
+function observationFrom(result, durationMs, stderr) {
+    const safeDuration = Math.max(0, Math.min(Number.MAX_SAFE_INTEGER, Math.trunc(durationMs)));
+    if (!stderr || stderr.bytes.byteLength === 0) {
+        return { result, durationMs: safeDuration };
+    }
+    // Buffer is already the bounded tail; decode lossily (partial leading code point → U+FFFD).
+    return {
+        result,
+        durationMs: safeDuration,
+        stderrTail: stderr.bytes.toString("utf8"),
+        ...(stderr.truncated ? { stderrTruncated: true } : {}),
+    };
+}
+function spawnFailureObservation(message, durationMs) {
+    const tail = tailUtf8Bytes(Buffer.from(message, "utf8"));
+    const safeDuration = Math.max(0, Math.min(Number.MAX_SAFE_INTEGER, Math.trunc(durationMs)));
+    return {
+        result: { kind: "spawn", message: tail.text },
+        durationMs: safeDuration,
+        ...(tail.truncated ? { stderrTruncated: true } : {}),
+    };
+}
+function killChild(child, signal) {
+    try {
+        child.kill(signal);
+    }
+    catch {
+        // Process may have raced out between the liveness check and kill.
+    }
+}
+/**
+ * Run the project-declared worktree bootstrap once.
+ * argv only (shell: false), cwd = new worktree, inherited env, stdin/stdout ignored, stderr piped.
+ */
+export async function runWorktreeBootstrap(input, dependencies = {}) {
+    const spawn = dependencies.spawn ?? nodeSpawn;
+    const nowMs = dependencies.nowMs ?? Date.now;
+    const wait = dependencies.wait ?? defaultWait;
+    const [program, ...args] = input.plan.command;
+    if (!program) {
+        return {
+            result: { kind: "spawn", message: "bootstrap command is empty" },
+            durationMs: 0,
+        };
+    }
+    const startedAt = nowMs();
+    const stderrTail = createRollingByteTail();
+    let child;
+    try {
+        child = spawn(program, args, {
+            cwd: input.cwd,
+            env: process.env,
+            shell: false,
+            stdio: ["ignore", "ignore", "pipe"],
+        });
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        return spawnFailureObservation(message, Math.max(0, nowMs() - startedAt));
+    }
+    return await new Promise((resolve) => {
+        let settled = false;
+        let timedOut = false;
+        let exited = false;
+        let timeoutHandle;
+        const finish = (observation) => {
+            if (settled)
+                return;
+            settled = true;
+            if (timeoutHandle)
+                clearTimeout(timeoutHandle);
+            resolve(observation);
+        };
+        child.stderr?.on("data", (chunk) => {
+            stderrTail.append(chunk);
+        });
+        child.on("error", (error) => {
+            const message = error instanceof Error ? error.message : String(error);
+            finish(spawnFailureObservation(message, Math.max(0, nowMs() - startedAt)));
+        });
+        child.on("close", (code, signal) => {
+            exited = true;
+            const durationMs = Math.max(0, nowMs() - startedAt);
+            const snap = stderrTail.snapshot();
+            const stderr = snap.bytes ? { bytes: snap.bytes, truncated: snap.truncated } : null;
+            if (timedOut) {
+                finish(observationFrom({ kind: "timeout" }, durationMs, stderr));
+                return;
+            }
+            if (signal) {
+                finish(observationFrom({ kind: "signal", signal }, durationMs, stderr));
+                return;
+            }
+            const exitCode = typeof code === "number" ? code : 1;
+            const normalized = Math.max(0, Math.min(255, exitCode));
+            if (normalized === 0) {
+                // Success discards stderr but still clamps durationMs.
+                finish(observationFrom({ kind: "exit", code: 0 }, durationMs, null));
+                return;
+            }
+            finish(observationFrom({ kind: "exit", code: normalized }, durationMs, stderr));
+        });
+        timeoutHandle = setTimeout(() => {
+            void (async () => {
+                if (settled || exited)
+                    return;
+                timedOut = true;
+                killChild(child, "SIGTERM");
+                await wait(WORKTREE_BOOTSTRAP_KILL_GRACE_MS);
+                // SIGKILL only if the child has not reached a terminal close yet.
+                if (!exited && !settled) {
+                    killChild(child, "SIGKILL");
+                }
+            })();
+        }, input.plan.timeoutMs);
+        timeoutHandle.unref?.();
+    });
+}
+export function bootstrapEntryDataFromObservation(observation) {
+    return {
+        result: observation.result,
+        durationMs: observation.durationMs,
+        ...(observation.stderrTail !== undefined ? { stderrTail: observation.stderrTail } : {}),
+        ...(observation.stderrTruncated ? { stderrTruncated: true } : {}),
+    };
+}
+export function isBootstrapSuccess(observation) {
+    return observation.result.kind === "exit" && observation.result.code === 0;
+}

package/build/core/worktree-path.js

@@ -3,10 +3,42 @@ import * as fs from "node:fs/promises";
 import { FlowError } from "../flow-error.js";
 import { createGit, wrapGitError } from "../git/core.js";
 import { readLedger } from "./ledger.js";
-import { deriveContractState, isTerminalState, listContractIds } from "./status.js";
+import { listContractIds } from "./ledger.js";
+import { deriveContractState, isTerminalState } from "./status.js";
 export function findBindEntry(entries) {
     return entries.find((entry) => entry.kind === "bind");
 }
+function parseWorktreeListPorcelainZ(output) {
+    const listings = [];
+    let current;
+    for (const field of output.split("\0")) {
+        if (field.startsWith("worktree ")) {
+            if (current)
+                listings.push(current);
+            current = { path: field.slice("worktree ".length) };
+            continue;
+        }
+        if (field.startsWith("branch ") && current) {
+            current.branch = field.slice("branch ".length);
+        }
+    }
+    if (current)
+        listings.push(current);
+    return listings;
+}
+async function listWorktrees(cwd) {
+    const git = createGit(cwd);
+    try {
+        return parseWorktreeListPorcelainZ(await git.raw(["worktree", "list", "--porcelain", "-z"]));
+    }
+    catch (error) {
+        throw wrapGitError("worktree list --porcelain -z", error, cwd);
+    }
+}
+function pathContains(root, candidate) {
+    const relative = path.relative(root, candidate);
+    return relative === "" || (!path.isAbsolute(relative) && relative !== ".." && !relative.startsWith(`..${path.sep}`));
+}
 export async function stableRepoRoot(cwd) {
     const git = createGit(cwd);
     let bare;
@@ -47,25 +79,12 @@ export async function requireContractWorktreePath(cwd, contractId) {
     return await contractWorktreePathFromBind(cwd, contractId, findBindEntry(ledger.entries));
 }
 async function findContractWorktree(cwd, contractId) {
-    const git = createGit(await stableRepoRoot(cwd));
-    let output;
-    try {
-        output = await git.raw(["worktree", "list", "--porcelain", "-z"]);
-    }
-    catch (error) {
-        throw wrapGitError("worktree list --porcelain -z", error, cwd);
-    }
     const expectedBranch = `refs/heads/keiyaku/${contractId}`;
-    let currentPath;
-    for (const field of output.split("\0")) {
-        if (field.startsWith("worktree ")) {
-            currentPath = field.slice("worktree ".length);
-            continue;
-        }
-        if (field === `branch ${expectedBranch}` && currentPath) {
-            const dotGit = await fs.stat(path.join(currentPath, ".git"));
+    for (const worktree of await listWorktrees(await stableRepoRoot(cwd))) {
+        if (worktree.branch === expectedBranch) {
+            const dotGit = await fs.stat(path.join(worktree.path, ".git"));
             if (!dotGit.isDirectory())
-                return { path: currentPath, primary: false };
+                return { path: worktree.path, primary: false };
             return { primary: true };
         }
     }
@@ -74,6 +93,41 @@ async function findContractWorktree(cwd, contractId) {
 export async function findContractWorktreePath(cwd, contractId) {
     return (await findContractWorktree(cwd, contractId)).path;
 }
+/**
+ * Resolve the active commission presented by an engine-owned contract
+ * worktree containing cwd. Ordinary repository directories and arbitrary
+ * worktrees never present a commission address.
+ */
+export async function contractPresentedByWorktree(cwd) {
+    const stableRoot = await stableRepoRoot(cwd);
+    const canonicalCwd = await fs.realpath(cwd);
+    for (const worktree of await listWorktrees(stableRoot)) {
+        const branchPrefix = "refs/heads/keiyaku/";
+        if (!worktree.branch?.startsWith(branchPrefix))
+            continue;
+        const contractId = worktree.branch.slice(branchPrefix.length);
+        const ledger = await readLedger(stableRoot, contractId);
+        if (!ledger || isTerminalState(deriveContractState(ledger.entries)))
+            continue;
+        const bind = findBindEntry(ledger.entries);
+        if (!bind || bind.data.workspace !== "worktree")
+            continue;
+        let canonicalWorktree;
+        let expectedWorktree;
+        try {
+            canonicalWorktree = await fs.realpath(worktree.path);
+            expectedWorktree = await fs.realpath(await contractWorktreePathFromBind(stableRoot, contractId, bind));
+        }
+        catch {
+            continue;
+        }
+        if (canonicalWorktree !== expectedWorktree)
+            continue;
+        if (pathContains(canonicalWorktree, canonicalCwd))
+            return contractId;
+    }
+    return undefined;
+}
 export async function cleanupContractWorkspace(cwd, contractId) {
     const stableRoot = await stableRepoRoot(cwd);
     const git = createGit(stableRoot);

package/build/flow-error.js

@@ -23,7 +23,7 @@ function resolveFlowErrorHint(code, context) {
         case "ACTIVE_KEIYAKU_EXISTS":
             return `Next: open an arc with \`${context.arcToolName}\`, then use \`${context.renewToolName}\` when delivery must follow the current base, or \`${context.closeToolName}\` to settle it.`;
         case "CONTRACT_AMBIGUOUS":
-            return "Address a specific contract workspace, or use `summon --bare` / `ask --bare` to run without contract attachment.";
+            return "Address a specific contract workspace, or use `call --bare` to run without contract attachment.";
         case "UNKNOWN_COMMAND":
             return "Run `keiyaku --help` to inspect available commands.";
         case "EMPTY_PARAM":
@@ -53,21 +53,19 @@ function resolveFlowErrorHint(code, context) {
         case "FROM_DRAFT_NOT_FOUND":
             return "The path in `from_draft` does not exist. `from_draft` must reference an existing file path (absolute or relative to `cwd`).";
         case "INVALID_KEIYAKU_DRAFT":
-            return "Invalid draft/input. Required fields are `title`, `goal`, `context`, and non-empty `criteria` (or equivalent sections in `from_draft`).";
+            return "Invalid draft/input. Use a `# <title>` heading with non-empty `## Objective` and `## Scope` sections (or the equivalent shape in `from_draft`).";
         case "KEIYAKU_FILE_EXISTS":
             return `\`${context.bindToolName}\` requires a clean slate. \`KEIYAKU.md\` must be removed before starting.`;
         case "DETACHED_HEAD":
             return "Repository is in detached HEAD state. Address an active contract workspace before retrying.";
         case "INVALID_RESPONSE_PATH":
-            return "`keiyaku resume RESPONSE_PATH` needs a valid previous Keiyaku response artifact that includes `session` and `subagent_name`.";
+            return "`keiyaku revive ARTIFACT_ID` needs a valid previous Keiyaku response artifact that includes complete provenance plus `session` and `subagent_name`.";
         case "INVALID_CLOSE_INTENT":
             return "Invalid close intent. Valid values are `CLAIM` and `FORFEIT`.";
         case "INVALID_SETTINGS":
             return `Fix invalid configuration in \`${SETTINGS_FILE}\` and retry.`;
         case "INVALID_EFFORT_OVERRIDE":
-            return "Choose one of: low, medium, high, max.";
-        case "UNSUPPORTED_EFFORT_OVERRIDE":
-            return "Choose a provider with a native effort control, or omit the generation override.";
+            return "Choose an effort value declared by the selected Akuma's effortOptions.";
         case "CONCURRENT_MODIFICATION":
             return `Concurrent repository changes were detected during \`${context.arcToolName}\` or \`${context.renewToolName}\`. Retry on the latest branch state.`;
         case "INTERNAL_STATE":

package/build/generated/version.js

@@ -1,2 +1,2 @@
 // Auto-generated by scripts/generate-version.mjs
-export const VERSION = "1.0.1";
+export const VERSION = "2.8.0";

package/build/git/branches.js

@@ -1,7 +1,12 @@
+import { simpleGit } from "simple-git";
 import { FlowError } from "../flow-error.js";
 import { createGit, wrapGitError } from "./core.js";
 export async function isGitRepo(cwd) {
-    const git = createGit(cwd);
+    const git = simpleGit(cwd);
+    git.env("GIT_TERMINAL_PROMPT", "0");
+    git.env("GCM_INTERACTIVE", "Never");
+    git.env("GIT_MERGE_AUTOEDIT", "no");
+    git.env("LC_ALL", "C");
     try {
         return await git.checkIsRepo();
     }

package/build/index.js

@@ -4,16 +4,19 @@ import * as fs from "node:fs/promises";
 import { getConfig, initializeConfig } from "./config/env.js";
 import { ENV_KEYS } from "./config/env-keys.js";
 import { logErrorWithCause } from "./telemetry/logger.js";
-import { runProjectionGeneration } from "./core/summon.js";
+import { runProjectionGenerationRuntime } from "./core/projection-generation-runtime.js";
 import { renderCliHelp, runCliCommand } from "./cli/index.js";
 import { assertSubagentCliCommandAllowed } from "./cli/subagent-guard.js";
 const packageVersion = VERSION;
 function findCliCwd(args) {
     for (let index = 0; index < args.length; index += 1) {
         const arg = args[index];
-        if (arg === "--cwd") {
+        // Tokens after the literal -- boundary are payload, never directory selectors.
+        if (arg === "--")
+            return undefined;
+        if (arg === "--cwd" || arg === "-C") {
             const value = args[index + 1];
-            return value && !value.startsWith("--") ? value : undefined;
+            return value && value !== "--" && !value.startsWith("--") ? value : undefined;
         }
         if (arg?.startsWith("--cwd=")) {
             const value = arg.slice("--cwd=".length).trim();
@@ -25,11 +28,11 @@ function findCliCwd(args) {
 async function main() {
     const cliArgs = process.argv.slice(2);
     if (cliArgs[0] === "__keiyaku-wake") {
-        if (cliArgs.length !== 2 || !cliArgs[1])
+        if (cliArgs.length !== 3 || !cliArgs[1] || !cliArgs[2])
             throw new Error("invalid internal wake invocation");
         // Internal only: canonicalize once at the boundary; no public command can reach here.
         const projectionDirectory = await fs.realpath(cliArgs[1]);
-        await runProjectionGeneration(projectionDirectory);
+        await runProjectionGenerationRuntime(projectionDirectory, cliArgs[2]);
         return;
     }
     initializeConfig(process.env, findCliCwd(cliArgs) ?? process.cwd());

package/build/keiyaku.js

@@ -7,7 +7,7 @@ export const TOOL_NAMES = {
     bind: "bind",
     arc: "arc",
     renew: "renew",
-    summon: "summon",
+    call: "call",
     amend: "amend",
     close: "petition",
     status: "status",
@@ -54,8 +54,6 @@ export const BUILTIN_AGENT_PROFILES = {
     "akuma-claude": { provider: "claude-agent-sdk", description: "Default Claude Agent SDK Akuma." },
 };
 export const CLAUDE_PERMISSION_MODES = ["default", "acceptEdits", "bypassPermissions", "plan", "dontAsk", "auto"];
-export const CLAUDE_EFFORT_LEVELS = ["low", "medium", "high", "max"];
-export const EFFORT_LEVELS = CLAUDE_EFFORT_LEVELS;
 export const CLAUDE_SETTING_SOURCES = ["project", "user", "local"];
 export const CLAUDE_DEFAULT_SETTING_SOURCES = ["project"];
 export const CLAUDE_DEFAULT_PERMISSION_MODE = "bypassPermissions";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@astrosheep/keiyaku",
-  "version": "1.0.1",
+  "version": "2.8.0",
   "description": "CLI for running iterative keiyaku workflows with Codex subagents.",
   "license": "MIT",
   "type": "module",
@@ -37,10 +37,10 @@
     "test:typecheck": "npx tsc --project tsconfig.tests.json",
     "prepublishOnly": "npm run build",
     "start": "node build/index.js",
-    "test:unit": "node --import ./tests/support/real-provider-path-sentinel.mjs --import tsx --test --test-concurrency=1 tests/unit/*.test.ts",
-    "test:integration": "npx tsc && node --import ./tests/support/real-provider-path-sentinel.mjs --import tsx --test --test-concurrency=3 tests/integration/integration.test.ts",
+    "test:unit": "node --import ./tests/support/real-provider-path-sentinel.mjs --import tsx --test --test-concurrency=8 tests/unit/*.test.ts",
+    "test:integration": "node --import ./tests/support/real-provider-path-sentinel.mjs --import tsx --test tests/integration/integration.test.ts",
     "pretest:cli-expect": "npm run build",
-    "test:cli-expect": "node --import ./tests/support/real-provider-path-sentinel.mjs --test --test-concurrency=1 tests/cli-expect/suite/*.test.mjs",
+    "test:cli-expect": "node --import ./tests/support/real-provider-path-sentinel.mjs --test --test-concurrency=8 tests/cli-expect/suite/*.test.mjs",
     "test:real-providers": "KEIYAKU_REAL_PROVIDERS=1 node --import tsx --test --test-concurrency=1 tests/real-provider/matrix.test.ts",
     "test": "npm run test:unit && npm run test:typecheck && npm run test:integration && npm run test:cli-expect",
     "release": "npm version patch && npm publish"
@@ -48,8 +48,9 @@
   "dependencies": {
     "@anthropic-ai/claude-agent-sdk": "^0.3.204",
     "@anthropic-ai/sdk": "^0.110.0",
-    "@earendil-works/pi-coding-agent": "^0.80.2",
+    "@earendil-works/pi-coding-agent": "0.80.2",
     "@modelcontextprotocol/sdk": "^1.29.0",
+    "@opencode-ai/sdk": "1.17.20",
     "@openai/codex-sdk": "^0.113.0",
     "simple-git": "^3.21.0",
     "zod": "4.3.6"

package/skills/keiyaku/SKILL.md

@@ -1,6 +1,6 @@
 ---
 name: keiyaku
-description: Use for the local Keiyaku CLI workflow: binding a contract, opening and closing delivery rounds, summoning Akuma helpers for scoped work, amending scope, inspecting status, petitioning for settlement, and forfeiting failed work.
+description: Use when you need Keiyaku tools to coordinate Akuma work, organize parallel operations, review diffs, and create or manage worktrees.
 allowed-tools: Bash(keiyaku *)
 ---
 
@@ -12,58 +12,17 @@ Prefer the CLI as the source of truth:
 
 ```bash
 keiyaku guide
-keiyaku akuma list
 keiyaku <command> --help
 ```
 
-## Basic Flow
-
-Use this shape for committed delivery work:
-
-```text
-bind -> round open -> [summon/ask | amend | delivery work]* -> delivery commits -> round close -> petition
-```
-
-- `bind`: create the active contract ledger and workspace files from Markdown stdin.
-- `round open`: record the scope/objective/brief before delivery work starts.
-- `summon` / `ask`: summon an Akuma helper for bounded work with `keiyaku summon NAME [prompt|-]` or `keiyaku ask NAME [prompt|-]`.
-- `resume`: continue a prior summon session with `keiyaku resume RESPONSE_PATH [prompt|-]`.
-- `akuma list` / `akuma show <name>`: inspect available Akuma profiles before choosing `keiyaku summon NAME`.
-- `round close`: after delivery commits exist, record the report and non-empty commit list.
-- `amend`: update the contract when scope, rules, or criteria changed.
-- `petition`: run the gated petition -> verdict -> engine-claim settlement pipeline.
-- `claim`: engine-only tombstone; use `keiyaku petition`.
-- `forfeit`: archive an addressed contract as abandoned, optionally with `--reason TEXT`.
-- `status`: inspect the Kanshi board: 現世 head, round sparkline, age, drift, stall, archive count.
-
-## Temporary Work
-
-For temporary tasks, quick inspection, or bounded helper work, use `summon` or `ask` directly. It does not require an active Keiyaku. If a round is open, the Akuma receives the round scope automatically; otherwise it receives only the task, context, and reference files.
+Akuma call/tell/wait/revive lifecycle is owned by the `keiyaku-akuma` skill. Load that skill for helper execution.
 
-Recommended summon prompts use this shape, but the CLI accepts plain text and does not require Markdown sections:
-
-```markdown
-# <short title>
+## Basic Flow
 
-## Task
-<what the Akuma should do>
+For committed delivery work, bind the contract, open an arc before implementation, commit delivery work, amend when the governing contract changes, renew when the base drifts, and petition only after the delivery is ready for settlement. Opening another arc seals the current one; petition also seals an open arc, so no extra closing arc is needed.
 
-## Context
-<optional background, file paths, errors, constraints>
-```
+Use `status` to inspect the Kanshi board and `forfeit` to archive abandoned work. Consult command help for their syntax and flags.
 
 ## Help
 
-Before guessing Markdown input sections, run the relevant help:
-
-```bash
-keiyaku guide
-keiyaku akuma list
-keiyaku round --help
-keiyaku summon --help
-keiyaku ask --help
-keiyaku resume --help
-keiyaku petition --help
-keiyaku claim --help
-keiyaku forfeit --help
-```
+Use `keiyaku <command> --help` for command syntax and flags, and `keiyaku guide` for long-form mechanics. Do not guess Markdown input sections or option defaults.