@astrosheep/keiyaku 4.6.7 → 4.6.9

package/build/src/akuma-body.js

@@ -11,8 +11,8 @@ import { contractRequestCommands } from "./library/contract-operations.js";
 import { createKeiyakuHandle } from "./library/keiyaku.js";
 import { Repo } from "./library/repo.js";
 import { settings } from "./settings.js";
-import { Tasks } from "./task/index.js";
-import { taskMutationRequestCommands } from "./task/mutation.js";
+import { Debts } from "./debt/index.js";
+import { debtMutationRequestCommands } from "./debt/mutation.js";
 import { World } from "./world.js";
 async function contractDependencies(repoRoot, processConfiguration) {
     const repo = await Repo.at({
@@ -68,35 +68,25 @@ function contractUpstream(processConfiguration) {
         },
     };
 }
-const TASK_LIFECYCLE = {
-    start: async (handle, input) => await handle.start(input),
-    stop: async (handle, input) => await handle.stop(input),
-    hold: async (handle, input) => await handle.hold(input),
-    resume: async (handle, input) => await handle.resume(input),
+const DEBT_LIFECYCLE = {
     done: async (handle, input) => await handle.done(input),
     drop: async (handle, input) => await handle.drop(input),
 };
 /**
- * The upper Body edge composes the forced-local Tasks SDK the descriptor
+ * The upper Body edge composes the forced-local Debts SDK the descriptor
  * execution entries consume. Each ability is one ordinary local product
- * operation; no generic task(request) dispatcher is introduced here.
+ * operation; no generic debt(request) dispatcher is introduced here.
  */
-function taskMutationRequestPort() {
+function debtMutationRequestPort() {
     return {
-        add: async ({ world, options }) => await Tasks.of(world).add(options),
-        addDocument: async ({ world, document }) => await Tasks.of(world).addDocument(document),
-        compose: async ({ world, markdown, defaultNamespace, actor, signal }) => await Tasks.of(world).compose({
-            markdown,
-            namespace: defaultNamespace,
-            actor,
-            ...(signal === undefined ? {} : { signal }),
-        }),
-        update: async ({ world, id, options }) => await Tasks.of(world).task({ id }).update(options),
-        lifecycle: async ({ world, verb, id, note, signal }) => await TASK_LIFECYCLE[verb](Tasks.of(world).task({ id }), {
+        add: async ({ world, options }) => await Debts.of(world).add(options),
+        addDocument: async ({ world, document }) => await Debts.of(world).addDocument(document),
+        update: async ({ world, id, options }) => await Debts.of(world).debt({ id }).update(options),
+        lifecycle: async ({ world, verb, id, note, signal }) => await DEBT_LIFECYCLE[verb](Debts.of(world).debt({ id }), {
             ...(note === undefined ? {} : { note }),
             ...(signal === undefined ? {} : { signal }),
         }),
-        batch: async ({ world, verb, ids, note, signal }) => await Tasks.of(world).batch({
+        batch: async ({ world, verb, ids, note, signal }) => await Debts.of(world).batch({
             verb,
             ids,
             ...(note === undefined ? {} : { note }),
@@ -110,7 +100,7 @@ export async function externalRequestCommandsFor(launch, processConfiguration) {
         world,
         commands: composeRequestCommands(selectionRequestCommands(selectionRequestPort(world, (message) => {
             void recordPluginDiagnostic(launch.paths, "outcome observation", message);
-        })), contractRequestCommands(contractUpstream(processConfiguration)), taskMutationRequestCommands(taskMutationRequestPort())),
+        })), contractRequestCommands(contractUpstream(processConfiguration)), debtMutationRequestCommands(debtMutationRequestPort())),
     };
 }
 function bodyProcessConfiguration() {

package/build/src/cli/akuma-caller.d.ts

@@ -0,0 +1,3 @@
+import { type AkumaCaller } from "../akuma/caller.js";
+/** Environment attribution belongs to the process edge, never SDK admission. */
+export declare function akumaCallerFromEnvironment(environment: NodeJS.ProcessEnv): Promise<AkumaCaller | undefined>;

package/build/src/cli/akuma-caller.js

@@ -0,0 +1,31 @@
+import { decodeAkumaCaller } from "../akuma/caller.js";
+import { World } from "../world.js";
+/** Environment attribution belongs to the process edge, never SDK admission. */
+export async function akumaCallerFromEnvironment(environment) {
+    const id = environment.KEIYAKU_ACTOR_ID;
+    const world = environment.KEIYAKU_ACTOR_WORLD;
+    if ((id === undefined) !== (world === undefined)) {
+        throw new TypeError("Akuma caller requires both KEIYAKU_ACTOR_ID and KEIYAKU_ACTOR_WORLD");
+    }
+    if (id !== undefined && world !== undefined) {
+        const resolved = await World.resolve({ cwd: world, repositoryRoot: world });
+        return decodeAkumaCaller({ kind: "akuma", akuId: id, world: resolved.candidate });
+    }
+    const hosts = [
+        { integration: "codex", id: environment.CODEX_THREAD_ID },
+        { integration: "pi", id: environment.PI_SESSION_ID },
+        { integration: "claude", id: environment.CLAUDE_CODE_SESSION_ID },
+    ].filter(({ id }) => id !== undefined && id !== "");
+    if (hosts.length > 1) {
+        throw new TypeError(`Ambiguous native host caller: ${hosts.map(({ integration }) => integration).join(", ")}`);
+    }
+    if (hosts[0])
+        return decodeAkumaCaller({ kind: "external", ...hosts[0] });
+    const external = environment.KEIYAKU_EXTERNAL_CALLER;
+    if (external === undefined)
+        return undefined;
+    const colon = external.indexOf(":");
+    if (colon < 0)
+        throw new TypeError("KEIYAKU_EXTERNAL_CALLER must be <integration>:<id>");
+    return decodeAkumaCaller({ kind: "external", integration: external.slice(0, colon), id: external.slice(colon + 1) });
+}

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

@@ -48,10 +48,9 @@ const AKUMA_COMMAND_SPECS = {
         details: [
             "The default mode is any; --all waits until every selected Akuma completes.",
             "An already completed member counts immediately, so repeating a selection can return at once.",
-            "Akuma names, completed activity, and the final result stream on stderr.",
-            "A streamed plural wait leaves stdout empty, and so does a single wait with no answer.",
-            "Only a single selected Akuma that answered writes to stdout, exactly its answer.",
-            "With --json nothing streams and stdout carries the result document.",
+            "Text prints each selected Akuma's status snapshot, then one failure fact for any Akuma it could not read.",
+            "An answer is part of that snapshot; wait writes no separate copy of it to stdout.",
+            "With --json stdout carries the result document.",
         ].join("\n"),
     },
     tell: {
@@ -175,11 +174,6 @@ function positiveIndex(raw, option, fail) {
         fail(`${option} exceeds the safe integer range`);
     return value;
 }
-function validateDirect(value, _fail) {
-    // Address validation belongs to the operation boundary so callers receive
-    // the compact Akuma refusal instead of a generic usage page.
-    return value;
-}
 function validateSet(value, fail) {
     if (value.startsWith("kei/"))
         return value;
@@ -192,7 +186,7 @@ function validateSet(value, fail) {
         }
         return value;
     }
-    return validateDirect(value, fail);
+    return value;
 }
 function parseWait(rawSelectors, flags, output, fail) {
     if (flags.any === true && flags.all === true)
@@ -236,7 +230,7 @@ function parseAkumaHistory(selector, flags, output, fail) {
         fail("history --id requires turn/<positive safe integer>");
     return {
         command: "history",
-        akuma: validateDirect(selector, fail),
+        akuma: selector,
         ...(id === undefined ? {} : { id }),
         last: flags.last === true,
         ...(flags.before === undefined ? {} : { before: positiveIndex(flags.before, "--before", fail) }),
@@ -256,7 +250,7 @@ function parseAddressed(action, rawSelectors, flags, output, fail) {
             fail("history accepts one complete aku/..., @alias, or kei/... selector");
         return parseHistory(selector, flags, output, fail);
     }
-    const akuma = validateDirect(rawSelectors[0], fail);
+    const akuma = rawSelectors[0];
     const at = stringFlag(flags.at, "fork requires --at <historyId>", fail);
     return { command: action, akuma, at, output };
 }
@@ -279,10 +273,10 @@ function parsePrompted(action, positionals, stdin, fail) {
                 : { prompt: { kind: "argument", value: argument } }),
     };
 }
-function parseTell(flags, subject, prompt, output, fail) {
+function parseTell(flags, subject, prompt, output) {
     return {
         command: "tell",
-        akuma: validateDirect(subject, fail),
+        akuma: subject,
         interrupt: flags.interrupt === true,
         prompt,
         output,
@@ -292,7 +286,7 @@ function parseAsk(flags, subject, prompt, output, fail) {
     const schema = flags.schema === undefined ? undefined : stringFlag(flags.schema, "ask --schema requires a file", fail);
     return {
         command: "ask",
-        akuma: validateDirect(subject, fail),
+        akuma: subject,
         interrupt: flags.interrupt === true,
         ...(schema === undefined ? {} : { schema }),
         ...(flags.wait === undefined ? {} : { timeoutMs: parseDuration(flags.wait, "--wait", fail) }),
@@ -361,7 +355,7 @@ export function parseAkumaCommand(argv) {
         return action === "call"
             ? parseCall(flags, parsed.subject, parsed.prompt, output, fail)
             : action === "tell"
-                ? parseTell(flags, parsed.subject, parsed.prompt, output, fail)
+                ? parseTell(flags, parsed.subject, parsed.prompt, output)
                 : parseAsk(flags, parsed.subject, parsed.prompt, output, fail);
     }
     if (spec.arity === "one-or-more" ? positionals.length === 0 : positionals.length !== spec.arity) {

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

@@ -1,3 +1,4 @@
+import { akumaCallerFromEnvironment } from "../akuma-caller.js";
 import { CliUsageError, isBlankInput } from "../usage.js";
 import { readFile } from "node:fs/promises";
 import { resolve } from "node:path";
@@ -13,8 +14,8 @@ import { World } from "../../world.js";
 import { contractFromInput } from "../selectors.js";
 import { ActivityDriver } from "../activity.js";
 import { displayContext, emit, resultContext, writeJson, writeStderr, writeStdout } from "../streams.js";
-import { callObservationStream, inputWaitStream, waitObservationStream, } from "../render/akuma-activity.js";
-import { askRawAnswer, callRawAnswer, historyRawAnswer, historyText, tellText, waitRawAnswer, waitText, } from "../render/akuma-activity.js";
+import { callObservationStream, inputWaitStream } from "../render/akuma-activity.js";
+import { askRawAnswer, callRawAnswer, historyRawAnswer, historyText, tellText, waitText, } from "../render/akuma-activity.js";
 import { askExitCode, askProgressStream, callExitCode, callObservationHead, forkExitCode, historyExitCode, killExitCode, renderCallText, renderForkText, renderKillText, tellExitCode, waitedTellProgress, } from "../render/akuma.js";
 export { isParsedAkumaCommand, renderAkumaHelp } from "./akuma-grammar.js";
 // ---------------------------------------------------------------------------
@@ -27,7 +28,7 @@ async function settingsAt(root, home) {
     });
 }
 function akumas(input) {
-    return akumasWithExecution(input.path, input.execution);
+    return akumasWithExecution(input.path, input.execution, { reportDiagnostic: writeStderr });
 }
 async function schemaFromFile(path) {
     try {
@@ -49,17 +50,6 @@ async function promptBody(action, command, input) {
         throw new CliUsageError(`${action} requires a nonblank prompt`);
     return bytes;
 }
-function waitObserver(stream, driver, onSelected) {
-    return {
-        selected: (selected) => {
-            onSelected?.(selected);
-            stream.select(selected);
-        },
-        observe: (observed) => {
-            driver.settle(stream.observe(observed), stream.frame());
-        },
-    };
-}
 async function inputInitiator(input) {
     let initiator;
     try {
@@ -68,9 +58,7 @@ async function inputInitiator(input) {
     catch { }
     if (initiator === undefined)
         return {};
-    // Plugins coordinate within an established World; a `call` may run where the
-    // marker does not exist yet, and activating there would only fail noisily.
-    // The initiator still travels with the request either way.
+    // Identity preparation needs established plugin custody, not just a candidate.
     if (!(await World.established(input.path)))
         return { initiator };
     await emitPluginSignal({
@@ -90,9 +78,15 @@ function emitAnswer(body, exact) {
 async function runCall(command, input) {
     const body = command.prompt === undefined ? undefined : await promptBody("call", { prompt: command.prompt }, input);
     const schema = command.schema === undefined ? undefined : await schemaFromFile(command.schema);
+    const declaredCaller = executionChannel(input.execution).kind === "body-request"
+        ? undefined
+        : await akumaCallerFromEnvironment(input.environment);
+    // Establish the selected World before preparing the submitting Square route.
+    await World.at(input.path);
     const caller = akumas(input);
     const request = {
         ...(await inputInitiator(input)),
+        ...(declaredCaller === undefined ? {} : { caller: declaredCaller }),
         archetype: command.archetype,
         ...(body === undefined ? {} : { body }),
         ...(input.home === undefined ? {} : { home: input.home }),
@@ -157,46 +151,19 @@ async function runCall(command, input) {
 }
 async function runWait(command, input) {
     const alias = command.akuma.length === 1 ? inputAlias(command.akuma[0]) : undefined;
-    const stream = command.output === "text" ? waitObservationStream(resultContext()) : undefined;
-    const driver = new ActivityDriver(process.stderr);
-    const startedAt = Date.now();
-    let selection;
-    const observer = stream === undefined
-        ? undefined
-        : waitObserver(stream, driver, (selected) => {
-            selection = selected;
-        });
-    try {
-        const result = await akumas(input).wait({
-            akuma: command.akuma,
-            ...(input.repo === undefined ? {} : { repo: input.repo }),
-            ...(command.completion === undefined ? {} : { completion: command.completion }),
-            ...(command.timeoutMs === undefined ? {} : { timeoutMs: command.timeoutMs }),
-            ...(input.signal === undefined ? {} : { signal: input.signal }),
-            ...(observer === undefined ? {} : { observe: observer }),
-        });
-        const streamed = stream !== undefined && stream.streamed();
-        if (stream !== undefined && streamed)
-            driver.conclude(stream.conclude(result));
-        const presentation = {
-            ...(alias === undefined ? {} : { alias }),
-            ...(selection === undefined ? {} : { selection }),
-            startedAt,
-        };
-        if (command.output === "json") {
-            writeJson(result);
-            return 0;
-        }
-        const raw = waitRawAnswer(result, streamed);
-        if (raw === undefined)
-            emitAnswer(waitText(result, presentation, displayContext()), false);
-        else
-            emitAnswer(raw, true);
+    const result = await akumas(input).wait({
+        akuma: command.akuma,
+        ...(input.repo === undefined ? {} : { repo: input.repo }),
+        ...(command.completion === undefined ? {} : { completion: command.completion }),
+        ...(command.timeoutMs === undefined ? {} : { timeoutMs: command.timeoutMs }),
+        ...(input.signal === undefined ? {} : { signal: input.signal }),
+    });
+    if (command.output === "json") {
+        writeJson(result);
         return 0;
     }
-    finally {
-        driver.close(stream?.flush() ?? []);
-    }
+    emitAnswer(waitText(result, { ...(alias === undefined ? {} : { alias }) }, displayContext()), false);
+    return 0;
 }
 async function runTell(command, input) {
     const body = await promptBody("tell", command, input);
@@ -287,7 +254,10 @@ async function runHistory(command, input) {
     return historyExitCode(result, command.id);
 }
 async function runFork(command, input) {
+    const caller = await akumaCallerFromEnvironment(input.environment);
     const receipt = await akumas(input).fork({
+        ...(await inputInitiator(input)),
+        ...(caller === undefined ? {} : { caller }),
         akuma: command.akuma,
         at: command.at,
         ...(input.repo === undefined ? {} : { repo: input.repo }),

package/build/src/cli/commands/contract-grammar.d.ts

@@ -1,6 +1,6 @@
 import { type ContractCommand } from "./contract-help.js";
 type CatalogQuery = Readonly<{
-    kind: "tasks";
+    kind: "debts";
     namespace?: readonly string[];
     limit?: number;
 }> | Readonly<{
@@ -23,8 +23,9 @@ type Actor = Readonly<{
 export type ParsedBind = Output & Actor & Readonly<{
     command: "bind";
     forkOf?: string;
-    task?: string;
-    target?: string;
+    debt?: string;
+    /** A literal target branch, or `null` for a deliberately targetless bind. */
+    target?: string | null;
     after?: readonly string[];
     gates?: readonly string[];
 }>;
@@ -60,19 +61,21 @@ export type ParsedAbandon = Output & Actor & Readonly<{
     contract?: string;
     note?: string;
 }>;
+export type ParsedShow = Output & Readonly<{
+    command: "show";
+    contract?: string;
+}>;
 export type ParsedStatus = Output & (Readonly<{
     command: "status";
     contract?: string;
     selectors?: readonly string[];
     akuma?: never;
-    guidance?: true;
     category?: never;
     limit?: never;
 }> | Readonly<{
     command: "status";
     contract: string;
     akuma: true;
-    guidance?: never;
     category?: never;
     limit?: never;
 }> | Readonly<{
@@ -82,7 +85,6 @@ export type ParsedStatus = Output & (Readonly<{
     contract?: never;
     selectors?: never;
     akuma?: never;
-    guidance?: never;
 }>);
 export type ParsedLs = Output & Readonly<{
     command: "ls";
@@ -119,7 +121,7 @@ export type ParsedContractParts = Readonly<{
     output: "text" | "json";
     actor?: string;
 }>;
-export type ParsedContractCommand = ParsedBind | ParsedAmend | ParsedDeliver | ParsedReview | ParsedArc | ParsedAbandon | ParsedStatus | ParsedLs | ParsedAudit | ParsedReconcile | ParsedNuke | ParsedSettings | ParsedRegion;
+export type ParsedContractCommand = ParsedBind | ParsedAmend | ParsedDeliver | ParsedReview | ParsedArc | ParsedAbandon | ParsedShow | ParsedStatus | ParsedLs | ParsedAudit | ParsedReconcile | ParsedNuke | ParsedSettings | ParsedRegion;
 export type StatusCategory = "akuma" | "contract";
 export declare function parseContractCommand(parts: ParsedContractParts): ParsedContractCommand;
 export {};

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

@@ -1,5 +1,5 @@
-import { archetypeName } from "../../akuma/identity.js";
-import { parseTaskNamespaceSelector } from "../../task/catalog.js";
+import { validateAkumaName } from "../../identity/normalize.js";
+import { parseDebtNamespaceSelector } from "../../debt/catalog.js";
 import { CliUsageError, commandGuide } from "../usage.js";
 import { CONTRACT_COMMAND_SPECS } from "./contract-help.js";
 function parseAkumaCatalogPath(value) {
@@ -9,11 +9,11 @@ function parseAkumaCatalogPath(value) {
         return { kind: "akuma" };
     const scopedGlob = /^aku\/([^/]+)\/\*$/u.exec(value);
     if (scopedGlob !== null)
-        return { kind: "akuma", archetype: archetypeName(scopedGlob[1]) };
+        return { kind: "akuma", archetype: validateAkumaName(scopedGlob[1]) };
     const match = /^aku\/([^/]+)\/?$/u.exec(value);
     if (match === null)
         return null;
-    return { kind: "akuma", archetype: archetypeName(match[1]) };
+    return { kind: "akuma", archetype: validateAkumaName(match[1]) };
 }
 function optionalFlag(flags, name) {
     const value = flags[name];
@@ -41,16 +41,23 @@ function parseGateNames(parts, command) {
     }
     return names;
 }
+function parseBindTarget(parts) {
+    const target = optionalFlag(parts.flags, "target");
+    const noTarget = parts.flags["no-target"] === true;
+    if (target !== undefined && noTarget)
+        refuse("bind", "--target and --no-target are mutually exclusive");
+    return noTarget ? null : target;
+}
 function parseBind(parts) {
     const forkOf = optionalFlag(parts.flags, "fork-of");
     if (forkOf !== undefined) {
         if (parts.stdin)
             refuse("bind", "fork bind reads no stdin");
-        for (const option of ["task", "after", "gates"]) {
+        for (const option of ["debt", "after", "gates"]) {
             if (parts.flags[option] !== undefined)
                 refuse("bind", `--${option} is not valid with --fork-of`);
         }
-        const target = optionalFlag(parts.flags, "target");
+        const target = parseBindTarget(parts);
         return {
             command: "bind",
             forkOf,
@@ -61,13 +68,13 @@ function parseBind(parts) {
     }
     if (!parts.stdin)
         refuse("bind", "bind requires stdin");
-    const task = optionalFlag(parts.flags, "task");
-    const target = optionalFlag(parts.flags, "target");
+    const debt = optionalFlag(parts.flags, "debt");
+    const target = parseBindTarget(parts);
     const after = parts.flags.after === undefined ? [] : Array.isArray(parts.flags.after) ? parts.flags.after : [parts.flags.after];
     const gates = parseGateNames(parts, "bind");
     return {
         command: "bind",
-        ...(task === undefined ? {} : { task }),
+        ...(debt === undefined ? {} : { debt }),
         ...(target === undefined ? {} : { target }),
         ...(parts.flags.after === undefined ? {} : { after }),
         ...(gates === undefined ? {} : { gates }),
@@ -142,29 +149,20 @@ function rejectStatusGlobs(positionals) {
             refuse("status", `unsupported status glob: ${selector}`);
     }
 }
-function parseStatusGuidance(parts, limit) {
-    if (limit !== undefined)
-        refuse("status", "--limit is not valid with --guidance");
+function showSelector(parts) {
     const selected = parts.positionals[0];
     if (selected !== undefined && STATUS_CATEGORY_SELECTORS.has(selected))
-        refuse("status", "--guidance cannot select a category");
+        refuse("show", "show cannot select a category");
     if (parts.positionals.length > 1)
-        refuse("status", "--guidance accepts at most one Contract selector");
+        refuse("show", "show accepts at most one Contract selector");
     if (selected?.startsWith("aku/") === true)
-        refuse("status", "--guidance cannot select an Akuma");
+        refuse("show", "show cannot select an Akuma");
     if (selected !== undefined && !selected.startsWith("@") && /[*?\[\]]/u.test(selected))
-        refuse("status", `unsupported status glob: ${selected}`);
-    return {
-        command: "status",
-        ...(selected === undefined ? {} : { contract: selected }),
-        guidance: true,
-        output: parts.output,
-    };
+        refuse("show", `unsupported show glob: ${selected}`);
+    return selected;
 }
 function parseStatus(parts) {
     const limit = listLimit(parts, "status");
-    if (parts.flags.guidance === true)
-        return parseStatusGuidance(parts, limit);
     rejectStatusGlobs(parts.positionals);
     if (parts.positionals.length > 1) {
         if (limit !== undefined)
@@ -196,38 +194,29 @@ function parseRegion(parts) {
         output: parts.output,
     };
 }
-function akumaCatalogQuery(query, parts) {
-    const limit = optionalFlag(parts.flags, "limit");
-    if (limit !== undefined && (!/^[1-9][0-9]*$/u.test(limit) || !Number.isSafeInteger(Number(limit))))
-        refuse("ls", "--limit requires a positive safe integer");
-    return {
-        ...query,
-        ...(limit === undefined ? {} : { limit: Number(limit) }),
-    };
-}
 function listLimit(parts, command = "ls") {
     const limit = optionalFlag(parts.flags, "limit");
     if (limit !== undefined && (!/^[1-9][0-9]*$/u.test(limit) || !Number.isSafeInteger(Number(limit))))
         refuse(command, "--limit requires a positive safe integer");
     return limit === undefined ? undefined : Number(limit);
 }
-function taskCatalogQuery(path, limit) {
-    if (path === "task" || path === "task/") {
-        return { kind: "tasks", namespace: [], ...(limit === undefined ? {} : { limit }) };
+function debtCatalogQuery(path, limit) {
+    if (path === "debt" || path === "debt/") {
+        return { kind: "debts", namespace: [], ...(limit === undefined ? {} : { limit }) };
     }
-    if (!path.startsWith("task/"))
+    if (!path.startsWith("debt/"))
         return null;
     if (!path.endsWith("/"))
-        refuse("ls", `invalid Task namespace selector: ${path}`);
-    const body = path.slice("task/".length, -1);
+        refuse("ls", `invalid Debt namespace selector: ${path}`);
+    const body = path.slice("debt/".length, -1);
     if (body.length === 0 || body.split("/").some((segment) => segment.length === 0))
-        refuse("ls", `invalid Task namespace selector: ${path}`);
+        refuse("ls", `invalid Debt namespace selector: ${path}`);
     try {
-        const namespace = parseTaskNamespaceSelector(path);
-        return { kind: "tasks", namespace, ...(limit === undefined ? {} : { limit }) };
+        const namespace = parseDebtNamespaceSelector(path);
+        return { kind: "debts", namespace, ...(limit === undefined ? {} : { limit }) };
     }
     catch (error) {
-        refuse("ls", error instanceof Error ? error.message : `invalid Task namespace selector: ${path}`);
+        refuse("ls", error instanceof Error ? error.message : `invalid Debt namespace selector: ${path}`);
     }
 }
 function parseLs(parts) {
@@ -235,9 +224,9 @@ function parseLs(parts) {
     if (path === undefined)
         refuse("ls", "ls requires a selector");
     const limit = listLimit(parts);
-    const taskQuery = taskCatalogQuery(path, limit);
-    if (taskQuery !== null)
-        return { command: "ls", query: taskQuery, output: parts.output };
+    const debtQuery = debtCatalogQuery(path, limit);
+    if (debtQuery !== null)
+        return { command: "ls", query: debtQuery, output: parts.output };
     if (path === "kei" || path === "kei/") {
         return {
             command: "ls",
@@ -249,7 +238,7 @@ function parseLs(parts) {
         const query = parseAkumaCatalogPath(path);
         if (query === null)
             refuse("ls", "ls requires a supported identity directory selector");
-        return { command: "ls", query: akumaCatalogQuery(query, parts), output: parts.output };
+        return { command: "ls", query: { ...query, ...(limit === undefined ? {} : { limit }) }, output: parts.output };
     }
     catch (error) {
         if (error instanceof CliUsageError)
@@ -287,6 +276,10 @@ export function parseContractCommand(parts) {
                 output: parts.output,
             };
         }
+        case "show": {
+            const contract = showSelector(parts);
+            return { command: "show", ...(contract === undefined ? {} : { contract }), output: parts.output };
+        }
         case "status":
             return parseStatus(parts);
         case "ls":

package/build/src/cli/commands/contract-help.d.ts

@@ -13,14 +13,15 @@ export declare const CONTRACT_COMMAND_SPECS: {
         readonly stdin: "optional";
         readonly flags: {
             readonly actor: "value";
-            readonly task: "value";
+            readonly debt: "value";
             readonly target: "value";
+            readonly "no-target": "boolean";
             readonly after: "repeat";
             readonly gates: "raw-value";
             readonly "fork-of": "value";
             readonly json: "boolean";
         };
-        readonly usage: "bind [--task <task/...>] [--target <ref>] [--after <kei/...> ...] [--gates <name,...>] [--actor <actor>] - | bind --fork-of <kei/...> [--target <ref>] [--actor <actor>]";
+        readonly usage: "bind [--debt <debt/...>] [--target <ref> | --no-target] [--after <kei/...> ...] [--gates <name,...>] [--actor <actor>] - | bind --fork-of <kei/...> [--target <ref> | --no-target] [--actor <actor>]";
         readonly purpose: "Create a Contract from stdin Markdown or copy an existing Contract as a starting point.";
         readonly details: string;
     };
@@ -88,15 +89,24 @@ export declare const CONTRACT_COMMAND_SPECS: {
         readonly usage: "abandon [<contract>|@<contract>] [--note <text>] [--actor <actor>]";
         readonly purpose: "End work on a Contract without delivering it; optionally record why.";
     };
+    readonly show: {
+        readonly positional: "optional";
+        readonly stdin: "none";
+        readonly flags: {
+            readonly json: "boolean";
+        };
+        readonly usage: "show [<contract>|@<contract>]";
+        readonly purpose: "Read one Contract's guidance.";
+        readonly details: string;
+    };
     readonly status: {
         readonly positional: "optional";
         readonly stdin: "none";
         readonly flags: {
-            readonly guidance: "boolean";
             readonly limit: "value";
             readonly json: "boolean";
         };
-        readonly usage: "status [<contract>|@name|<aku/...>]...\nstatus (aku|aku/|aku/*) [--limit <count>]\nstatus (kei|kei/|kei/*) [--limit <count>]\nstatus --guidance [<contract>|@<contract>]";
+        readonly usage: "status [<contract>|@name|<aku/...>]...\nstatus (aku|aku/|aku/*) [--limit <count>]\nstatus (kei|kei/|kei/*) [--limit <count>]";
         readonly purpose: "Show the world overview or selected Contract and Akuma status.";
         readonly details: string;
     };
@@ -107,8 +117,8 @@ export declare const CONTRACT_COMMAND_SPECS: {
             readonly limit: "value";
             readonly json: "boolean";
         };
-        readonly usage: "ls task[/] [--limit <count>]\nls kei[/] [--limit <count>]\nls aku[/] [--limit <count>]\nls aku/<name>[/] [--limit <count>]\nls \"aku/<name>/*\" [--limit <count>]\nls \"aku/*/*\" [--limit <count>]";
-        readonly purpose: "List tasks (ls task), contracts (ls kei), or akumas (ls aku).";
+        readonly usage: "ls debt[/] [--limit <count>]\nls kei[/] [--limit <count>]\nls aku[/] [--limit <count>]\nls aku/<name>[/] [--limit <count>]\nls \"aku/<name>/*\" [--limit <count>]\nls \"aku/*/*\" [--limit <count>]";
+        readonly purpose: "List debts (ls debt), contracts (ls kei), or akumas (ls aku).";
         readonly details: string;
     };
     readonly audit: {
@@ -143,7 +153,7 @@ export declare const CONTRACT_COMMAND_SPECS: {
         };
         readonly usage: "nuke [--confirm <world-directory>]";
         readonly purpose: "Remove Keiyaku-owned data from this World.";
-        readonly details: "Stops Akumas and removes this World's Tasks and Keiyaku-created worktrees and Git references. --confirm must exactly match this World's directory; source files are not deleted.";
+        readonly details: "Stops Akumas and removes this World's Debts and Keiyaku-created worktrees and Git references. --confirm must exactly match this World's directory; source files are not deleted.";
     };
     readonly settings: {
         readonly positional: "none";