@astrosheep/keiyaku 4.0.4 → 4.0.5

package/build/src/akuma-body.js

@@ -1,7 +1,12 @@
 import { runAkumaBody } from "./akuma/body.js";
 import { worldRootForAkumaPaths } from "./akuma/identity.js";
 import { executeKillAkuma, executeTellAkuma, executeWaitAkuma, } from "./library/fleet.js";
-function upstreamFor(launch) {
+import { requireBranchesToBeUpToDateFrom, worktreeHooksFrom, } from "./library/configuration.js";
+import { executeForwardedDeliver, executeForwardedReview, } from "./library/contract.js";
+import { Repo } from "./library/repo.js";
+import { settings } from "./settings.js";
+import { executeTaskMutation } from "./task/mutation.js";
+export function upstreamFor(launch, processConfiguration) {
     const path = worldRootForAkumaPaths(launch.paths);
     return {
         wait: async (input) => await executeWaitAkuma({
@@ -26,6 +31,54 @@ function upstreamFor(launch) {
                 service: result.results.map(({ id, evidence }) => ({ id, evidence })),
             };
         },
+        deliver: async (input) => {
+            const [repo, configuration] = await Promise.all([
+                Repo.at({
+                    path: input.repoRoot,
+                    ...(processConfiguration.gitPath === undefined ? {} : { gitPath: processConfiguration.gitPath }),
+                }),
+                settings({
+                    root: input.repoRoot,
+                    ...(processConfiguration.home === undefined ? {} : { home: processConfiguration.home }),
+                }),
+            ]);
+            return await executeForwardedDeliver({
+                repo,
+                contractId: input.contractId,
+                requester: input.requester,
+                ...(input.message === undefined ? {} : { message: input.message }),
+                includeDirty: input.includeDirty,
+                requireBranchesToBeUpToDate: requireBranchesToBeUpToDateFrom({ settings: configuration }),
+                hooks: worktreeHooksFrom({ settings: configuration }),
+                signal: input.signal,
+            });
+        },
+        review: async (input) => {
+            const [repo, configuration] = await Promise.all([
+                Repo.at({
+                    path: input.repoRoot,
+                    ...(processConfiguration.gitPath === undefined ? {} : { gitPath: processConfiguration.gitPath }),
+                }),
+                settings({
+                    root: input.repoRoot,
+                    ...(processConfiguration.home === undefined ? {} : { home: processConfiguration.home }),
+                }),
+            ]);
+            return await executeForwardedReview({
+                repo,
+                contractId: input.contractId,
+                requester: input.requester,
+                verdict: input.verdict,
+                ...(input.summary === undefined ? {} : { summary: input.summary }),
+                hooks: worktreeHooksFrom({ settings: configuration }),
+            });
+        },
+        task: async (input) => await executeTaskMutation({
+            world: input.world,
+            request: input.request,
+            requester: input.requester,
+            signal: input.signal,
+        }),
     };
 }
 await runAkumaBody(upstreamFor);

package/build/src/body/arc.js

@@ -1,15 +1,8 @@
-import { parseToAST } from "../markdown/parse.js";
-import { indexDocument, indexedHeadings, normalizeTitle, rawSlice, sectionContent, } from "../markdown/query.js";
+import { sectionContent } from "../markdown/query.js";
+import { decodeDocumentEnvelope } from "./envelope.js";
 function refusal(message) {
     throw new TypeError(message);
 }
-function nonblankRaw(document, node) {
-    return rawSlice(document, node.span).trim().length > 0;
-}
-function topLevelSections(document) {
-    return indexedHeadings(indexDocument(document), { level: 2 })
-        .filter((node) => node.type === "section");
-}
 function requiredProse(document, sections, name) {
     const section = sections.get(name);
     if (section === undefined)
@@ -20,31 +13,13 @@ function requiredProse(document, sections, name) {
     return value;
 }
 export function decodeArcDocument(source) {
-    const document = parseToAST(source);
-    if (document.frontmatter !== undefined)
-        refusal("arc document may not contain frontmatter");
-    const titles = indexedHeadings(indexDocument(document), { level: 1 })
-        .filter((node) => node.type === "section");
-    if (titles.length !== 1)
-        refusal("arc document requires exactly one H1 title");
-    const title = titles[0];
+    const { document, title, sections } = decodeDocumentEnvelope(source, "arc");
     if (title.title.trim().length === 0)
         refusal("arc title must be nonblank");
-    if (title.children.some((node) => nonblankRaw(document, node))) {
-        refusal("arc title may not contain content before the first H2 section");
-    }
-    const stray = document.children.filter((node) => node.type !== "section" && nonblankRaw(document, node));
-    if (stray.length > 0)
-        refusal("arc document contains content outside an H1 or H2 section");
-    const sections = new Map();
-    for (const section of topLevelSections(document)) {
-        const name = normalizeTitle(section.title);
-        if (sections.has(name))
-            refusal(`duplicate arc section '${section.title}'`);
+    for (const [name, section] of sections) {
         if (name !== "objective" && name !== "brief") {
             refusal(`arc document does not allow ## ${section.title}`);
         }
-        sections.set(name, section);
     }
     return {
         title: title.title,

package/build/src/body/decode.js

@@ -1,29 +1,12 @@
 import { mintDocumentKey, mintDocumentSegmentKey } from "./keys.js";
-import { parseToAST } from "../markdown/parse.js";
-import { directChildren, indexDocument, indexedHeadings, normalizeTitle, rawSlice, sectionContent, } from "../markdown/query.js";
+import { decodeDocumentEnvelope } from "./envelope.js";
+import { directChildren, normalizeTitle, rawSlice, sectionContent, } from "../markdown/query.js";
 import { CONTRACT_SECTIONS, RESERVED_SECTIONS } from "./shape.js";
 import { decodeRegion, RegionDocumentError } from "./region.js";
 import { decodeVerificationDeclarations, VerificationDocumentError } from "./verification.js";
 function refusal(message) {
     throw new TypeError(message);
 }
-function nonblankRaw(document, node) {
-    return rawSlice(document, node.span).trim().length > 0;
-}
-function topLevelSections(document) {
-    return indexedHeadings(indexDocument(document), { level: 2 })
-        .filter((node) => node.type === "section");
-}
-function indexedSections(document) {
-    const sections = new Map();
-    for (const section of topLevelSections(document)) {
-        const title = normalizeTitle(section.title);
-        if (sections.has(title))
-            refusal(`duplicate contract section '${section.title}'`);
-        sections.set(title, section);
-    }
-    return sections;
-}
 function requireSections(sections) {
     for (const [name, spec] of Object.entries(CONTRACT_SECTIONS)) {
         if (spec.required && !sections.has(name))
@@ -72,14 +55,6 @@ function criteria(document, section) {
         return { title, body };
     });
 }
-function rejectUnownedBytes(document, title) {
-    if (title.children.some((node) => nonblankRaw(document, node))) {
-        refusal("contract title may not contain content before the first H2 section");
-    }
-    const stray = document.children.filter((node) => node.type !== "section" && nonblankRaw(document, node));
-    if (stray.length > 0)
-        refusal("contract document contains content outside an H1 or H2 section");
-}
 function verification(document, section) {
     try {
         return decodeVerificationDeclarations(document, section);
@@ -91,22 +66,14 @@ function verification(document, section) {
     }
 }
 export function decodeContractDocument(source) {
-    let document;
+    let envelope;
     try {
-        document = parseToAST(source);
+        envelope = decodeDocumentEnvelope(source, "contract");
     }
     catch (error) {
         refusal(error instanceof Error ? error.message : String(error));
     }
-    if (document.frontmatter !== undefined)
-        refusal("contract document may not contain frontmatter");
-    const titles = indexedHeadings(indexDocument(document), { level: 1 })
-        .filter((node) => node.type === "section");
-    if (titles.length !== 1)
-        refusal("contract document requires exactly one H1 title");
-    const title = titles[0];
-    rejectUnownedBytes(document, title);
-    const sections = indexedSections(document);
+    const { document, title, sections, sectionNodes } = envelope;
     requireSections(sections);
     for (const name of RESERVED_SECTIONS) {
         if (sections.has(name))
@@ -131,7 +98,6 @@ export function decodeContractDocument(source) {
         verification: verificationSection === undefined ? [] : verification(document, verificationSection),
         extensions,
     };
-    const sectionNodes = topLevelSections(document);
     const segments = sectionNodes.map((section) => mintDocumentSegmentKey(document.source, section.span));
     return {
         ...body,

package/build/src/body/envelope.d.ts

@@ -0,0 +1,7 @@
+import type { DocumentNode, SectionNode } from "../markdown/types.js";
+export declare function decodeDocumentEnvelope(source: string, kind: "arc" | "contract"): Readonly<{
+    document: DocumentNode;
+    title: SectionNode;
+    sections: ReadonlyMap<string, SectionNode>;
+    sectionNodes: readonly SectionNode[];
+}>;

package/build/src/body/envelope.js

@@ -0,0 +1,37 @@
+import { parseToAST } from "../markdown/parse.js";
+import { indexDocument, indexedHeadings, normalizeTitle, rawSlice } from "../markdown/query.js";
+function refusal(message) {
+    throw new TypeError(message);
+}
+function nonblankRaw(document, node) {
+    return rawSlice(document, node.span).trim().length > 0;
+}
+function topLevelSections(document) {
+    return indexedHeadings(indexDocument(document), { level: 2 })
+        .filter((node) => node.type === "section");
+}
+export function decodeDocumentEnvelope(source, kind) {
+    const document = parseToAST(source);
+    if (document.frontmatter !== undefined)
+        refusal(`${kind} document may not contain frontmatter`);
+    const titles = indexedHeadings(indexDocument(document), { level: 1 })
+        .filter((node) => node.type === "section");
+    if (titles.length !== 1)
+        refusal(`${kind} document requires exactly one H1 title`);
+    const title = titles[0];
+    if (title.children.some((node) => nonblankRaw(document, node))) {
+        refusal(`${kind} title may not contain content before the first H2 section`);
+    }
+    if (document.children.some((node) => node.type !== "section" && nonblankRaw(document, node))) {
+        refusal(`${kind} document contains content outside an H1 or H2 section`);
+    }
+    const sectionNodes = topLevelSections(document);
+    const sections = new Map();
+    for (const section of sectionNodes) {
+        const name = normalizeTitle(section.title);
+        if (sections.has(name))
+            refusal(`duplicate ${kind} section '${section.title}'`);
+        sections.set(name, section);
+    }
+    return { document, title, sections, sectionNodes };
+}

package/build/src/cli/accepted.js

@@ -1,10 +1,11 @@
 import { KeiyakuRefused, KeiyakuRetry, } from "../index.js";
 function acceptedFacts(result) {
-    return result.facts.map((fact) => ({
-        contract: fact.contract,
-        entry: fact.entry,
-        kind: fact.kind,
-    }));
+    return result.facts.map((fact) => fact.kind === "reintegrated"
+        ? { contract: fact.contract, entry: fact.entry, kind: fact.kind, data: fact.data }
+        : { contract: fact.contract, entry: fact.entry, kind: fact.kind });
+}
+function attestationFor(facts, gate) {
+    return facts.findLast((fact) => fact.kind === "attestation" && fact.data.gate === gate);
 }
 function acceptedEnvelope(result, coordinate) {
     const contract = coordinate ?? result.facts[0]?.contract;
@@ -45,7 +46,7 @@ export function acceptedAmend(result, coordinate) {
 }
 export function acceptedDeliver(result, coordinate) {
     const value = result.value;
-    const attestation = result.facts.find((fact) => fact.kind === "attestation");
+    const attestation = attestationFor(result.facts, "verified");
     const verificationVerdict = attestation?.data.verdict ?? value.verificationReuse?.verdict;
     return {
         ...acceptedEnvelope(result, coordinate),
@@ -60,15 +61,22 @@ export function acceptedDeliver(result, coordinate) {
 }
 export function acceptedReview(result, coordinate) {
     const value = result.value;
-    const attestation = result.facts.find((fact) => fact.kind === "attestation");
-    if (attestation === undefined)
+    const reviewAttestation = attestationFor(result.facts, "reviewed");
+    if (reviewAttestation === undefined)
         throw new Error("accepted review is missing its attestation fact");
+    const verificationAttestation = attestationFor(result.facts, "verified");
+    const verificationVerdict = verificationAttestation?.data.verdict ?? value.verificationReuse?.verdict;
     return {
         ...acceptedEnvelope(result, coordinate),
         verb: "review",
-        verdict: attestation.data.verdict,
+        verdict: reviewAttestation.data.verdict,
+        ...(verificationVerdict === undefined ? {} : { verificationVerdict }),
+        ...(value.verification === undefined ? {} : { verification: value.verification }),
+        ...(value.verificationReuse === undefined ? {} : { verificationReuse: value.verificationReuse }),
         ...(value.placement === undefined ? {} : { placement: value.placement }),
         ...(value.workspace === undefined ? {} : { workspace: value.workspace }),
+        ...(value.cleanup === undefined ? {} : { cleanup: value.cleanup }),
+        ...(value.leak === undefined ? {} : { leak: value.leak }),
     };
 }
 export function acceptedArc(result, coordinate) {

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

@@ -83,11 +83,11 @@ export function renderAkumaUsage(action) {
     return usageLine(AKUMA_COMMAND_SPECS[action].usage);
 }
 export function parseAkumaCatalogPath(value) {
-    if (value === "aku/")
+    if (value === "aku" || value === "aku/")
         return { kind: "archetypes" };
     if (value === "aku/*/*")
         return { kind: "akuma" };
-    const match = /^aku\/(.+)\/$/u.exec(value);
+    const match = /^aku\/([^/]+)\/?$/u.exec(value);
     if (match === null)
         return null;
     return { kind: "akuma", archetype: archetypeName(match[1]) };

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

@@ -1,4 +1,4 @@
-export type ContractFlagKind = "boolean" | "value" | "repeat-value";
+export type ContractFlagKind = "boolean" | "value" | "raw-value" | "repeat-value";
 export type ContractCommandSpec = Readonly<{
     positional: "none" | "optional";
     stdin: "none" | "optional" | "required";
@@ -17,10 +17,10 @@ export declare const CONTRACT_COMMAND_SPECS: {
             readonly target: "value";
             readonly here: "boolean";
             readonly after: "repeat-value";
-            readonly gates: "value";
+            readonly gates: "raw-value";
             readonly json: "boolean";
         };
-        readonly usage: "bind [--task <task/...>] [--target <ref>] [--here] [--after <kei/...> ...] [--gates <name>] [--actor <actor>] [--json] -";
+        readonly usage: "bind [--task <task/...>] [--target <ref>] [--here] [--after <kei/...> ...] [--gates <name,...>] [--actor <actor>] [--json] -";
         readonly purpose: "Create one Contract from stdin Markdown.";
     };
     readonly amend: {
@@ -30,10 +30,10 @@ export declare const CONTRACT_COMMAND_SPECS: {
             readonly actor: "value";
             readonly after: "repeat-value";
             readonly "clear-after": "boolean";
-            readonly gates: "value";
+            readonly gates: "raw-value";
             readonly json: "boolean";
         };
-        readonly usage: "amend [<contract>|@<contract>] [--after <kei/...> ... | --clear-after] [--gates <name>] [--actor <actor>] [--json] [-]";
+        readonly usage: "amend [<contract>|@<contract>] [--after <kei/...> ... | --clear-after] [--gates <name,...>] [--actor <actor>] [--json] [-]";
         readonly purpose: "Amend one Contract's document operations or structured terms.";
     };
     readonly deliver: {
@@ -106,7 +106,7 @@ export declare const CONTRACT_COMMAND_SPECS: {
         readonly flags: {
             readonly json: "boolean";
         };
-        readonly 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]";
+        readonly 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]";
         readonly purpose: "List one identity directory.";
     };
     readonly audit: {

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

@@ -4,15 +4,15 @@ export const AMEND_MINIMAL_STDIN_HELP = [
     "  <complete replacement>",
 ].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." },
+    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>] [--json] -", 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>] [--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." },
+    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." },

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

@@ -1,4 +1,6 @@
 import { Tasks, } from "../../task/index.js";
+import { injectedBodyRequests, requestBodyTask } from "../../akuma/requests.js";
+import { decodeTaskMutationRequest } from "../../task/mutation.js";
 function value(command, name) {
     const item = command.flags[name];
     return typeof item === "string" ? item : undefined;
@@ -54,6 +56,82 @@ async function invokeUpdate(tasks, command, readStdin) {
         ...(addRelates === undefined ? {} : { addRelates }), ...(dropRelates === undefined ? {} : { dropRelates }),
     });
 }
+async function addMutationRequest(command, input) {
+    const selectedNamespace = namespace(value(command, "namespace"));
+    if (command.stdin === "document")
+        return { action: "task.addDocument", input: {
+                markdown: await input.readStdin(),
+                ...(selectedNamespace === undefined ? {} : { 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], ...(selectedNamespace === undefined ? {} : { 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) {
+    if (command.action === "add")
+        return await addMutationRequest(command, input);
+    if (command.action === "compose")
+        return { action: "task.compose", markdown: await input.readStdin() };
+    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 });
+        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 }) });
+    }
+}
 async function invokeRead(tasks, command) {
     const id = command.positionals[0];
     switch (command.action) {
@@ -97,15 +175,7 @@ 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) {
     if (isWorldObservation(command))
         return observeWorldRead(tasks, command);
     if (command.action === "show" || command.action === "tree")
@@ -138,3 +208,22 @@ export async function invokeTask(command, input) {
         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 requests = injectedBodyRequests();
+    if (requests !== null && forwardsMutation(command)) {
+        const request = validatedMutationRequest(await mutationRequest(command, input));
+        return await requestBodyTask({ directory: requests, world, request });
+    }
+    return await invokeLocalMutation(Tasks.of(world), command, input);
+}

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

@@ -13,6 +13,7 @@ export type CliCoordinateInput = Readonly<{
     processCwd?: string;
     cwd?: string;
     repo?: string;
+    gitPath?: string;
     command: ParsedCommand;
 }>;
 export declare function assertExplicitRepoUse(command: ParsedCommand, repo: string | undefined): void;

package/build/src/cli/coordinates.js

@@ -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)
@@ -106,10 +109,10 @@ 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 world = await resolveWorld(cwd, worldRepo);

package/build/src/cli/invoke.js

@@ -12,6 +12,8 @@ import { CliUsageError, renderCommandUsage } from "./parse.js";
 import { isBlankInput } from "./usage.js";
 import { canonicalContractSelector, contractFromInput, resolveContextualContract, resolveKanshiContract, } from "./selectors.js";
 import { resolveNamedAddress } from "../library/address.js";
+import { injectedBodyRequests } from "../akuma/requests.js";
+import { EMPTY_WORKTREE_HOOKS } from "../library/configuration.js";
 import { assertExplicitRepoUse, resolveCliCoordinates } from "./coordinates.js";
 import { BindDraftError, preserveBindDraft } from "./draft.js";
 async function readStdin() {
@@ -67,8 +69,8 @@ function consumeSettings(run) {
         throw error;
     }
 }
-function selectedGates(value, name) {
-    return consumeSettings(() => gatesFrom({ settings: value, ...(name === undefined ? {} : { name }) }));
+function selectedGates(value, names) {
+    return consumeSettings(() => gatesFrom({ settings: value, ...(names === undefined ? {} : { names }) }));
 }
 function selectedGitPolicy(value) {
     return consumeSettings(() => requireBranchesToBeUpToDateFrom({ settings: value }));
@@ -83,6 +85,14 @@ function actorFromEdge(actor, environment) {
     }
     return resolved;
 }
+function gitPathFromEdge(environment) {
+    const value = environment.KEIYAKU_GIT_PATH;
+    if (value === undefined)
+        return undefined;
+    if (value.trim().length === 0)
+        throw new CliUsageError("KEIYAKU_GIT_PATH requires a nonblank value");
+    return value;
+}
 async function selectContract(repo, selector, scope) {
     if (selector !== undefined && !selector.startsWith("@"))
         return contractFromInput(repo, selector);
@@ -162,10 +172,15 @@ async function invokeAudit(parsed, seat, requireBranchesToBeUpToDate) {
         hooks: seat.hooks,
     }), (result) => acceptedAudit(result, seat.id), { coordinate: seat.id });
 }
-async function invokeExisting({ parsed, repo, edge, scope, configuration, hooks }) {
+async function existingSeat({ parsed, repo, edge, scope, hooks }) {
     const { id, contract } = await selectContract(repo, parsed.contract, scope);
     const actor = actorFromEdge(parsed.actor, edge.environment);
-    const seat = { contract, id, ...(actor === undefined ? {} : { actor }), hooks };
+    return { contract, id, ...(actor === undefined ? {} : { actor }), hooks };
+}
+async function invokeExisting(input) {
+    const { parsed, repo, edge, configuration, hooks } = input;
+    const seat = await existingSeat(input);
+    const { id, contract, actor } = seat;
     switch (parsed.command) {
         case "amend": {
             const markdown = parsed.stdin === true ? await edge.readStdin() : undefined;
@@ -355,10 +370,13 @@ async function invokeContractHistory(repo, contract) {
 }
 // eslint-disable-next-line complexity -- command dispatch keeps the CLI's existing boundary in one place.
 async function invokeParsed(invocation, runtime) {
+    const environment = runtime.environment ?? process.env;
+    const gitPath = gitPathFromEdge(environment);
     const coordinates = await resolveCliCoordinates({
         ...(runtime.cwd === undefined ? {} : { processCwd: runtime.cwd }),
         ...(invocation.cwd === undefined ? {} : { cwd: invocation.cwd }),
         ...(invocation.repo === undefined ? {} : { repo: invocation.repo }),
+        ...(gitPath === undefined ? {} : { gitPath }),
         command: invocation.command,
     });
     const { cwd, cwdSource, repo, world, candidateWorld, establishWorld } = coordinates;
@@ -410,6 +428,12 @@ async function invokeParsed(invocation, runtime) {
     if (parsed.command === "region")
         return invokeRegion(parsed, world, repo);
     const scope = cwd;
+    if ((parsed.command === "deliver" || parsed.command === "review") && injectedBodyRequests() !== null) {
+        const seat = await existingSeat({ parsed, repo, edge, scope, hooks: EMPTY_WORKTREE_HOOKS });
+        return parsed.command === "deliver"
+            ? await invokeDeliver(parsed, seat, false)
+            : await invokeReview(parsed, seat, edge.readStdin);
+    }
     const configuration = await settingsAt(world ?? undefined, home);
     const hooks = consumeSettings(() => worktreeHooksFrom({ settings: configuration }));
     if (parsed.command === "show") {

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

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