@astrosheep/keiyaku 4.6.3 → 4.6.6

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

@@ -1,7 +1,7 @@
 import { dirname, resolve } from "node:path";
 import { fileURLToPath } from "node:url";
 import { CliUsageError, commandGuide, usageLine } from "../usage.js";
-export const HARNESS_NAMES = ["codex", "claude", "opencode", "pi"];
+const HARNESS_NAMES = ["codex", "claude", "opencode", "pi"];
 export const INSTALL_USAGE = "install <codex|claude|opencode|pi>\ninstall --all";
 export const INSTALL_ROOT_PURPOSE = "Install the Keiyaku plugin into a supported coding harness.";
 function isHarness(value) {
@@ -83,9 +83,6 @@ function diagnostic(argv, outcome) {
     const detail = outcome.stderr.trim() || outcome.stdout.trim();
     return `${argv[0]} exited ${outcome.code}${detail.length === 0 ? "" : `: ${detail}`}`;
 }
-export function installAssetsRoot() {
-    return ASSET_ROOT;
-}
 export async function installHarnesses(harnesses, environment, runner) {
     const run = runner ?? (await import("../../runtime/proc/run.js")).runCrossPlatformProcess;
     const results = [];

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

@@ -1,4 +1,5 @@
-import { CliUsageError, isBlankInput, TASK_FAMILY_USAGE_GUIDE, unknownCommandGuide, } from "../usage.js";
+import { CliUsageError, TASK_FAMILY_USAGE_GUIDE, unknownCommandGuide } from "../usage.js";
+import { scanArgs } from "../scan.js";
 import { parseTaskNamespaceSelector } from "../../task/catalog.js";
 import { parseTaskId } from "../../task/identity.js";
 import { parseTaskQueryExpression, validateTaskLimit, validateTaskParent, } from "./task-query.js";
@@ -241,73 +242,16 @@ export function taskUsageGuide(action) {
         help: `keiyaku task ${action} --help`,
     };
 }
-function setFlag(flags, name, kind, value, fail) {
-    if (flags[name] !== undefined && kind !== "repeat")
-        fail(`duplicate option: --${name}`);
-    if (kind === "boolean") {
-        flags[name] = true;
-        return;
-    }
-    if (value === undefined)
-        fail(`--${name} requires a value`);
-    if (isBlankInput(value))
-        fail(`--${name} requires a nonblank value`);
-    if (kind === "repeat") {
-        const current = flags[name];
-        flags[name] = [...(Array.isArray(current) ? current : []), value];
-    }
-    else
-        flags[name] = value;
-}
-function scanTaskOption(input, fail) {
-    const token = input.argv[input.index], name = token.slice(2), kind = input.spec.flags[name];
-    if (kind === undefined)
-        fail(`option ${token} is not valid for task ${input.action}`);
-    const next = kind === "boolean" ? undefined : input.argv[input.index + 1];
-    if (next === "-" && input.action === "update" && name === "body") {
-        if (input.stdin !== undefined)
-            fail("stdin marker '-' may appear only once");
-        input.flags[name] = "";
-        return { index: input.index + 1, stdin: name };
-    }
-    if (kind !== "boolean" && (next === undefined || next.startsWith("--") || next === "-"))
-        fail(`--${name} requires a value`);
-    setFlag(input.flags, name, kind, next, fail);
+/** One scan spec per Task action: `-` reads the document, or `--body -` replaces an update body. */
+function scanSpec(action, spec) {
     return {
-        index: input.index + (kind === "boolean" ? 0 : 1),
-        ...(input.stdin === undefined ? {} : { stdin: input.stdin }),
+        subject: `task ${action}`,
+        flags: spec.flags,
+        ...(spec.stdin === undefined ? {} : { stdin: spec.stdin }),
+        stdinRefusal: "stdin marker '-' is not valid here",
+        ...(action === "update" ? { stdinValue: "body" } : {}),
     };
 }
-function scanTaskArgv(action, argv, fail) {
-    const spec = TASK_COMMAND_SPECS[action], positionals = [], flags = {};
-    let stdin;
-    let positionalOnly = false;
-    for (let index = 1; index < argv.length; index += 1) {
-        const token = argv[index];
-        if (!positionalOnly && token === "--") {
-            positionalOnly = true;
-            continue;
-        }
-        if (!positionalOnly && token === "-") {
-            if (spec.stdin === undefined)
-                fail("stdin marker '-' is not valid here");
-            if (stdin !== undefined)
-                fail("stdin marker '-' may appear only once");
-            stdin = spec.stdin;
-            continue;
-        }
-        if (positionalOnly || !token.startsWith("--")) {
-            if (isBlankInput(token))
-                fail(`task ${action} requires a nonblank value`);
-            positionals.push(token);
-            continue;
-        }
-        const scanned = scanTaskOption({ action, spec, argv, index, flags, ...(stdin === undefined ? {} : { stdin }) }, fail);
-        index = scanned.index;
-        stdin = scanned.stdin;
-    }
-    return { positionals, flags, ...(stdin === undefined ? {} : { stdin }) };
-}
 function validateUpdate(scanned, fail) {
     const flags = scanned.flags;
     if (flags.body !== undefined && flags.append !== undefined)
@@ -419,7 +363,7 @@ export function parseTaskCommand(argv) {
     const fail = (message) => {
         throw new CliUsageError(message, taskUsageGuide(action));
     };
-    const scanned = scanTaskArgv(action, argv, fail);
+    const scanned = scanArgs(argv, scanSpec(action, TASK_COMMAND_SPECS[action]), fail);
     validateTaskScan(action, scanned, fail);
     let where;
     if (action === "query" && typeof scanned.flags.where === "string") {

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

@@ -1,5 +1,4 @@
 import type { ParsedTaskCommand } from "./task-grammar.js";
 import type { CliRuntime } from "../runtime.js";
 import type { CliCoordinates } from "../coordinates.js";
-export { renderTaskHelp } from "./task-grammar.js";
 export declare function runTaskCommand(command: ParsedTaskCommand, coordinates: CliCoordinates, runtime: CliRuntime): Promise<number>;

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

@@ -1,13 +1,12 @@
 import { CliUsageError, isBlankInput } from "../usage.js";
 import { parseTaskNamespaceSelector } from "../../task/catalog.js";
-import { taskRowViewLimit, tasksWithExecution, } from "../../task/index.js";
+import { tasksWithExecution, taskRowViewLimit, } from "../../task/index.js";
 import { taskCompositionNamespaceHeader } from "../../task/compose-language.js";
-import { resolveTaskNamespaceContext, writeTaskNamespaceContext } from "../../task/context.js";
-import { displayContext, writeJson, writeStderr, writeStdout } from "../streams.js";
-import { renderTaskCompose, renderTaskContext, renderTaskDoctor, renderTaskFailure, renderTaskIncompleteDiagnostic, renderTaskLifecycle, renderTaskList, renderTaskMutation, renderTaskShow, renderTaskTree, renderTaskUpdate, taskExitCode, } from "../render/task.js";
+import { installNamespaceContext, resolveTaskNamespaceContext } from "../../task/context.js";
+import { displayContext, emit, writeJson, writeStderr, writeStdout } from "../streams.js";
+import { renderDoctor, renderTaskCompose, renderTaskContext, renderTaskFailure, renderTaskIncompleteDiagnostic, renderTaskLifecycle, renderTaskList, renderTaskMutation, renderTaskShow, renderTaskTree, renderTaskUpdate, taskExitCode, } from "../render/task.js";
 import { actorFromEdge } from "../actor.js";
 import { taskQuerySelection } from "../../task/query.js";
-export { renderTaskHelp } from "./task-grammar.js";
 function value(command, name) {
     const item = command.flags[name];
     return typeof item === "string" ? item : undefined;
@@ -59,17 +58,6 @@ function taskStdinDiagnostic(command) {
             return undefined;
     }
 }
-/**
- * The shared output primitive: one native answer, its matching rendered text, and the native exit
- * classifier's verdict. JSON writes the untouched native value; text writes the rendered lines.
- */
-function emitTask(output, result, project, code) {
-    if (output === "json")
-        writeJson(result);
-    else
-        writeStdout(project());
-    return code;
-}
 async function invokeAdd(input) {
     const { tasks, command, current = [] } = input;
     const selectedNamespace = namespace(value(command, "namespace")) ?? current;
@@ -137,17 +125,14 @@ async function runShow(command, tasks) {
         details.push(await tasks.task({ id }).read());
     const missing = details.findIndex((detail) => detail === null);
     const code = missing >= 0 ? 1 : 0;
-    if (command.output === "json") {
-        writeJson(handles.length === 1 ? details[0] : details);
-        return code;
-    }
+    const projected = handles.length === 1 ? details[0] : details;
     if (missing >= 0) {
         const refusal = { kind: "refused", refusal: { kind: "task-missing", taskId: handles[missing] } };
-        return emitTask(command.output, refusal, () => renderTaskShow(refusal, displayContext()), code);
+        return emit(command.output, projected, () => renderTaskShow(refusal, displayContext()), code);
     }
     const found = details.filter((detail) => detail !== null);
     const result = found.length === 1 ? found[0] : found;
-    return emitTask(command.output, result, () => renderTaskShow(result, displayContext()), code);
+    return emit(command.output, projected, () => renderTaskShow(result, displayContext()), code);
 }
 /** Presentation-only list scope the leaf acquired, never part of the native answer. */
 function listPresentation(command) {
@@ -169,7 +154,7 @@ async function runRead(input) {
                     : { namespace: explicitListNamespace(command) }),
                 ...(limit(command) === undefined ? {} : { limit: limit(command) }),
             });
-            return emitTask(command.output, result, () => renderTaskList("ls", scope, result, displayContext()), taskExitCode(result));
+            return emit(command.output, result, () => renderTaskList("ls", scope, result, displayContext()), taskExitCode(result));
         }
         case "ready": {
             const result = await tasks.ready({
@@ -177,7 +162,7 @@ async function runRead(input) {
                 ...(value(command, "parent") === undefined ? {} : { parent: value(command, "parent") }),
                 ...(limit(command) === undefined ? {} : { limit: limit(command) }),
             });
-            return emitTask(command.output, result, () => renderTaskList("ready", scope, result, displayContext()), taskExitCode(result));
+            return emit(command.output, result, () => renderTaskList("ready", scope, result, displayContext()), taskExitCode(result));
         }
         case "blocked": {
             const result = await tasks.blocked({
@@ -185,7 +170,7 @@ async function runRead(input) {
                 ...(value(command, "parent") === undefined ? {} : { parent: value(command, "parent") }),
                 ...(limit(command) === undefined ? {} : { limit: limit(command) }),
             });
-            return emitTask(command.output, result, () => renderTaskList("blocked", scope, result, displayContext()), taskExitCode(result));
+            return emit(command.output, result, () => renderTaskList("blocked", scope, result, displayContext()), taskExitCode(result));
         }
         case "query": {
             const result = await tasks.query({
@@ -194,15 +179,15 @@ async function runRead(input) {
                 ...(value(command, "sort") === undefined ? {} : { sort: value(command, "sort") }),
                 ...(limit(command) === undefined ? {} : { limit: limit(command) }),
             });
-            return emitTask(command.output, result, () => renderTaskList("query", scope, result, displayContext()), taskExitCode(result));
+            return emit(command.output, result, () => renderTaskList("query", scope, result, displayContext()), taskExitCode(result));
         }
         case "tree": {
             const result = await tasks.task({ id }).tree();
-            return emitTask(command.output, result, () => renderTaskTree(result, displayContext()), taskExitCode(result));
+            return emit(command.output, result, () => renderTaskTree(result, displayContext()), taskExitCode(result));
         }
         case "doctor": {
             const result = await tasks.doctor();
-            return emitTask(command.output, result, () => renderTaskDoctor(result), taskExitCode(result));
+            return emit(command.output, result, () => renderDoctor(result), taskExitCode(result));
         }
         default:
             throw new Error(`task action is not a read: ${command.action}`);
@@ -231,26 +216,22 @@ function missingWorld(command) {
             return 1;
         }
         const refusal = missingTask(command.positionals[0]);
-        return emitTask(output, refusal, () => renderTaskShow(refusal, displayContext()), 1);
+        return emit(output, refusal, () => renderTaskShow(refusal, displayContext()), 1);
     }
     if (isWorldObservationAction(command) || (command.action === "compose" && command.flags.plan === true)) {
-        if (output === "json")
-            writeJson({ kind: "absent" });
-        else
-            writeStdout("task world absent");
-        return 1;
+        return emit(output, { kind: "absent" }, () => "task world absent", 1);
     }
     if (command.action === "context") {
         const result = { kind: "accepted", value: { namespace: [], source: "default-root" } };
-        return emitTask(output, result, () => renderTaskContext(result, displayContext()), taskExitCode(result));
+        return emit(output, result, () => renderTaskContext(result, displayContext()), taskExitCode(result));
     }
     if (command.action === "tree") {
         const result = missingTask(command.positionals[0]);
-        return emitTask(output, result, () => renderTaskTree(result, displayContext()), taskExitCode(result));
+        return emit(output, result, () => renderTaskTree(result, displayContext()), taskExitCode(result));
     }
     if (command.action === "update") {
         const result = missingTask(command.positionals[0]);
-        return emitTask(output, result, () => renderTaskUpdate(result, displayContext()), taskExitCode(result));
+        return emit(output, result, () => renderTaskUpdate(result, displayContext()), taskExitCode(result));
     }
     if (command.action === "start" ||
         command.action === "stop" ||
@@ -258,18 +239,18 @@ function missingWorld(command) {
         command.action === "resume") {
         if (command.positionals.length === 1) {
             const result = missingTask(command.positionals[0]);
-            return emitTask(output, result, () => renderTaskMutation(command.action, result, displayContext()), taskExitCode(result));
+            return emit(output, result, () => renderTaskMutation(command.action, result, displayContext()), taskExitCode(result));
         }
         const result = {
             items: command.positionals.map((id) => ({ id: id, outcome: missingTask(id) })),
         };
-        return emitTask(output, result, () => renderTaskLifecycle(command.action, result, displayContext()), taskExitCode(result));
+        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 emitTask(output, result, () => renderTaskLifecycle(command.action, result, displayContext()), taskExitCode(result));
+        return emit(output, result, () => renderTaskLifecycle(command.action, result, displayContext()), taskExitCode(result));
     }
     throw new Error(`task action has no missing-world answer: ${command.action}`);
 }
@@ -300,7 +281,7 @@ async function runBatchLifecycle(tasks, command, verb) {
         ids: command.positionals,
         ...(note === undefined ? {} : { note }),
     });
-    return emitTask(command.output, result, () => renderTaskLifecycle(verb, result, displayContext()), taskExitCode(result));
+    return emit(command.output, result, () => renderTaskLifecycle(verb, result, displayContext()), taskExitCode(result));
 }
 async function runMutation(input) {
     const { tasks, command, current, stdin, composeMarkdown, composeNamespace } = input;
@@ -309,17 +290,17 @@ async function runMutation(input) {
     switch (command.action) {
         case "add": {
             const result = await invokeAdd(input);
-            return emitTask(command.output, result, () => renderTaskMutation("add", result, displayContext()), taskExitCode(result));
+            return emit(command.output, result, () => renderTaskMutation("add", result, displayContext()), taskExitCode(result));
         }
         case "update": {
             const result = await invokeUpdate(input);
-            return emitTask(command.output, result, () => renderTaskUpdate(result, displayContext()), taskExitCode(result));
+            return emit(command.output, result, () => renderTaskUpdate(result, displayContext()), taskExitCode(result));
         }
         case "start":
         case "stop":
         case "resume": {
             const result = await invokeLifecycle(tasks, command.positionals, command.positionals[0], command.action);
-            return emitTask(command.output, result, () => renderTaskLifecycle(command.action, result, displayContext()), taskExitCode(result));
+            return emit(command.output, result, () => renderTaskLifecycle(command.action, result, displayContext()), taskExitCode(result));
         }
         case "hold":
         case "done":
@@ -328,20 +309,20 @@ async function runMutation(input) {
         case "context": {
             const selected = namespace(command.positionals[0]);
             if (selected !== undefined) {
-                await writeTaskNamespaceContext(input.context.writeRoot ?? input.context.directory, selected);
+                await installNamespaceContext(input.context.writeRoot ?? input.context.directory, selected);
                 const resolved = await resolveTaskNamespaceContext(input.context);
                 if (typeof resolved === "object" && "kind" in resolved) {
                     const result = { kind: "refused", refusal: resolved };
-                    return emitTask(command.output, result, () => renderTaskContext(result, displayContext()), taskExitCode(result));
+                    return emit(command.output, result, () => renderTaskContext(result, displayContext()), taskExitCode(result));
                 }
                 const result = { kind: "accepted", value: resolved };
-                return emitTask(command.output, result, () => renderTaskContext(result, displayContext()), taskExitCode(result));
+                return emit(command.output, result, () => renderTaskContext(result, displayContext()), taskExitCode(result));
             }
             const result = {
                 kind: "accepted",
                 value: { namespace: current ?? [], source: "default-root" },
             };
-            return emitTask(command.output, result, () => renderTaskContext(result, displayContext()), taskExitCode(result));
+            return emit(command.output, result, () => renderTaskContext(result, displayContext()), taskExitCode(result));
         }
         case "compose": {
             const result = await tasks.compose({
@@ -376,14 +357,14 @@ function refuseNamespace(command, refusal) {
         case "blocked":
         case "query": {
             const action = command.action;
-            return emitTask(command.output, result, () => renderTaskList(action, listPresentation(command), result, displayContext()), taskExitCode(result));
+            return emit(command.output, result, () => renderTaskList(action, listPresentation(command), result, displayContext()), taskExitCode(result));
         }
         case "add":
-            return emitTask(command.output, result, () => renderTaskMutation("add", result, displayContext()), taskExitCode(result));
+            return emit(command.output, result, () => renderTaskMutation("add", result, displayContext()), taskExitCode(result));
         case "context":
-            return emitTask(command.output, result, () => renderTaskContext(result, displayContext()), taskExitCode(result));
+            return emit(command.output, result, () => renderTaskContext(result, displayContext()), taskExitCode(result));
         case "compose":
-            return emitTask(command.output, result, () => renderTaskFailure("compose", result, displayContext()), taskExitCode(result));
+            return emit(command.output, result, () => renderTaskFailure("compose", result, displayContext()), taskExitCode(result));
         default:
             throw new Error(`task action has no namespace refusal: ${command.action}`);
     }
@@ -425,7 +406,7 @@ export async function runTaskCommand(command, coordinates, runtime) {
         current = resolved.namespace;
         if (command.action === "context" && command.positionals.length === 0) {
             const result = { kind: "accepted", value: resolved };
-            return emitTask(command.output, result, () => renderTaskContext(result, displayContext()), taskExitCode(result));
+            return emit(command.output, result, () => renderTaskContext(result, displayContext()), taskExitCode(result));
         }
     }
     if (command.action === "show")

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

@@ -15,7 +15,7 @@ export type CliCoordinates = Readonly<{
     }>;
     establishWorld: () => Promise<WorldRoot>;
 }>;
-export type CliCoordinateInput = Readonly<{
+type CliCoordinateInput = Readonly<{
     processCwd?: string;
     cwd?: string;
     repo?: string;
@@ -35,7 +35,6 @@ export declare const cliCoordinateDiscovery: {
     }>>;
     resolve(input: CliCoordinateInput): Promise<CliCoordinates>;
 };
-export declare function resolveCliCoordinates(input: CliCoordinateInput): Promise<CliCoordinates>;
 type InvocationCoordinatesInput = Readonly<{
     processCwd?: string;
     cwd?: string;

package/build/src/cli/coordinates.js

@@ -103,9 +103,6 @@ async function resolveWorld(cwd, repo) {
         throw error;
     }
 }
-export async function resolveCliCoordinates(input) {
-    return cliCoordinateDiscovery.resolve(input);
-}
 /** One explicit Git executable override from the process edge; a blank value is usage, not absence. */
 function gitPathFromEdge(environment) {
     const value = environment.KEIYAKU_GIT_PATH;
@@ -118,7 +115,7 @@ function gitPathFromEdge(environment) {
 /** The one process-edge coordinate resolution: explicit filesystem inputs plus the command's Repo policy. */
 export async function resolveInvocationCoordinates(invocation, environment) {
     const gitPath = gitPathFromEdge(environment);
-    return resolveCliCoordinates({
+    return cliCoordinateDiscovery.resolve({
         ...(invocation.processCwd === undefined ? {} : { processCwd: invocation.processCwd }),
         ...(invocation.cwd === undefined ? {} : { cwd: invocation.cwd }),
         ...(invocation.repo === undefined ? {} : { repo: invocation.repo }),

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

@@ -6,13 +6,12 @@ import { type ContractCommand as Command } from "./commands/contract-help.js";
 import { type CliUsageGuide } from "./usage.js";
 export { CliUsageError } from "./usage.js";
 export type { CliUsageGuide } from "./usage.js";
-export { renderContractHelp } from "./commands/contract-help.js";
 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 CliHelpCoordinate = Readonly<{
+type CliHelpCoordinate = Readonly<{
     kind: "root";
 }> | Readonly<{
     kind: "contract";
@@ -37,7 +36,7 @@ export type ParsedInvocation = Readonly<{
     version: true;
 }>;
 type RepoUse = "none" | "optional" | "required";
-export type CommandRepoPolicy = Readonly<{
+type CommandRepoPolicy = Readonly<{
     use: RepoUse;
     acceptsExplicit: boolean;
 }>;

package/build/src/cli/parse.js

@@ -4,9 +4,9 @@ import { INSTALL_ROOT_PURPOSE, INSTALL_USAGE, parseInstallCommand, renderInstall
 import { parseContractCommand, } from "./commands/contract-grammar.js";
 import { CONTRACT_COMMAND_SPECS, renderContractHelp as renderContractHelpForOwner, } from "./commands/contract-help.js";
 import { renderOpaqueBlock, renderTextBlock } from "./render/terminal.js";
+import { scanArgs } from "./scan.js";
 import { CliUsageError, commandGuide, isBlankInput, ROOT_USAGE_GUIDE, unknownCommandGuide, } from "./usage.js";
 export { CliUsageError } from "./usage.js";
-export { renderContractHelp } from "./commands/contract-help.js";
 const ROOT_USAGE = [
     "usage  keiyaku <command> [options]",
     "      keiyaku <command> --help   shows that command's complete usage",
@@ -140,63 +140,14 @@ export function assertExplicitRepoUse(command, repo) {
 function refuse(command, message) {
     throw new CliUsageError(message, commandGuide(command, CONTRACT_COMMAND_SPECS[command].usage));
 }
-function scanStdin(command, state) {
-    if (state.stdin)
-        refuse(command, "stdin marker '-' may appear only once");
-    if (CONTRACT_COMMAND_SPECS[command].stdin === "none")
-        refuse(command, `${command} reads no stdin`);
-    state.stdin = true;
-}
-function scanOption(command, argv, state, index) {
-    const token = argv[index];
-    const name = token.slice(2);
-    const spec = CONTRACT_COMMAND_SPECS[command];
-    const kind = spec.flags[name];
-    if (kind === undefined)
-        refuse(command, `option ${token} is not valid for ${command}`);
-    if (state.flags[name] !== undefined && kind !== "repeat-value")
-        refuse(command, `duplicate option: ${token}`);
-    if (kind === "boolean") {
-        state.flags[name] = true;
-        return index;
-    }
-    const value = argv[index + 1];
-    if (value === undefined || value.startsWith("--"))
-        refuse(command, `${token} requires a value`);
-    if (kind !== "raw-value" && value === "-") {
-        refuse(command, `${token} requires a value`);
-    }
-    if (kind !== "raw-value" && isBlankInput(value))
-        refuse(command, `${token} requires a nonblank value`);
-    if (kind === "repeat-value") {
-        const values = state.flags[name];
-        state.flags[name] = [...(Array.isArray(values) ? values : values === undefined ? [] : [values]), value];
-    }
-    else {
-        state.flags[name] = value;
-    }
-    return index + 1;
-}
-function scanContractTokens(command, argv, state) {
-    let positionalOnly = false;
-    for (let index = 1; index < argv.length; index += 1) {
-        const token = argv[index];
-        if (!positionalOnly && token === "--") {
-            positionalOnly = true;
-            continue;
-        }
-        if (!positionalOnly && token === "-") {
-            scanStdin(command, state);
-            continue;
-        }
-        if (!positionalOnly && token.startsWith("--")) {
-            index = scanOption(command, argv, state, index);
-            continue;
-        }
-        if (isBlankInput(token))
-            refuse(command, `${command} requires a nonblank value`);
-        state.positionals.push(token);
-    }
+/** The contract surfaces' one scan spec: `-` carries the edge's own stdin input. */
+function contractScanSpec(command, spec) {
+    return {
+        subject: command,
+        flags: spec.flags,
+        ...(spec.stdin === "none" ? {} : { stdin: "input" }),
+        stdinRefusal: `${command} reads no stdin`,
+    };
 }
 function scanArgv(argv) {
     const candidate = argv[0];
@@ -205,20 +156,27 @@ function scanArgv(argv) {
     }
     const command = candidate;
     const spec = CONTRACT_COMMAND_SPECS[command];
-    const state = { flags: {}, positionals: [], stdin: false };
-    scanContractTokens(command, argv, state);
-    if (spec.positional === "none" && state.positionals.length > 0) {
+    const scanned = scanArgs(argv, contractScanSpec(command, spec), (message) => refuse(command, message));
+    const stdin = scanned.stdin !== undefined;
+    if (spec.positional === "none" && scanned.positionals.length > 0) {
         refuse(command, `${command} accepts no contract`);
     }
-    if (spec.positional === "optional" && state.positionals.length > 1 && command !== "status") {
+    if (spec.positional === "optional" && scanned.positionals.length > 1 && command !== "status") {
         refuse(command, `${command} accepts at most one contract`);
     }
-    if (spec.stdin === "required" && !state.stdin) {
+    if (spec.stdin === "required" && !stdin) {
         refuse(command, `${command} requires stdin`);
     }
-    const output = state.flags.json === true ? "json" : "text";
-    const actor = typeof state.flags.actor === "string" ? state.flags.actor : undefined;
-    return { command, ...state, output, ...(actor === undefined ? {} : { actor }) };
+    const output = scanned.flags.json === true ? "json" : "text";
+    const actor = typeof scanned.flags.actor === "string" ? scanned.flags.actor : undefined;
+    return {
+        command,
+        flags: scanned.flags,
+        positionals: scanned.positionals,
+        stdin,
+        output,
+        ...(actor === undefined ? {} : { actor }),
+    };
 }
 function invocationOptions(argv) {
     let cwd;

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

@@ -1,13 +1,13 @@
 import type { LiveStatusObservation } from "../../akuma/akuma-observe.js";
 import type { TellResult } from "../../akuma/body.js";
 import type { AkuId } from "../../akuma/identity.js";
-import type { AkumaAskResult, AkumaKillResult, AkumaObservation, AkumaTellResult, AkumaWaitResult } from "../../akuma/selection-observation.js";
+import type { AkumaAskResult, AkumaKillResult, AkumaTellResult } from "../../akuma/selection-observation.js";
 import type { CallWaitHead, ForkResult } from "../../index.js";
 import type { CallResult } from "../../library/akuma-creation.js";
 import type { AkumaHistoryResult } from "../../library/selection.js";
 import { type ObservedCallHead } from "./akuma-activity.js";
 import { type TextRenderContext } from "./terminal.js";
-export type AskProgress = Readonly<{
+type AskProgress = Readonly<{
     admitted: (tell: TellResult, id: AkuId) => readonly string[];
     observe: (observation: LiveStatusObservation) => readonly string[];
     frame: () => readonly string[];
@@ -21,20 +21,6 @@ export declare function callObservationHead(input: Readonly<{
     akuma: string;
 }> & CallWaitHead): ObservedCallHead;
 export declare function renderCallText(result: CallResult, streamed: boolean, context: TextRenderContext): string;
-export declare function renderWaitText(result: AkumaWaitResult, presentation: Readonly<{
-    alias?: string;
-    startedAt?: number;
-    selection?: readonly import("./akuma-activity.js").WaitSelectedIdentity[];
-}>, context?: TextRenderContext): string;
-export declare function renderStatusText(status: AkumaObservation, alias: string | undefined, context?: TextRenderContext): string;
-export declare function renderTellText(result: AkumaTellResult, alias: string | undefined, context?: TextRenderContext, options?: Readonly<{
-    identity?: boolean;
-}>): string;
-export declare function renderHistoryText(result: AkumaHistoryResult, presentation: Readonly<{
-    alias?: string;
-    id?: string;
-    last?: boolean;
-}>, context?: TextRenderContext): string;
 export declare function renderForkText(receipt: ForkResult): string;
 export declare function renderKillText(result: AkumaKillResult, alias: string | undefined, context: TextRenderContext): string;
 export declare function callExitCode(result: CallResult): number;
@@ -43,3 +29,4 @@ export declare function tellExitCode(result: AkumaTellResult): number;
 export declare function askExitCode(result: AkumaAskResult): number;
 export declare function forkExitCode(receipt: ForkResult): number;
 export declare function historyExitCode(result: AkumaHistoryResult, id: string | undefined): number;
+export {};

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

@@ -1,4 +1,4 @@
-import { DEFAULT_CONTEXT, associatedIdentity, historyText, inputWaitStream, killResultText, snapshotHeading, snapshotText, tellText, waitText, } from "./akuma-activity.js";
+import { associatedIdentity, inputWaitStream, killResultText, snapshotHeading, tellText, } from "./akuma-activity.js";
 import { safeText } from "./terminal.js";
 export function askProgressStream(akuma, alias, context) {
     let target = akuma;
@@ -94,18 +94,6 @@ export function renderCallText(result, streamed, context) {
         ...(inputObservation.completedAt === undefined ? {} : { completedAt: inputObservation.completedAt }),
     });
 }
-export function renderWaitText(result, presentation, context = DEFAULT_CONTEXT) {
-    return waitText(result, presentation, context);
-}
-export function renderStatusText(status, alias, context = DEFAULT_CONTEXT) {
-    return snapshotText(status, context, ...(alias === undefined ? [{}] : [{ alias }]));
-}
-export function renderTellText(result, alias, context = DEFAULT_CONTEXT, options = {}) {
-    return tellText(result, alias, context, options);
-}
-export function renderHistoryText(result, presentation, context = DEFAULT_CONTEXT) {
-    return historyText(result, presentation, context);
-}
 export function renderForkText(receipt) {
     if (receipt.kind !== "forked") {
         if (receipt.kind === "unknown-history")

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

@@ -110,7 +110,7 @@ function targetLines(report, columns, addressed, abbreviations) {
 }
 function obligationLines(result, columns) {
     return [
-        ...executionCleanupLines(effectCleanup(result.effects).filter((issue) => issue.kind !== "worktree-leak"), columns, result.contract),
+        ...executionCleanupLines(effectCleanup(result.effects), columns, result.contract),
         ...executionStopLines(effectExecutionStops(result.effects), columns),
     ];
 }