@astrosheep/keiyaku 4.0.4 → 4.0.6

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

@@ -1,20 +1,26 @@
-export const AMEND_MINIMAL_STDIN_HELP = [
-    "minimal stdin:",
-    "  ## Replace: Design",
-    "  <complete replacement>",
+export const AMEND_OPERATIONS_HELP = [
+    "stdin operations (H2 sections only, no H1):",
+    "  ## Replace: Context|Objective|Design|Region|Criteria|Verification|<extension>",
+    "  ## Append: Context|Objective|Design|Criteria|<extension>",
+    "  ## Add: Criteria|<new-extension-title>",
+    "  ## Update: Criterion <existing-title>|<existing-extension-title>",
+    "  ## Remove: Criterion <existing-title>|<existing-extension-title>",
+    "",
+    "full operation grammar: docs/document.md, Amend Operations",
 ].join("\n");
 export const CONTRACT_COMMAND_SPECS = {
-    bind: { positional: "none", stdin: "required", flags: { actor: "value", task: "value", target: "value", here: "boolean", after: "repeat-value", gates: "value", json: "boolean" }, usage: "bind [--task <task/...>] [--target <ref>] [--here] [--after <kei/...> ...] [--gates <name>] [--actor <actor>] [--json] -", purpose: "Create one Contract from stdin Markdown." },
-    amend: { positional: "optional", stdin: "optional", flags: { actor: "value", after: "repeat-value", "clear-after": "boolean", gates: "value", json: "boolean" }, usage: "amend [<contract>|@<contract>] [--after <kei/...> ... | --clear-after] [--gates <name>] [--actor <actor>] [--json] [-]", purpose: "Amend one Contract's document operations or structured terms." },
-    deliver: { positional: "optional", stdin: "none", flags: { actor: "value", message: "value", "include-dirty": "boolean", json: "boolean" }, usage: "deliver [<contract>|@<contract>] [--message <text>] [--include-dirty] [--actor <actor>] [--json]", purpose: "Deliver one Contract candidate." },
-    review: { positional: "optional", stdin: "optional", flags: { actor: "value", satisfied: "boolean", unsatisfied: "boolean", summary: "value", json: "boolean" }, usage: "review [<contract>|@<contract>] (--satisfied | --unsatisfied) (--summary <text> | -) [--actor <actor>] [--json]", purpose: "Record one review verdict." },
-    arc: { positional: "optional", stdin: "required", flags: { actor: "value", json: "boolean" }, usage: "arc [<contract>|@<contract>] [--actor <actor>] [--json] -", purpose: "Record stdin arc Markdown for one Contract." },
-    abandon: { positional: "optional", stdin: "none", flags: { actor: "value", note: "value", json: "boolean" }, usage: "abandon [<contract>|@<contract>] [--note <text>] [--actor <actor>] [--json]", purpose: "Abandon one Contract with an optional note." },
-    status: { positional: "optional", stdin: "none", flags: { json: "boolean" }, usage: "status [<contract>|@name|<aku/...>] [--json]", purpose: "Read the world status board or one Contract projection." },
-    show: { positional: "optional", stdin: "none", flags: { json: "boolean" }, usage: "show [<contract>|@<contract>] [--json]", purpose: "Read one Contract guidance projection." },
-    ls: { positional: "optional", stdin: "none", flags: { json: "boolean" }, usage: "ls task/ [--json]\n       keiyaku ls kei/ [--json]\n       keiyaku ls aku/ [--json]\n       keiyaku ls aku/<akuma>/ [--json]\n       keiyaku ls \"aku/*/*\" [--json]", purpose: "List one identity directory." },
-    audit: { positional: "optional", stdin: "none", flags: { "include-dirty": "boolean", diff: "boolean", actor: "value", json: "boolean" }, usage: "audit [<contract>|@<contract>] [--include-dirty] [--diff] [--actor <actor>] [--json]", purpose: "Ask what candidate preparation, Verification, and target placement would do." },
-    reconcile: { positional: "optional", stdin: "none", flags: { "retry-hooks": "boolean", json: "boolean" }, usage: "reconcile [<contract>|@<contract>] [--retry-hooks] [--json]", purpose: "Reconcile one Contract or the invocation world." },
-    settings: { positional: "none", stdin: "none", flags: { json: "boolean" }, usage: "settings [--json]", purpose: "Read user and project Settings resources." },
-    region: { positional: "optional", stdin: "none", flags: { overlap: "boolean", path: "value", json: "boolean" }, usage: "region [<contract>] [--overlap] [--json]\n       region --path <repo-relative-path> [--json]", purpose: "Read active declared Contract Regions." },
+    bind: { positional: "none", stdin: "required", flags: { actor: "value", task: "value", target: "value", here: "boolean", after: "repeat-value", gates: "raw-value", json: "boolean" }, usage: "bind [--task <task/...>] [--target <ref>] [--here] [--after <kei/...> ...] [--gates <name,...>] [--actor <actor>] -", purpose: "Create one Contract from stdin Markdown." },
+    amend: { positional: "optional", stdin: "optional", flags: { actor: "value", after: "repeat-value", "clear-after": "boolean", gates: "raw-value", json: "boolean" }, usage: "amend [<contract>|@<contract>] [--after <kei/...> ... | --clear-after] [--gates <name,...>] [--actor <actor>] [-]", purpose: "Amend one Contract's document operations or structured terms." },
+    deliver: { positional: "optional", stdin: "none", flags: { actor: "value", message: "value", "include-dirty": "boolean", "materialize-conflict": "boolean", json: "boolean" }, usage: "deliver [<contract>|@<contract>] [--message <text>] [--include-dirty] [--materialize-conflict] [--actor <actor>]", purpose: "Deliver one Contract candidate." },
+    review: { positional: "optional", stdin: "optional", flags: { actor: "value", satisfied: "boolean", unsatisfied: "boolean", summary: "value", json: "boolean" }, usage: "review [<contract>|@<contract>] (--satisfied | --unsatisfied) (--summary <text> | -) [--actor <actor>]", purpose: "Record one review verdict." },
+    arc: { positional: "optional", stdin: "required", flags: { actor: "value", json: "boolean" }, usage: "arc [<contract>|@<contract>] [--actor <actor>] -", purpose: "Record stdin arc Markdown for one Contract." },
+    abandon: { positional: "optional", stdin: "none", flags: { actor: "value", note: "value", json: "boolean" }, usage: "abandon [<contract>|@<contract>] [--note <text>] [--actor <actor>]", purpose: "Abandon one Contract with an optional note." },
+    status: { positional: "optional", stdin: "none", flags: { json: "boolean" }, usage: "status [<contract>|@name|<aku/...>]", purpose: "Read the world status board or one Contract projection." },
+    show: { positional: "optional", stdin: "none", flags: { json: "boolean" }, usage: "show [<contract>|@<contract>]", purpose: "Read one Contract guidance projection." },
+    ls: { positional: "optional", stdin: "none", flags: { json: "boolean" }, usage: "ls task[/]\n       keiyaku ls kei[/]\n       keiyaku ls aku[/]\n       keiyaku ls aku/<akuma>[/]\n       keiyaku ls \"aku/*/*\"", purpose: "List one identity directory." },
+    audit: { positional: "optional", stdin: "none", flags: { "include-dirty": "boolean", diff: "boolean", actor: "value", json: "boolean" }, usage: "audit [<contract>|@<contract>] [--include-dirty] [--diff] [--actor <actor>]", purpose: "Ask what candidate preparation, Verification, and target placement would do." },
+    reconcile: { positional: "optional", stdin: "none", flags: { "retry-hooks": "boolean", json: "boolean" }, usage: "reconcile [<contract>|@<contract>] [--retry-hooks]", purpose: "Reconcile one Contract or the invocation world." },
+    nuke: { positional: "none", stdin: "none", flags: { confirm: "value", json: "boolean" }, usage: "nuke [--confirm <WorldRoot>]", purpose: "Remove Keiyaku-owned data from one confirmed World." },
+    settings: { positional: "none", stdin: "none", flags: { json: "boolean" }, usage: "settings", purpose: "Read user and project Settings resources." },
+    region: { positional: "optional", stdin: "none", flags: { overlap: "boolean", path: "value", json: "boolean" }, usage: "region [<contract>] [--overlap]\n       region --path <repo-relative-path>", purpose: "Read active declared Contract Regions." },
 };

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

@@ -1,4 +1,4 @@
-import { type ProcessInput, type ProcessOutcome } from "../../runtime/proc/run.js";
+import type { ProcessInput, ProcessOutcome } from "../../runtime/proc/run.js";
 export declare const HARNESS_NAMES: readonly ["codex", "claude", "opencode", "pi"];
 export type HarnessName = typeof HARNESS_NAMES[number];
 export type ParsedInstallCommand = Readonly<{
@@ -16,7 +16,7 @@ export type InstallInvocationResult = Readonly<{
     results: readonly HarnessInstallResult[];
 }>;
 export type InstallRunner = (input: ProcessInput) => Promise<ProcessOutcome>;
-export declare const INSTALL_USAGE = "install <codex|claude|opencode|pi> [--json]\n       install --all [--json]";
+export declare const INSTALL_USAGE = "install <codex|claude|opencode|pi>\n       install --all";
 export declare function parseInstallCommand(argv: readonly string[]): ParsedInstallCommand;
 export declare function renderInstallHelp(): string;
 export declare function installAssetsRoot(): string;

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

@@ -1,9 +1,8 @@
 import { dirname, resolve } from "node:path";
 import { fileURLToPath } from "node:url";
-import { runCrossPlatformProcess } from "../../runtime/proc/run.js";
-import { CliUsageError, usageLine, withJsonAutomationHelp } from "../usage.js";
+import { CliUsageError, usageLine } from "../usage.js";
 export const HARNESS_NAMES = ["codex", "claude", "opencode", "pi"];
-export const INSTALL_USAGE = "install <codex|claude|opencode|pi> [--json]\n       install --all [--json]";
+export const INSTALL_USAGE = "install <codex|claude|opencode|pi>\n       install --all";
 function isHarness(value) {
     return value !== undefined && HARNESS_NAMES.includes(value);
 }
@@ -43,7 +42,7 @@ export function parseInstallCommand(argv) {
     };
 }
 export function renderInstallHelp() {
-    return withJsonAutomationHelp(`Install the Keiyaku skills into one or more agent harnesses.\n\n${usageLine(INSTALL_USAGE)}`);
+    return `Install the Keiyaku skills into one or more agent harnesses.\n\n${usageLine(INSTALL_USAGE)}`;
 }
 const INSTALL_TIMEOUT_MS = 5 * 60 * 1000;
 const ASSET_ROOT = resolve(dirname(fileURLToPath(import.meta.url)), "../../../integrations/marketplace");
@@ -80,12 +79,13 @@ function diagnostic(argv, outcome) {
 export function installAssetsRoot() {
     return ASSET_ROOT;
 }
-export async function installHarnesses(harnesses, environment, runner = runCrossPlatformProcess) {
+export async function installHarnesses(harnesses, environment, runner) {
+    const run = runner ?? (await import("../../runtime/proc/run.js")).runCrossPlatformProcess;
     const results = [];
     for (const harness of harnesses) {
         let failure;
         for (const argv of recipes(harness)) {
-            const detail = diagnostic(argv, await runner({ argv, env: environment, timeoutMs: INSTALL_TIMEOUT_MS }));
+            const detail = diagnostic(argv, await run({ argv, env: environment, timeoutMs: INSTALL_TIMEOUT_MS }));
             if (detail.length > 0) {
                 failure = detail;
                 break;

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

@@ -0,0 +1,10 @@
+import { type NukeResult } from "../../index.js";
+import type { WorldRoot } from "../../world.js";
+import { type ParsedCommand } from "../parse.js";
+import type { InvocationResult } from "../result.js";
+export declare function invokeNuke(command: Extract<ParsedCommand, {
+    command: "nuke";
+}>, world: WorldRoot | null): Promise<Readonly<{
+    kind: "nuke";
+    result: NukeResult;
+}> | InvocationResult>;

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

@@ -0,0 +1,20 @@
+import { Keiyaku, KeiyakuRefused } from "../../index.js";
+import { CliUsageError } from "../parse.js";
+export async function invokeNuke(command, world) {
+    if (world === null)
+        throw new CliUsageError("no Keiyaku world contains the invocation cwd");
+    try {
+        return {
+            kind: "nuke",
+            result: await Keiyaku.nuke({
+                world,
+                ...(command.confirm === undefined ? {} : { confirm: command.confirm }),
+            }),
+        };
+    }
+    catch (error) {
+        if (error instanceof KeiyakuRefused)
+            return { kind: "refused", verb: "nuke", refusal: error.refusal };
+        throw error;
+    }
+}

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

@@ -16,9 +16,24 @@ export type TaskWorldObservation = Readonly<{
 }>;
 type TaskInput = Readonly<{
     world: WorldRoot | null;
+    context: Readonly<{
+        directory: string;
+        boundary: string;
+    }>;
     establish(): Promise<WorldRoot>;
     readStdin(): Promise<string>;
     actor?: string;
 }>;
+export declare function invokeTaskFromEdge(input: Readonly<{
+    parsed: ParsedTaskCommand;
+    world: WorldRoot | null;
+    context: Readonly<{
+        directory: string;
+        boundary: string;
+    }>;
+    establish: () => Promise<WorldRoot>;
+    readStdin: () => Promise<string>;
+    actor: string | undefined;
+}>): Promise<TaskInvocationResult>;
 export declare function invokeTask(command: ParsedTaskCommand, input: TaskInput): Promise<TaskInvocationResult>;
 export {};

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

@@ -1,4 +1,24 @@
 import { Tasks, } from "../../task/index.js";
+import { injectedBodyRequests, requestBodyTask } from "../../akuma/requests.js";
+import { decodeTaskMutationRequest } from "../../task/mutation.js";
+import { resolveTaskNamespaceContext, writeTaskNamespaceContext } from "../../task/context.js";
+import { CliUsageError } from "../usage.js";
+export async function invokeTaskFromEdge(input) {
+    try {
+        return await invokeTask(input.parsed, {
+            world: input.world,
+            context: input.context,
+            establish: input.establish,
+            readStdin: input.readStdin,
+            ...(input.actor === undefined ? {} : { actor: input.actor }),
+        });
+    }
+    catch (error) {
+        if (error instanceof TypeError)
+            throw new CliUsageError(error.message);
+        throw error;
+    }
+}
 function value(command, name) {
     const item = command.flags[name];
     return typeof item === "string" ? item : undefined;
@@ -17,8 +37,8 @@ function priority(raw) {
 function state(raw) { return raw; }
 function ids(items) { return items; }
 function limit(command) { const raw = value(command, "limit"); return raw === undefined ? undefined : Number(raw); }
-async function invokeAdd(tasks, command, input) {
-    const selectedNamespace = namespace(value(command, "namespace"));
+async function invokeAdd(tasks, command, input, current) {
+    const selectedNamespace = namespace(value(command, "namespace")) ?? current;
     const actor = input.actor;
     if (command.stdin === "document") {
         return tasks.addDocument({
@@ -54,17 +74,96 @@ async function invokeUpdate(tasks, command, readStdin) {
         ...(addRelates === undefined ? {} : { addRelates }), ...(dropRelates === undefined ? {} : { dropRelates }),
     });
 }
-async function invokeRead(tasks, command) {
+async function addMutationRequest(command, input, current) {
+    const selectedNamespace = namespace(value(command, "namespace")) ?? current;
+    if (command.stdin === "document")
+        return { action: "task.addDocument", input: {
+                markdown: await input.readStdin(),
+                namespace: selectedNamespace,
+            } };
+    const body = value(command, "body"), note = value(command, "note");
+    const initialState = state(value(command, "state")), selectedPriority = priority(value(command, "priority"));
+    const needs = ids(values(command, "needs")), parent = value(command, "parent");
+    const supersedes = ids(values(command, "supersedes")), relates = ids(values(command, "relates"));
+    return { action: "task.add", input: {
+            title: command.positionals[0], namespace: selectedNamespace,
+            ...(body === undefined ? {} : { body }), ...(note === undefined ? {} : { note }),
+            ...(initialState === undefined ? {} : { state: initialState }),
+            ...(selectedPriority === undefined ? {} : { priority: selectedPriority }),
+            ...(needs === undefined ? {} : { needs }), ...(parent === undefined ? {} : { parent: parent }),
+            ...(supersedes === undefined ? {} : { supersedes }), ...(relates === undefined ? {} : { relates }),
+        } };
+}
+async function updateMutationRequest(command, input) {
+    const body = command.stdin === "body" ? await input.readStdin() : value(command, "body");
+    const appendBody = command.stdin === "append" ? await input.readStdin() : value(command, "append");
+    const note = command.stdin === "note" ? await input.readStdin() : value(command, "note");
+    const title = value(command, "title"), selectedPriority = priority(value(command, "priority"));
+    const addNeeds = ids(values(command, "needs")), dropNeeds = ids(values(command, "drop-needs"));
+    const parent = value(command, "parent"), addSupersedes = ids(values(command, "supersedes"));
+    const dropSupersedes = ids(values(command, "drop-supersedes")), addRelates = ids(values(command, "relates"));
+    const dropRelates = ids(values(command, "drop-relates"));
+    return { action: "task.update", id: command.positionals[0], input: {
+            ...(title === undefined ? {} : { title }), ...(body === undefined ? {} : { body }),
+            ...(appendBody === undefined ? {} : { appendBody }), ...(note === undefined ? {} : { note }),
+            ...(selectedPriority === undefined ? {} : { priority: selectedPriority }),
+            ...(addNeeds === undefined ? {} : { addNeeds }), ...(dropNeeds === undefined ? {} : { dropNeeds }),
+            ...(command.flags["no-parent"] === true ? { parent: null }
+                : parent === undefined ? {} : { parent: parent }),
+            ...(addSupersedes === undefined ? {} : { addSupersedes }),
+            ...(dropSupersedes === undefined ? {} : { dropSupersedes }),
+            ...(addRelates === undefined ? {} : { addRelates }), ...(dropRelates === undefined ? {} : { dropRelates }),
+        } };
+}
+function lifecycleMutationRequest(command) {
+    const id = command.positionals[0];
+    switch (command.action) {
+        case "start": return { action: "task.start", id };
+        case "stop": return { action: "task.stop", id };
+        case "resume": return { action: "task.resume", id };
+        case "hold": return { action: "task.hold", ids: command.positionals };
+        case "done": return { action: "task.done", ids: command.positionals, ...(value(command, "note") === undefined ? {} : { note: value(command, "note") }) };
+        case "drop": return { action: "task.drop", ids: command.positionals, ...(value(command, "note") === undefined ? {} : { note: value(command, "note") }) };
+        default: throw new Error(`task action cannot forward: ${command.action}`);
+    }
+}
+async function mutationRequest(command, input, current) {
+    if (command.action === "add")
+        return await addMutationRequest(command, input, current);
+    if (command.action === "compose")
+        return { action: "task.compose", markdown: await input.readStdin(), namespace: current };
+    if (command.action === "update")
+        return await updateMutationRequest(command, input);
+    return lifecycleMutationRequest(command);
+}
+function validatedMutationRequest(request) {
+    switch (request.action) {
+        case "task.add":
+        case "task.addDocument": return decodeTaskMutationRequest(request.action, { input: request.input });
+        case "task.compose": return decodeTaskMutationRequest(request.action, { markdown: request.markdown, namespace: request.namespace });
+        case "task.update": return decodeTaskMutationRequest(request.action, { id: request.id, input: request.input });
+        case "task.start":
+        case "task.stop":
+        case "task.resume": return decodeTaskMutationRequest(request.action, { id: request.id });
+        case "task.hold": return decodeTaskMutationRequest(request.action, { ids: request.ids });
+        case "task.done":
+        case "task.drop": return decodeTaskMutationRequest(request.action, { ids: request.ids, ...(request.note === undefined ? {} : { note: request.note }) });
+    }
+}
+function readScope(command, current) {
+    return command.flags.world === true ? { scope: "world" } : { namespace: current ?? [] };
+}
+async function invokeRead(tasks, command, current) {
     const id = command.positionals[0];
     switch (command.action) {
         case "show": {
             const detail = await tasks.task({ id }).read();
             return detail ?? { kind: "refused", refusal: { kind: "task-missing", taskId: id } };
         }
-        case "ls": return tasks.list({ selection: command.flags.all === true ? "all" : command.flags.closed === true ? "closed" : "active", ...(command.flags.world === true ? { scope: "world" } : {}), ...(limit(command) === undefined ? {} : { limit: limit(command) }) });
-        case "ready": return tasks.ready({ ...(command.flags.world === true ? { scope: "world" } : {}), ...(value(command, "parent") === undefined ? {} : { parent: value(command, "parent") }), ...(limit(command) === undefined ? {} : { limit: limit(command) }) });
-        case "blocked": return tasks.blocked({ ...(command.flags.world === true ? { scope: "world" } : {}), ...(value(command, "parent") === undefined ? {} : { parent: value(command, "parent") }), ...(limit(command) === undefined ? {} : { limit: limit(command) }) });
-        case "query": return tasks.query({ ...(command.where === undefined ? {} : { where: command.where }), ...(command.flags.world === true ? { scope: "world" } : {}), ...(value(command, "sort") === undefined ? {} : { sort: value(command, "sort") }), ...(limit(command) === undefined ? {} : { limit: limit(command) }) });
+        case "ls": return tasks.list({ selection: command.flags.all === true ? "all" : command.flags.closed === true ? "closed" : "active", ...readScope(command, current), ...(limit(command) === undefined ? {} : { limit: limit(command) }) });
+        case "ready": return tasks.ready({ ...readScope(command, current), ...(value(command, "parent") === undefined ? {} : { parent: value(command, "parent") }), ...(limit(command) === undefined ? {} : { limit: limit(command) }) });
+        case "blocked": return tasks.blocked({ ...readScope(command, current), ...(value(command, "parent") === undefined ? {} : { parent: value(command, "parent") }), ...(limit(command) === undefined ? {} : { limit: limit(command) }) });
+        case "query": return tasks.query({ ...(command.where === undefined ? {} : { where: command.where }), ...readScope(command, current), ...(value(command, "sort") === undefined ? {} : { sort: value(command, "sort") }), ...(limit(command) === undefined ? {} : { limit: limit(command) }) });
         case "tree": return tasks.task({ id }).tree();
         case "doctor": return tasks.doctor();
         default: throw new Error(`task action is not a read: ${command.action}`);
@@ -75,9 +174,9 @@ function isWorldObservation(command) {
         || command.action === "query" || command.action === "doctor";
 }
 function diagnostic(error) { return error instanceof Error ? error.message : String(error); }
-async function observeWorldRead(tasks, command) {
+async function observeWorldRead(tasks, command, current) {
     try {
-        return { kind: "present", value: await invokeRead(tasks, command) };
+        return { kind: "present", value: await invokeRead(tasks, command, current) };
     }
     catch (error) {
         return { kind: "failed", failure: { message: diagnostic(error) } };
@@ -97,21 +196,13 @@ function missingWorld(command) {
     }
     return missing(command.positionals[0]);
 }
-export async function invokeTask(command, input) {
-    let world = input.world;
-    if (world === null && (command.action === "add" || command.action === "compose"
-        || (command.action === "namespace" && command.positionals.length > 0))) {
-        world = await input.establish();
-    }
-    if (world === null)
-        return missingWorld(command);
-    const tasks = Tasks.of(world);
+async function invokeLocalMutation(tasks, command, input, current) {
     if (isWorldObservation(command))
-        return observeWorldRead(tasks, command);
+        return observeWorldRead(tasks, command, current);
     if (command.action === "show" || command.action === "tree")
-        return invokeRead(tasks, command);
+        return invokeRead(tasks, command, current);
     if (command.action === "add")
-        return await invokeAdd(tasks, command, input);
+        return await invokeAdd(tasks, command, input, current ?? []);
     if (command.action === "update")
         return await invokeUpdate(tasks, command, input.readStdin);
     const id = command.positionals[0];
@@ -131,10 +222,39 @@ export async function invokeTask(command, input) {
         case "namespace": {
             const selected = namespace(command.positionals[0]);
             if (selected !== undefined)
-                await tasks.setNamespace({ namespace: selected });
-            return tasks.namespace();
+                await writeTaskNamespaceContext(input.context.directory, selected);
+            return { kind: "accepted", value: selected ?? current ?? [] };
         }
-        case "compose": return tasks.compose({ markdown: await input.readStdin(), ...(input.actor === undefined ? {} : { actor: input.actor }) });
+        case "compose": return tasks.compose({ markdown: await input.readStdin(), namespace: current ?? [], ...(input.actor === undefined ? {} : { actor: input.actor }) });
         default: throw new Error(`task action has no invocation: ${command.action}`);
     }
 }
+function establishesWorld(command) {
+    return command.action === "add" || command.action === "compose"
+        || (command.action === "namespace" && command.positionals.length > 0);
+}
+function forwardsMutation(command) {
+    return command.action !== "show" && command.action !== "tree"
+        && command.action !== "namespace" && !isWorldObservation(command);
+}
+export async function invokeTask(command, input) {
+    const world = input.world ?? (establishesWorld(command) ? await input.establish() : null);
+    if (world === null)
+        return missingWorld(command);
+    const tasks = Tasks.of(world);
+    const contextSensitive = command.action === "namespace" || command.action === "add" || command.action === "compose"
+        || ((command.action === "ls" || command.action === "ready" || command.action === "blocked" || command.action === "query") && command.flags.world !== true);
+    let current;
+    if (contextSensitive) {
+        const resolved = await resolveTaskNamespaceContext(input.context);
+        if (typeof resolved === "object" && "kind" in resolved)
+            return { kind: "refused", refusal: resolved };
+        current = resolved;
+    }
+    const requests = injectedBodyRequests();
+    if (requests !== null && forwardsMutation(command)) {
+        const request = validatedMutationRequest(await mutationRequest(command, input, current ?? []));
+        return await requestBodyTask({ directory: requests, world, request });
+    }
+    return await invokeLocalMutation(tasks, command, input, current);
+}

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

@@ -1,5 +1,5 @@
-import { type TaskQueryExpression } from "../../task/index.js";
-export type { TaskQueryExpression } from "../../task/index.js";
+import { type TaskQueryExpression } from "../../task/query.js";
+export type { TaskQueryExpression } from "../../task/query.js";
 export declare function parseTaskQueryExpression(source: string): TaskQueryExpression;
 export declare function validateTaskLimit(source: string): void;
 export declare function validateTaskParent(source: string): void;

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

@@ -1,5 +1,4 @@
-import { TASK_RELATION_PREDICATE_FIELDS, } from "../../task/index.js";
-import { MAX_TASK_LIMIT, normalizeTaskQuery } from "../../task/query.js";
+import { MAX_TASK_LIMIT, TASK_RELATION_PREDICATE_FIELDS, normalizeTaskQuery, } from "../../task/query.js";
 function syntax(message, offset) { throw new Error(`${message} at column ${offset + 1}`); }
 function scanString(source, offset) {
     let index = offset + 1;

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

@@ -1,4 +1,4 @@
-import { CliUsageError, isBlankInput, usageLine, withJsonAutomationHelp } from "../usage.js";
+import { CliUsageError, isBlankInput, usageLine } from "../usage.js";
 import { parseTaskQueryExpression, validateTaskLimit, validateTaskParent, } from "./task-query.js";
 const COMMON = { json: "boolean" };
 const TASK_COMMAND_SPECS = {
@@ -9,18 +9,18 @@ const TASK_COMMAND_SPECS = {
   [--note <text>] [--actor <actor>]
   [--needs <TaskId>]... [--parent <TaskId>]
   [--supersedes <TaskId>]... [--relates <TaskId>]...
-  [--body <text>] [--json]
-task add [--namespace <ns>] [--actor <actor>] [--json] -`,
+  [--body <text>]
+task add [--namespace <ns>] [--actor <actor>] -`,
         purpose: "Create one Task from flags or a canonical stdin document.",
     },
-    show: { arity: [1, 1], flags: COMMON, usage: "task show <TaskId> [--json]", purpose: "Read one Task and its relationships." },
-    ls: { arity: [0, 0], flags: { ...COMMON, closed: "boolean", all: "boolean", world: "boolean", limit: "value" }, usage: "task ls [--closed | --all] [--world] [--limit <n>] [--json]", purpose: "List Tasks in the selected scope." },
-    ready: { arity: [0, 0], flags: { ...COMMON, world: "boolean", parent: "value", limit: "value" }, usage: "task ready [--world] [--parent <TaskId>] [--limit <n>] [--json]", purpose: "List open Tasks whose every need is terminal." },
-    blocked: { arity: [0, 0], flags: { ...COMMON, world: "boolean", parent: "value", limit: "value" }, usage: "task blocked [--world] [--parent <TaskId>] [--limit <n>] [--json]", purpose: "List Tasks blocked by dependencies." },
+    show: { arity: [1, 1], flags: COMMON, usage: "task show <TaskId>", purpose: "Read one Task and its relationships." },
+    ls: { arity: [0, 0], flags: { ...COMMON, closed: "boolean", all: "boolean", world: "boolean", limit: "value" }, usage: "task ls [--closed | --all] [--world] [--limit <n>]", purpose: "List Tasks in the selected scope." },
+    ready: { arity: [0, 0], flags: { ...COMMON, world: "boolean", parent: "value", limit: "value" }, usage: "task ready [--world] [--parent <TaskId>] [--limit <n>]", purpose: "List open Tasks whose every need is terminal." },
+    blocked: { arity: [0, 0], flags: { ...COMMON, world: "boolean", parent: "value", limit: "value" }, usage: "task blocked [--world] [--parent <TaskId>] [--limit <n>]", purpose: "List Tasks blocked by dependencies." },
     query: { arity: [0, 0], flags: { ...COMMON, where: "value", world: "boolean", sort: "value", limit: "value" }, usage: `task query [--where <expression>] [--world]
-  [--sort priority|created|updated|id] [--limit <n>] [--json]`, purpose: "Query Task facts with a typed boolean expression." },
-    tree: { arity: [1, 1], flags: COMMON, usage: "task tree <TaskId> [--json]", purpose: "Read one Task parent decomposition tree." },
-    doctor: { arity: [0, 0], flags: COMMON, usage: "task doctor [--json]", purpose: "Inspect Task authority without repairing it." },
+  [--sort priority|created|updated|id] [--limit <n>]`, purpose: "Query Task facts with a typed boolean expression." },
+    tree: { arity: [1, 1], flags: COMMON, usage: "task tree <TaskId>", purpose: "Read one Task parent decomposition tree." },
+    doctor: { arity: [0, 0], flags: COMMON, usage: "task doctor", purpose: "Inspect Task authority without repairing it." },
     update: {
         arity: [1, 1], flags: { ...COMMON, title: "value", body: "value", append: "value", note: "value", priority: "value", needs: "repeat", "drop-needs": "repeat", parent: "value", "no-parent": "boolean", supersedes: "repeat", "drop-supersedes": "repeat", relates: "repeat", "drop-relates": "repeat" },
         usage: `task update <TaskId> [--title <text>] [--body <text>|- | --append <text>|-]
@@ -28,17 +28,17 @@ task add [--namespace <ns>] [--actor <actor>] [--json] -`,
   [--priority 0..3] [--needs <TaskId>]... [--drop-needs <TaskId>]...
   [--parent <TaskId> | --no-parent]
   [--supersedes <TaskId>]... [--drop-supersedes <TaskId>]...
-  [--relates <TaskId>]... [--drop-relates <TaskId>]... [--json]`,
+  [--relates <TaskId>]... [--drop-relates <TaskId>]...`,
         purpose: "Apply one or more patches to a Task.",
     },
-    start: { arity: [1, 1], flags: COMMON, usage: "task start <TaskId> [--json]", purpose: "Move one open Task into progress." },
-    stop: { arity: [1, 1], flags: COMMON, usage: "task stop <TaskId> [--json]", purpose: "Return one in-progress Task to open." },
-    hold: { arity: [1, Number.POSITIVE_INFINITY], flags: COMMON, usage: "task hold <TaskId>... [--json]", purpose: "Put one or more Tasks on hold." },
-    resume: { arity: [1, 1], flags: COMMON, usage: "task resume <TaskId> [--json]", purpose: "Return one held Task to open." },
-    done: { arity: [1, Number.POSITIVE_INFINITY], flags: { ...COMMON, note: "value" }, usage: "task done <TaskId>... [--note <text>] [--json]", purpose: "Mark one or more Tasks done." },
-    drop: { arity: [1, Number.POSITIVE_INFINITY], flags: { ...COMMON, note: "value" }, usage: "task drop <TaskId>... [--note <text>] [--json]", purpose: "Drop one or more Tasks." },
-    namespace: { arity: [0, 1], flags: COMMON, usage: "task namespace [<namespace>] [--json]", purpose: "Read or replace the current Task namespace." },
-    compose: { arity: [0, 0], stdin: "compose", flags: { ...COMMON, actor: "value" }, usage: "task compose [--actor <actor>] [--json] -", purpose: "Admit Task documents independently; partial admission has no cross-file atomicity or rollback." },
+    start: { arity: [1, 1], flags: COMMON, usage: "task start <TaskId>", purpose: "Move one open Task into progress." },
+    stop: { arity: [1, 1], flags: COMMON, usage: "task stop <TaskId>", purpose: "Return one in-progress Task to open." },
+    hold: { arity: [1, Number.POSITIVE_INFINITY], flags: COMMON, usage: "task hold <TaskId>...", purpose: "Put one or more Tasks on hold." },
+    resume: { arity: [1, 1], flags: COMMON, usage: "task resume <TaskId>", purpose: "Return one held Task to open." },
+    done: { arity: [1, Number.POSITIVE_INFINITY], flags: { ...COMMON, note: "value" }, usage: "task done <TaskId>... [--note <text>]", purpose: "Mark one or more Tasks done." },
+    drop: { arity: [1, Number.POSITIVE_INFINITY], flags: { ...COMMON, note: "value" }, usage: "task drop <TaskId>... [--note <text>]", purpose: "Drop one or more Tasks." },
+    namespace: { arity: [0, 1], flags: COMMON, usage: "task namespace [<namespace>]", purpose: "Read or replace the current Task namespace." },
+    compose: { arity: [0, 0], stdin: "compose", flags: { ...COMMON, actor: "value" }, usage: "task compose [--actor <actor>] -", purpose: "Admit Task documents independently; partial admission has no cross-file atomicity or rollback." },
 };
 export function isTaskAction(value) {
     return value !== undefined && Object.hasOwn(TASK_COMMAND_SPECS, value);
@@ -46,14 +46,14 @@ export function isTaskAction(value) {
 export function renderTaskHelp(action) {
     if (action !== undefined) {
         const spec = TASK_COMMAND_SPECS[action];
-        return withJsonAutomationHelp(`${spec.purpose}\n\n${usageLine(spec.usage)}`);
+        return `${spec.purpose}\n\n${usageLine(spec.usage)}`;
     }
-    return withJsonAutomationHelp([
+    return [
         "usage: keiyaku task <command> ...",
         "",
         "commands:",
         ...Object.values(TASK_COMMAND_SPECS).flatMap((spec) => spec.usage.split("\n").map((line) => `  ${line}`).concat(`    ${spec.purpose}`)),
-    ].join("\n"));
+    ].join("\n");
 }
 export function renderTaskUsage(action) {
     return usageLine(TASK_COMMAND_SPECS[action].usage);

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

@@ -1,4 +1,4 @@
-import { Repo } from "../index.js";
+import { Repo } from "../library/repo.js";
 import { type WorldRoot } from "../world.js";
 import { type ParsedCommand } from "./parse.js";
 export type CliCoordinates = Readonly<{
@@ -7,13 +7,17 @@ export type CliCoordinates = Readonly<{
     repo?: Repo;
     world: WorldRoot | null;
     candidateWorld: WorldRoot | null;
+    taskContext: Readonly<{
+        directory: string;
+        boundary: string;
+    }>;
     establishWorld: () => Promise<WorldRoot>;
 }>;
 export type CliCoordinateInput = Readonly<{
     processCwd?: string;
     cwd?: string;
     repo?: string;
+    gitPath?: string;
     command: ParsedCommand;
 }>;
-export declare function assertExplicitRepoUse(command: ParsedCommand, repo: string | undefined): void;
 export declare function resolveCliCoordinates(input: CliCoordinateInput): Promise<CliCoordinates>;

package/build/src/cli/coordinates.js

@@ -1,8 +1,8 @@
 import { realpath } from "node:fs/promises";
 import { resolve } from "node:path";
-import { NoGitWorldError, Repo } from "../index.js";
+import { NoGitWorldError, Repo } from "../library/repo.js";
 import { World, WorldError } from "../world.js";
-import { CliUsageError } from "./parse.js";
+import { CliUsageError, commandRepoPolicy } from "./parse.js";
 async function canonicalInvocationCwd(input) {
     try {
         return await realpath(input);
@@ -11,9 +11,12 @@ async function canonicalInvocationCwd(input) {
         throw new CliUsageError(`invocation cwd is not an existing directory: ${input}`);
     }
 }
-async function discoverRepoAt(coordinate) {
+async function discoverRepoAt(coordinate, gitPath) {
     try {
-        return { kind: "present", repo: await Repo.at({ path: coordinate }) };
+        return {
+            kind: "present",
+            repo: await Repo.at({ path: coordinate, ...(gitPath === undefined ? {} : { gitPath }) }),
+        };
     }
     catch (error) {
         if (error instanceof NoGitWorldError)
@@ -21,55 +24,6 @@ async function discoverRepoAt(coordinate) {
         throw error;
     }
 }
-function repoPolicy(command) {
-    switch (command.command) {
-        case "bind":
-        case "amend":
-        case "deliver":
-        case "review":
-        case "arc":
-        case "abandon":
-        case "audit":
-        case "reconcile":
-        case "show":
-        case "region":
-            return { use: "required", acceptsExplicit: true };
-        case "ls":
-            return { use: command.query.kind === "contracts" ? "required" : "none", acceptsExplicit: false };
-        case "status":
-        case "tell":
-            return { use: "optional", acceptsExplicit: false };
-        case "history":
-            return "contract" in command
-                ? { use: "required", acceptsExplicit: true }
-                : { use: "optional", acceptsExplicit: false };
-        case "fork":
-            return { use: "optional", acceptsExplicit: true };
-        case "wait":
-        case "kill": {
-            const contractSelector = command.akuma.some((selector) => selector.startsWith("kei/"));
-            return { use: contractSelector ? "required" : "optional", acceptsExplicit: contractSelector };
-        }
-        case "call":
-            return {
-                use: command.contract === undefined ? "none" : "required",
-                acceptsExplicit: command.contract !== undefined,
-            };
-        case "settings":
-        case "task":
-        case "install":
-            return { use: "none", acceptsExplicit: false };
-    }
-}
-function refuseUnusedRepo(command) {
-    if (command.command === "call")
-        throw new CliUsageError("--repo has no consumer without --contract");
-    throw new CliUsageError(`--repo has no consumer for ${command.command}`);
-}
-export function assertExplicitRepoUse(command, repo) {
-    if (repo !== undefined && !repoPolicy(command).acceptsExplicit)
-        refuseUnusedRepo(command);
-}
 function repoFor(use, discovery) {
     if (use === "none")
         return undefined;
@@ -106,19 +60,21 @@ 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);
+    const invocationRepo = await discoverRepoAt(cwd, input.gitPath);
     const selectedRepo = input.repo === undefined
         ? invocationRepo
-        : await discoverRepoAt(resolve(cwd, input.repo));
+        : await discoverRepoAt(resolve(cwd, input.repo), input.gitPath);
     const worldRepo = invocationRepo.kind === "present" ? invocationRepo.repo : undefined;
-    const repo = repoFor(repoPolicy(input.command).use, selectedRepo);
+    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 },
         establishWorld: world.establish,
     };
 }