@astrosheep/keiyaku 2.8.4 → 2.9.0

package/build/core/{render.js → contract-view.js}

@@ -1,10 +1,8 @@
-import { deriveContractState, } from "./status.js";
+import { shortCommitHash } from "../git/commits.js";
+import { deriveContractState } from "./status/lifecycle.js";
 const VERB_COLUMN_WIDTH = 11;
 const TIME_COLUMN_WIDTH = 6;
 const ACTOR_COLUMN_WIDTH = 11;
-export function shortCommitHash(hash) {
-    return hash.slice(0, 12);
-}
 function compactWhitespace(value) {
     return value.replace(/\s+/g, " ").trim();
 }
@@ -245,144 +243,18 @@ export function renderContractView(input) {
         "scope:",
         ...bind.data.scope.map((pattern) => `- ${pattern}`),
         "",
+        "checks:",
+        ...bind.data.checks.map((check) => `- ${check}`),
+        "",
+        ...(bind.data.extensions.length > 0
+            ? [
+                ...bind.data.extensions.flatMap((extension) => extension.content.length > 0
+                    ? [`## ${extension.title}`, extension.content, ""]
+                    : [`## ${extension.title}`, ""]),
+            ]
+            : []),
         "log:",
         renderVerticalLog(input),
         "",
     ].join("\n");
 }
-function shortHead(hash) {
-    if (!hash)
-        return "????????";
-    return hash.slice(0, 7);
-}
-export function formatAgeMs(ms) {
-    if (ms === undefined)
-        return undefined;
-    const seconds = Math.max(0, Math.floor(ms / 1_000));
-    if (seconds < 60)
-        return `${seconds}s`;
-    const minutes = Math.floor(seconds / 60);
-    if (minutes < 60)
-        return `${minutes}m`;
-    const hours = Math.floor(minutes / 60);
-    if (hours < 24)
-        return `${hours}h`;
-    return `${Math.floor(hours / 24)}d`;
-}
-function arcSparkline(arcs) {
-    if (arcs <= 0)
-        return "";
-    return Array.from({ length: arcs }, () => "·").join("──");
-}
-function pendingAfterIds(contract) {
-    return contract.after.filter((item) => !item.terminal).map((item) => item.id);
-}
-function kanshiGlyph(contract) {
-    if (contract.state.state === "corrupt")
-        return "×";
-    if (pendingAfterIds(contract).length > 0)
-        return "○";
-    if (contract.state.state === "petitioned")
-        return "◎";
-    return "●";
-}
-export function projectionGlyph(state) {
-    switch (state) {
-        case "out":
-            return "●";
-        case "lost":
-            return "○";
-        case "done":
-            return "◎";
-        case "dismissed":
-            return "×";
-        case "dead":
-            return "✕";
-        case "minting":
-            return "…";
-        case "startup-timeout":
-            return "!";
-        case "unknown":
-            return "?";
-    }
-}
-function renderDriftMark(drift) {
-    if (drift.state === "drift")
-        return `▲${drift.behindBy}`;
-    if (drift.state === "orphaned")
-        return "▲orphaned";
-    return undefined;
-}
-export function renderKanshiBoard(status) {
-    const head = shortHead(status.defaultHead);
-    if (status.contracts.length === 0) {
-        if (status.targetFilter !== null) {
-            return `現世 ${head} · target ${status.targetFilter}\nno commissions on target ${status.targetFilter}\n`;
-        }
-        return `現世 ${head} 无在飞契约\n`;
-    }
-    const header = status.targetFilter !== null
-        ? `現世 ${head} · target ${status.targetFilter}`
-        : `現世 ${head}`;
-    const lines = [header, ""];
-    for (const contract of status.contracts) {
-        const glyph = kanshiGlyph(contract);
-        const name = contract.slug;
-        const spark = arcSparkline(contract.arcs);
-        const facts = [];
-        const lifecycle = contract.state.state;
-        if (lifecycle === "bound" || lifecycle === "active" || lifecycle === "petitioned") {
-            facts.push(lifecycle);
-        }
-        if (contract.place) {
-            facts.push(`@${contract.place}`);
-        }
-        const arcObjective = compactWhitespace(contract.currentArc.objective || "(no arc objective)");
-        const arcMark = contract.currentArc.state === "open"
-            ? `a${contract.currentArc.number}+`
-            : `a${contract.currentArc.number}`;
-        facts.push(`${arcMark} ${arcObjective}`);
-        facts.push(`next ${contract.nextStep.detail}`);
-        const age = formatAgeMs(contract.lastActiveMs);
-        if (age)
-            facts.push(age);
-        if (contract.queuePosition)
-            facts.push(`Q${contract.queuePosition}`);
-        const drift = renderDriftMark(contract.baseDrift);
-        if (drift)
-            facts.push(drift);
-        if (contract.nextStep.hint)
-            facts.push(contract.nextStep.hint);
-        const pending = pendingAfterIds(contract);
-        if (pending.length > 0) {
-            facts.push(`⧗ ${pending.map((id) => {
-                const dot = id.indexOf(".");
-                return dot > 0 ? id.slice(0, dot) : id;
-            }).join(",")}`);
-        }
-        if (contract.state.state === "corrupt") {
-            facts.push(`corrupt (${contract.state.reason ?? contract.corruptReason ?? "unknown"})`);
-        }
-        if (contract.queueHeadStalled) {
-            facts.push("朱 stall 去广场");
-        }
-        const sparkCol = spark.padEnd(14);
-        const factText = facts.join(" · ");
-        lines.push(`${glyph} ${name.padEnd(18)} ${sparkCol} ${factText}`.trimEnd());
-        if (contract.bootstrapDiagnostics.some((diagnostic) => diagnostic.kind === "plan-without-result")) {
-            lines.push("  ! bootstrap · no result recorded · forfeit and re-bind");
-        }
-        for (const diagnostic of contract.queueDiagnostics) {
-            if (diagnostic.kind === "legacy-petition") {
-                lines.push("  ! legacy petition · no seat · reject then re-petition");
-                continue;
-            }
-            if (diagnostic.kind === "duplicate-seat") {
-                lines.push(`  ! seat ${diagnostic.seat} duplicated with ${diagnostic.with} · ordered by contract id`);
-                continue;
-            }
-            lines.push(`  ! target mismatch · petitioned ${diagnostic.petitioned} · derived ${diagnostic.derived}`);
-        }
-    }
-    return `${lines.join("\n")}\n`;
-}

package/build/core/draft.js

@@ -1,14 +1,34 @@
 import { FlowError } from "../flow-error.js";
 import { extractListItems, parseToAST, renderSectionContent } from "./markdown/parser.js";
 import { normalizeScopePattern } from "./scope.js";
-const KNOWN_SECTIONS = new Set(["objective", "scope"]);
+const KNOWN_SECTIONS = new Set(["objective", "scope", "checks"]);
 function invalidBindDraft(message) {
     throw new FlowError("INVALID_KEIYAKU_DRAFT", `INVALID_BIND_DRAFT: ${message}`);
 }
 function normalizeSectionName(name) {
     return name.trim().toLowerCase();
 }
-function findUnexpectedScopeLine(section) {
+/**
+ * Canonicalize extension Markdown by dropping only leading/trailing blank
+ * physical lines. Retained lines keep every byte (indentation, trailing
+ * spaces, fences, internal blanks). Entirely blank input becomes "".
+ */
+function normalizeExtensionContent(content) {
+    const lines = content.split(/\r?\n/);
+    let start = 0;
+    while (start < lines.length && lines[start].trim().length === 0) {
+        start += 1;
+    }
+    let end = lines.length;
+    while (end > start && lines[end - 1].trim().length === 0) {
+        end -= 1;
+    }
+    if (start >= end) {
+        return "";
+    }
+    return lines.slice(start, end).join("\n");
+}
+function findUnexpectedListOnlyLine(section) {
     for (const child of section.children) {
         if (child.type === "list")
             continue;
@@ -27,40 +47,78 @@ function findUnexpectedScopeLine(section) {
     }
     return null;
 }
+function extractSingleLineChecks(section) {
+    const unexpected = findUnexpectedListOnlyLine(section);
+    if (unexpected) {
+        invalidBindDraft(`Checks must be a bullet list; found '${unexpected}'`);
+    }
+    const items = extractListItems(section);
+    if (items.length === 0) {
+        const hasListNode = section.children.some((child) => child.type === "list");
+        if (hasListNode) {
+            invalidBindDraft("empty check in bind draft");
+        }
+        invalidBindDraft("Checks must be a bullet list; found empty Checks section");
+    }
+    return items.map((item) => {
+        const trimmed = item.trim();
+        if (trimmed.length === 0) {
+            invalidBindDraft("empty check in bind draft");
+        }
+        if (item.includes("\n") || item.includes("\r")) {
+            invalidBindDraft("check items must be a single line");
+        }
+        return trimmed;
+    });
+}
 export function parseBindDraft(content) {
     const ast = parseToAST(content);
     let name;
+    let seenH1 = false;
     const sections = new Map();
+    const extensions = [];
     for (const node of ast.children) {
         if (node.type !== "section")
             continue;
-        if (node.level === 1 && name === undefined) {
+        if (node.level === 1) {
+            if (seenH1) {
+                invalidBindDraft("bind draft allows exactly one H1 heading");
+            }
+            seenH1 = true;
             name = node.title.trim() || undefined;
             continue;
         }
         if (node.level !== 2)
             continue;
         const normalized = normalizeSectionName(node.title);
-        if (!KNOWN_SECTIONS.has(normalized))
+        if (KNOWN_SECTIONS.has(normalized)) {
+            if (sections.has(normalized)) {
+                invalidBindDraft(`duplicate section '${node.title}' in bind draft`);
+            }
+            sections.set(normalized, node);
             continue;
-        if (sections.has(normalized)) {
-            invalidBindDraft(`duplicate section '${node.title}' in bind draft`);
         }
-        sections.set(normalized, node);
+        extensions.push({
+            title: node.title.trim(),
+            content: normalizeExtensionContent(renderSectionContent(node)),
+        });
     }
     if (!name) {
-        invalidBindDraft("missing H1 in bind draft; expected '# <name>' followed by '## Objective' and '## Scope'");
+        invalidBindDraft("missing H1 in bind draft; expected '# <name>' followed by '## Objective', '## Scope', and '## Checks'");
     }
     const objective = sections.get("objective");
     const scope = sections.get("scope");
+    const checks = sections.get("checks");
     if (!objective)
         invalidBindDraft("missing Objective section in bind draft");
     if (!scope)
         invalidBindDraft("missing Scope section in bind draft");
+    if (!checks)
+        invalidBindDraft("missing Checks section in bind draft");
     const objectiveText = renderSectionContent(objective).trim();
     if (!objectiveText)
         invalidBindDraft("Objective section cannot be empty");
-    const unexpectedScopeLine = findUnexpectedScopeLine(scope);
+    const unexpectedScopeLine = findUnexpectedListOnlyLine(scope);
     if (unexpectedScopeLine) {
         invalidBindDraft(`Scope must be a bullet list; found '${unexpectedScopeLine}'`);
     }
@@ -77,5 +135,45 @@ export function parseBindDraft(content) {
             }
             return normalizeScopePattern(item);
         }),
+        checks: extractSingleLineChecks(checks),
+        extensions,
+    };
+}
+export function renderBindDraft(draft) {
+    const sections = [
+        `# ${draft.name}`,
+        `## Objective\n${draft.objective}`,
+        `## Scope\n${draft.scope.map((pattern) => `- ${pattern}`).join("\n")}`,
+        `## Checks\n${draft.checks.map((check) => `- ${check}`).join("\n")}`,
+    ];
+    for (const extension of draft.extensions) {
+        const content = normalizeExtensionContent(extension.content);
+        if (content.length > 0) {
+            sections.push(`## ${extension.title}\n${content}`);
+        }
+        else {
+            sections.push(`## ${extension.title}`);
+        }
+    }
+    return `${sections.join("\n\n")}\n`;
+}
+export function compileBindDraftFlags(input) {
+    for (const [flag, value] of [
+        ["--place", input.place],
+        ["--objective", input.objective],
+        ["--scope", input.scope],
+        ["--checks", input.checks],
+    ]) {
+        if (value.includes("\n") || value.includes("\r")) {
+            throw new FlowError("EMPTY_PARAM", `${flag} must be a single line`);
+        }
+    }
+    const draft = {
+        name: input.place,
+        objective: input.objective,
+        scope: [input.scope],
+        checks: [input.checks],
+        extensions: [],
     };
+    return renderBindDraft(parseBindDraft(renderBindDraft(draft)));
 }

package/build/core/entry.js

@@ -52,6 +52,14 @@ export const bindEntryDataSchema = z
     name: nonEmptyString,
     objective: nonEmptyString,
     scope: z.array(scopePatternString).min(1),
+    checks: z.array(nonBlankString).min(1),
+    extensions: z
+        .array(z
+        .object({
+        title: nonBlankString,
+        content: z.string(),
+    })
+        .strict()),
     base: shaSchema,
     target: fullBranchRefSchema,
     workspace: z.enum(["worktree", "here"]),
@@ -111,7 +119,7 @@ export const arcEntryDataSchema = z
     .strict();
 export const sealEntryDataSchema = z
     .object({
-    arc: z.number().int().positive(),
+    arc: z.number().int().nonnegative(),
     sealedBy: z.enum(["arc", "renew", "petition"]),
     oldFence: shaSchema,
     newFence: shaSchema,

package/build/core/execution-coordinate.js

@@ -1,23 +1,7 @@
 import { isCommissionId } from "./ids.js";
-function isRecord(value) {
-    return value !== null && typeof value === "object" && !Array.isArray(value);
-}
-function assertExactFields(value, required, optional, prefix, invalid) {
-    for (const field of required) {
-        if (!(field in value))
-            throw invalid(prefix ? `${prefix}.${field}` : field, "is missing");
-    }
-    const allowed = new Set([...required, ...optional]);
-    const unknown = Object.keys(value).filter((field) => !allowed.has(field)).sort()[0];
-    if (unknown !== undefined)
-        throw invalid(prefix ? `${prefix}.${unknown}` : unknown, "is unknown");
-}
-function requireNonBlank(value, field, invalid) {
-    if (typeof value !== "string" || value.trim() === "")
-        throw invalid(field, "must be a non-blank string");
-}
+import { assertExactFields, assertNonBlankString, isPlainRecord, } from "./validation.js";
 export function parseExecutionAuthority(value, invalid) {
-    if (!isRecord(value))
+    if (!isPlainRecord(value))
         throw invalid("authority", "must be an object");
     if (!("kind" in value))
         throw invalid("authority.kind", "is missing");
@@ -34,13 +18,13 @@ export function parseExecutionAuthority(value, invalid) {
     throw invalid("authority.kind", "must be 'repository' or 'user'");
 }
 export function parseExecutionBinding(value, invalid) {
-    if (!isRecord(value))
+    if (!isPlainRecord(value))
         throw invalid("binding", "must be an object");
     if (!("kind" in value))
         throw invalid("binding.kind", "is missing");
     if (value.kind === "commission") {
         assertExactFields(value, ["kind", "commissionId"], [], "binding", invalid);
-        requireNonBlank(value.commissionId, "binding.commissionId", invalid);
+        assertNonBlankString(value.commissionId, "binding.commissionId", invalid);
         if (!isCommissionId(value.commissionId))
             throw invalid("binding.commissionId", "must be a full commission ID");
         return { kind: "commission", commissionId: value.commissionId };

package/build/core/execution-pact.js

@@ -1,6 +1,7 @@
 import * as path from "node:path";
 import { ProjectionStateError } from "./atomic-publish.js";
 import { parseExecutionBinding as parseCanonicalExecutionBinding, parseExecutionCoordinates, } from "./execution-coordinate.js";
+import { assertExactFields, assertNonBlankString, isPlainRecord, } from "./validation.js";
 const TOP_LEVEL_FIELDS = [
     "version",
     "pid",
@@ -16,31 +17,14 @@ const PACT_FIELD_NAMES = TOP_LEVEL_FIELDS.filter((field) => field !== "authority
 function pactError(pactPath, field, reason) {
     return new ProjectionStateError(`invalid projection pact at ${pactPath}: field '${field}' ${reason}`);
 }
-function isRecord(value) {
-    return value !== null && typeof value === "object" && !Array.isArray(value);
-}
-function assertExactFields(value, required, optional, pactPath, fieldPrefix) {
-    for (const field of required) {
-        if (!(field in value)) {
-            throw pactError(pactPath, fieldPrefix ? `${fieldPrefix}.${field}` : field, "is missing");
-        }
-    }
-    const allowed = new Set([...required, ...optional]);
-    const unknown = Object.keys(value).filter((field) => !allowed.has(field)).sort()[0];
-    if (unknown !== undefined) {
-        throw pactError(pactPath, fieldPrefix ? `${fieldPrefix}.${unknown}` : unknown, "is unknown");
-    }
-}
-function assertNonBlankString(value, pactPath, field) {
-    if (typeof value !== "string" || value.trim() === "") {
-        throw pactError(pactPath, field, "must be a non-blank string");
-    }
+function pactInvalid(pactPath) {
+    return (field, reason) => pactError(pactPath, field, reason);
 }
 /** Parse the pre-publication authority choice without inventing a durable identity. */
 export function parseExecutionAuthoritySelection(value, pactPath = "projection identity", expectedKind) {
-    if (!isRecord(value))
+    if (!isPlainRecord(value))
         throw pactError(pactPath, "authority", "must be an object");
-    assertExactFields(value, ["kind"], [], pactPath, "authority");
+    assertExactFields(value, ["kind"], [], "authority", pactInvalid(pactPath));
     if (value.kind !== "repository" && value.kind !== "user") {
         throw pactError(pactPath, "authority.kind", "must be 'repository' or 'user'");
     }
@@ -57,9 +41,9 @@ export function assertExecutionPactCoordinates(authorityValue, bindingValue, pac
     return parseExecutionCoordinates(authorityValue, bindingValue, (field, reason) => pactError(pactPath, field, reason));
 }
 function parseEffectivePolicy(value, pactPath) {
-    if (!isRecord(value))
+    if (!isPlainRecord(value))
         throw pactError(pactPath, "effectivePolicy", "must be an object");
-    assertExactFields(value, [], ["access", "network", "webSearch"], pactPath, "effectivePolicy");
+    assertExactFields(value, [], ["access", "network", "webSearch"], "effectivePolicy", pactInvalid(pactPath));
     if (value.access !== undefined && value.access !== "read" && value.access !== "write" && value.access !== "auto") {
         throw pactError(pactPath, "effectivePolicy.access", "must be 'read', 'write', or 'auto'");
     }
@@ -77,14 +61,15 @@ function parseExecutionPactFieldsRecord(value, pactPath) {
     if (!Number.isInteger(value.pid) || value.pid < 0) {
         throw pactError(pactPath, "pid", "must be a non-negative integer");
     }
-    assertNonBlankString(value.akuma, pactPath, "akuma");
-    assertNonBlankString(value.provider, pactPath, "provider");
-    assertNonBlankString(value.mintedAt, pactPath, "mintedAt");
+    const invalid = pactInvalid(pactPath);
+    assertNonBlankString(value.akuma, "akuma", invalid);
+    assertNonBlankString(value.provider, "provider", invalid);
+    assertNonBlankString(value.mintedAt, "mintedAt", invalid);
     const mintedAtMs = Date.parse(value.mintedAt);
     if (!Number.isFinite(mintedAtMs) || new Date(mintedAtMs).toISOString() !== value.mintedAt) {
         throw pactError(pactPath, "mintedAt", "must be an ISO-8601 timestamp");
     }
-    assertNonBlankString(value.workspaceRoot, pactPath, "workspaceRoot");
+    assertNonBlankString(value.workspaceRoot, "workspaceRoot", invalid);
     if (!path.isAbsolute(value.workspaceRoot)) {
         throw pactError(pactPath, "workspaceRoot", "must be an absolute path");
     }
@@ -104,15 +89,15 @@ function parseExecutionPactFieldsRecord(value, pactPath) {
 }
 /** Validate every pact field that exists before a repository identity is minted. */
 export function parseExecutionPactFields(value, pactPath = "projection identity") {
-    if (!isRecord(value))
+    if (!isPlainRecord(value))
         throw pactError(pactPath, "$", "must be an object");
-    assertExactFields(value, PACT_FIELD_NAMES, TOP_LEVEL_OPTIONAL_FIELDS, pactPath, "");
+    assertExactFields(value, PACT_FIELD_NAMES, TOP_LEVEL_OPTIONAL_FIELDS, "", pactInvalid(pactPath));
     return parseExecutionPactFieldsRecord(value, pactPath);
 }
 export function parseExecutionPact(value, pactPath = "projection identity") {
-    if (!isRecord(value))
+    if (!isPlainRecord(value))
         throw pactError(pactPath, "$", "must be an object");
-    assertExactFields(value, TOP_LEVEL_FIELDS, TOP_LEVEL_OPTIONAL_FIELDS, pactPath, "");
+    assertExactFields(value, TOP_LEVEL_FIELDS, TOP_LEVEL_OPTIONAL_FIELDS, "", pactInvalid(pactPath));
     const fields = parseExecutionPactFieldsRecord(value, pactPath);
     const { authority, binding } = assertExecutionPactCoordinates(value.authority, fields.binding, pactPath);
     return {

package/build/core/forfeit.js

@@ -1,21 +1,27 @@
 import { FlowError } from "../flow-error.js";
 import { activeLedgerRef, appendWithRetry, readLedger } from "./ledger.js";
 import { releaseScope } from "./registry.js";
-import { deriveContractState, isTerminalState } from "./status.js";
+import { deriveContractState, isTerminalState } from "./status/lifecycle.js";
+import { reconcileTaskForfeit } from "./task-contract.js";
 import { cleanupContractWorkspace, stableRepoRoot } from "./worktree-path.js";
 async function cleanupForfeit(cwd, contractId, actor, at) {
     const stableRoot = await stableRepoRoot(cwd);
     await releaseScope(stableRoot, { contractId, actor, at });
     return await cleanupContractWorkspace(stableRoot, contractId);
 }
-export async function forfeitContract(input) {
+export async function forfeitContract(input, deps = {}) {
     const at = new Date(input.nowMs).toISOString();
-    const ledger = await readLedger(input.cwd, input.contractId);
+    const stableRoot = await stableRepoRoot(input.cwd);
+    const ledger = await readLedger(stableRoot, input.contractId);
     if (ledger) {
         const state = deriveContractState(ledger.entries);
         if (state.state === "forfeited") {
-            // Already-forfeited retry only performs idempotent cleanup.
-            const cleanup = await cleanupForfeit(input.cwd, input.contractId, input.actor, at);
+            await reconcileTaskForfeit({
+                cwd: stableRoot,
+                contractId: input.contractId,
+                publishLedger: async () => undefined,
+            });
+            const cleanup = await (deps.cleanupForfeit ?? cleanupForfeit)(stableRoot, input.contractId, input.actor, at);
             return { contractId: input.contractId, cleanup };
         }
     }
@@ -26,25 +32,32 @@ export async function forfeitContract(input) {
     if (state.state === "corrupt" || isTerminalState(state)) {
         throw new FlowError("INTERNAL_STATE", `contract ${input.contractId} cannot forfeit from state ${state.state}`);
     }
-    const result = await appendWithRetry(input.cwd, activeLedgerRef(input.contractId), () => {
-        const entry = {
-            v: 1,
-            kind: "forfeit",
-            contract: input.contractId,
-            at,
-            actor: input.actor,
-            data: {
-                reason: input.reason,
-                by: input.actor,
-                ...(input.note?.trim() ? { note: input.note.trim() } : {}),
-            },
-        };
-        return entry;
+    await reconcileTaskForfeit({
+        cwd: stableRoot,
+        contractId: input.contractId,
+        publishLedger: async () => {
+            const result = await appendWithRetry(stableRoot, activeLedgerRef(input.contractId), () => {
+                const entry = {
+                    v: 1,
+                    kind: "forfeit",
+                    contract: input.contractId,
+                    at,
+                    actor: input.actor,
+                    data: {
+                        reason: input.reason,
+                        by: input.actor,
+                        ...(input.note?.trim() ? { note: input.note.trim() } : {}),
+                    },
+                };
+                return entry;
+            });
+            if (!result.ok)
+                throw new FlowError("INTERNAL_STATE", `failed to forfeit ${input.contractId}: ${result.reason}`);
+            return result;
+        },
     });
-    if (!result.ok)
-        throw new FlowError("INTERNAL_STATE", `failed to forfeit ${input.contractId}: ${result.reason}`);
     // Forfeit entry naturally removes membership; no dequeue record.
-    const cleanup = await cleanupForfeit(input.cwd, input.contractId, input.actor, at);
+    const cleanup = await (deps.cleanupForfeit ?? cleanupForfeit)(stableRoot, input.contractId, input.actor, at);
     return { contractId: input.contractId, cleanup };
 }
 export async function forfeitContractCommand(input) {

package/build/core/hints.js

@@ -9,7 +9,7 @@ const HELP_BODY_TEMPLATE = [
     `- **\${bind}**: Create the active contract ledger and workspace files from Markdown stdin. The worktree must be clean; call it once per Keiyaku.`,
     `- **\${arc}**: Record the delivery arc title, objective, and brief before work starts. It seals any open arc and does not run agents or mutate delivery code.`,
     `- **\${call}**: Call a ${ACTOR_IDENTITY} for bounded work. An open arc supplies scoped context; the caller still owns review, integration, and commits.`,
-    `- **akuma list / akuma show**: Inspect available ${ACTOR_IDENTITY_PLURAL} and their resolved provider/executable before choosing \`keiyaku call NAME\`.`,
+    `- **akuma ls / akuma view**: Inspect available ${ACTOR_IDENTITY_PLURAL} and their resolved provider/executable before choosing \`keiyaku call NAME\`.`,
     "- **delivery commits**: Commit the actual code or documentation changes in git before sealing them.",
     `- **\${renew}**: Capture receipts, update delivery onto the default branch, seal the open arc, and record the new base.`,
     `- **\${amend}**: Update the Keiyaku when scope, rules, criteria, or intent changed.`,
@@ -22,7 +22,7 @@ const HELP_BODY_TEMPLATE = [
     `- \`\${arc}\` and \`\${renew}\` are ledger operations; they do not call agents and do not edit delivery code.`,
     `- \`\${call}\` can run outside a Keiyaku, but an open arc gives the ${ACTOR_IDENTITY} better context.`,
     `- \`\${call}\` starts a new session. Use \`keiyaku revive ARTIFACT_ID\` to continue a prior response artifact.`,
-    "- `akuma list` and `akuma show <name>` are read-only inspection commands; they do not start a helper.",
+    "- `akuma ls` and `akuma view <name>` are read-only inspection commands; they do not start a helper.",
     "- `keiyaku revive` restores the agent from the response artifact; `--incognito` calls cannot be revived later.",
     "- Premature `petition` requests are rejected; continue with `${arc}`, `${call}`, or `${renew}` until the work is verified.",
     "",

package/build/core/log.js

@@ -1,7 +1,7 @@
 import { FlowError } from "../flow-error.js";
 import { readLedger } from "./ledger.js";
-import { renderContractView } from "./render.js";
-import { deriveContractState } from "./status.js";
+import { renderContractView } from "./contract-view.js";
+import { deriveContractState } from "./status/lifecycle.js";
 export async function readContractLog(input) {
     const ledger = await readLedger(input.cwd, input.contractId);
     if (!ledger) {

package/build/core/petition-claim-gates.js

@@ -1,8 +1,10 @@
 import { spawn } from "node:child_process";
 import { getConfig } from "../config/env.js";
-import { assertSettingsKnobUsable, loadKeiyakuSettings, resolveReviewerAgentName, } from "../config/settings.js";
-import { loadAkumaCatalogV2 } from "../config/akuma-loader_v2.js";
-import { formatAvailableAgentNamesV2 } from "../agents/selector_v2.js";
+import { assertSettingsKnobUsable } from "../config/settings/disease.js";
+import { resolveReviewerAgentName } from "../config/settings/knobs.js";
+import { loadKeiyakuSettings } from "../config/settings/loader.js";
+import { loadAkumaCatalog } from "../config/akuma-loader.js";
+import { formatAvailableAgentNames } from "../agents/selector.js";
 import { getDiffStats } from "../git/diff/preview.js";
 import { readDiff } from "../git/diff/read.js";
 import { getCurrentBranch } from "../git/branches.js";
@@ -11,7 +13,7 @@ import { DIFF_PREVIEW_TEXT_MAX_CHARS } from "../keiyaku.js";
 import { FlowError } from "../flow-error.js";
 import { persistResponseHistory } from "./transcripts.js";
 import { logInfo } from "../telemetry/logger.js";
-import { execSubagent } from "./call.js";
+import { execSubagent } from "./call/call.js";
 import { readContractLog } from "./log.js";
 import { buildVerificationFailureHints } from "./hints.js";
 const CLAIM_VERIFICATION_OUTPUT_MAX_CHARS = 1200;
@@ -168,10 +170,10 @@ export function createAgentReviewGate() {
             }
             const settings = loaded.knobs;
             const reviewerAgentName = resolveReviewerAgentName(settings);
-            const catalog = await loadAkumaCatalogV2(cwd);
+            const catalog = await loadAkumaCatalog(cwd);
             const availableNames = Object.keys(catalog.selected);
             if (catalog.selected[reviewerAgentName] === undefined) {
-                throw new FlowError("UNKNOWN_SUBAGENT", `Unknown agent '${reviewerAgentName}'. Expected one of: ${formatAvailableAgentNamesV2(availableNames)}`);
+                throw new FlowError("UNKNOWN_SUBAGENT", `Unknown agent '${reviewerAgentName}'. Expected one of: ${formatAvailableAgentNames(availableNames)}`);
             }
             const [contractLog, diffStat, fullDiff, currentBranch, headRef] = await Promise.all([
                 readContractLog({ cwd, contractId }),