@astrosheep/keiyaku 4.0.2 → 4.0.4

package/build/src/cli/render/contract.js

@@ -1,5 +1,5 @@
 import { renderAcceptedAudit } from "./audit.js";
-import { appendHookPayload, cleanupLines, hookFailureSummary, leakLines, outcomeLines, receiptPayload, receiptRow, reuseLines, stopLines, } from "./receipt.js";
+import { appendHookPayload, cleanupLines, hookFailureSummary, leakLines, outcomeLines, receiptPayload, receiptRow, reuseLines, stopLines, titleLines, } from "./receipt.js";
 import { gitShortStat, renderOpaqueBlock } from "./terminal.js";
 const HANG = "   ";
 function isRecord(value) {
@@ -30,6 +30,13 @@ function effectRows(effect, columns) {
             { text: effect.path, opaque: true },
         ], columns);
     }
+    else if (effect.kind === "recovery-snapshot") {
+        receiptRow(lines, mark, "recovery-snapshot", [
+            { text: effect.action },
+            { text: effect.snapshot, opaque: true },
+            { text: effect.retention },
+        ], columns);
+    }
     else {
         receiptRow(lines, mark, "ref", [
             { text: effect.action },
@@ -104,7 +111,6 @@ function pushBlock(lines, block) {
 }
 function acceptedRecord(result, columns) {
     const record = [];
-    receiptRow(record, " ", "head", [{ text: result.head, opaque: true }], columns);
     for (const fact of result.facts) {
         const contract = fact.contract === result.contract ? [] : [{ text: fact.contract, opaque: true }];
         receiptRow(record, " ", "journal", [
@@ -113,15 +119,10 @@ function acceptedRecord(result, columns) {
             { text: `· ${fact.kind}` },
         ], columns);
     }
-    if (result.verb === "bind") {
-        receiptRow(record, " ", "target", [{ text: result.target ?? "null", opaque: true }], columns);
-    }
+    receiptRow(record, " ", "head", [{ text: result.head, opaque: true }], columns);
     if (result.verb === "deliver") {
         pushBlock(record, reuseLines(result.verificationReuse, columns));
     }
-    if (result.verb === "amend") {
-        receiptPayload(record, "diff", result.diff);
-    }
     const changed = result.effects.filter(changedEffect);
     const unchanged = result.effects.filter((effect) => !changedEffect(effect));
     for (const effect of [...changed, ...unchanged])
@@ -146,22 +147,15 @@ function acceptedLagRows(result, columns) {
     }
     return obligations;
 }
-function acceptedObligations(result, columns) {
-    const obligations = [];
-    if (result.verb === "deliver" && result.verification !== undefined) {
-        obligations.push(...stopLines("verification", result.verification, columns, result.contract));
-    }
-    if (result.placement !== undefined) {
-        obligations.push(...stopLines("claim", result.placement, columns, result.contract));
-    }
-    if (result.verb === "deliver") {
-        if (result.cleanup !== undefined)
-            pushBlock(obligations, cleanupLines(result.cleanup, columns));
-        if (result.leak !== undefined)
-            pushBlock(obligations, leakLines(result.leak, columns));
-    }
-    obligations.push(...acceptedLagRows(result, columns));
-    return obligations;
+function indentRecord(lines) {
+    let payload = false;
+    return lines.map((line) => {
+        if (line.length === 0) {
+            payload = !payload;
+            return line;
+        }
+        return payload ? line : `  ${line}`;
+    });
 }
 function acceptedDeviations(result, columns) {
     const deviations = [];
@@ -178,32 +172,120 @@ function acceptedDeviations(result, columns) {
     }
     return deviations;
 }
-function renderAcceptedReceipt(result, context) {
-    const columns = context?.columns ?? 80;
-    const lines = outcomeLines("✓", result.verb, "accepted", result.contract, columns);
-    if (result.verb === "deliver" || result.verb === "review") {
-        lines.push(...acceptedObligations(result, columns));
+function recordBlock(result, columns) {
+    const rows = [...acceptedRecord(result, columns), ...acceptedLagRows(result, columns)];
+    return ["  record", ...indentRecord(rows)];
+}
+function verificationVerdictLine(verdict, columns) {
+    const lines = [];
+    receiptRow(lines, verdict === "satisfied" ? "✓" : "!", "verification", [
+        { text: verdict === "satisfied" ? "passed" : "failed" },
+    ], columns);
+    return lines;
+}
+function renderAcceptedBind(result, columns) {
+    const lines = titleLines("✓", "bound", result.contract, columns);
+    receiptRow(lines, " ", "workspace", [
+        { text: result.workspace === "worktree" ? "managed worktree" : "here" },
+    ], columns);
+    if (result.target === null)
+        receiptRow(lines, " ", "no target", [], columns);
+    else
+        receiptRow(lines, " ", "target", [{ text: result.target, opaque: true }], columns);
+    lines.push(...acceptedDeviations(result, columns), ...recordBlock(result, columns));
+    return lines.join("\n");
+}
+function renderAcceptedAmend(result, columns) {
+    const lines = titleLines("✓", "terms replaced", result.contract, columns);
+    receiptPayload(lines, "  terms diff", result.diff);
+    lines.push(...acceptedDeviations(result, columns), ...recordBlock(result, columns));
+    return lines.join("\n");
+}
+function renderAcceptedDeliver(result, columns) {
+    const complete = result.facts.some((fact) => fact.kind === "claimed");
+    const title = complete ? "delivered" : "deliver — not complete";
+    const lines = titleLines("✓", title, result.contract, columns);
+    if (!complete)
+        receiptRow(lines, " ", "candidate", [{ text: "kept" }], columns);
+    if (result.verification !== undefined) {
+        lines.push(...stopLines("verification", result.verification, columns, result.contract));
     }
-    else {
-        lines.push(...acceptedLagRows(result, columns));
+    else if (result.verificationVerdict !== undefined) {
+        lines.push(...verificationVerdictLine(result.verificationVerdict, columns));
+    }
+    if (!complete && result.placement !== undefined) {
+        lines.push(...stopLines("completion", result.placement, columns, result.contract));
+    }
+    else if (!complete && (result.verification !== undefined || result.verificationVerdict === "unsatisfied")) {
+        receiptRow(lines, "·", "completion", [{ text: "not attempted" }], columns);
+    }
+    if (result.cleanup !== undefined)
+        pushBlock(lines, cleanupLines(result.cleanup, columns));
+    if (result.leak !== undefined)
+        pushBlock(lines, leakLines(result.leak, columns));
+    lines.push(...recordBlock(result, columns));
+    return lines.join("\n");
+}
+function renderAcceptedReview(result, columns) {
+    const complete = result.facts.some((fact) => fact.kind === "claimed");
+    const lines = titleLines("✓", `review ${result.verdict}`, result.contract, columns);
+    receiptRow(lines, complete ? "✓" : "!", "contract", [
+        { text: complete ? "complete" : "not complete" },
+    ], columns);
+    if (result.placement !== undefined) {
+        lines.push(...stopLines("completion", result.placement, columns, result.contract));
     }
-    if (result.verb === "bind" || result.verb === "amend" || result.verb === "review") {
-        lines.push(...acceptedDeviations(result, columns));
+    lines.push(...acceptedDeviations(result, columns), ...recordBlock(result, columns));
+    return lines.join("\n");
+}
+function renderAcceptedArc(result, columns) {
+    const lines = titleLines("✓", "chapter recorded", result.contract, columns);
+    receiptRow(lines, " ", "chapter", [
+        { text: String(result.chapter.seq) },
+        { text: "·" },
+        { text: result.chapter.title },
+    ], columns);
+    lines.push(...recordBlock(result, columns));
+    return lines.join("\n");
+}
+function renderAcceptedAbandon(result, columns) {
+    const lines = titleLines("✓", "abandoned", result.contract, columns);
+    if (result.note !== undefined)
+        receiptRow(lines, " ", "note", [{ text: result.note }], columns);
+    for (const effect of result.effects) {
+        if (effect.kind === "worktree") {
+            receiptRow(lines, " ", "workspace", [
+                { text: effect.action },
+                { text: effect.path, opaque: true },
+            ], columns);
+        }
+        else if (effect.kind === "recovery-snapshot") {
+            receiptRow(lines, " ", "recovery snapshot", [
+                { text: effect.snapshot, opaque: true },
+                { text: `· ${effect.retention}` },
+            ], columns);
+        }
     }
-    lines.push(...acceptedRecord(result, columns));
+    lines.push(...recordBlock(result, columns));
     return lines.join("\n");
 }
 export function renderAccepted(result, context) {
+    const columns = context?.columns ?? 80;
     switch (result.verb) {
         case "audit":
             return renderAcceptedAudit(result, context);
         case "bind":
+            return renderAcceptedBind(result, columns);
         case "amend":
-        case "deliver":
+            return renderAcceptedAmend(result, columns);
         case "review":
+            return renderAcceptedReview(result, columns);
         case "arc":
+            return renderAcceptedArc(result, columns);
         case "abandon":
-            return renderAcceptedReceipt(result, context);
+            return renderAcceptedAbandon(result, columns);
+        case "deliver":
+            return renderAcceptedDeliver(result, columns);
     }
 }
 export function renderRetry(result, context) {
@@ -213,3 +295,88 @@ export function renderRetry(result, context) {
         : [];
     return [...outcomeLines("?", result.verb, "retry", result.contract, columns), ...detail].join("\n");
 }
+function journalCount(events, source) {
+    return events.filter((event) => event.source === source).length;
+}
+function journalHead(fact) {
+    return fact.actor === undefined
+        ? `${fact.at} ${fact.kind} · ${fact.entry}`
+        : `${fact.at} ${fact.kind} · ${fact.entry} · ${fact.actor}`;
+}
+function listFact(label, values) {
+    return values.length === 0 ? [`  ${label} 0`] : [`  ${label} ${values.join(" · ")}`];
+}
+function journalBody(fact) {
+    switch (fact.kind) {
+        case "bind": {
+            const { coordinates, terms } = fact.data;
+            return [
+                `  start ${coordinates.start}`,
+                ...(coordinates.target === undefined ? [] : [`  target ${coordinates.target}`]),
+                `  workspace ${coordinates.workspace}`,
+                `  document ${terms.document.key}`,
+                ...listFact("gates", terms.gates),
+                ...listFact("after", terms.after),
+            ];
+        }
+        case "amend":
+            return [
+                `  document ${fact.data.document.key}`,
+                ...listFact("gates", fact.data.gates),
+                ...listFact("after", fact.data.after),
+            ];
+        case "bound":
+            return [];
+        case "deliver": {
+            const { tenderSnapshot, integration, method, policy } = fact.data;
+            return [
+                `  tender ${tenderSnapshot}`,
+                `  predecessor ${integration.predecessor}`,
+                `  snapshot ${integration.snapshot}`,
+                `  change ${integration.changeId}`,
+                `  method ${method}`,
+                `  require-branches-to-be-up-to-date ${String(policy.requireBranchesToBeUpToDate)}`,
+            ];
+        }
+        case "attestation": {
+            const lines = [
+                `  gate ${fact.data.gate}`,
+                `  verdict ${fact.data.verdict}`,
+                `  subject ${fact.data.subject}`,
+            ];
+            if (fact.data.summary !== undefined)
+                receiptPayload(lines, "summary", fact.data.summary);
+            return lines;
+        }
+        case "claimed":
+            return [`  delivery ${fact.data.delivery}`];
+        case "arc": {
+            const lines = [`  sequence ${String(fact.data.seq)}`, `  title ${fact.data.title}`];
+            receiptPayload(lines, "objective", fact.data.objective);
+            receiptPayload(lines, "brief", fact.data.brief);
+            return lines;
+        }
+        case "abandoned": {
+            if (fact.data.note === undefined)
+                return [];
+            const lines = [];
+            receiptPayload(lines, "note", fact.data.note);
+            return lines;
+        }
+    }
+}
+function contractHistoryEventLines(event) {
+    if (event.source === "dispatch") {
+        return [`${event.dispatch.dispatchedAt} dispatch · ${event.dispatch.akuId}`];
+    }
+    return [journalHead(event.fact), ...journalBody(event.fact)];
+}
+export function renderContractHistory(history) {
+    const journals = journalCount(history.events, "journal");
+    const dispatches = journalCount(history.events, "dispatch");
+    return [
+        `history ${history.id} · ${journals} journal · ${dispatches} dispatch`,
+        "",
+        ...history.events.flatMap(contractHistoryEventLines),
+    ].join("\n");
+}

package/build/src/cli/render/kanshi.js

@@ -193,7 +193,56 @@ function endpointFact(id, observed) {
         return `-> ${id} (unavailable)`;
     return `-> ${id}`;
 }
-function renderContracts(report, context, selection) {
+function renderNamespaceTasks(row, context) {
+    if (row.namespaceTasks.kind === "absent")
+        return plumbFacts(["namespace tasks absent"], context.columns);
+    if (row.namespaceTasks.kind === "failed") {
+        return plumbFacts([`namespace tasks failed ${row.namespaceTasks.failure.message}`], context.columns);
+    }
+    const lines = [...plumbFacts([`namespace tasks ${row.namespaceTasks.value.length}`], context.columns)];
+    for (const task of row.namespaceTasks.value) {
+        const scan = `${taskMark(task)} ${task.id} · P${task.priority} ${task.disposition}`;
+        const title = safeText(task.title);
+        const inline = `${scan} — ${title}`;
+        if (displayColumns(inline) <= context.columns - displayColumns(PLUMB)) {
+            lines.push(...plumbFacts([inline], context.columns));
+        }
+        else {
+            lines.push(...plumbFacts([`${scan} —`], context.columns));
+            lines.push(...plumbBlock(title, context.columns));
+        }
+    }
+    return lines;
+}
+function renderContractRow(row, report, context, selection) {
+    const hot = contractHot(row);
+    const compact = !hot && selection !== "contract";
+    const title = row.title ?? "title unavailable";
+    const phase = `${row.phase} · ${formatAge(row.phaseAt, report.observedAt)}`;
+    const lines = [identityLine(contractMark(row), row.id)];
+    lines.push(...plumbFacts(compact ? [title, phase, ...targetFacts(row)] : [title], context.columns));
+    if (!compact)
+        lines.push(...plumbFacts([phase, ...targetFacts(row)], context.columns));
+    lines.push(...plumbFacts([workspaceState(row)], context.columns));
+    if (showWorkspacePath(row, hot || selection === "contract")
+        && row.workspaceObservation.kind !== "unappointed"
+        && row.workspaceObservation.location.kind === "worktree") {
+        lines.push(plumbPath(row.workspaceObservation.location.path));
+    }
+    lines.push(...renderGates(row.gates.reports, report.observedAt, context.columns, selection === "contract"));
+    if (row.holder.kind === "held")
+        lines.push(...plumbFacts([`task ${row.holder.taskId}`], context.columns));
+    if (row.holder.kind === "unavailable")
+        lines.push(...plumbFacts(["holder unavailable"], context.columns));
+    for (const attached of row.fleet) {
+        const aliases = attached.aliases.length === 0 ? "" : ` (${attached.aliases.join(" ")})`;
+        lines.push(...plumbFacts([`akuma ${attached.id}${aliases}`], context.columns));
+    }
+    if (selection === "contract")
+        lines.push(...renderNamespaceTasks(row, context));
+    return lines;
+}
+function renderContracts(report, context) {
     const section = report.contracts;
     if (section.kind === "absent")
         return sectionAbsent("KEIYAKU", context.columns);
@@ -204,37 +253,21 @@ function renderContracts(report, context, selection) {
         ...section.value.rows.filter((row) => !contractHot(row)),
     ];
     const lines = [aperture("KEIYAKU", context.columns)];
-    for (const row of rows) {
-        const hot = contractHot(row);
-        const compact = !hot && selection !== "contract";
-        const title = row.title ?? "title unavailable";
-        const phase = `${row.phase} · ${formatAge(row.phaseAt, report.observedAt)}`;
-        lines.push(identityLine(contractMark(row), row.id));
-        lines.push(...plumbFacts(compact
-            ? [title, phase, ...targetFacts(row)]
-            : [title], context.columns));
-        if (!compact)
-            lines.push(...plumbFacts([phase, ...targetFacts(row)], context.columns));
-        lines.push(...plumbFacts([workspaceState(row)], context.columns));
-        if (showWorkspacePath(row, hot || selection === "contract")
-            && row.workspaceObservation.kind !== "unappointed"
-            && row.workspaceObservation.location.kind === "worktree") {
-            lines.push(plumbPath(row.workspaceObservation.location.path));
-        }
-        lines.push(...renderGates(row.gates.reports, report.observedAt, context.columns, selection === "contract"));
-        if (row.holder.kind === "held")
-            lines.push(...plumbFacts([`task ${row.holder.taskId}`], context.columns));
-        if (row.holder.kind === "unavailable")
-            lines.push(...plumbFacts(["holder unavailable"], context.columns));
-        for (const attached of row.fleet) {
-            const aliases = attached.aliases.length === 0 ? "" : ` (${attached.aliases.join(" ")})`;
-            lines.push(...plumbFacts([`akuma ${attached.id}${aliases}`], context.columns));
-        }
-    }
+    for (const row of rows)
+        lines.push(...renderContractRow(row, report, context, "world"));
     const attention = rows.filter(contractHot).length;
     lines.push(aperture(`${rows.length} keiyaku · ${attention} attention`, context.columns));
     return lines;
 }
+function renderSelectedContract(report, context) {
+    const section = report.contracts;
+    if (section.kind === "absent")
+        return [`${PLUMB}keiyaku absent`];
+    if (section.kind === "failed")
+        return [tone(`! ${safeText(section.failure.message)}`, "alert", context.color)];
+    const row = section.value.rows[0];
+    return row === undefined ? [`${PLUMB}keiyaku absent`] : renderContractRow(row, report, context, "contract");
+}
 function renderTasks(report, context) {
     const section = report.tasks;
     if (section.kind === "absent")
@@ -335,10 +368,12 @@ function splitHorizon(report, columns) {
     return [`kanshi ${HORIZON}${RULE.repeat(left)} ${aggregate} ${HORIZON}${RULE.repeat(right)} ${world}`];
 }
 export function renderKanshiText(report, context = { columns: 80, color: false }, selection = "world") {
+    if (selection === "contract")
+        return renderSelectedContract(report, context).join("\n");
     return [
         ...splitHorizon(report, context.columns),
         "",
-        ...renderContracts(report, context, selection),
+        ...renderContracts(report, context),
         "",
         ...renderTasks(report, context),
         "",

package/build/src/cli/render/receipt.d.ts

@@ -10,10 +10,11 @@ type HookFailure = Extract<Lag, {
 export declare function receiptRow(lines: string[], mark: string, label: string, segments: readonly ReceiptSegment[], columns: number): void;
 export declare function receiptPayload(lines: string[], label: string, payload: string): void;
 export declare function outcomeLines(mark: "✓" | "!" | "?", verb: string, word: "accepted" | "refused" | "retry", contract: string | undefined, columns?: number): string[];
+export declare function titleLines(mark: string, title: string, contract: string, columns?: number): string[];
 export declare function hookFailureSummary(failure: HookFailure): string;
 export declare function appendHookPayload(lines: string[], failure: HookFailure): void;
 export declare function reuseLines(reuse: VerificationReuse | undefined, columns: number): readonly string[];
-export declare function stopLines(label: "verification" | "claim", stop: VerificationStop | PlacementStop, columns: number, addressed: string): readonly string[];
+export declare function stopLines(label: "verification" | "completion", stop: VerificationStop | PlacementStop, columns: number, addressed: string): readonly string[];
 export declare function cleanupLines(cleanup: NonNullable<AcceptedDeliverResult["cleanup"]>, columns: number): readonly string[];
 export declare function leakLines(leak: NonNullable<AcceptedDeliverResult["leak"]>, columns: number): readonly string[];
 export {};

package/build/src/cli/render/receipt.js

@@ -30,6 +30,13 @@ export function outcomeLines(mark, verb, word, contract, columns = 80) {
         return [inline];
     return [`${base} —`, `  ${safeText(contract)}`];
 }
+export function titleLines(mark, title, contract, columns = 80) {
+    const base = `${mark} ${title}`;
+    const inline = `${base} — ${contract}`;
+    if (displayColumns(inline) <= columns)
+        return [inline];
+    return [`${base} —`, `  ${safeText(contract)}`];
+}
 export function hookFailureSummary(failure) {
     if (failure.kind === "timeout" || failure.kind === "unknown-exit")
         return failure.kind;
@@ -73,7 +80,8 @@ export function stopLines(label, stop, columns, addressed) {
         }
     }
     const lines = [];
-    receiptRow(lines, "!", label, detail, columns);
+    const state = label === "verification" ? "failed" : "blocked";
+    receiptRow(lines, "!", label, [{ text: state }, { text: "·" }, ...detail], columns);
     if ("failure" in stop && stop.failure === "environment-failure" && "command" in stop) {
         appendHookPayload(lines, stop.detail);
     }

package/build/src/cli/render/text.js

@@ -1,5 +1,5 @@
 import { renderObservation } from "./board.js";
-import { renderAccepted, renderRetry } from "./contract.js";
+import { renderAccepted, renderContractHistory, renderRetry } from "./contract.js";
 import { renderKanshiText } from "./kanshi.js";
 import { renderRefusal } from "./refusal.js";
 import { renderCatalogText } from "./catalog.js";
@@ -11,6 +11,8 @@ export function renderText(result, context) {
         return renderKanshiText(result.report, context, result.selection);
     if (result.kind === "catalog")
         return renderCatalogText(result.catalog);
+    if (result.kind === "contract-history")
+        return renderContractHistory(result.history);
     if (result.kind === "region")
         return renderRegionText(result.region);
     if (result.kind === "accepted")

package/build/src/cli/result.d.ts

@@ -1,4 +1,4 @@
-import type { AuditReport, ContractId, Fact, MutationResult, PlacementStop, ReconcileReport, Review, VerificationReuse, VerificationStop } from "../index.js";
+import type { AuditReport, ContractHistory, ContractId, Fact, MutationResult, PlacementStop, ReconcileReport, Review, VerificationReuse, VerificationStop } from "../index.js";
 import type { KanshiReport } from "../kanshi/index.js";
 import type { RegionRead, Section } from "../kanshi/index.js";
 import type { Catalog } from "../index.js";
@@ -29,6 +29,7 @@ export type AcceptedEnvelope = Readonly<{
 }>;
 export type AcceptedBindResult = AcceptedEnvelope & Readonly<{
     verb: "bind";
+    workspace: "worktree" | "here";
     target: string | null;
     verification?: never;
     verificationReuse?: never;
@@ -36,8 +37,11 @@ export type AcceptedBindResult = AcceptedEnvelope & Readonly<{
     cleanup?: never;
     leak?: never;
     report?: never;
-    workspace?: never;
     diff?: never;
+    verificationVerdict?: never;
+    verdict?: never;
+    chapter?: never;
+    note?: never;
 }> & RegionObservation;
 export type AcceptedAmendResult = AcceptedEnvelope & Readonly<{
     verb: "amend";
@@ -50,9 +54,14 @@ export type AcceptedAmendResult = AcceptedEnvelope & Readonly<{
     leak?: never;
     report?: never;
     workspace?: never;
+    verificationVerdict?: never;
+    verdict?: never;
+    chapter?: never;
+    note?: never;
 }> & RegionObservation;
 export type AcceptedDeliverResult = AcceptedEnvelope & Readonly<{
     verb: "deliver";
+    verificationVerdict?: "satisfied" | "unsatisfied";
     verification?: VerificationStop;
     verificationReuse?: VerificationReuse;
     placement?: PlacementStop;
@@ -64,9 +73,13 @@ export type AcceptedDeliverResult = AcceptedEnvelope & Readonly<{
     report?: never;
     workspace?: never;
     diff?: never;
+    verdict?: never;
+    chapter?: never;
+    note?: never;
 }>;
 export type AcceptedReviewResult = AcceptedEnvelope & Readonly<{
     verb: "review";
+    verdict: "satisfied" | "unsatisfied";
     placement?: PlacementStop;
     workspace?: Review["workspace"];
     target?: never;
@@ -78,9 +91,16 @@ export type AcceptedReviewResult = AcceptedEnvelope & Readonly<{
     overlapFailure?: never;
     report?: never;
     diff?: never;
+    verificationVerdict?: never;
+    chapter?: never;
+    note?: never;
 }>;
 export type AcceptedArcResult = AcceptedEnvelope & Readonly<{
     verb: "arc";
+    chapter: Readonly<{
+        seq: number;
+        title: string;
+    }>;
     target?: never;
     verification?: never;
     verificationReuse?: never;
@@ -92,9 +112,13 @@ export type AcceptedArcResult = AcceptedEnvelope & Readonly<{
     report?: never;
     workspace?: never;
     diff?: never;
+    verificationVerdict?: never;
+    verdict?: never;
+    note?: never;
 }>;
 export type AcceptedAbandonResult = AcceptedEnvelope & Readonly<{
     verb: "abandon";
+    note?: string;
     target?: never;
     verification?: never;
     verificationReuse?: never;
@@ -106,6 +130,9 @@ export type AcceptedAbandonResult = AcceptedEnvelope & Readonly<{
     report?: never;
     workspace?: never;
     diff?: never;
+    verificationVerdict?: never;
+    verdict?: never;
+    chapter?: never;
 }>;
 export type AcceptedAuditResult = AcceptedEnvelope & Readonly<{
     verb: "audit";
@@ -120,6 +147,10 @@ export type AcceptedAuditResult = AcceptedEnvelope & Readonly<{
     overlapFailure?: never;
     workspace?: never;
     diff?: never;
+    verificationVerdict?: never;
+    verdict?: never;
+    chapter?: never;
+    note?: never;
 }>;
 export type AcceptedResult = AcceptedBindResult | AcceptedAmendResult | AcceptedDeliverResult | AcceptedReviewResult | AcceptedArcResult | AcceptedAbandonResult | AcceptedAuditResult;
 export type RefusedResult = Readonly<{
@@ -158,5 +189,9 @@ export type CatalogResult = Readonly<{
     kind: "catalog";
     catalog: Catalog;
 }>;
-export type InvocationResult = AcceptedResult | RefusedResult | RetryResult | ObservationResult | GuidanceResult | StatusResult | RegionResult | CatalogResult;
+export type ContractHistoryResult = Readonly<{
+    kind: "contract-history";
+    history: ContractHistory;
+}>;
+export type InvocationResult = AcceptedResult | RefusedResult | RetryResult | ObservationResult | GuidanceResult | StatusResult | RegionResult | CatalogResult | ContractHistoryResult;
 export {};

package/build/src/cli/selectors.d.ts

@@ -6,4 +6,5 @@ export type SelectedContract = Readonly<{
 }>;
 export declare function contractFromInput(repo: Repo, value: string): SelectedContract;
 export declare function resolveContextualContract(board: ContractBoard, selector: string | undefined, scope: string): ContractId;
+export declare function canonicalContractSelector(selector: string): ContractId;
 export declare function resolveKanshiContract(report: KanshiReport, selector: string): string;

package/build/src/cli/selectors.js

@@ -50,12 +50,7 @@ export function resolveContextualContract(board, selector, scope) {
         return resolveShortContract(board.rows, selector);
     return selectorError(`contract selector must be kei/<contract-segment> or @<contract-segment>: ${selector}`);
 }
-export function resolveKanshiContract(report, selector) {
-    if (report.contracts.kind !== "present") {
-        return selectorError(`cannot select a contract while the Contract world is ${report.contracts.kind}`);
-    }
-    if (selector.startsWith("@"))
-        return resolveShortContract(report.contracts.value.rows, selector);
+export function canonicalContractSelector(selector) {
     try {
         identitySegments({ family: "kei", value: selector });
     }
@@ -64,3 +59,11 @@ export function resolveKanshiContract(report, selector) {
     }
     return selector;
 }
+export function resolveKanshiContract(report, selector) {
+    if (report.contracts.kind !== "present") {
+        return selectorError(`cannot select a contract while the Contract world is ${report.contracts.kind}`);
+    }
+    if (selector.startsWith("@"))
+        return resolveShortContract(report.contracts.value.rows, selector);
+    return canonicalContractSelector(selector);
+}

package/build/src/cli/usage.d.ts

@@ -3,5 +3,7 @@ export declare class CliUsageError extends Error {
     readonly projection?: string | undefined;
     constructor(diagnostic: string, projection?: string | undefined);
 }
+export declare const JSON_AUTOMATION_HELP = "--json is only for automation script input/output and should not be used for daily interactive use.";
+export declare function withJsonAutomationHelp(help: string): string;
 export declare function isBlankInput(value: string): boolean;
 export declare function usageLine(usage: string): string;

package/build/src/cli/usage.js

@@ -8,6 +8,10 @@ export class CliUsageError extends Error {
         this.name = "CliUsageError";
     }
 }
+export const JSON_AUTOMATION_HELP = "--json is only for automation script input/output and should not be used for daily interactive use.";
+export function withJsonAutomationHelp(help) {
+    return help.includes("--json") ? `${help}\n\n${JSON_AUTOMATION_HELP}` : help;
+}
 export function isBlankInput(value) {
     return value.trim().length === 0;
 }

package/build/src/contract-worktree.js

@@ -48,6 +48,9 @@ const FULFILLMENT = [
     "### Deliverer", "",
     "Implement and verify the Objective under the Design, Region, and Criteria in this Contract.",
     "When an Arc is active, stay within that current chapter.",
+    "For work requiring three or more steps, prefer `keiyaku task -C <worktree>` "
+        + "to organize and manage Tasks.",
+    "Promptly update progress for Tasks already present in the current worktree.",
     "Leave lifecycle decisions to the caller; report the candidate, verification performed, and any unmet term.", "",
     "### Reviewer", "",
     "Review this Contract worktree against the complete Contract.",