@astrosheep/keiyaku 4.5.11 → 4.5.13

package/build/src/bounded-list.js

@@ -0,0 +1,14 @@
+export const DEFAULT_BOUNDED_LIST_LIMIT = 50;
+export const MAX_BOUNDED_LIST_LIMIT = 500;
+export function boundedListLimit(value = undefined) {
+    if (value === undefined)
+        return DEFAULT_BOUNDED_LIST_LIMIT;
+    if (!Number.isSafeInteger(value) || value < 1 || value > MAX_BOUNDED_LIST_LIMIT) {
+        throw new TypeError(`limit must be an integer from 1 to ${MAX_BOUNDED_LIST_LIMIT}`);
+    }
+    return value;
+}
+export function projectBoundedList(rows, limit) {
+    const projected = rows.slice(0, limit + 1);
+    return { rows: projected.slice(0, limit), hasMore: projected.length > limit };
+}

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

@@ -1,6 +1,6 @@
 import { type AmendResult, type AuditReport, type BindResult, type ContractId, type Delivery, type MutationResult, type Review } from "../index.js";
 import type { AcceptedAbandonResult, AcceptedAmendResult, AcceptedArcResult, AcceptedAuditResult, AcceptedBindResult, AcceptedDeliverResult, AcceptedResult, AcceptedReviewResult, InvocationResult } from "./result.js";
-type MutationObservation = Pick<MutationResult<unknown>, "facts" | "head" | "lags" | "settlementLags" | "recoverySnapshot">;
+type MutationObservation = Pick<MutationResult<unknown>, "facts" | "head" | "lags" | "settlementLags" | "recoverySnapshot" | "seatClose">;
 type MutationCallOptions = Readonly<{
     coordinate?: ContractId;
     projectRefusal?: (refusal: unknown) => unknown;

package/build/src/cli/accepted.js

@@ -20,6 +20,7 @@ function acceptedEnvelope(result, coordinate) {
         settlementLags: result.settlementLags,
         ...(result.recoverySnapshot === undefined ? {} : { recoverySnapshot: result.recoverySnapshot }),
         ...(result.lags.length === 0 || firstLag === undefined ? {} : { lag: [firstLag, ...result.lags.slice(1)] }),
+        ...(result.seatClose === undefined || result.seatClose.length === 0 ? {} : { seatClose: result.seatClose }),
     };
 }
 function acceptedRegion(result) {

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

@@ -2,13 +2,6 @@ import { Keiyaku, } from "../../index.js";
 import { beginCall, finishCall } from "../../library/akuma-creation.js";
 import { killAkuma, tellAkuma, waitAkuma } from "../../library/fleet.js";
 import { localExecutionContext } from "../../akuma/requests.js";
-import { recognizeAndListen } from "../square-edge.js";
-function withRollbackDiagnostic(primary, rollback) {
-    const primaryText = primary instanceof Error ? primary.message : String(primary);
-    const rollbackText = rollback instanceof Error ? rollback.message : String(rollback);
-    const error = new Error(`${primaryText}; ${rollbackText}`, { cause: primary });
-    return error;
-}
 function inputAlias(selector) {
     return selector.startsWith("@") ? selector : undefined;
 }
@@ -127,24 +120,7 @@ export async function invokeAkuma(command, input) {
                 ...(command.alias === undefined ? {} : { alias: command.alias }),
                 ...(command.allowed === undefined ? {} : { allowed: command.allowed }),
             }, input.execution ?? localExecutionContext());
-            const listener = born.born.kind === "born"
-                ? await recognizeAndListen(input.path, input.environment, born.born.allocated)
-                : undefined;
-            let result;
-            try {
-                result = await (input.finishCall ?? finishCall)(born, listener?.participantName);
-            }
-            catch (error) {
-                if (listener?.committed === true) {
-                    try {
-                        await listener.rollback();
-                    }
-                    catch (rollbackError) {
-                        throw withRollbackDiagnostic(error, rollbackError);
-                    }
-                }
-                throw error;
-            }
+            const result = await (input.finishCall ?? finishCall)(born);
             return { kind: "akuma", action: "call", result, world: input.path };
         }
         case "wait":

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

@@ -22,6 +22,7 @@ export declare const CONTRACT_COMMAND_SPECS: {
         };
         readonly usage: "bind [--task <task/...>] [--target <ref>] [--after <kei/...> ...] [--gates <name,...>] [--actor <actor>] [--json] - | bind --fork-of <kei/...> [--target <ref>] [--actor <actor>] [--json]";
         readonly purpose: "Create one Contract from stdin Markdown or a sibling fork.";
+        readonly details: string;
     };
     readonly amend: {
         readonly positional: "optional";
@@ -60,7 +61,8 @@ export declare const CONTRACT_COMMAND_SPECS: {
             readonly json: "boolean";
         };
         readonly usage: "review [<contract>|@<contract>] (--satisfied | --unsatisfied) (--summary <text> | -) [--json]";
-        readonly purpose: "Record one review verdict.";
+        readonly purpose: "Record one review verdict over this Contract's current subject.";
+        readonly details: string;
     };
     readonly arc: {
         readonly positional: "optional";
@@ -105,9 +107,10 @@ export declare const CONTRACT_COMMAND_SPECS: {
         readonly positional: "optional";
         readonly stdin: "none";
         readonly flags: {
+            readonly limit: "value";
             readonly json: "boolean";
         };
-        readonly usage: "ls task[/] [--json]\nls kei[/] [--json]\nls aku[/] [--json]\nls aku/<akuma>[/] [--json]\nls \"aku/*/*\" [--json]";
+        readonly usage: "ls task[/] [--limit <count>] [--json]\nls kei[/] [--limit <count>] [--json]\nls aku[/] [--json]\nls aku/<akuma>[/] [--limit <count>] [--json]\nls \"aku/*/*\" [--limit <count>] [--json]";
         readonly purpose: "List one identity directory.";
     };
     readonly audit: {

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

@@ -14,6 +14,24 @@ export const CONTRACT_COMMAND_SPECS = {
         },
         usage: "bind [--task <task/...>] [--target <ref>] [--after <kei/...> ...] [--gates <name,...>] [--actor <actor>] [--json] - | bind --fork-of <kei/...> [--target <ref>] [--actor <actor>] [--json]",
         purpose: "Create one Contract from stdin Markdown or a sibling fork.",
+        details: [
+            "stdin is Contract Markdown:",
+            "  # <title>",
+            "  ## Context       motivation, authority, baseline, and boundaries",
+            "  ## Objective    one observable end state",
+            "  ## Design       closed decisions and ordering",
+            "  ## Region       one fenced path-pattern declaration",
+            "  ## Criteria     one or more ### <criterion> entries",
+            "  ## Verification optional fenced executor declarations",
+            "",
+            "Region uses one closed fence with no info string or exactly 'txt'; put one",
+            "repository-relative path pattern on each nonblank line. A trailing '/'",
+            "is directory shorthand for 'path/**'.",
+            "",
+            "Verification uses one or more closed bash, zsh, or pwsh fences. Its fence",
+            "may add timeout=<integer><ms|s|m|h>; the section contains no other prose.",
+            "Unknown ## sections are retained as extensions; reserved section names are refused.",
+        ].join("\n"),
     },
     amend: {
         positional: "optional",
@@ -42,19 +60,28 @@ export const CONTRACT_COMMAND_SPECS = {
         usage: "deliver [<contract>|@<contract>] [--message <text>] [--include-dirty] [--materialize-conflict] [--json]",
         purpose: "Deliver your work as this Contract's candidate.",
         details: [
-            "A clean worktree delivers its HEAD; --include-dirty captures every non-ignored",
-            "byte as an immutable commit object without changing the appointed worktree's HEAD",
-            "or real index. Runs or reuses Verification and requests placement: when every",
-            "prerequisite and declared gate is current, the same invocation places and claims.",
-            "Otherwise the candidate is recorded and the Contract is tendered. A prior git",
-            "commit is optional preparation — it never delivers, and delivering never",
-            "satisfies a review gate.",
+            "The subject is the whole Contract. An Arc names the chapter you are in — it",
+            "frames the work, it never shrinks what the Contract accepts. Finishing a chapter",
+            "is progress; deliver is the different claim that the worktree, as it stands, is",
+            "the Contract's candidate.",
+            "",
+            "A clean worktree delivers its HEAD. --include-dirty captures every non-ignored",
+            "change as an immutable commit; your branch and index are untouched, so a prior",
+            "git commit is optional preparation, never a requirement.",
+            "",
+            "Delivering records the candidate and requests placement. If prerequisites and",
+            "every declared gate already hold, this same invocation places and the Contract is",
+            "claimed; otherwise the candidate stays recorded and the Contract is tendered.",
+            "Delivering again replaces the candidate and stales any earlier review of it.",
+            "Deliver never satisfies a review gate — review is someone's independent verdict,",
+            "not a side effect of delivering.",
             "",
             "  --include-dirty         Include all non-ignored worktree bytes, including an",
             "                          unmerged shared index, in the candidate commit.",
             "  --materialize-conflict  After a conflict result, project the judged targetHead",
-            "                          into the worktree as an uncommitted merge. Not a",
-            "                          delivery: resolve, then deliver with --include-dirty.",
+            "                          into the worktree as an uncommitted merge. With",
+            "                          --include-dirty, captured non-ignored bytes are kept",
+            "                          as the merge base. Not a delivery: resolve, then deliver with --include-dirty.",
         ].join("\n"),
     },
     review: {
@@ -62,7 +89,30 @@ export const CONTRACT_COMMAND_SPECS = {
         stdin: "optional",
         flags: { satisfied: "boolean", unsatisfied: "boolean", summary: "value", json: "boolean" },
         usage: "review [<contract>|@<contract>] (--satisfied | --unsatisfied) (--summary <text> | -) [--json]",
-        purpose: "Record one review verdict.",
+        purpose: "Record one review verdict over this Contract's current subject.",
+        details: [
+            "You are judging the whole Contract, not the current Arc. The subject is whatever",
+            "the Contract binds right now: the delivered candidate if one exists, or the current",
+            "document and worktree state before any delivery. Pre-delivery review is real",
+            "testimony over that subject — it creates no candidate, and without a delivered",
+            "candidate it can never place.",
+            "",
+            "The question --satisfied answers is: does the complete current subject meet",
+            "everything this Contract's acceptance asks — now, on evidence you already hold?",
+            "A finished chapter is never grounds for satisfied.",
+            "",
+            "--satisfied records that verdict and requests placement. If a delivered candidate,",
+            "prerequisites, and every declared gate hold, this same invocation places and the",
+            "Contract is claimed — a terminal state; a verdict that places cannot be taken back.",
+            "Verify the complete current subject first, then testify. If anything still blocks",
+            "placement, the verdict is recorded and the Contract stays active.",
+            "",
+            "--unsatisfied records what is not met and never requests placement.",
+            "",
+            "--summary is your testimony, not decoration. Satisfied: the conclusion that the",
+            "whole Contract is complete, and the evidence it rests on. Unsatisfied: the specific",
+            "blocker, missing evidence, or unmet term.",
+        ].join("\n"),
     },
     arc: {
         positional: "optional",
@@ -95,8 +145,8 @@ export const CONTRACT_COMMAND_SPECS = {
     ls: {
         positional: "optional",
         stdin: "none",
-        flags: { json: "boolean" },
-        usage: 'ls task[/] [--json]\nls kei[/] [--json]\nls aku[/] [--json]\nls aku/<akuma>[/] [--json]\nls "aku/*/*" [--json]',
+        flags: { limit: "value", json: "boolean" },
+        usage: 'ls task[/] [--limit <count>] [--json]\nls kei[/] [--limit <count>] [--json]\nls aku[/] [--json]\nls aku/<akuma>[/] [--limit <count>] [--json]\nls "aku/*/*" [--limit <count>] [--json]',
         purpose: "List one identity directory.",
     },
     audit: {

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

@@ -22,5 +22,10 @@ export type ContractMutationInput = Readonly<{
     establishWorld: () => Promise<WorldRoot>;
     execution: ExecutionContext;
 }>;
+export declare function admitMarkdownBindSyntax(input: Readonly<{
+    markdown: string;
+    processCwd?: string;
+    cwd?: string;
+}>): Promise<void>;
 export declare function invokeContractMutation(input: ContractMutationInput): Promise<InvocationResult>;
 export {};

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

@@ -33,13 +33,38 @@ async function selectContract(repo, selector, scope, library) {
         : resolveContextualContract(await library.list({ repo }), selector, scope);
     return { id, contract: library.of({ repo, id }) };
 }
+function draftWarning(error) {
+    return { warning: `bind draft could not be preserved: ${error instanceof Error ? error.message : String(error)}` };
+}
 async function bindDraftReceipt(establishWorld, markdown) {
     const { preserveBindDraft } = await import("../draft.js");
     try {
         return preserveBindDraft(await establishWorld(), markdown);
     }
     catch (error) {
-        return { warning: `bind draft could not be preserved: ${error instanceof Error ? error.message : String(error)}` };
+        return draftWarning(error);
+    }
+}
+async function bindDraftReceiptAtCwd(input, markdown) {
+    const { preserveBindDraft } = await import("../draft.js");
+    try {
+        const { resolveInvocationCwd } = await import("../coordinates.js");
+        return await preserveBindDraft(await resolveInvocationCwd(input), markdown);
+    }
+    catch (error) {
+        return draftWarning(error);
+    }
+}
+export async function admitMarkdownBindSyntax(input) {
+    try {
+        const { parseMarkdownBindDocument } = await import("../../library/contract.js");
+        parseMarkdownBindDocument(input.markdown);
+    }
+    catch (error) {
+        if (!(error instanceof TypeError))
+            throw error;
+        const { BindDraftError } = await import("../draft.js");
+        throw new BindDraftError(error, await bindDraftReceiptAtCwd(input, input.markdown));
     }
 }
 async function invokeBind(input) {

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

@@ -137,31 +137,63 @@ function parseRegion(parts) {
         output: parts.output,
     };
 }
+function akumaCatalogQuery(query, parts) {
+    const limit = optionalFlag(parts.flags, "limit");
+    if (query.kind !== "akuma") {
+        if (limit !== undefined)
+            refuse("ls", "--limit requires an Akuma instance directory");
+        return query;
+    }
+    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) {
+    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 limit === undefined ? undefined : Number(limit);
+}
+function taskCatalogQuery(path, limit) {
+    if (path === "task" || path === "task/") {
+        return { kind: "tasks", namespace: [], ...(limit === undefined ? {} : { limit }) };
+    }
+    if (!path.startsWith("task/"))
+        return null;
+    if (!path.endsWith("/"))
+        refuse("ls", `invalid Task namespace selector: ${path}`);
+    const body = path.slice("task/".length, -1);
+    if (body.length === 0 || body.split("/").some((segment) => segment.length === 0))
+        refuse("ls", `invalid Task namespace selector: ${path}`);
+    try {
+        const namespace = parseTaskNamespaceSelector(path);
+        return { kind: "tasks", namespace, ...(limit === undefined ? {} : { limit }) };
+    }
+    catch (error) {
+        refuse("ls", error instanceof Error ? error.message : `invalid Task namespace selector: ${path}`);
+    }
+}
 function parseLs(parts) {
     const path = parts.positionals[0];
-    if (path === "task" || path === "task/")
-        return { command: "ls", query: { kind: "tasks", namespace: [] }, output: parts.output };
-    if (path.startsWith("task/")) {
-        if (!path.endsWith("/"))
-            refuse("ls", `invalid Task namespace selector: ${path}`);
-        const body = path.slice("task/".length, -1);
-        if (body.length === 0 || body.split("/").some((segment) => segment.length === 0))
-            refuse("ls", `invalid Task namespace selector: ${path}`);
-        try {
-            const namespace = parseTaskNamespaceSelector(path);
-            return { command: "ls", query: { kind: "tasks", namespace }, output: parts.output };
-        }
-        catch (error) {
-            refuse("ls", error instanceof Error ? error.message : `invalid Task namespace selector: ${path}`);
-        }
+    const limit = listLimit(parts);
+    const taskQuery = taskCatalogQuery(path, limit);
+    if (taskQuery !== null)
+        return { command: "ls", query: taskQuery, output: parts.output };
+    if (path === "kei" || path === "kei/") {
+        return {
+            command: "ls",
+            query: { kind: "contracts", ...(limit === undefined ? {} : { limit }) },
+            output: parts.output,
+        };
     }
-    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 a supported identity directory selector");
-        return { command: "ls", query, output: parts.output };
+        return { command: "ls", query: akumaCatalogQuery(query, parts), output: parts.output };
     }
     catch (error) {
         if (error instanceof CliUsageError)

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

@@ -1,5 +1,4 @@
-/* eslint-disable max-lines -- Task edge keeps native reads, forwarding, and local dispatch together. */
-import { Tasks, } from "../../task/index.js";
+import { Tasks, taskRowViewLimit, } from "../../task/index.js";
 import { taskCompositionNamespaceHeader } from "../../task/compose-language.js";
 import { observeTaskDetails } from "../../task/operations.js";
 import { parseTaskNamespaceSelector } from "../../task/catalog.js";
@@ -51,6 +50,14 @@ function limit(command) {
     const raw = value(command, "limit");
     return raw === undefined ? undefined : Number(raw);
 }
+function validateTaskRowView(command) {
+    if (command.action === "ls" ||
+        command.action === "ready" ||
+        command.action === "blocked" ||
+        command.action === "query") {
+        taskRowViewLimit(limit(command));
+    }
+}
 function explicitListNamespace(command) {
     return command.action === "ls" && command.positionals.length === 1
         ? parseTaskNamespaceSelector(command.positionals[0])
@@ -257,6 +264,7 @@ function establishesWorld(command) {
 }
 // eslint-disable-next-line complexity -- this is the single CLI edge ordering world, context, forwarding, and local execution.
 export async function invokeTask(command, input) {
+    validateTaskRowView(command);
     const planOnly = command.action === "compose" && command.flags.plan === true;
     const composeMarkdown = command.action === "compose" ? await input.readStdin() : undefined;
     const composition = composeMarkdown === undefined ? undefined : taskCompositionNamespaceHeader(composeMarkdown);

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

@@ -1,4 +1,4 @@
-import { MAX_TASK_LIMIT, TASK_RELATION_PREDICATE_FIELDS, normalizeTaskQuery, } from "../../task/query.js";
+import { TASK_RELATION_PREDICATE_FIELDS, normalizeTaskQuery, } from "../../task/query.js";
 function syntax(message, offset) {
     throw new Error(`${message} at column ${offset + 1}`);
 }
@@ -262,9 +262,8 @@ export function parseTaskQueryExpression(source) {
     return normalizeTaskQuery(new Parser(lex(source)).parse());
 }
 export function validateTaskLimit(source) {
-    if (!/^[1-9][0-9]*$/u.test(source) || Number(source) > MAX_TASK_LIMIT) {
-        throw new Error(`--limit must be an integer from 1 to ${MAX_TASK_LIMIT}`);
-    }
+    if (!/^[1-9][0-9]*$/u.test(source) || !Number.isSafeInteger(Number(source)))
+        throw new Error("--limit requires a positive safe integer");
 }
 export function validateTaskParent(source) {
     try {

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

@@ -22,4 +22,17 @@ export type CliCoordinateInput = Readonly<{
     gitPath?: string;
     command: ParsedCommand;
 }>;
+export declare function resolveInvocationCwd(input: Readonly<{
+    processCwd?: string;
+    cwd?: string;
+}>): Promise<string>;
+export declare const cliCoordinateDiscovery: {
+    repoAt(coordinate: string, gitPath?: string): Promise<Repo>;
+    worldResolve(cwd: string, repositoryRoot?: string): Promise<Readonly<{
+        root: WorldRoot | null;
+        candidate: WorldRoot | null;
+        establish: () => Promise<WorldRoot>;
+    }>>;
+    resolve(input: CliCoordinateInput): Promise<CliCoordinates>;
+};
 export declare function resolveCliCoordinates(input: CliCoordinateInput): Promise<CliCoordinates>;

package/build/src/cli/coordinates.js

@@ -11,11 +11,15 @@ async function canonicalInvocationCwd(input) {
         throw new CliUsageError(`invocation cwd is not an existing directory: ${input}`);
     }
 }
+export async function resolveInvocationCwd(input) {
+    const processCwd = resolve(input.processCwd ?? ".");
+    return canonicalInvocationCwd(resolve(processCwd, input.cwd ?? "."));
+}
 async function discoverRepoAt(coordinate, gitPath) {
     try {
         return {
             kind: "present",
-            repo: await Repo.at({ path: coordinate, ...(gitPath === undefined ? {} : { gitPath }) }),
+            repo: await cliCoordinateDiscovery.repoAt(coordinate, gitPath),
         };
     }
     catch (error) {
@@ -44,9 +48,40 @@ function repoFor(use, discovery) {
         throw discovery.error;
     return undefined;
 }
+export const cliCoordinateDiscovery = {
+    async repoAt(coordinate, gitPath) {
+        return Repo.at({ path: coordinate, ...(gitPath === undefined ? {} : { gitPath }) });
+    },
+    async worldResolve(cwd, repositoryRoot) {
+        return World.resolve({ cwd, ...(repositoryRoot === undefined ? {} : { repositoryRoot }) });
+    },
+    async resolve(input) {
+        const cwd = await resolveInvocationCwd(input);
+        const invocationRepo = await discoverRepoAt(cwd, input.gitPath);
+        const selectedRepo = input.repo === undefined ? invocationRepo : await discoverRepoAt(resolve(cwd, input.repo), input.gitPath);
+        const worldRepo = invocationRepo.kind === "present" ? invocationRepo.repo : undefined;
+        const repo = repoFor(commandRepoPolicy(input.command).use, selectedRepo);
+        const world = await resolveWorld(cwd, worldRepo);
+        const boundary = worldRepo === undefined ? (world.root ?? world.candidate ?? cwd) : worldRepo.cwd;
+        return {
+            cwd,
+            cwdSource: input.cwd === undefined ? "process" : "input",
+            ...(repo === undefined ? {} : { repo }),
+            world: world.root,
+            candidateWorld: world.candidate,
+            taskContext: {
+                directory: cwd,
+                boundary,
+                writeRoot: worldRepo === undefined ? boundary : cwd,
+                managed: await managedContractWorktree(boundary),
+            },
+            establishWorld: world.establish,
+        };
+    },
+};
 async function resolveWorld(cwd, repo) {
     try {
-        const resolution = await World.resolve({ cwd, ...(repo === undefined ? {} : { repositoryRoot: repo.root }) });
+        const resolution = await cliCoordinateDiscovery.worldResolve(cwd, repo?.root);
         return {
             root: resolution.root,
             candidate: resolution.candidate,
@@ -69,26 +104,5 @@ async function resolveWorld(cwd, repo) {
     }
 }
 export async function resolveCliCoordinates(input) {
-    const processCwd = resolve(input.processCwd ?? ".");
-    const cwd = await canonicalInvocationCwd(resolve(processCwd, input.cwd ?? "."));
-    const invocationRepo = await discoverRepoAt(cwd, input.gitPath);
-    const selectedRepo = input.repo === undefined ? invocationRepo : await discoverRepoAt(resolve(cwd, input.repo), input.gitPath);
-    const worldRepo = invocationRepo.kind === "present" ? invocationRepo.repo : undefined;
-    const repo = repoFor(commandRepoPolicy(input.command).use, selectedRepo);
-    const world = await resolveWorld(cwd, worldRepo);
-    const boundary = worldRepo === undefined ? (world.root ?? world.candidate ?? cwd) : worldRepo.cwd;
-    return {
-        cwd,
-        cwdSource: input.cwd === undefined ? "process" : "input",
-        ...(repo === undefined ? {} : { repo }),
-        world: world.root,
-        candidateWorld: world.candidate,
-        taskContext: {
-            directory: cwd,
-            boundary,
-            writeRoot: worldRepo === undefined ? boundary : cwd,
-            managed: await managedContractWorktree(boundary),
-        },
-        establishWorld: world.establish,
-    };
+    return cliCoordinateDiscovery.resolve(input);
 }

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

@@ -5,4 +5,4 @@ export declare class BindDraftError extends Error {
     readonly draft: BindDraftReceipt;
     constructor(original: unknown, draft: BindDraftReceipt);
 }
-export declare function preserveBindDraft(world: WorldRoot, markdown: string, now?: number): Promise<BindDraftReceipt>;
+export declare function preserveBindDraft(world: WorldRoot | string, markdown: string, now?: number): Promise<BindDraftReceipt>;

package/build/src/cli/invoke.js

@@ -162,7 +162,11 @@ async function invokeCatalog(parsed, world, repo, home) {
         if (parsed.query.kind === "archetypes") {
             return {
                 kind: "catalog",
-                catalog: await Keiyaku.ls({ query: parsed.query, ...(home === undefined ? {} : { home }) }),
+                catalog: await Keiyaku.ls({
+                    query: parsed.query,
+                    ...(world === null ? {} : { path: world }),
+                    ...(home === undefined ? {} : { home }),
+                }),
             };
         }
         if (world === null)
@@ -406,6 +410,15 @@ export async function invoke(invocation, runtime = {}) {
         }
         const acquiredRuntime = await withAcquiredStdin(command, withResolvedTaskActor(command, runtime));
         runtime.onOperationStart?.();
+        if (command.command === "bind" && command.forkOf === undefined) {
+            const markdown = await (acquiredRuntime.readStdin ?? readStdin)();
+            const { admitMarkdownBindSyntax } = await import("./commands/contract-invoke.js");
+            await admitMarkdownBindSyntax({
+                markdown,
+                ...(runtime.cwd === undefined ? {} : { processCwd: runtime.cwd }),
+                ...(invocation.cwd === undefined ? {} : { cwd: invocation.cwd }),
+            });
+        }
         return await invokeParsed({
             ...(invocation.cwd === undefined ? {} : { cwd: invocation.cwd }),
             ...(invocation.repo === undefined ? {} : { repo: invocation.repo }),

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

@@ -16,7 +16,6 @@ type SnapshotCoreOptions = Readonly<{
     facts?: readonly string[];
 }>;
 export declare function snapshotText(view: SnapshotView, context: TextRenderContext, options?: SnapshotCoreOptions): string;
-export declare function killObservationText(id: string, evidence: KillEvidence, observation: AkumaObservationStage, context: TextRenderContext, alias?: string): string;
 export declare function killResultText(id: string, evidence: KillEvidence, alias?: string): string;
 export declare function mutationObservationStageText(id: string, observation: AkumaObservationStage, context: TextRenderContext, options?: SnapshotCoreOptions & Readonly<{
     showLife?: boolean;

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

@@ -182,38 +182,15 @@ function taskDispositionMark(disposition) {
         return "●";
     return disposition === "blocked" ? "‖" : "○";
 }
-function changeStat(group) {
-    let added = 0;
-    let removed = 0;
-    for (const change of group) {
-        if (change.diffstat === undefined)
-            return "+? -?";
-        added += change.diffstat.added;
-        removed += change.diffstat.removed;
-    }
-    return `+${added} -${removed}`;
-}
-function groupedChangeRows(changes) {
-    const groups = [];
-    const seen = new Map();
-    for (const change of changes) {
-        const index = seen.get(change.path);
-        if (index === undefined) {
-            seen.set(change.path, groups.length);
-            groups.push([change]);
-        }
-        else
-            groups[index].push(change);
-    }
-    return groups.map((group) => ({ path: group[0].path, stat: changeStat(group) }));
+function changeStat(change) {
+    return change.diffstat === undefined ? "+? -?" : `+${change.diffstat.added} -${change.diffstat.removed}`;
 }
 function renderReportedChangeLines(snapshot) {
-    const rows = groupedChangeRows(snapshot.reportedChanges);
-    const width = rows.reduce((max, row) => Math.max(max, row.stat.length), 0);
+    const width = snapshot.reportedChanges.reduce((max, change) => Math.max(max, changeStat(change).length), 0);
     return [
         `changes ${snapshot.reportedChanges.length + snapshot.reportedChangesOmitted}`,
-        ...rows.map((row) => `  ${row.stat.padEnd(width)}  ${safeText(row.path)}`),
-        ...(snapshot.reportedChangesOmitted > 0 ? [`  ⋮ ${snapshot.reportedChangesOmitted} earlier changes`] : []),
+        ...snapshot.reportedChanges.map((change) => `  ${changeStat(change).padEnd(width)}  ${safeText(change.path)}`),
+        ...(snapshot.reportedChangesOmitted > 0 ? [`  ⋮ ${snapshot.reportedChangesOmitted} more files`] : []),
     ];
 }
 function renderTaskRow(row, columns) {
@@ -292,16 +269,6 @@ function killResultLabel(evidence) {
         return "✓ already stopped";
     return `! not killed · ${evidence}`;
 }
-function latestKillActivity(snapshot, context) {
-    const rows = snapshot.entries.flatMap((entry) => (entry.kind === "row" ? [entry.row] : []));
-    const latest = rows.reduce((selected, row) => (selected === undefined || row.sequence > selected.sequence ? row : selected), undefined);
-    return latest === undefined ? [] : groupedRows([latest], context);
-}
-export function killObservationText(id, evidence, observation, context, alias) {
-    const heading = snapshotHeading(id, alias, observation.kind === "observed" ? observation.contract : undefined);
-    const activity = observation.kind === "observed" ? latestKillActivity(observation.status.timeline, context) : [];
-    return [...heading, ...activity, "", killResultLabel(evidence)].join("\n");
-}
 export function killResultText(id, evidence, alias) {
     return [...snapshotHeading(id, alias, undefined), "", killResultLabel(evidence)].join("\n");
 }

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

@@ -3,8 +3,11 @@ import { DEFAULT_CONTEXT, akumaRawAnswer, associatedIdentity, historyText, killR
 import { safeText } from "./terminal.js";
 export { akumaRawAnswer } from "./akuma-activity.js";
 function dispatchLines(stage) {
-    if (stage.kind === "none" || stage.kind === "dispatched")
+    if (stage.kind === "none")
         return [];
+    if (stage.kind === "dispatched") {
+        return (stage.seatClose ?? []).map((lag) => `dispatch lag ${lag.kind} ${safeText(lag.diagnostic)}`);
+    }
     if (stage.failure.kind === "conflict")
         return [`dispatch failed conflict ${stage.failure.current.contractId}`];
     return [`dispatch failed ${stage.failure.kind} ${safeText(stage.failure.diagnostic)}`];

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

@@ -1,4 +1,4 @@
-import { cleanupLines, leakLines, receiptPayload, receiptRow, stopLines, titleLines } from "./receipt.js";
+import { cleanupLines, leakLines, receiptPayload, receiptRow, seatCloseLines, stopLines, titleLines, } from "./receipt.js";
 import { renderRefusalFacts } from "./refusal.js";
 import { gitShortStat, renderOpaqueBlock } from "./terminal.js";
 const CHILD = "  ";
@@ -78,6 +78,9 @@ function obligationLines(result, columns) {
     return [
         ...(result.cleanup === undefined ? [] : cleanupLines(result.cleanup, columns)),
         ...(result.leak === undefined ? [] : leakLines(result.leak, columns)),
+        ...(result.seatClose === undefined || result.seatClose.length === 0
+            ? []
+            : seatCloseLines(result.seatClose, columns)),
     ];
 }
 function recordLines(result, columns) {