@astrosheep/keiyaku 2.9.3 → 2.9.5

package/skills/keiyaku-task/SKILL.md

@@ -8,23 +8,27 @@ allowed-tools: Bash(keiyaku *)
 
 Planning notes that live in the repo. Executing them is `keiyaku-workflow` (`bind --task`).
 
-## Mind model
+## Core ideas
 
-A task is a Markdown file in `.keiyaku/tasks/` — id `k-<12hex>`, priority 0–3 (0 highest, default 2), optional body. It has no branch and runs nothing; it's the queue you pull from. States:
+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 done. Ready is computed for you — `status` and `task ls` surface it.
+**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 "fix the flaky pump test"      # body: pipe stdin for details
+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 open, priority order
-keiyaku task view k-xxxx                        # full detail incl. needs/blocks
+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
@@ -41,10 +45,15 @@ keiyaku task doctor                             # check board integrity
 ## Promoting to a contract
 
 ```bash
-keiyaku bind --task k-xxxx
+keiyaku bind --task fix-parser
+keiyaku bind --task fix-parser --task fix-parser-help - < contract.md
 ```
 
-Only a **ready** task binds. in_progress → `task stop` first; blocked → finish its needs first. Binding links the task to the contract; the contract's intent you still write yourself — the title doesn't auto-expand into a spec.
+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 name/objective defaults; provide a partial
+bind document for any missing `Scope` or `Checks`.
 
 ## Gotcha
 

package/skills/keiyaku-workflow/SKILL.md

@@ -8,9 +8,15 @@ allowed-tools: Bash(keiyaku *)
 
 How a contract lives. Running akuma is the `keiyaku-akuma` skill; task planning is `keiyaku-task`.
 
-## Mind model
+## Core ideas
 
-A contract = one branch + one worktree + a ledger (its record file in the repo). You work inside the worktree however you like; keiyaku only judges the result at petition. States:
+- A contract is one delivery intent with one ledger, branch, and linked worktree.
+- Workers edit and test; the host reviews their dirty tree and commits accepted bytes.
+- `audit` reads one pinned candidate. `petition` is the settlement action.
+- Scope is an audit boundary, not a write lock. Amend changed intent before delivery.
+- An arc is a named story chapter for one coherent stretch inside the contract.
+
+Lifecycle:
 
 ```
 bound → active → petitioned → claimed | forfeited
@@ -21,13 +27,21 @@ bound → active → petitioned → claimed | forfeited
 ```bash
 keiyaku bind --place fix-pump --objective "make the pump test pass" \
              --scope "src/pump/**" --checks "pump tests green"
-# or the same four fields as Markdown: keiyaku bind < contract.md
+# or the same four fields as Markdown: keiyaku bind - < contract.md
 #   (# <name> / ## Objective / ## Scope / ## Checks)
-# or promote a ready task:            keiyaku bind --task k-xxxx
+# or promote one or more ready tasks:
+keiyaku bind --task fix-parser --task fix-parser-help - < contract.md
+
+cd .keiyaku/wt/fix-pump          # worker edits/tests here and leaves a dirty tree
 
-cd .keiyaku/wt/fix-pump          # worktree lives at .keiyaku/wt/<place>; commit normally
+# Back on the host after reviewing the worker's diff and test report:
+git -C .keiyaku/wt/fix-pump add -- <accepted-paths>
+git -C .keiyaku/wt/fix-pump commit -m "fix pump"
 
-keiyaku petition <<'EOF'
+# Rehearse the exact pinned delivery before settlement:
+keiyaku @fix-pump audit
+
+keiyaku petition - <<'EOF'
 ## Oath
 I made the pump test pass; ran the suite, all green.
 EOF
@@ -37,21 +51,56 @@ EOF
 # The oath is required (OATH_MISSING otherwise) and checked for presence, not content.
 ```
 
-That's the whole small case: bind → commit → petition.
+A task is optional planning, not a prerequisite. Bind directly for new work;
+use `--task` only when promoting existing tracked planning into this contract.
+
+That's the whole small case: bind → worker dirty-tree handoff → host review/commit → petition.
+
+Multi-bind tasks only when they are evidence for the same delivery intent, share
+one coherent write surface, and should settle together. This reduces competing
+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.
+
+Commissioned workers never write Git metadata. The host alone reviews and
+commits accepted bytes before `arc`, `renew`, or `petition`.
 
 ## Mid-flight commands (use when needed, skip otherwise)
 
 ```bash
-keiyaku arc < arc.md         # optional iteration boundary: seals the current intent, opens
+keiyaku arc - < arc.md       # optional iteration boundary: seals the current intent, opens
                              #   the next. Markdown: # <title> / ## Objective / ## Brief.
                              #   Only needed when one contract has multiple distinct pushes.
 keiyaku renew                # main moved under you → rebase onto it. Refuses on conflict
                              #   instead of guessing; resolve, then renew again.
-keiyaku amend < amendment.md # scope/checks changed → update the paper before the code
+keiyaku amend - < amendment.md # scope/checks changed → update the paper before the code
+# Scope terms can be appended durably during a lifecycle operation:
+keiyaku @fix-pump arc --append-scope "docs/generated/**" - < arc.md
+keiyaku @fix-pump renew --append-scope "docs/generated/**"
 keiyaku log                  # this contract's history
 ```
 
+`amend` accepts prose plus an optional ordered scope-pattern delta:
+
+````markdown
+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
+`!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.
 - 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.

package/build/agents/providers/codex-sdk.js

@@ -1,329 +0,0 @@
-import { z } from "zod";
-import { Codex, } from "@openai/codex-sdk";
-import { CODEX_MODEL_REASONING_EFFORT_CONFIG_KEY } from "../../keiyaku.js";
-import { appendDebugBlock, appendDebugLog } from "../../telemetry/debug-log.js";
-import { SUBAGENT_SESSION_VERSION } from "../session.js";
-import { createProjectionDriver } from "../harness/execution-handle.js";
-import { boundActivityExcerpt } from "../harness/activity-values.js";
-import { buildSubagentEnv, emitProviderEvidence, sha256Utf8 } from "../harness/runtime.js";
-import { coerceString } from "../harness/runtime.js";
-import { AGENT_PLAN_ITEM_TEXT_MAX_CHARS, AGENT_PLAN_MAX_ITEMS, AGENT_THOUGHT_TEXT_MAX_CHARS, } from "../harness/events.js";
-import { appendEventType, renderEventTypeSummary } from "./event-type-tail.js";
-/** Identity-only opacity boundary for Codex SDK ThreadOptions modelReasoningEffort. */
-function toCodexSdkModelReasoningEffort(effort) {
-    return effort;
-}
-function withCodexSdkModelReasoningEffort(threadOptions) {
-    const raw = threadOptions.modelReasoningEffort;
-    if (typeof raw !== "string")
-        return threadOptions;
-    return {
-        ...threadOptions,
-        modelReasoningEffort: toCodexSdkModelReasoningEffort(raw),
-    };
-}
-let codexConstructor = Codex;
-function getCodexConstructor(override) {
-    if (override)
-        return override;
-    return codexConstructor;
-}
-/** @deprecated Use CodexSdkOptions.codexConstructor instead. */
-export function setCodexSdkConstructorForTests(constructor) {
-    codexConstructor = constructor;
-}
-/** @deprecated Use CodexSdkOptions.codexConstructor instead. */
-export function resetCodexSdkConstructorForTests() {
-    codexConstructor = Codex;
-}
-export const codexThreadSchema = z.object({ threadId: z.string().trim().min(1) });
-const CODEX_EVENT_THREAD_STARTED = "thread.started";
-const CODEX_EVENT_TURN_STARTED = "turn.started";
-const CODEX_EVENT_TURN_FAILED = "turn.failed";
-const CODEX_EVENT_ERROR = "error";
-const CODEX_EVENT_ITEM_STARTED = "item.started";
-const CODEX_EVENT_ITEM_COMPLETED = "item.completed";
-const CODEX_EVENT_ITEM_UPDATED = "item.updated";
-const CODEX_EVENT_TURN_COMPLETED = "turn.completed";
-const CODEX_SDK_PROVIDER = "codex-sdk";
-const CODEX_SDK_ACKNOWLEDGED_UNPERSISTED = new Set([CODEX_EVENT_THREAD_STARTED]);
-const CODEX_SDK_MAPPED = new Set([
-    CODEX_EVENT_TURN_STARTED,
-    CODEX_EVENT_TURN_COMPLETED,
-    CODEX_EVENT_TURN_FAILED,
-    CODEX_EVENT_ERROR,
-    CODEX_EVENT_ITEM_STARTED,
-    CODEX_EVENT_ITEM_UPDATED,
-    CODEX_EVENT_ITEM_COMPLETED,
-]);
-function codexSdkIngressDisposition(type) {
-    if (CODEX_SDK_ACKNOWLEDGED_UNPERSISTED.has(type))
-        return "acknowledged-unpersisted";
-    if (CODEX_SDK_MAPPED.has(type))
-        return "mapped";
-    return "unknown";
-}
-function extractAgentMessage(event) {
-    if (event.type !== CODEX_EVENT_ITEM_COMPLETED && event.type !== CODEX_EVENT_ITEM_UPDATED) {
-        return undefined;
-    }
-    if (event.item.type !== "agent_message")
-        return undefined;
-    const text = coerceString(event.item.text);
-    if (!text)
-        return undefined;
-    return { id: event.item.id, text };
-}
-function codexActivityCall(item) {
-    switch (item.type) {
-        case "command_execution": return { kind: "run", command: item.command };
-        case "file_change": return {
-            kind: "fileChange",
-            changes: item.changes.map((change) => ({ op: change.kind, path: change.path })),
-        };
-        case "mcp_tool_call": return { kind: "other", display: `${item.server}.${item.tool}` };
-        case "web_search": return { kind: "search", query: item.query };
-    }
-}
-function codexMcpResultMessage(item) {
-    if (item.error?.message)
-        return boundActivityExcerpt(item.error.message);
-    const text = item.result?.content.flatMap((block) => (block.type === "text" && typeof block.text === "string" ? [block.text] : [])).join("\n");
-    return text ? boundActivityExcerpt(text) : undefined;
-}
-function codexActivityResult(item) {
-    switch (item.type) {
-        case "command_execution": return {
-            status: item.status === "failed" || (item.exit_code !== undefined && item.exit_code !== 0) ? "error" : "ok",
-            ...(item.aggregated_output ? { message: boundActivityExcerpt(item.aggregated_output) } : {}),
-            ...(item.exit_code === undefined ? {} : { exitCode: item.exit_code }),
-        };
-        case "file_change": return { status: item.status === "failed" ? "error" : "ok" };
-        case "mcp_tool_call": {
-            const message = codexMcpResultMessage(item);
-            return { status: item.status === "failed" ? "error" : "ok", ...(message ? { message } : {}) };
-        }
-        case "web_search": return { status: "ok" };
-    }
-}
-function emitCodexSemanticEvent(builder, event) {
-    if (event.type === CODEX_EVENT_TURN_STARTED) {
-        builder.emit({ type: "turn", phase: "started" });
-        return;
-    }
-    if (event.type === CODEX_EVENT_TURN_COMPLETED) {
-        builder.emit({
-            type: "usage",
-            inputTokens: event.usage.input_tokens,
-            outputTokens: event.usage.output_tokens,
-            cachedInputTokens: event.usage.cached_input_tokens,
-        });
-        builder.emit({ type: "turn", phase: "completed" });
-        return;
-    }
-    if (event.type !== CODEX_EVENT_ITEM_STARTED &&
-        event.type !== CODEX_EVENT_ITEM_UPDATED &&
-        event.type !== CODEX_EVENT_ITEM_COMPLETED) {
-        return;
-    }
-    if (event.item.type === "reasoning" &&
-        (event.type === CODEX_EVENT_ITEM_UPDATED || event.type === CODEX_EVENT_ITEM_COMPLETED)) {
-        const truncated = event.item.text.length > AGENT_THOUGHT_TEXT_MAX_CHARS;
-        builder.emit({
-            type: "thought",
-            id: event.item.id,
-            text: event.item.text.slice(0, AGENT_THOUGHT_TEXT_MAX_CHARS),
-            final: event.type === CODEX_EVENT_ITEM_COMPLETED,
-            ...(truncated ? { truncated: true } : {}),
-        });
-        return;
-    }
-    if (event.item.type === "todo_list") {
-        builder.emit({
-            type: "plan",
-            id: event.item.id,
-            items: event.item.items.slice(0, AGENT_PLAN_MAX_ITEMS).map((item) => ({
-                text: item.text.slice(0, AGENT_PLAN_ITEM_TEXT_MAX_CHARS),
-                done: item.completed,
-            })),
-        });
-        return;
-    }
-    if (event.item.type !== "command_execution" &&
-        event.item.type !== "file_change" &&
-        event.item.type !== "mcp_tool_call" &&
-        event.item.type !== "web_search") {
-        return;
-    }
-    const phase = event.type === CODEX_EVENT_ITEM_STARTED
-        ? "started"
-        : event.type === CODEX_EVENT_ITEM_UPDATED
-            ? "updated"
-            : "completed";
-    builder.emit({
-        type: "activity",
-        phase,
-        id: event.item.id,
-        tool: event.item.type,
-        call: codexActivityCall(event.item),
-        ...(phase === "started" ? {} : { result: codexActivityResult(event.item) }),
-    });
-}
-/** @deprecated Use the codex-app-server adapter. */
-export async function startCodexSdk(prompt, cwd, options) {
-    const threadId = options.threadId?.trim();
-    const recordedEventTypes = [];
-    let totalEventCount = 0;
-    let activeAbort;
-    let runReturned = false;
-    appendDebugLog(`startCodexSdk: executable=${options.executable ?? "codex"} model=${options.model ?? "default"} ${CODEX_MODEL_REASONING_EFFORT_CONFIG_KEY}=${String(options.config?.[CODEX_MODEL_REASONING_EFFORT_CONFIG_KEY] ?? "default")} mode=${threadId ? "resume" : "fresh"}`, { cwd, section: CODEX_SDK_PROVIDER });
-    return createProjectionDriver({
-        steerMode: "replay",
-        initialTurn: options.initialTurn,
-        onIngress: options.onIngress,
-        async abort(mode) {
-            activeAbort?.abort();
-            if (mode === "force" && !runReturned) {
-                throw new Error("codex-sdk cannot guarantee forced termination");
-            }
-        },
-        async run(builder) {
-            activeAbort = new AbortController();
-            const linked = options.signal ?? builder.signal;
-            const onOuterAbort = () => activeAbort?.abort();
-            linked.addEventListener("abort", onOuterAbort, { once: true });
-            if (linked.aborted)
-                onOuterAbort();
-            builder.signal.addEventListener("abort", onOuterAbort, { once: true });
-            try {
-                const env = buildSubagentEnv();
-                const codexOptions = {
-                    codexPathOverride: options.executable,
-                    profile: options.profile,
-                    config: options.config,
-                    env,
-                };
-                const sdk = new (getCodexConstructor(options.codexConstructor))(codexOptions);
-                const threadOptions = withCodexSdkModelReasoningEffort(options.threadOptions);
-                const thread = threadId ? sdk.resumeThread(threadId, threadOptions) : sdk.startThread(threadOptions);
-                const streamed = await thread.runStreamed(prompt, { signal: activeAbort.signal });
-                const eventIterator = streamed.events[Symbol.asyncIterator]();
-                // The SDK iterable is lazy: its first next() starts the native run.
-                // Record outbound bytes immediately before that crossing, then ack only
-                // after it settles (including a legitimate no-event completion).
-                if (options.onEvidence) {
-                    emitProviderEvidence(options.onEvidence, {
-                        type: "outbound",
-                        provider: CODEX_SDK_PROVIDER,
-                        direction: "input",
-                        kind: "replay-prompt",
-                        ...sha256Utf8(prompt),
-                    }, (text) => builder.emit({ type: "diagnostic", text }));
-                }
-                const firstEvent = await eventIterator.next();
-                if (options.onEvidence) {
-                    emitProviderEvidence(options.onEvidence, {
-                        type: "ack",
-                        provider: CODEX_SDK_PROVIDER,
-                        fence: { kind: "ordinal", ordinal: 0 },
-                        outbound: "run",
-                    }, (text) => builder.emit({ type: "diagnostic", text }));
-                }
-                const events = async function* () {
-                    if (!firstEvent.done)
-                        yield firstEvent.value;
-                    while (true) {
-                        const next = await eventIterator.next();
-                        if (next.done)
-                            return;
-                        yield next.value;
-                    }
-                };
-                let resumeToken;
-                let lastAgentMessage;
-                let turnFailedMessage;
-                let streamErrorMessage;
-                for await (const event of events()) {
-                    if (activeAbort.signal.aborted) {
-                        throw Object.assign(new Error(`${CODEX_SDK_PROVIDER} exec cancelled by client`), { name: "AbortError" });
-                    }
-                    totalEventCount += 1;
-                    appendEventType(recordedEventTypes, event.type);
-                    builder.ingress(CODEX_SDK_PROVIDER, event.type, event, codexSdkIngressDisposition(event.type), () => {
-                        if (event.type === CODEX_EVENT_THREAD_STARTED) {
-                            resumeToken = event.thread_id;
-                            if (options.onEvidence)
-                                emitProviderEvidence(options.onEvidence, { type: "session", provider: CODEX_SDK_PROVIDER, threadId: resumeToken }, (text) => builder.emit({ type: "diagnostic", text }));
-                        }
-                        else if (event.type === CODEX_EVENT_TURN_STARTED && !resumeToken) {
-                            builder.emit({
-                                type: "fail",
-                                message: `${CODEX_SDK_PROVIDER} exec emitted turn.started before thread.started with thread_id`,
-                            });
-                            throw new Error(`${CODEX_SDK_PROVIDER} exec emitted turn.started before thread.started with thread_id`);
-                        }
-                        else if (event.type === CODEX_EVENT_TURN_FAILED) {
-                            turnFailedMessage = coerceString(event.error.message) ?? `${CODEX_SDK_PROVIDER} turn failed`;
-                        }
-                        else if (event.type === CODEX_EVENT_ERROR) {
-                            streamErrorMessage = coerceString(event.message) ?? `${CODEX_SDK_PROVIDER} stream error`;
-                            builder.emit({ type: "diagnostic", text: `${streamErrorMessage}\n` });
-                        }
-                        emitCodexSemanticEvent(builder, event);
-                        const message = extractAgentMessage(event);
-                        if (message) {
-                            lastAgentMessage = message.text;
-                            builder.emit({ type: "message", id: message.id, text: message.text });
-                        }
-                    });
-                }
-                if (turnFailedMessage) {
-                    builder.emit({ type: "diagnostic", text: turnFailedMessage });
-                    builder.emit({ type: "fail", message: turnFailedMessage });
-                    throw new Error(turnFailedMessage);
-                }
-                if (streamErrorMessage && !lastAgentMessage) {
-                    builder.emit({ type: "fail", message: streamErrorMessage });
-                    throw new Error(streamErrorMessage);
-                }
-                if (!resumeToken) {
-                    appendDebugLog(`Missing required codex event: ${CODEX_EVENT_THREAD_STARTED} with thread_id.`, {
-                        cwd,
-                        section: CODEX_SDK_PROVIDER,
-                    });
-                    appendDebugBlock("codex-sdk stdout event types", renderEventTypeSummary(recordedEventTypes, totalEventCount), {
-                        cwd,
-                        section: CODEX_SDK_PROVIDER,
-                    });
-                    builder.emit({
-                        type: "fail",
-                        message: `${CODEX_SDK_PROVIDER} exec succeeded but did not emit a ${CODEX_EVENT_THREAD_STARTED} event with thread_id`,
-                    });
-                    throw new Error(`${CODEX_SDK_PROVIDER} exec succeeded but did not emit a ${CODEX_EVENT_THREAD_STARTED} event with thread_id`);
-                }
-                const finalMessage = lastAgentMessage ?? "";
-                const session = {
-                    provider: "codex-sdk",
-                    version: SUBAGENT_SESSION_VERSION,
-                    handle: { threadId: resumeToken },
-                };
-                if (options.onEvidence)
-                    emitProviderEvidence(options.onEvidence, { type: "checkpoint", provider: CODEX_SDK_PROVIDER, fence: { kind: "ordinal", ordinal: 1 }, source: "response" }, (text) => builder.emit({ type: "diagnostic", text }));
-                builder.emit({
-                    type: "done",
-                    finalMessage,
-                    session,
-                });
-                return { finalMessage, session };
-            }
-            catch (error) {
-                appendDebugLog(`startCodexSdk error: ${error instanceof Error ? `${error.name}: ${error.message}` : String(error)}`, { cwd, section: CODEX_SDK_PROVIDER });
-                throw error;
-            }
-            finally {
-                runReturned = true;
-                linked.removeEventListener("abort", onOuterAbort);
-            }
-        },
-    });
-}

package/build/cli/commands/task/view/meta.js

@@ -1,8 +0,0 @@
-export const meta = {
-    command: "task view",
-    summary: "View one task",
-    usage: ["keiyaku task view [-C|--cwd DIR] ID [--json]"],
-    stdin: "none",
-    flags: ["cwd", "json"],
-    purpose: "Read one task from the working-tree board.",
-};

package/build/core/command-io.js

@@ -1,174 +0,0 @@
-import { ACTOR_IDENTITY } from "../keiyaku.js";
-import { FlowError } from "../flow-error.js";
-import { parseMarkdownListSection, parseMarkdownStructure } from "./markdown/sections.js";
-import { KeiyakuParseError } from "./markdown/types.js";
-import { normalizeSectionTitle } from "./markdown/titles.js";
-import { isBlankScopePatternLine, normalizeScopePattern, ScopePatternError } from "./scope.js";
-function amendScopeHeading(name) {
-    return `## Scope ${name[0].toUpperCase()}${name.slice(1)}`;
-}
-function sourceLines(markdown) {
-    const lines = [];
-    let start = 0;
-    while (start < markdown.length) {
-        const newline = markdown.indexOf("\n", start);
-        const end = newline === -1 ? markdown.length : newline;
-        const next = newline === -1 ? markdown.length : newline + 1;
-        const raw = markdown.slice(start, end);
-        lines.push({ text: raw.endsWith("\r") ? raw.slice(0, -1) : raw, start, end, next });
-        start = next;
-    }
-    return lines;
-}
-function amendHeading(line) {
-    const match = line.match(/^ {0,3}(#{1,2})(?!#)[ \t]+(.+)$/);
-    if (!match)
-        return null;
-    const level = match[1].length;
-    const title = normalizeSectionTitle(match[2]);
-    if (level !== 2)
-        return { level };
-    if (title === "scope add")
-        return { level, name: "add" };
-    return { level };
-}
-function amendFence(line) {
-    const match = line.match(/^ {0,3}(`{3,}|~{3,})/);
-    if (!match)
-        return null;
-    const marker = match[1];
-    return { delimiter: marker[0], length: marker.length };
-}
-function parseAmendScopeSections(markdown) {
-    const lines = sourceLines(markdown);
-    const sections = {};
-    let active;
-    let fence;
-    let frontMatterEnd = -1;
-    if (lines[0]?.text.trim() === "---") {
-        for (let index = 1; index < lines.length; index += 1) {
-            if (lines[index].text.trim() === "---") {
-                frontMatterEnd = index;
-                break;
-            }
-        }
-    }
-    const finishActive = (end) => {
-        if (!active)
-            return;
-        sections[active.name] = { ...active, end };
-        active = undefined;
-    };
-    for (let index = 0; index < lines.length; index += 1) {
-        const line = lines[index];
-        if (index <= frontMatterEnd)
-            continue;
-        const marker = amendFence(line.text);
-        if (fence) {
-            if (marker && marker.delimiter === fence.delimiter && marker.length >= fence.length) {
-                fence = undefined;
-            }
-            continue;
-        }
-        if (marker) {
-            fence = marker;
-            continue;
-        }
-        const heading = amendHeading(line.text);
-        if (!heading)
-            continue;
-        finishActive(line.start);
-        if (!heading.name)
-            continue;
-        if (sections[heading.name]) {
-            throw new FlowError("INVALID_KEIYAKU_DRAFT", `amend input may contain ${amendScopeHeading(heading.name)} at most once`);
-        }
-        active = { name: heading.name, start: line.start, contentStart: line.next };
-    }
-    finishActive(markdown.length);
-    let prose = markdown;
-    for (const section of Object.values(sections).sort((left, right) => right.start - left.start)) {
-        prose = `${prose.slice(0, section.start)}${prose.slice(section.end)}`;
-    }
-    return { sections, prose };
-}
-function scopePatterns(markdown, section) {
-    const patterns = markdown
-        .slice(section.contentStart, section.end)
-        .split(/\r?\n/)
-        .filter((line) => !isBlankScopePatternLine(line))
-        .map((pattern) => {
-        try {
-            // Do not trim() here: gitignore treats trailing `\ ` as a significant space.
-            return normalizeScopePattern(pattern);
-        }
-        catch (error) {
-            if (error instanceof ScopePatternError) {
-                throw new FlowError("INVALID_KEIYAKU_DRAFT", error.message);
-            }
-            throw error;
-        }
-    });
-    if (patterns.length === 0) {
-        throw new FlowError("INVALID_KEIYAKU_DRAFT", `amend input has an empty ${amendScopeHeading(section.name)} section`);
-    }
-    return patterns;
-}
-export function buildAmendInput(markdown, cwd, contractId, contractAddressSource) {
-    const { sections, prose } = parseAmendScopeSections(markdown);
-    const add = sections.add ? scopePatterns(markdown, sections.add) : [];
-    if (!prose.trim()) {
-        throw new FlowError("EMPTY_PARAM", "amendment cannot be empty");
-    }
-    return {
-        cwd,
-        ...(contractId ? { contractId } : {}),
-        ...(contractAddressSource ? { contractAddressSource } : {}),
-        amendment: prose,
-        ...(sections.add ? { scopeDelta: { add } } : {}),
-    };
-}
-export function defaultActorClock(nowMs = Date.now()) {
-    return { actor: ACTOR_IDENTITY, nowMs };
-}
-export function parseCommandMarkdown(content) {
-    try {
-        const parsed = parseMarkdownStructure(content);
-        const sections = new Map();
-        for (const [key, lines] of parsed.sections.entries()) {
-            sections.set(key, lines.join("\n").trim());
-        }
-        return { title: parsed.title, sections };
-    }
-    catch (error) {
-        if (error instanceof KeiyakuParseError) {
-            throw new FlowError("INVALID_KEIYAKU_DRAFT", error.message, { cause: error });
-        }
-        throw error;
-    }
-}
-export function requireMarkdownTextSection(parts, name) {
-    const normalized = normalizeSectionTitle(name);
-    const value = parts.sections.get(normalized)?.trim();
-    if (!value) {
-        throw new FlowError("INVALID_KEIYAKU_DRAFT", `missing required section: ## ${name}`);
-    }
-    return value;
-}
-export function requireMarkdownListSection(parts, name) {
-    const text = requireMarkdownTextSection(parts, name);
-    const items = parseMarkdownListSection(text)
-        .map((item) => item.trim())
-        .filter((item) => item.length > 0);
-    if (items.length === 0) {
-        throw new FlowError("INVALID_KEIYAKU_DRAFT", `missing required section: ## ${name}`);
-    }
-    return items;
-}
-export function requireMarkdownTitle(parts) {
-    const title = parts.title?.trim();
-    if (!title) {
-        throw new FlowError("INVALID_KEIYAKU_DRAFT", "missing required title: # Title");
-    }
-    return title;
-}