@astrosheep/keiyaku 4.6.7 → 4.6.8

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, {

package/build/src/cli/runtime.js

@@ -1,7 +1,6 @@
 import { AkumaNotBornError, AkumaObservationError } from "../akuma/akuma-errors.js";
-import { AkumaArchetypeError } from "../akuma/archetype.js";
-import { AKUMA_REQUESTS_ENV } from "../akuma/provider.js";
-import { bodyRequestExecution, localExecutionContext } from "../akuma/requests.js";
+import { executionForEnvironment } from "../akuma/requests.js";
+import { AkumaArchetypeError } from "../index.js";
 import { AkumaAddressError, AkumaWorldScopeError } from "../library/address.js";
 import { encodeFailureWire, KeiyakuError } from "../library/outcome.js";
 import { isParsedAkumaCommand, runAkumaCommand } from "./commands/akuma.js";
@@ -28,11 +27,6 @@ function memoized(reader) {
     let value;
     return () => (value ??= reader());
 }
-function executionForEnvironment(environment) {
-    return environment[AKUMA_REQUESTS_ENV] === undefined
-        ? localExecutionContext()
-        : bodyRequestExecution({ directory: environment[AKUMA_REQUESTS_ENV] });
-}
 function homeFromEnvironment(environment) {
     const mapped = environment.KEIYAKU_HOME?.trim();
     return mapped === undefined || mapped.length === 0 ? undefined : mapped;
@@ -175,16 +169,16 @@ export async function runCliCommand(invocation, input = {}) {
     const home = homeFromEnvironment(environment);
     const cancellation = cliCancellation(input.signal);
     let progress;
-    const runtime = {
-        environment,
-        execution: executionForEnvironment(environment),
-        ...(home === undefined ? {} : { home }),
-        readStdin: memoized(input.readStdin ?? processStdin),
-        signal: cancellation.signal,
-        progress: () => (progress ??= writeExecutionProgress()),
-        ...(input.actor === undefined ? {} : { actor: input.actor }),
-    };
     try {
+        const runtime = {
+            environment,
+            execution: await executionForEnvironment(environment, cancellation.signal),
+            ...(home === undefined ? {} : { home }),
+            readStdin: memoized(input.readStdin ?? processStdin),
+            signal: cancellation.signal,
+            progress: () => (progress ??= writeExecutionProgress()),
+            ...(input.actor === undefined ? {} : { actor: input.actor }),
+        };
         if (command.command === "install")
             return await runInstall(command, environment);
         await admitBindInput(command, invocation, runtime, input.cwd ?? process.cwd());

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

@@ -1,14 +1,11 @@
 import { type ExecutionContext } from "../akuma/requests.js";
-import type { ContractBoard, ContractId, Keiyaku, Repo } from "../index.js";
-import type { KanshiReport } from "../kanshi/index.js";
+import { Keiyaku, type ContractId, type Repo } from "../index.js";
 type SelectedContract = Readonly<{
     id: ContractId;
     contract: Keiyaku;
 }>;
 export declare function contractFromInput(repo: Repo, value: string, execution?: ExecutionContext): SelectedContract;
-export declare function resolveContextualContract(board: ContractBoard, selector: string | undefined, scope: string): ContractId;
-/** Resolve one explicit, short, or worktree-contextual selector to its Contract id. */
-export declare function resolveContractId(repo: Repo, selector: string | undefined, scope: string): Promise<ContractId>;
+/** Adapt public Contract resolution evidence to the existing CLI usage diagnostics. */
+export declare function resolveContractId(repo: Repo, selector: string | undefined, cwd: string): Promise<ContractId>;
 export declare function canonicalContractSelector(selector: string): ContractId;
-export declare function resolveKanshiContract(report: KanshiReport, selector: string): string;
 export {};

package/build/src/cli/selectors.js

@@ -1,76 +1,45 @@
-import { resolve } from "node:path";
 import { localExecutionContext } from "../akuma/requests.js";
 import { identitySegments } from "../identity/coordinates.js";
+import { Keiyaku } from "../index.js";
 import { composeContractLibrary } from "../library/contract-composition.js";
 import { createKeiyakuHandle } from "../library/keiyaku.js";
 import { CliUsageError } from "./parse.js";
-function selectorError(message) {
-    throw new CliUsageError(message);
-}
-function activeManagedCandidates(rows) {
-    return rows.flatMap((contract) => {
-        if (contract.disposition !== "active" || contract.workspace !== "worktree" || contract.worktreePath === null)
-            return [];
-        return [{ id: contract.id, worktreePath: contract.worktreePath }];
-    });
-}
 export function contractFromInput(repo, value, execution = localExecutionContext()) {
     try {
         const id = value;
         return { id, contract: composeContractLibrary(execution, createKeiyakuHandle).select({ repo, id }) };
     }
     catch (error) {
-        selectorError(error instanceof Error ? error.message : String(error));
+        throw new CliUsageError(error instanceof Error ? error.message : String(error));
     }
 }
-function resolveShortContract(rows, selector) {
-    if (selector.startsWith("@kei/"))
-        selectorError(`redundant short contract selector: ${selector}`);
-    const short = selector.slice(1);
-    const candidates = activeManagedCandidates(rows).filter((candidate) => candidate.id.slice("kei/".length) === short);
-    if (candidates.length === 0)
-        selectorError(`unknown contract selector: ${selector}`);
-    if (candidates.length !== 1)
-        selectorError(`ambiguous contract selector: ${selector}`);
-    return candidates[0].id;
-}
-function resolveOmittedContract(board, scope) {
-    const candidates = activeManagedCandidates(board.rows).filter((candidate) => resolve(scope) === resolve(candidate.worktreePath));
-    if (candidates.length === 0) {
-        selectorError("an explicit full or @ contract selector is required outside a managed worktree");
+/** Adapt public Contract resolution evidence to the existing CLI usage diagnostics. */
+export async function resolveContractId(repo, selector, cwd) {
+    const result = await Keiyaku.with().resolve({ repo, ...(selector === undefined ? {} : { selector }), cwd });
+    if (result.kind === "resolved")
+        return result.id;
+    const refusal = result.refusal;
+    switch (refusal.kind) {
+        case "invalid-selector":
+            throw new CliUsageError(refusal.diagnostic);
+        case "redundant-short-selector":
+            throw new CliUsageError(`redundant short contract selector: ${refusal.selector}`);
+        case "unknown-short-selector":
+            throw new CliUsageError(`unknown contract selector: ${refusal.selector}`);
+        case "ambiguous-selector":
+            throw new CliUsageError("selector" in refusal
+                ? `ambiguous contract selector: ${refusal.selector}`
+                : "ambiguous managed worktree contract selector");
+        case "no-contextual-match":
+            throw new CliUsageError("an explicit full or @ contract selector is required outside a managed worktree");
     }
-    if (candidates.length !== 1)
-        selectorError("ambiguous managed worktree contract selector");
-    return candidates[0].id;
-}
-export function resolveContextualContract(board, selector, scope) {
-    if (selector === undefined)
-        return resolveOmittedContract(board, scope);
-    if (selector.startsWith("@"))
-        return resolveShortContract(board.rows, selector);
-    return selectorError(`contract selector must be kei/<contract-segment> or @<contract-segment>: ${selector}`);
-}
-/** Resolve one explicit, short, or worktree-contextual selector to its Contract id. */
-export async function resolveContractId(repo, selector, scope) {
-    if (selector !== undefined && !selector.startsWith("@"))
-        return contractFromInput(repo, selector).id;
-    const { listKeiyaku } = await import("../library/contract-composition.js");
-    return resolveContextualContract(await listKeiyaku({ repo }), selector, scope);
 }
 export function canonicalContractSelector(selector) {
     try {
         identitySegments({ family: "kei", value: selector });
     }
     catch {
-        return selectorError(`contract selector must use kei/: ${selector}`);
+        throw new CliUsageError(`contract selector must use kei/: ${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);
-}