@astrosheep/keiyaku 4.6.6 → 4.6.8

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

@@ -1,7 +1,6 @@
-import { listArchetypeDefinitions } from "../../akuma/archetype.js";
 import { executionChannel } from "../../akuma/requests.js";
-import { Akumas, Keiyaku, KeiyakuError, nuke } from "../../index.js";
-import { kanshi, kanshiCategory, observeKanshi, selectKanshi, selectRegion } from "../../kanshi/index.js";
+import { Akumas, Keiyaku, KeiyakuError, kanshiCategory, listArchetypeDefinitions, nuke } from "../../index.js";
+import { kanshi, observeKanshi, selectRegion } from "../../kanshi/index.js";
 import { resolveNamedAddress } from "../../library/address.js";
 import { composeContractLibrary, observeKeiyaku } from "../../library/contract-composition.js";
 import { validateArcMarkdown, validateContractMarkdown } from "../../library/input.js";
@@ -20,11 +19,9 @@ import { reconcileHasFailure, renderReconcile } from "../render/reconcile.js";
 import { renderConflictMaterialized, renderRefusal } from "../render/refusal.js";
 import { renderRegionText } from "../render/region.js";
 import { renderSettingsText, settingsJsonValue } from "../render/settings.js";
-import { canonicalContractSelector, contractFromInput, resolveContractId, resolveKanshiContract, } from "../selectors.js";
-import { displayContext, emit, writeJson, writeStdout } from "../streams.js";
+import { canonicalContractSelector, contractFromInput, resolveContractId } from "../selectors.js";
+import { displayContext, emit, writeJson, writeStderr, writeStdout } from "../streams.js";
 import { CliUsageError, isBlankInput } from "../usage.js";
-import { amendFromCommand } from "./amend.js";
-import { bindFromCommand } from "./bind.js";
 function requiredRepo(coordinates) {
     if (coordinates.repo === undefined)
         throw new CliUsageError("this command requires a resolved Repo");
@@ -50,17 +47,6 @@ async function contractSettings(command, execution, world, home) {
 function draftWarning(error) {
     return { warning: `bind draft could not be preserved: ${error instanceof Error ? error.message : String(error)}` };
 }
-/** Preserve a refused bind draft at the invocation cwd; coordinates are not yet available. */
-async function bindDraftReceiptAtCwd(input, markdown) {
-    try {
-        return await preserveBindDraft(await resolveInvocationCwd(input), markdown);
-    }
-    catch (error) {
-        if (error instanceof Error && "executionReceipt" in error)
-            throw error;
-        return draftWarning(error);
-    }
-}
 /**
  * The one bind-document admission that runs before coordinate resolution, so a malformed document
  * refuses as a draft-bearing refusal instead of a later Repo/Git failure. Reads the memoized stdin.
@@ -76,7 +62,7 @@ export async function admitBindMarkdown(input) {
             throw error;
         if (!(error instanceof TypeError) && !(error instanceof KeiyakuError && error.category === "invalid-input"))
             throw error;
-        throw new BindDraftError(error, await bindDraftReceiptAtCwd(input, input.markdown));
+        throw new BindDraftError(error, await bindDraftReceipt(() => resolveInvocationCwd(input), input.markdown));
     }
 }
 async function bindDraftReceipt(world, markdown) {
@@ -145,41 +131,32 @@ async function contractLibrary(command, execution, configuration, runtime) {
     return composeContractLibrary(execution, createKeiyakuHandle, {
         ...(configuration === undefined ? {} : { settings: configuration }),
         ...(actor === undefined ? {} : { actor }),
-    }, 
-    // The CLI owns this default: an omitted Markdown --target names the invocation branch.
-    { kind: "current-branch" });
+    });
 }
 async function runBind(command, input, library) {
     const { coordinates, runtime } = input;
     const repo = requiredRepo(coordinates);
     const actor = actorFromEdge(command.actor, runtime.environment);
     if (command.forkOf !== undefined) {
-        const answer = await bindFromCommand({
-            command,
+        const answer = await library.bind({
             repo,
-            library,
+            forkOf: contractFromInput(repo, command.forkOf).id,
+            ...(command.target === undefined ? {} : { target: command.target }),
             ...(actor === undefined ? {} : { actor }),
         });
         return await finishContractAnswer(answer, command.output);
     }
     const markdown = await runtime.readStdin();
-    if (isBlankInput(markdown))
-        throw new CliUsageError("bind requires a nonblank stdin document");
     try {
-        validateContractMarkdown(markdown);
-    }
-    catch (error) {
-        if (!(error instanceof TypeError) && !(error instanceof KeiyakuError && error.category === "invalid-input"))
-            throw error;
-        throw new BindDraftError(error, await bindDraftReceipt(coordinates.establishWorld, markdown));
-    }
-    try {
-        const answer = await bindFromCommand({
-            command,
+        const after = command.after?.map((id) => contractFromInput(repo, id).id);
+        const answer = await library.bind({
             repo,
-            library,
             markdown,
+            ...(command.task === undefined ? {} : { task: command.task }),
+            ...(command.target === undefined ? {} : { target: command.target }),
             ...(actor === undefined ? {} : { actor }),
+            ...(after === undefined ? {} : { after }),
+            ...(command.gates === undefined ? {} : { gates: command.gates }),
         });
         if (answer.kind !== "refused")
             return await finishContractAnswer(answer, command.output);
@@ -203,13 +180,13 @@ async function runAmend(command, input, seat) {
     const markdown = command.stdin === true ? await runtime.readStdin() : undefined;
     if (markdown !== undefined && isBlankInput(markdown))
         throw new CliUsageError("amend requires a nonblank stdin document");
-    const answer = await amendFromCommand({
-        command,
-        repo: requiredRepo(coordinates),
-        contract: seat.contract,
+    const repo = requiredRepo(coordinates);
+    const after = command.clearAfter === true ? [] : command.after?.map((id) => contractFromInput(repo, id).id);
+    const answer = await seat.contract.amend({
         ...(markdown === undefined ? {} : { markdown }),
-        ...(command.gates === undefined ? {} : { gates: command.gates }),
         ...(seat.actor === undefined ? {} : { actor: seat.actor }),
+        ...(after === undefined ? {} : { after }),
+        ...(command.gates === undefined ? {} : { gates: command.gates }),
     });
     return await finishContractAnswer(answer, command.output);
 }
@@ -366,7 +343,7 @@ async function runLs(command, coordinates, home) {
 async function readAkumaStatus(akuma, alias, coordinates) {
     if (coordinates.world === null)
         throw new CliUsageError("no Keiyaku world contains the Akuma selector");
-    const status = await Akumas.of(coordinates.world).status({
+    const status = await Akumas.of(coordinates.world, { reportDiagnostic: writeStderr }).status({
         akuma,
         ...(coordinates.repo === undefined ? {} : { repo: coordinates.repo }),
     });
@@ -473,13 +450,7 @@ async function runStatusIdentity(command, coordinates) {
         }
         return emit(command.output, report, () => renderKanshiText(report, displayContext(), "contract"), 0);
     }
-    const report = await kanshi({
-        world: coordinates.world,
-        ...(coordinates.repo === undefined ? {} : { repo: coordinates.repo }),
-    });
-    const contract = resolveKanshiContract(report, command.contract);
-    const selected = selectKanshi({ report, contract });
-    return emit(command.output, selected, () => renderKanshiText(selected, displayContext(), "contract"), 0);
+    throw new CliUsageError(`contract selector must use kei/: ${command.contract}`);
 }
 async function runStatus(command, coordinates) {
     if (command.guidance === true)
@@ -501,10 +472,10 @@ async function runRegion(command, coordinates) {
         const report = await kanshi({ world: coordinates.world, repo, region: { kind: "path", patterns: command.paths } });
         return emitSection(report.region ?? { kind: "absent" });
     }
+    const contract = command.contract === undefined ? undefined : await resolveContractId(repo, command.contract, coordinates.cwd);
     const report = await kanshi({ world: coordinates.world, repo, region: { kind: "declarations" } });
-    if (command.contract === undefined)
+    if (contract === undefined)
         return emitSection(report.region ?? { kind: "absent" });
-    const contract = resolveKanshiContract(report, command.contract);
     const observed = await observeKeiyaku({ repo, id: contract });
     if (observed.kind === "missing" || observed.row.phase === "claimed" || observed.row.phase === "abandoned") {
         const refusal = {

package/build/src/cli/commands/install.js

@@ -47,8 +47,8 @@ export function renderInstallHelp() {
     return `${INSTALL_ROOT_PURPOSE}\n\n${usageLine(INSTALL_USAGE)}\n\n--all continues past failures; any failure exits 1.`;
 }
 const INSTALL_TIMEOUT_MS = 5 * 60 * 1000;
-const ASSET_ROOT = resolve(dirname(fileURLToPath(import.meta.url)), "../../../integrations/marketplace");
-const PLUGIN_ROOT = resolve(ASSET_ROOT, "plugins/keiyaku");
+const ASSET_ROOT = resolve(dirname(fileURLToPath(import.meta.url)), "../../../plugins");
+const OPENCODE_PLUGIN_ROOT = resolve(ASSET_ROOT, "opencode");
 const PI_PACKAGE_SOURCE = "npm:@astrosheep/keiyaku";
 function recipes(harness) {
     switch (harness) {
@@ -64,7 +64,7 @@ function recipes(harness) {
                 ["claude", "plugin", "update", "keiyaku@keiyaku", "--scope", "user"],
             ];
         case "opencode":
-            return [["opencode", "plugin", PLUGIN_ROOT, "--global", "--force"]];
+            return [["opencode", "plugin", OPENCODE_PLUGIN_ROOT, "--global", "--force"]];
         case "pi":
             return [["pi", "install", PI_PACKAGE_SOURCE]];
     }

package/build/src/cli/commands/task.js

@@ -156,21 +156,15 @@ async function runRead(input) {
             });
             return emit(command.output, result, () => renderTaskList("ls", scope, result, displayContext()), taskExitCode(result));
         }
-        case "ready": {
-            const result = await tasks.ready({
-                ...readScope(command, current),
-                ...(value(command, "parent") === undefined ? {} : { parent: value(command, "parent") }),
-                ...(limit(command) === undefined ? {} : { limit: limit(command) }),
-            });
-            return emit(command.output, result, () => renderTaskList("ready", scope, result, displayContext()), taskExitCode(result));
-        }
+        case "ready":
         case "blocked": {
-            const result = await tasks.blocked({
+            const action = command.action;
+            const result = await tasks[action]({
                 ...readScope(command, current),
                 ...(value(command, "parent") === undefined ? {} : { parent: value(command, "parent") }),
                 ...(limit(command) === undefined ? {} : { limit: limit(command) }),
             });
-            return emit(command.output, result, () => renderTaskList("blocked", scope, result, displayContext()), taskExitCode(result));
+            return emit(command.output, result, () => renderTaskList(action, scope, result, displayContext()), taskExitCode(result));
         }
         case "query": {
             const result = await tasks.query({
@@ -233,26 +227,18 @@ function missingWorld(command) {
         const result = missingTask(command.positionals[0]);
         return emit(output, result, () => renderTaskUpdate(result, displayContext()), taskExitCode(result));
     }
-    if (command.action === "start" ||
-        command.action === "stop" ||
-        command.action === "hold" ||
-        command.action === "resume") {
-        if (command.positionals.length === 1) {
-            const result = missingTask(command.positionals[0]);
-            return emit(output, result, () => renderTaskMutation(command.action, result, displayContext()), taskExitCode(result));
-        }
-        const result = {
-            items: command.positionals.map((id) => ({ id: id, outcome: missingTask(id) })),
-        };
-        return emit(output, result, () => renderTaskLifecycle(command.action, result, displayContext()), taskExitCode(result));
-    }
-    if (command.action === "done" || command.action === "drop") {
-        const result = {
-            items: command.positionals.map((id) => ({ id: id, outcome: missingTask(id) })),
-        };
-        return emit(output, result, () => renderTaskLifecycle(command.action, result, displayContext()), taskExitCode(result));
+    const singleLifecycle = ["start", "stop", "hold", "resume"].includes(command.action);
+    const batchLifecycle = ["done", "drop"].includes(command.action);
+    if (!singleLifecycle && !batchLifecycle)
+        throw new Error(`task action has no missing-world answer: ${command.action}`);
+    if (singleLifecycle && command.positionals.length === 1) {
+        const result = missingTask(command.positionals[0]);
+        return emit(output, result, () => renderTaskMutation(command.action, result, displayContext()), taskExitCode(result));
     }
-    throw new Error(`task action has no missing-world answer: ${command.action}`);
+    const result = {
+        items: command.positionals.map((id) => ({ id: id, outcome: missingTask(id) })),
+    };
+    return emit(output, result, () => renderTaskLifecycle(command.action, result, displayContext()), taskExitCode(result));
 }
 /**
  * One compose execution outcome: JSON keeps the untouched native value, while an incomplete text
@@ -284,7 +270,7 @@ async function runBatchLifecycle(tasks, command, verb) {
     return emit(command.output, result, () => renderTaskLifecycle(verb, result, displayContext()), taskExitCode(result));
 }
 async function runMutation(input) {
-    const { tasks, command, current, stdin, composeMarkdown, composeNamespace } = input;
+    const { tasks, command, current, stdin, composeNamespace } = input;
     if (isWorldObservationAction(command) || command.action === "tree")
         return await runRead(input);
     switch (command.action) {
@@ -326,7 +312,7 @@ async function runMutation(input) {
         }
         case "compose": {
             const result = await tasks.compose({
-                markdown: composeMarkdown ?? stdin ?? "",
+                markdown: stdin ?? "",
                 namespace: composeNamespace ?? current ?? [],
                 ...(input.actor === undefined ? {} : { actor: input.actor }),
                 ...(command.flags.plan === true ? { plan: true } : {}),
@@ -377,8 +363,7 @@ export async function runTaskCommand(command, coordinates, runtime) {
     if (stdinDiagnostic !== undefined && isBlankInput(stdin ?? ""))
         throw new CliUsageError(stdinDiagnostic);
     const planOnly = command.action === "compose" && command.flags.plan === true;
-    const composeMarkdown = command.action === "compose" ? stdin : undefined;
-    const composition = composeMarkdown === undefined ? undefined : taskCompositionNamespaceHeader(composeMarkdown);
+    const composition = command.action === "compose" && stdin !== undefined ? taskCompositionNamespaceHeader(stdin) : undefined;
     const explicitNamespace = command.action === "add"
         ? namespace(value(command, "namespace"))
         : command.action === "compose" && composition?.specified
@@ -414,12 +399,10 @@ export async function runTaskCommand(command, coordinates, runtime) {
     return await runMutation({
         tasks,
         command,
-        runtime,
         context: coordinates.taskContext,
         ...(actor === undefined ? {} : { actor }),
         ...(current === undefined ? {} : { current }),
         ...(stdin === undefined ? {} : { stdin }),
-        ...(composeMarkdown === undefined ? {} : { composeMarkdown }),
         ...(explicitNamespace === undefined ? {} : { composeNamespace: explicitNamespace }),
     });
 }

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

@@ -1,7 +1,7 @@
 import { type ParsedTaskCommand, type TaskAction } from "./commands/task-grammar.js";
 import { type AkumaAction, type ParsedAkumaCommand } from "./commands/akuma-grammar.js";
 import { type ParsedInstallCommand } from "./commands/install.js";
-import { type ParsedAbandon, type ParsedAmend, type ParsedArc, type ParsedAudit, type ParsedBind, type ParsedDeliver, type ParsedLs, type ParsedNuke, type ParsedReconcile, type ParsedRegion, type ParsedReview, type ParsedSettings, type ParsedStatus } from "./commands/contract-grammar.js";
+import { type ParsedContractCommand } from "./commands/contract-grammar.js";
 import { type ContractCommand as Command } from "./commands/contract-help.js";
 import { type CliUsageGuide } from "./usage.js";
 export { CliUsageError } from "./usage.js";
@@ -10,7 +10,7 @@ export type { Command };
 export declare function renderRootHelp(columns?: number): string;
 export declare function usageGuideForCommand(command: ParsedCommand): CliUsageGuide;
 export declare function renderHelp(coordinate: CliHelpCoordinate, columns?: number): string;
-export type ParsedCommand = ParsedBind | ParsedAmend | ParsedDeliver | ParsedReview | ParsedArc | ParsedAbandon | ParsedStatus | ParsedLs | ParsedAudit | ParsedReconcile | ParsedNuke | ParsedSettings | ParsedRegion | ParsedInstallCommand | ParsedAkumaCommand | ParsedTaskCommand;
+export type ParsedCommand = ParsedContractCommand | ParsedInstallCommand | ParsedAkumaCommand | ParsedTaskCommand;
 type CliHelpCoordinate = Readonly<{
     kind: "root";
 }> | Readonly<{

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

@@ -1,11 +1,8 @@
 import type { AkumaList } from "../../akuma/akuma.js";
-import type { ArchetypeCatalogRow } from "../../akuma/archetype.js";
+import type { ArchetypeCatalog } from "../../index.js";
 import type { ContractList } from "../../library/contract-types.js";
 import type { TaskPage, TaskRow } from "../../task/index.js";
 export declare function renderAkumaCatalogue(list: AkumaList, archetype: string | null): string;
 export declare function renderContractCatalogue(list: ContractList): string;
-export declare function renderArchetypeCatalogue(list: Readonly<{
-    rows: readonly ArchetypeCatalogRow[];
-    hasMore: boolean;
-}>): string;
+export declare function renderArchetypeCatalogue(list: ArchetypeCatalog): string;
 export declare function renderTaskCatalogue(list: TaskPage<TaskRow>, namespace: readonly string[]): string;

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

@@ -1,5 +1,5 @@
 import { parseAkuId } from "../../akuma/identity.js";
-import { lifecycleWord, shortGitId } from "./contract-observation.js";
+import { gateDisplayName, lifecycleWord, shortGitId } from "./contract-observation.js";
 import { receiptPayload } from "./receipt.js";
 import { renderOpaqueBlock, DEFAULT_CLI_COLUMNS } from "./terminal.js";
 function journalCount(events, source) {
@@ -120,15 +120,12 @@ function eventAt(event) {
 function eventKind(event) {
     return event.source === "journal" ? event.fact.kind : "dispatch";
 }
-function gateNoun(gate) {
-    return gate === "reviewed" ? "review" : gate === "verified" ? "verification" : gate;
-}
 function mark(verdict) {
     return verdict === "satisfied" ? "✓" : "×";
 }
 function bindLine(bind, dispatch) {
     const target = bind.data.coordinates.target?.replace(/^refs\/heads\//u, "") ?? "targetless";
-    const gates = bind.data.terms.gates.map(gateNoun);
+    const gates = bind.data.terms.gates.map(gateDisplayName);
     const gateFact = gates.length === 0 ? "" : ` · ${gates.length === 1 ? "gate" : "gates"} ${gates.join(" · ")}`;
     let alias = "";
     if (dispatch?.source === "dispatch") {
@@ -190,7 +187,7 @@ function skeletonBeatLines(beat, history) {
             ];
         }
         case "attestation":
-            return [`${clock(first)} ${mark(fact.data.verdict)} ${gateNoun(fact.data.gate)}${evidenceSuffix()}`];
+            return [`${clock(first)} ${mark(fact.data.verdict)} ${gateDisplayName(fact.data.gate)}${evidenceSuffix()}`];
         case "amend": {
             const changed = [fact.data.gates.length > 0 ? "gates" : "", fact.data.after.length > 0 ? "after" : ""]
                 .filter((value) => value.length > 0)

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

@@ -40,26 +40,7 @@ function checkoutBehindRows(path, target, columns) {
 }
 function lagRows(lag, columns) {
     const lines = [];
-    if (lag.kind === "worktree-retained") {
-        receiptRow(lines, "!", "lag", [{ text: "worktree retained" }, { text: lag.path, opaque: true }], columns);
-    }
-    else if (lag.kind === "worktree-follow-retained") {
-        receiptRow(lines, "!", "lag", [
-            { text: "worktree follow retained" },
-            { text: "·" },
-            { text: lag.reason.replaceAll("-", " ") },
-            { text: "·" },
-            { text: lag.path, opaque: true },
-        ], columns);
-    }
-    else if (lag.kind === "unsealed-bytes") {
-        receiptRow(lines, "!", "lag", [{ text: "unsealed bytes" }, { text: lag.path, opaque: true }], columns);
-    }
-    else if (lag.kind === "target-checkout-retained") {
-        pushBlock(lines, checkoutBehindRows(lag.path, lag.target, columns));
-        receiptPayload(lines, "reason", lag.diagnostic);
-    }
-    else if (lag.kind === "worktree-hook-failed") {
+    if (lag.kind === "worktree-hook-failed") {
         receiptRow(lines, "!", "lag", [
             {
                 text: `worktree-hook-failed ${lag.phase} ${lag.path} command ${lag.command} name ${lag.name} ${hookFailureSummary(lag.failure)}`,
@@ -153,24 +134,12 @@ function overlapRows(overlaps, color) {
     }
     return lines;
 }
-function pushBlock(lines, block) {
-    if (block.length === 0)
-        return;
-    lines.push(...block);
-}
-function acceptedRecord(result, columns) {
-    const record = [];
-    const recoverySnapshot = effectRecoverySnapshot(result.effects);
-    if (recoverySnapshot !== undefined)
-        receiptRow(record, " ", "recovery snapshot", [{ text: recoverySnapshot, opaque: true }], columns);
-    return record;
-}
 function acceptedLagRows(result, columns) {
     const obligations = [];
     // A checkout this invocation's own follow could not carry is loud; the same arm's reconciliation lag
     // is pre-existing residue and stays in the typed result only.
     for (const checkout of effectRetainedCheckouts(result.effects) ?? []) {
-        pushBlock(obligations, checkoutBehindRows(checkout.path, checkout.target, columns));
+        obligations.push(...checkoutBehindRows(checkout.path, checkout.target, columns));
     }
     for (const { contract, lag } of effectLags(result.effects)) {
         if (lag.kind === "worktree-retained" ||
@@ -180,29 +149,34 @@ function acceptedLagRows(result, columns) {
             continue;
         if (contract !== result.contract)
             receiptRow(obligations, "!", "lag owner", [{ text: contract, opaque: true }], columns);
-        pushBlock(obligations, lagRows(lag, columns));
+        obligations.push(...lagRows(lag, columns));
     }
     for (const { contract, lag } of effectSettlementLags(result.effects)) {
         if (contract !== result.contract)
             receiptRow(obligations, "!", "settlement owner", [{ text: contract, opaque: true }], columns);
-        pushBlock(obligations, settlementLagRows(lag, columns));
+        obligations.push(...settlementLagRows(lag, columns));
     }
-    pushBlock(obligations, executionCleanupLines(effectCleanup(result.effects), columns, result.contract));
-    pushBlock(obligations, executionStopLines(effectExecutionStops(result.effects), columns));
+    obligations.push(...executionCleanupLines(effectCleanup(result.effects), columns, result.contract));
+    obligations.push(...executionStopLines(effectExecutionStops(result.effects), columns));
     return obligations;
 }
 function acceptedDeviations(result, columns, color) {
     const deviations = [];
     if (result.value.overlaps !== undefined)
-        pushBlock(deviations, overlapRows(result.value.overlaps, color));
+        deviations.push(...overlapRows(result.value.overlaps, color));
     if (result.value.overlapFailure !== undefined) {
         receiptRow(deviations, "!", "overlap", [{ text: "unavailable" }], columns);
         receiptPayload(deviations, "reason", result.value.overlapFailure);
     }
     return deviations;
 }
+/** Evidence handles stay in JSON and history; ordinary receipt text carries only outstanding obligations. */
 function recordBlock(result, columns) {
-    const rows = [...acceptedRecord(result, columns), ...acceptedLagRows(result, columns)];
+    const rows = [];
+    const recoverySnapshot = effectRecoverySnapshot(result.effects);
+    if (recoverySnapshot !== undefined)
+        receiptRow(rows, " ", "recovery snapshot", [{ text: recoverySnapshot, opaque: true }], columns);
+    rows.push(...acceptedLagRows(result, columns));
     return rows;
 }
 /** A terminal command names the worktree it retired, or the retained worktree it failed to remove. */
@@ -279,15 +253,6 @@ function completedPlacementLines(result, columns) {
     receiptRow(lines, "✓", lifecycleWord("claimed"), [], columns);
     return lines;
 }
-/** Evidence handles stay in JSON and history; ordinary receipt text carries only outstanding obligations. */
-function obligationLines(result, columns) {
-    const rows = [];
-    const recoverySnapshot = effectRecoverySnapshot(result.effects);
-    if (recoverySnapshot !== undefined)
-        receiptRow(rows, " ", "recovery snapshot", [{ text: recoverySnapshot, opaque: true }], columns);
-    rows.push(...acceptedLagRows(result, columns));
-    return rows;
-}
 function movementLines(result, columns) {
     const count = result.facts.filter((fact) => fact.kind === "reintegrated").length;
     if (count === 0)
@@ -403,7 +368,7 @@ function renderAcceptedDeliver(result, columns) {
         lines.push(...stopLines(verification.stop, columns, result.contract));
     if (!complete && result.value.placement !== undefined)
         lines.push(...stopLines(result.value.placement, columns, result.contract));
-    lines.push(...continuationLines(result, columns), ...(complete ? obligationLines(result, columns) : recordBlock(result, columns)), ...worktreeRetirementLines(result, columns), ...gatesAwaitLines(result.value.placement));
+    lines.push(...continuationLines(result, columns), ...recordBlock(result, columns), ...worktreeRetirementLines(result, columns), ...gatesAwaitLines(result.value.placement));
     return lines.join("\n");
 }
 function renderAcceptedReview(result, columns) {
@@ -416,7 +381,7 @@ function renderAcceptedReview(result, columns) {
         lines.push(...stopLines(result.value.placement, columns, result.contract));
     }
     lines.push(...continuationLines(result, columns));
-    lines.push(...obligationLines(result, columns));
+    lines.push(...recordBlock(result, columns));
     lines.push(...worktreeRetirementLines(result, columns));
     lines.push(...gatesAwaitLines(result.value.placement));
     return lines.join("\n");

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

@@ -1,3 +1,4 @@
+import { gateDisplayName } from "./contract-observation.js";
 import { renderRefusalFacts } from "./refusal.js";
 import { DEFAULT_CLI_COLUMNS, displayColumns, orderRefusalFacts, renderOpaqueBlock, safeText, quotedText, } from "./terminal.js";
 export function receiptRow(lines, mark, label, segments, columns) {
@@ -73,14 +74,6 @@ function prerequisiteRows(stop, columns) {
     }
     return lines;
 }
-/** Requirement names speak as plain event nouns; the "gate" class word never prints on a receipt. */
-function eventNoun(gate) {
-    if (gate === "reviewed")
-        return "review";
-    if (gate === "verified")
-        return "verification";
-    return gate;
-}
 /** Only a recorded unsatisfied verdict alarms; missing and stale requirements fold into the await line. */
 function gateAlarmRows(stop, columns) {
     if (!("refusal" in stop) || stop.refusal?.kind !== "gates-unsatisfied")
@@ -90,7 +83,7 @@ function gateAlarmRows(stop, columns) {
         const { gate, current } = report;
         if (current.kind !== "attested")
             continue;
-        receiptRow(lines, "!", eventNoun(gate), [{ text: `· ${current.verdict}` }, { text: `· at ${current.at}` }], columns);
+        receiptRow(lines, "!", gateDisplayName(gate), [{ text: `· ${current.verdict}` }, { text: `· at ${current.at}` }], columns);
         if (current.summary !== undefined)
             receiptPayload(lines, "  summary", current.summary);
     }
@@ -106,7 +99,7 @@ export function gatesAwaitLines(placement) {
         return [];
     const events = placement.refusal.unmet
         .filter((report) => report.current.kind !== "attested")
-        .map((report) => eventNoun(report.gate));
+        .map((report) => gateDisplayName(report.gate));
     if (events.length === 0)
         return [];
     return [`⧗ awaiting ${events.length > 3 ? `${events.length} gates` : events.join(", ")}`];

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

@@ -22,17 +22,15 @@ type TaskFailure = Extract<TaskMutationResult, {
 /** Task dispositions and relation states are snake_case facts; people read them as words. */
 export declare function dispositionText(word: string): string;
 export declare function taskFrameHead(view: string, scope: string): string;
-export declare function renderDoctor(report: TaskDoctorReport): string;
-/** One addressed show selection rendered directly from its native answer. */
-export declare function renderTaskShow(result: TaskShowResult, context?: TextRenderContext): string;
-/** One list read rendered from its native answer and the leaf's presentation-only scope. */
 export declare function renderTaskList(action: "ls" | "ready" | "blocked" | "query", scope: TaskListScope, result: TaskListOutcome, context?: TextRenderContext): string;
+export declare function renderTaskShow(result: TaskShowResult, context?: TextRenderContext): string;
+export declare function renderDoctor(report: TaskDoctorReport): string;
+export declare function renderTaskUpdate(result: TaskUpdateResult, context?: TextRenderContext): string;
+export declare function renderTaskCompose(result: TaskCompositionResult, context?: TextRenderContext): string;
 export declare function renderTaskTree(result: TaskDecompositionTree, context?: TextRenderContext): string;
 export declare function renderTaskContext(result: TaskContextResult, context?: TextRenderContext): string;
-export declare function renderTaskCompose(result: TaskCompositionResult, context?: TextRenderContext): string;
 /** One single-Task mutation answer; `verb` is the literal action the leaf invoked. */
 export declare function renderTaskMutation(verb: string, result: TaskMutationResult, context?: TextRenderContext): string;
-export declare function renderTaskUpdate(result: TaskUpdateResult, context?: TextRenderContext): string;
 /** One lifecycle answer: a single mutation or a plural batch, both native shapes. */
 export declare function renderTaskLifecycle(verb: string, result: TaskMutationResult | TaskBatchResult, context?: TextRenderContext): string;
 /** A native refusal the CLI edge raised for one action, through the shared refusal grammar. */

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

@@ -33,15 +33,8 @@ function stateEntity(task) {
         title: task.title,
     };
 }
-const TASK_REFUSAL_WORDS = {
-    "task-missing": "task missing",
-    "invalid-lifecycle-transition": "invalid lifecycle transition",
-    "invalid-namespace-context": "invalid namespace context",
-    "relation-owned-by-other": "relation owned by other",
-    "invalid-composition": "invalid composition",
-};
 function projectRefusal(refusal) {
-    const diagnostic = TASK_REFUSAL_WORDS[refusal.kind] ?? refusal.kind.replaceAll("-", " ");
+    const diagnostic = refusal.kind.replaceAll("-", " ");
     if (refusal.kind === "task-missing")
         return { diagnostic, facts: [`task  ${refusal.taskId}`] };
     if (refusal.kind === "invalid-lifecycle-transition") {
@@ -110,7 +103,8 @@ function renderListRow(item, columns, omitDisposition) {
     }
     return lines;
 }
-function renderRows(action, scope, result, columns) {
+export function renderTaskList(action, scope, result, context = DEFAULT_CONTEXT) {
+    const columns = context.columns;
     if (result.kind !== "accepted")
         return renderFailure(action, result, columns);
     const view = action === "ls" ? "tasks" : action;
@@ -162,7 +156,8 @@ function renderShowDetail(result, columns) {
         receiptPayload(lines, "body", task.body);
     return lines.join("\n");
 }
-function renderShow(result, columns) {
+export function renderTaskShow(result, context = DEFAULT_CONTEXT) {
+    const columns = context.columns;
     if (Array.isArray(result))
         return result.map((detail) => renderShowDetail(detail, columns)).join("\n\n");
     if ("kind" in result)
@@ -214,7 +209,8 @@ function renderMutation(action, result, columns) {
         return renderFailure(action, result, columns);
     return renderAcceptedMutation(action, result.value, columns);
 }
-function renderUpdate(result, columns) {
+export function renderTaskUpdate(result, context = DEFAULT_CONTEXT) {
+    const columns = context.columns;
     if (result.kind !== "accepted")
         return renderFailure("update", result, columns);
     return renderAcceptedMutation("update", result.value.task, columns, result.value.changedFields);
@@ -259,7 +255,8 @@ function renderPlan(result) {
     }
     return lines.join("\n");
 }
-function renderCompose(result, columns) {
+export function renderTaskCompose(result, context = DEFAULT_CONTEXT) {
+    const columns = context.columns;
     if (result.kind === "incomplete")
         return "";
     if (result.kind === "planned")
@@ -272,14 +269,6 @@ function renderCompose(result, columns) {
         ...admissionLines(result.admissions),
     ].join("\n");
 }
-/** One addressed show selection rendered directly from its native answer. */
-export function renderTaskShow(result, context = DEFAULT_CONTEXT) {
-    return renderShow(result, context.columns);
-}
-/** One list read rendered from its native answer and the leaf's presentation-only scope. */
-export function renderTaskList(action, scope, result, context = DEFAULT_CONTEXT) {
-    return renderRows(action, scope, result, context.columns);
-}
 export function renderTaskTree(result, context = DEFAULT_CONTEXT) {
     return result.kind === "accepted"
         ? treeLines(result.value, context.columns).join("\n")
@@ -291,16 +280,10 @@ export function renderTaskContext(result, context = DEFAULT_CONTEXT) {
     const value = result.value.namespace.length === 0 ? "root" : result.value.namespace.join("/");
     return `context ${value} · ${result.value.source}`;
 }
-export function renderTaskCompose(result, context = DEFAULT_CONTEXT) {
-    return renderCompose(result, context.columns);
-}
 /** One single-Task mutation answer; `verb` is the literal action the leaf invoked. */
 export function renderTaskMutation(verb, result, context = DEFAULT_CONTEXT) {
     return renderMutation(verb, result, context.columns);
 }
-export function renderTaskUpdate(result, context = DEFAULT_CONTEXT) {
-    return renderUpdate(result, context.columns);
-}
 /** One lifecycle answer: a single mutation or a plural batch, both native shapes. */
 export function renderTaskLifecycle(verb, result, context = DEFAULT_CONTEXT) {
     return "items" in result ? renderBatch(verb, result, context.columns) : renderMutation(verb, result, context.columns);

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

@@ -1,5 +1,5 @@
 import { type LibraryExecution } from "../akuma/requests.js";
-import type { ActorId } from "../index.js";
+import { type ActorId } from "../index.js";
 import type { ExecutionObserver } from "../protocol/execution-observation.js";
 import { type ParsedCommand, type ParsedInvocation } from "./parse.js";
 export type ParsedCommandInvocation = Extract<ParsedInvocation, {