@astrosheep/keiyaku 4.0.3 → 4.0.5

package/build/src/cli/invoke.js

@@ -1,5 +1,5 @@
-import { AkumaWorldScopeError, gatesFrom, Keiyaku, requireBranchesToBeUpToDateFrom, settings, SettingsError, worktreeHooksFrom } from "../index.js";
-import { kanshi, selectKanshi, selectRegion } from "../kanshi/index.js";
+import { AkumaWorldScopeError, gatesFrom, Keiyaku, KeiyakuRefused, requireBranchesToBeUpToDateFrom, settings, SettingsError, worktreeHooksFrom, } from "../index.js";
+import { kanshi, observeKanshi, selectKanshi, selectRegion, } from "../kanshi/index.js";
 import { resolveActor } from "./actor.js";
 import { acceptedAbandon, acceptedAmend, acceptedArc, acceptedAudit, acceptedBind, acceptedDeliver, acceptedReview, resultFromMutationCall, } from "./accepted.js";
 import { amendFromCommand } from "./commands/amend.js";
@@ -10,8 +10,10 @@ import { installHarnesses } from "./commands/install.js";
 import { invokeTask } from "./commands/task-invoke.js";
 import { CliUsageError, renderCommandUsage } from "./parse.js";
 import { isBlankInput } from "./usage.js";
-import { contractFromInput, resolveContextualContract, resolveKanshiContract } from "./selectors.js";
+import { canonicalContractSelector, contractFromInput, resolveContextualContract, resolveKanshiContract, } from "./selectors.js";
 import { resolveNamedAddress } from "../library/address.js";
+import { injectedBodyRequests } from "../akuma/requests.js";
+import { EMPTY_WORKTREE_HOOKS } from "../library/configuration.js";
 import { assertExplicitRepoUse, resolveCliCoordinates } from "./coordinates.js";
 import { BindDraftError, preserveBindDraft } from "./draft.js";
 async function readStdin() {
@@ -23,9 +25,10 @@ async function readStdin() {
 function selectedStdinDiagnostic(command) {
     switch (command.command) {
         case "bind":
-        case "amend":
         case "arc":
             return `${command.command} requires a nonblank stdin document`;
+        case "amend":
+            return command.stdin === true ? "amend requires a nonblank stdin document" : undefined;
         case "review":
             return command.summaryFromStdin === true ? "review requires a nonblank summary" : undefined;
         case "call":
@@ -53,13 +56,12 @@ async function withAcquiredStdin(command, runtime) {
         throw new CliUsageError(diagnostic);
     return { ...runtime, readStdin: async () => bytes };
 }
-function settingsAt(root, environment) {
-    const home = environment.KEIYAKU_HOME?.trim();
-    return settings({ ...(root === undefined ? {} : { root }), ...(home === undefined || home.length === 0 ? {} : { home }) });
+function settingsAt(root, home) {
+    return settings({ ...(root === undefined ? {} : { root }), ...(home === undefined ? {} : { home }) });
 }
-function selectedGates(value, name) {
+function consumeSettings(run) {
     try {
-        return gatesFrom({ settings: value, ...(name === undefined ? {} : { name }) });
+        return run();
     }
     catch (error) {
         if (error instanceof SettingsError)
@@ -67,25 +69,11 @@ function selectedGates(value, name) {
         throw error;
     }
 }
-function selectedHooks(value) {
-    try {
-        return worktreeHooksFrom({ settings: value });
-    }
-    catch (error) {
-        if (error instanceof SettingsError)
-            throw new CliUsageError(error.message);
-        throw error;
-    }
+function selectedGates(value, names) {
+    return consumeSettings(() => gatesFrom({ settings: value, ...(names === undefined ? {} : { names }) }));
 }
 function selectedGitPolicy(value) {
-    try {
-        return requireBranchesToBeUpToDateFrom({ settings: value });
-    }
-    catch (error) {
-        if (error instanceof SettingsError)
-            throw new CliUsageError(error.message);
-        throw error;
-    }
+    return consumeSettings(() => requireBranchesToBeUpToDateFrom({ settings: value }));
 }
 function actorFromEdge(actor, environment) {
     let resolved;
@@ -97,6 +85,14 @@ function actorFromEdge(actor, environment) {
     }
     return resolved;
 }
+function gitPathFromEdge(environment) {
+    const value = environment.KEIYAKU_GIT_PATH;
+    if (value === undefined)
+        return undefined;
+    if (value.trim().length === 0)
+        throw new CliUsageError("KEIYAKU_GIT_PATH requires a nonblank value");
+    return value;
+}
 async function selectContract(repo, selector, scope) {
     if (selector !== undefined && !selector.startsWith("@"))
         return contractFromInput(repo, selector);
@@ -127,7 +123,7 @@ async function invokeBind({ parsed, repo, edge, configuration, hooks, establishW
             const bound = accepted.facts.find((fact) => fact.kind === "bind");
             if (bound === undefined || bound.kind !== "bind")
                 throw new Error("accepted bind is missing its bind fact");
-            return acceptedBind(accepted, bound.data.coordinates.target ?? null);
+            return acceptedBind(accepted, bound.data.coordinates);
         });
         if (result.kind !== "refused")
             return result;
@@ -176,17 +172,30 @@ async function invokeAudit(parsed, seat, requireBranchesToBeUpToDate) {
         hooks: seat.hooks,
     }), (result) => acceptedAudit(result, seat.id), { coordinate: seat.id });
 }
-async function invokeExisting({ parsed, repo, edge, scope, configuration, hooks }) {
+async function existingSeat({ parsed, repo, edge, scope, hooks }) {
     const { id, contract } = await selectContract(repo, parsed.contract, scope);
     const actor = actorFromEdge(parsed.actor, edge.environment);
-    const seat = { contract, id, ...(actor === undefined ? {} : { actor }), hooks };
+    return { contract, id, ...(actor === undefined ? {} : { actor }), hooks };
+}
+async function invokeExisting(input) {
+    const { parsed, repo, edge, configuration, hooks } = input;
+    const seat = await existingSeat(input);
+    const { id, contract, actor } = seat;
     switch (parsed.command) {
         case "amend": {
-            const markdown = await edge.readStdin();
+            const markdown = parsed.stdin === true ? await edge.readStdin() : undefined;
             const gates = parsed.gates === undefined
                 ? undefined
                 : selectedGates(configuration, parsed.gates);
-            return resultFromMutationCall("amend", () => amendFromCommand({ command: parsed, repo, contract, markdown, gates, ...(actor === undefined ? {} : { actor }), hooks }), (result) => acceptedAmend(result, id), { coordinate: id });
+            return resultFromMutationCall("amend", () => amendFromCommand({
+                command: parsed,
+                repo,
+                contract,
+                ...(markdown === undefined ? {} : { markdown }),
+                gates,
+                ...(actor === undefined ? {} : { actor }),
+                hooks,
+            }), (result) => acceptedAmend(result, id), { coordinate: id });
         }
         case "deliver":
             return invokeDeliver(parsed, seat, selectedGitPolicy(configuration));
@@ -212,32 +221,23 @@ async function invokeExisting({ parsed, repo, edge, scope, configuration, hooks
             return parsed;
     }
 }
-async function invokeAkumaCommand(parsed, input) {
-    const { path, executionCwd, repo, configuration, edge } = input;
-    if (parsed.command === "call" && parsed.contract !== undefined) {
-        if (repo === undefined)
+async function invokeAkumaFromEdge(parsed, input) {
+    try {
+        const { path, statedCwd, repo, home, configuration, edge } = input;
+        if (parsed.command === "call" && parsed.contract !== undefined && repo === undefined) {
             throw new Error("call with Contract requires a resolved Repo");
-        const selected = contractFromInput(repo, parsed.contract);
+        }
         return await invokeAkuma(parsed, {
             path,
-            ...(executionCwd === undefined ? {} : { executionCwd }),
-            settings: configuration,
-            contract: selected.contract,
+            ...(statedCwd === undefined ? {} : { statedCwd }),
+            ...(home === undefined ? {} : { home }),
+            ...(configuration === undefined ? {} : { settings: configuration }),
+            ...(parsed.command === "call" && parsed.contract !== undefined
+                ? { contract: contractFromInput(repo, parsed.contract).contract }
+                : repo === undefined ? {} : { repo }),
             readStdin: edge.readStdin,
         });
     }
-    return await invokeAkuma(parsed, {
-        path,
-        ...(executionCwd === undefined ? {} : { executionCwd }),
-        settings: configuration,
-        ...(repo === undefined ? {} : { repo }),
-        readStdin: edge.readStdin,
-    });
-}
-async function invokeAkumaFromEdge(parsed, input) {
-    try {
-        return await invokeAkumaCommand(parsed, input);
-    }
     catch (error) {
         if (error instanceof AkumaWorldScopeError)
             throw error;
@@ -252,7 +252,7 @@ async function akumaWorldFor(parsed, located, candidate, establish) {
         throw new CliUsageError("no Keiyaku world contains the invocation cwd");
     return world;
 }
-async function invokeCatalog(parsed, world, repo, edge) {
+async function invokeCatalog(parsed, world, repo, home) {
     try {
         if (parsed.query.kind === "contracts") {
             if (repo === undefined)
@@ -262,7 +262,7 @@ async function invokeCatalog(parsed, world, repo, edge) {
         if (parsed.query.kind === "archetypes") {
             return {
                 kind: "catalog",
-                catalog: await Keiyaku.ls({ query: parsed.query, settings: await settingsAt(undefined, edge.environment) }),
+                catalog: await Keiyaku.ls({ query: parsed.query, ...(home === undefined ? {} : { home }) }),
             };
         }
         if (world === null)
@@ -278,12 +278,11 @@ async function invokeCatalog(parsed, world, repo, edge) {
         throw error;
     }
 }
-async function invokeStatus(parsed, world, repo, edge) {
-    const configuration = await settingsAt(world ?? undefined, edge.environment);
+async function invokeStatus(parsed, world, repo) {
     if (parsed.akuma === true) {
         if (world === null)
             throw new CliUsageError("no Keiyaku world contains the invocation cwd");
-        return invokeAkumaStatus(world, parsed.contract, configuration, undefined, repo);
+        return invokeAkumaStatus(world, parsed.contract, undefined, repo);
     }
     if (parsed.contract === undefined) {
         const report = await kanshi({ world, ...(repo === undefined ? {} : { repo }) });
@@ -291,18 +290,18 @@ async function invokeStatus(parsed, world, repo, edge) {
     }
     if (parsed.contract.startsWith("@")) {
         try {
-            const address = await resolveNamedAddress({
-                path: world,
+            const observation = await observeKanshi({ world, ...(repo === undefined ? {} : { repo }) });
+            const address = resolveNamedAddress({
                 selector: parsed.contract,
-                contracts: repo === undefined ? [] : (await Keiyaku.list({ repo })).rows,
+                report: observation.report,
+                aliases: observation.aliases,
             });
             if (address.kind === "akuma") {
                 if (world === null)
                     throw new CliUsageError("no Keiyaku world contains the invocation cwd");
-                return invokeAkumaStatus(world, address.id, configuration, parsed.contract, repo);
+                return invokeAkumaStatus(world, address.id, parsed.contract, repo);
             }
-            const report = await kanshi({ world, ...(repo === undefined ? {} : { repo }) });
-            return { kind: "status", report: selectKanshi({ report, contract: address.id }), selection: "contract" };
+            return { kind: "status", report: selectKanshi({ report: observation.report, contract: address.id }), selection: "contract" };
         }
         catch (error) {
             if (error instanceof TypeError)
@@ -310,6 +309,16 @@ async function invokeStatus(parsed, world, repo, edge) {
             throw error;
         }
     }
+    if (parsed.contract.startsWith("kei/")) {
+        if (repo === undefined)
+            throw new CliUsageError("cannot select a contract while the Contract world is absent");
+        const contract = canonicalContractSelector(parsed.contract);
+        return {
+            kind: "status",
+            report: await kanshi({ world, repo, contract }),
+            selection: "contract",
+        };
+    }
     const report = await kanshi({ world, ...(repo === undefined ? {} : { repo }) });
     const contract = resolveKanshiContract(report, parsed.contract);
     return { kind: "status", report: selectKanshi({ report, contract }), selection: "contract" };
@@ -343,22 +352,43 @@ async function invokeRegion(parsed, world, repo) {
     const selection = parsed.overlap ? { kind: "overlap", contract } : { kind: "contract", contract };
     return { kind: "region", region: { kind: "present", value: selectRegion({ declarations: report.region.value.declarations, selection }) } };
 }
+async function invokeContractHistory(repo, contract) {
+    if (repo === undefined)
+        throw new Error("history kei/... requires a resolved Repo");
+    const selected = contractFromInput(repo, contract);
+    try {
+        return { kind: "contract-history", history: await selected.contract.history() };
+    }
+    catch (error) {
+        if (error instanceof TypeError)
+            throw new CliUsageError(error.message);
+        if (error instanceof KeiyakuRefused) {
+            return { kind: "refused", verb: "history", contract: selected.id, refusal: error.refusal };
+        }
+        throw error;
+    }
+}
 // eslint-disable-next-line complexity -- command dispatch keeps the CLI's existing boundary in one place.
 async function invokeParsed(invocation, runtime) {
+    const environment = runtime.environment ?? process.env;
+    const gitPath = gitPathFromEdge(environment);
     const coordinates = await resolveCliCoordinates({
         ...(runtime.cwd === undefined ? {} : { processCwd: runtime.cwd }),
         ...(invocation.cwd === undefined ? {} : { cwd: invocation.cwd }),
         ...(invocation.repo === undefined ? {} : { repo: invocation.repo }),
+        ...(gitPath === undefined ? {} : { gitPath }),
         command: invocation.command,
     });
-    const { cwd, repo, world, candidateWorld, establishWorld } = coordinates;
+    const { cwd, cwdSource, repo, world, candidateWorld, establishWorld } = coordinates;
     const edge = {
         environment: runtime.environment ?? process.env,
         readStdin: runtime.readStdin ?? readStdin,
     };
     const parsed = invocation.command;
+    const mapped = edge.environment.KEIYAKU_HOME?.trim();
+    const home = mapped === undefined || mapped.length === 0 ? undefined : mapped;
     if (parsed.command === "settings") {
-        return { kind: "settings", value: await settingsAt(world ?? undefined, edge.environment) };
+        return { kind: "settings", value: await settingsAt(world ?? undefined, home) };
     }
     if (parsed.command === "task") {
         try {
@@ -375,30 +405,37 @@ async function invokeParsed(invocation, runtime) {
             throw error;
         }
     }
+    if (parsed.command === "history" && "contract" in parsed)
+        return await invokeContractHistory(repo, parsed.contract);
     if (isParsedAkumaCommand(parsed)) {
         const akumaWorld = await akumaWorldFor(parsed, world, candidateWorld, coordinates.establishWorld);
-        const configuration = await settingsAt(akumaWorld, edge.environment);
+        const configuration = parsed.command === "call" ? await settingsAt(akumaWorld, home) : undefined;
         return await invokeAkumaFromEdge(parsed, {
             path: akumaWorld,
-            ...(parsed.command === "call" && parsed.contract !== undefined && invocation.cwd === undefined
-                ? {}
-                : { executionCwd: cwd }),
+            ...(cwdSource === "input" ? { statedCwd: cwd } : {}),
             ...(repo === undefined ? {} : { repo }),
-            configuration,
+            ...(parsed.command === "call" && home !== undefined ? { home } : {}),
+            ...(configuration === undefined ? {} : { configuration }),
             edge,
         });
     }
     if (parsed.command === "ls")
-        return await invokeCatalog(parsed, world, repo, edge);
+        return await invokeCatalog(parsed, world, repo, home);
     if (parsed.command === "status")
-        return await invokeStatus(parsed, world, repo, edge);
+        return await invokeStatus(parsed, world, repo);
     if (repo === undefined)
         throw new Error(`${parsed.command} requires a resolved Repo`);
     if (parsed.command === "region")
         return invokeRegion(parsed, world, repo);
     const scope = cwd;
-    const configuration = await settingsAt(world ?? undefined, edge.environment);
-    const hooks = selectedHooks(configuration);
+    if ((parsed.command === "deliver" || parsed.command === "review") && injectedBodyRequests() !== null) {
+        const seat = await existingSeat({ parsed, repo, edge, scope, hooks: EMPTY_WORKTREE_HOOKS });
+        return parsed.command === "deliver"
+            ? await invokeDeliver(parsed, seat, false)
+            : await invokeReview(parsed, seat, edge.readStdin);
+    }
+    const configuration = await settingsAt(world ?? undefined, home);
+    const hooks = consumeSettings(() => worktreeHooksFrom({ settings: configuration }));
     if (parsed.command === "show") {
         const selected = await selectContract(repo, parsed.contract, scope);
         return { kind: "guidance", contract: selected.id, guidance: await selected.contract.guidance() };
@@ -427,13 +464,17 @@ export async function invoke(invocation, runtime = {}) {
     try {
         const command = invocation.command;
         assertExplicitRepoUse(command, invocation.repo);
-        if (command.command === "install")
+        if (command.command === "install") {
+            runtime.onOperationStart?.();
             return installHarnesses(command.harnesses, runtime.environment ?? process.env);
+        }
+        const acquiredRuntime = await withAcquiredStdin(command, withResolvedTaskActor(command, runtime));
+        runtime.onOperationStart?.();
         return await invokeParsed({
             ...(invocation.cwd === undefined ? {} : { cwd: invocation.cwd }),
             ...(invocation.repo === undefined ? {} : { repo: invocation.repo }),
             command,
-        }, await withAcquiredStdin(command, withResolvedTaskActor(command, runtime)));
+        }, acquiredRuntime);
     }
     catch (error) {
         if (error instanceof CliUsageError && error.projection === undefined) {

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

@@ -1 +1,3 @@
+import { type ParsedCommand } from "./parse.js";
+export declare function invocationStart(command: ParsedCommand): string | undefined;
 export declare function main(argv?: readonly string[]): Promise<number>;

package/build/src/cli/main.js

@@ -28,7 +28,7 @@ function writeTask(command, result) {
     return taskExitCode(result);
 }
 function writeAkuma(command, result) {
-    const output = command.output === "json" ? renderAkumaJson(command, result) : renderAkumaText(command, result, {
+    const output = command.output === "json" ? renderAkumaJson(result) : renderAkumaText(command, result, {
         columns: process.stdout.isTTY === true && Number.isInteger(process.stdout.columns) ? process.stdout.columns : 80,
         color: process.stdout.isTTY === true && process.env.NO_COLOR === undefined,
     });
@@ -46,6 +46,18 @@ function renderHelp(coordinate) {
         case "akuma": return renderAkumaHelp(coordinate.action);
     }
 }
+export function invocationStart(command) {
+    if (command.output === "json")
+        return undefined;
+    switch (command.command) {
+        case "bind": return "⧖ preparing keiyaku";
+        case "deliver": return "⧖ delivering";
+        case "audit": return "⧖ auditing";
+        case "reconcile": return "⧖ reconciling";
+        case "install": return "⧖ installing skills";
+        default: return undefined;
+    }
+}
 function writeGuidance(command, result) {
     if (command.output === "json")
         process.stdout.write(`${JSON.stringify({ contract: result.contract, guidance: result.guidance })}\n`);
@@ -71,8 +83,17 @@ function writeResult(command, result) {
         process.stdout.write(`${command.output === "json" ? JSON.stringify(settingsJsonValue(value)) : renderSettingsText(value)}\n`);
         return 0;
     }
-    if (isParsedAkumaCommand(command)
-        || (typeof result === "object" && result !== null && "kind" in result && result.kind === "akuma")) {
+    if (typeof result === "object" && result !== null && "kind" in result && result.kind === "contract-history") {
+        const history = result.history;
+        const output = command.output === "json" ? JSON.stringify(history) : renderText(result);
+        process.stdout.write(`${output}\n`);
+        return 0;
+    }
+    const akumaResult = typeof result === "object" && result !== null && "kind" in result && result.kind === "akuma";
+    if (isParsedAkumaCommand(command)) {
+        return writeAkuma(command, result);
+    }
+    if (akumaResult && command.command === "status") {
         return writeAkuma(command, result);
     }
     const contractResult = result;
@@ -111,7 +132,11 @@ export async function main(argv = process.argv.slice(2)) {
         }
         output = parsed.command.output;
         const { invoke } = await import("./invoke.js");
-        const result = await invoke(parsed, { cwd: process.cwd() });
+        const start = invocationStart(parsed.command);
+        const result = await invoke(parsed, {
+            cwd: process.cwd(),
+            ...(start === undefined ? {} : { onOperationStart: () => { process.stderr.write(`${start}\n`); } }),
+        });
         return writeResult(parsed.command, result);
     }
     catch (error) {

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

@@ -20,14 +20,15 @@ export type ParsedBind = Output & Actor & Readonly<{
     target?: string;
     workspace?: "here";
     after?: readonly string[];
-    gates?: string;
+    gates?: readonly string[];
 }>;
 export type ParsedAmend = Output & Actor & Readonly<{
     command: "amend";
     contract?: string;
     after?: readonly string[];
     clearAfter?: true;
-    gates?: string;
+    gates?: readonly string[];
+    stdin?: true;
 }>;
 export type ParsedDeliver = Output & Actor & Readonly<{
     command: "deliver";

package/build/src/cli/parse.js

@@ -1,7 +1,7 @@
 import { isTaskAction, parseTaskCommand, renderTaskUsage, } from "./commands/task.js";
 import { isAkumaAction, parseAkumaCatalogPath, parseAkumaCommand, renderAkumaRootRows, renderAkumaUsage, } from "./commands/akuma.js";
 import { INSTALL_USAGE, parseInstallCommand, renderInstallHelp } from "./commands/install.js";
-import { AMEND_MINIMAL_STDIN_HELP, CONTRACT_COMMAND_SPECS } from "./commands/contract.js";
+import { AMEND_MINIMAL_STDIN_HELP, CONTRACT_COMMAND_SPECS, } from "./commands/contract.js";
 import { CliUsageError, isBlankInput, usageLine, withJsonAutomationHelp } from "./usage.js";
 export { CliUsageError } from "./usage.js";
 const ROOT_USAGE = "usage: keiyaku [-C <path>] [--repo <path>] <command> [<contract>|@<contract>] [--flag ...] [-]";
@@ -69,9 +69,12 @@ function scanOption(command, argv, state, index) {
         return index;
     }
     const value = argv[index + 1];
-    if (value === undefined || value === "-" || value.startsWith("--"))
+    if (value === undefined)
         refuse(command, `${token} requires a value`);
-    if (isBlankInput(value))
+    if (kind !== "raw-value" && (value === "-" || value.startsWith("--"))) {
+        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];
@@ -121,7 +124,7 @@ function parseBind(parts) {
     const task = optionalFlag(parts.flags, "task");
     const target = optionalFlag(parts.flags, "target");
     const after = parts.flags.after === undefined ? [] : Array.isArray(parts.flags.after) ? parts.flags.after : [parts.flags.after];
-    const gates = optionalFlag(parts.flags, "gates");
+    const gates = parseGateBundleNames(parts, "bind");
     return {
         command: "bind",
         ...(task === undefined ? {} : { task }),
@@ -138,7 +141,10 @@ function parseAmend(parts) {
     const after = parts.flags.after === undefined ? [] : Array.isArray(parts.flags.after) ? parts.flags.after : [parts.flags.after];
     if (parts.flags["clear-after"] === true && after.length > 0)
         refuse("amend", "--clear-after and --after are mutually exclusive");
-    const gates = optionalFlag(parts.flags, "gates");
+    const gates = parseGateBundleNames(parts, "amend");
+    if (!parts.stdin && parts.flags.after === undefined && parts.flags["clear-after"] !== true && gates === undefined) {
+        refuse("amend", "amend requires stdin or --after, --clear-after, or --gates");
+    }
     return {
         command: "amend",
         ...(contract === undefined ? {} : { contract }),
@@ -146,9 +152,20 @@ function parseAmend(parts) {
         ...(parts.flags["clear-after"] === true ? { clearAfter: true } : {}),
         ...(gates === undefined ? {} : { gates }),
         ...(parts.actor === undefined ? {} : { actor: parts.actor }),
+        ...(parts.stdin ? { stdin: true } : {}),
         output: parts.output,
     };
 }
+function parseGateBundleNames(parts, command) {
+    const value = optionalFlag(parts.flags, "gates");
+    if (value === undefined)
+        return undefined;
+    const names = value.split(",");
+    if (names.some((name) => name.length === 0)) {
+        refuse(command, "--gates requires nonempty comma-separated names");
+    }
+    return names;
+}
 function parseDeliver(parts) {
     const contract = parts.positionals[0];
     const message = optionalFlag(parts.flags, "message");
@@ -236,14 +253,14 @@ function parseRegion(parts) {
 }
 function parseLs(parts) {
     const path = parts.positionals[0];
-    if (path === "task/")
+    if (path === "task" || path === "task/")
         return { command: "ls", query: { kind: "tasks" }, output: parts.output };
-    if (path === "kei/")
+    if (path === "kei" || path === "kei/")
         return { command: "ls", query: { kind: "contracts" }, output: parts.output };
     try {
         const query = parseAkumaCatalogPath(path);
         if (query === null)
-            refuse("ls", "ls requires an identity directory with a trailing slash");
+            refuse("ls", "ls requires a supported identity directory selector");
         return { command: "ls", query, output: parts.output };
     }
     catch (error) {

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

@@ -4,5 +4,5 @@ import { type TextRenderContext } from "./terminal.js";
 export declare function akumaRawAnswer(result: AkumaInvocationResult): string | undefined;
 export declare function renderAkumaText(command: ParsedCommand, result: AkumaInvocationResult, context?: TextRenderContext): string;
 export declare function akumaExitCode(result: AkumaInvocationResult): number;
-export declare function akumaJsonValue(command: ParsedCommand, result: AkumaInvocationResult): unknown;
-export declare function renderAkumaJson(command: ParsedCommand, result: AkumaInvocationResult): string;
+export declare function akumaJsonValue(result: AkumaInvocationResult): unknown;
+export declare function renderAkumaJson(result: AkumaInvocationResult): string;