@astrosheep/keiyaku 2.9.2 → 2.9.4

package/build/artifact-directories.js

@@ -0,0 +1,22 @@
+import * as path from "path";
+export const KEIYAKU_DRAFT_DIR = path.join(".keiyaku", "draft");
+export const RESPONSE_HISTORY_DIR = path.join(".keiyaku", "response");
+export const KEIYAKU_ARTIFACT_DIRS = [KEIYAKU_DRAFT_DIR, RESPONSE_HISTORY_DIR];
+function formatArtifactDirectory(directory) {
+    return `\`${directory}/\``;
+}
+export function formatArtifactDirectories(directories) {
+    const formatted = directories.map(formatArtifactDirectory);
+    if (formatted.length === 0)
+        return "";
+    if (formatted.length === 1)
+        return formatted[0];
+    if (formatted.length === 2)
+        return `${formatted[0]} and ${formatted[1]}`;
+    return `${formatted.slice(0, -1).join(", ")}, and ${formatted[formatted.length - 1]}`;
+}
+function buildArtifactNotice(directory) {
+    return `Auto-generated artifact. Add ${formatArtifactDirectory(directory)} to \`.gitignore\` if you do not want it tracked.`;
+}
+export const DRAFT_ARTIFACT_NOTICE = buildArtifactNotice(KEIYAKU_ARTIFACT_DIRS[0]);
+export const RESPONSE_ARTIFACT_NOTICE = buildArtifactNotice(KEIYAKU_ARTIFACT_DIRS[1]);

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

@@ -1,4 +1,4 @@
-import { missingSubcommandError } from "../../../help.js";
+import { missingSubcommandError } from "../../../missing-subcommand.js";
 export const handler = async () => {
     throw missingSubcommandError("akuma", ["ls", "view"]);
 };

package/build/cli/commands/akuma/view/handler.js

@@ -2,12 +2,12 @@ import { FlowError } from "../../../../flow-error.js";
 import { assertSettingsKnobUsable } from "../../../../config/settings/disease.js";
 import { loadKeiyakuSettings } from "../../../../config/settings/loader.js";
 import { loadAkumaCatalog } from "../../../../config/akuma-loader.js";
-import { readProjectionStatusBoard } from "../../../../core/projection-status.js";
+import { readProjectionStatusBoard } from "../../../../core/projection/index.js";
 import { isResponseArtifactId } from "../../../../core/response-artifact-id.js";
 import { textResponse } from "../../../render/shared.js";
 import { renderProjectionStatusSection } from "../../../render/status.js";
 import { projectDirectory } from "../../shared.js";
-import { renderAkumaShow } from "../../akuma.js";
+import { renderAkumaShow, renderAkumaView } from "../../akuma.js";
 const NONTERMINAL_PROJECTION_STATES = new Set([
     "minting",
     "startup-timeout",
@@ -28,7 +28,8 @@ export const handler = async (_stdin, flags, _signal, positional) => {
     assertSettingsKnobUsable(loaded, "default");
     assertSettingsKnobUsable(loaded, "reviewer");
     const profile = renderAkumaShow(await loadAkumaCatalog(cwd), loaded.providerInstances, loaded.knobs, name).trimEnd();
-    const rows = (readProjectionStatusBoard(cwd, Date.now(), { showAll: true })?.rows ?? []).filter((row) => row.akuma === name && NONTERMINAL_PROJECTION_STATES.has(row.state));
+    const projectionStatus = await readProjectionStatusBoard(cwd, Date.now(), { showAll: true });
+    const rows = (projectionStatus?.rows ?? []).filter((row) => row.akuma === name && NONTERMINAL_PROJECTION_STATES.has(row.state));
     const projections = renderProjectionStatusSection({ rows }).trimEnd();
-    return textResponse(projections ? `${profile}\n\n${projections}` : profile);
+    return textResponse(renderAkumaView(profile, projections));
 };

package/build/cli/commands/akuma.js

@@ -140,6 +140,12 @@ export function renderAkumaList(catalog, providerInstances, settings) {
     }
     return lines.join("\n");
 }
+/** Compose profile inspection with an optional nonterminal projection section. */
+export function renderAkumaView(profile, projectionsSection) {
+    return projectionsSection ? `${profile}
+
+${projectionsSection}` : profile;
+}
 export function renderAkumaShow(catalog, providerInstances, settings, name) {
     const candidate = catalog.selected[name];
     if (candidate === undefined) {

package/build/cli/commands/contract/amend/handler.js

@@ -1,10 +1,16 @@
 import { amendKeiyaku } from "../../../../core/amend.js";
-import { buildAmendInput } from "../../../../core/command-io.js";
+import { resolveExistingContractAddress } from "../../../../core/addressing.js";
+import { buildAmendInput } from "../../../../core/amend.js";
 import { buildAmendResponse } from "../../../render/arc.js";
 import { renderCoreResult } from "../../../render/shared.js";
 import { effectiveDirectory, repositoryDirectory } from "../../shared.js";
 export const handler = async (stdin, flags) => {
     const parsed = buildAmendInput(stdin, effectiveDirectory(flags), flags.contractId, flags.contractAddressSource);
     const cwd = await repositoryDirectory(flags, "amend");
-    return renderCoreResult(amendKeiyaku({ ...parsed, cwd }), buildAmendResponse);
+    const address = await resolveExistingContractAddress(cwd, flags.contractId, flags.contractAddressSource, effectiveDirectory(flags));
+    return renderCoreResult(amendKeiyaku({
+        ...parsed,
+        cwd,
+        address,
+    }), buildAmendResponse);
 };

package/build/cli/commands/contract/arc/handler.js

@@ -1,9 +1,15 @@
 import { arcKeiyaku, buildArcInput } from "../../../../core/arc.js";
+import { resolveExistingContractAddress } from "../../../../core/addressing.js";
 import { buildArcResponse } from "../../../render/arc.js";
 import { renderCoreResult } from "../../../render/shared.js";
 import { effectiveDirectory, repositoryDirectory } from "../../shared.js";
 export const handler = async (stdin, flags) => {
     const parsed = buildArcInput(stdin, effectiveDirectory(flags), flags.waivePaths, flags.contractId, flags.contractAddressSource);
     const cwd = await repositoryDirectory(flags, "arc");
-    return renderCoreResult(arcKeiyaku({ ...parsed, cwd }), buildArcResponse);
+    const address = await resolveExistingContractAddress(cwd, flags.contractId, flags.contractAddressSource, effectiveDirectory(flags));
+    return renderCoreResult(arcKeiyaku({
+        ...parsed,
+        cwd,
+        address,
+    }), buildArcResponse);
 };

package/build/cli/commands/contract/bind/handler.js

@@ -1,9 +1,9 @@
 import { bindContract } from "../../../../core/bind.js";
-import { defaultActorClock } from "../../../../core/command-io.js";
+import { defaultActorClock } from "../../../../core/outcome-base.js";
 import { writeDraftArtifact } from "../../../draft-artifact.js";
 import { buildBindDraftResponse, buildBindResponse, textResponse } from "../../../render/shared.js";
 import { repositoryDirectory } from "../../shared.js";
-export const handler = async (stdin, flags) => {
+export const handler = async (stdin, flags, signal) => {
     if (flags.dryRun) {
         return textResponse(stdin);
     }
@@ -14,7 +14,8 @@ export const handler = async (stdin, flags) => {
     const result = await bindContract({
         cwd, draft: stdin, ...defaultActorClock(), workspace: "worktree",
         after: flags.after ?? [], exclusive: flags.exclusive,
-        ...(flags.bindTaskId === undefined ? {} : { taskId: flags.bindTaskId }),
+        ...(flags.bindTaskIds === undefined ? {} : { taskIds: flags.bindTaskIds }),
+        signal,
         onProgress: (line) => {
             process.stdout.write(`${line}\n`);
         },

package/build/cli/commands/contract/bind/meta.js

@@ -2,14 +2,14 @@ export const meta = {
     command: "bind",
     summary: "Create a contract ledger and workspace files",
     usage: [
-        "keiyaku bind [-C|--cwd DIR] [--repo DIR] [--task ID] < keiyaku.md",
-        "keiyaku bind [-C|--cwd DIR] [--repo DIR] [--task ID] --place NAME --objective TEXT --scope GLOB --checks CHECK [--dry-run]",
+        "keiyaku bind [-C|--cwd DIR] [--repo DIR] [--task ID]... <<'KEIYAKU'",
+        "keiyaku bind [-C|--cwd DIR] [--repo DIR] [--task ID]... --place NAME --objective TEXT --scope GLOB --checks CHECK [--dry-run]",
     ],
     stdin: "optional",
     flags: ["cwd", "repo", "after", "exclusive", "draft-only", "place", "objective", "scope", "checks", "task", "dry-run"],
     // contract is parseable only so the mouth can reject it with bind-specific copy.
     parseFlags: ["cwd", "repo", "contract", "after", "exclusive", "draft-only", "place", "objective", "scope", "checks", "task", "dry-run"],
-    purpose: "Bind a Keiyaku from a contract draft.",
+    purpose: "Bind a Keiyaku from contract Markdown on stdin.",
     input: [
         "# <name>",
         "",
@@ -17,14 +17,41 @@ export const meta = {
         "<what the commission should accomplish>",
         "",
         "## Scope",
-        "- <glob>",
+        "- <pattern>",
         "",
         "## Checks",
-        "- <acceptance check>",
+        "- <verification>",
     ],
     notes: [
-        "bind creates a commission and does not accept @addr or --contract.",
-        "Use either stdin Markdown or all four domain flags; they cannot be combined.",
+        "bind creates a contract and does not accept @addr or --contract.",
+        "Primary form is stdin Markdown (full document below).",
+        "With --task, title and body supply name/objective defaults; stdin may send only the missing sections and any present section overrides the task default.",
+        "Domain flags remain available as a full-document alternative; they cannot mix with stdin Markdown.",
+    ],
+    examples: [
+        [
+            "keiyaku bind <<'KEIYAKU'",
+            "# <name>",
+            "",
+            "## Objective",
+            "<what the commission should accomplish>",
+            "",
+            "## Scope",
+            "- <pattern>",
+            "",
+            "## Checks",
+            "- <verification>",
+            "KEIYAKU",
+        ].join("\n"),
+        [
+            "keiyaku bind --task fix-flaky-pump <<'KEIYAKU'",
+            "## Scope",
+            "- <pattern>",
+            "",
+            "## Checks",
+            "- <verification>",
+            "KEIYAKU",
+        ].join("\n"),
     ],
     completionRank: 0,
 };

package/build/cli/commands/contract/forfeit/handler.js

@@ -1,11 +1,11 @@
-import { resolveContractAddress, withResolvedAddress } from "../../../../core/addressing.js";
-import { defaultActorClock } from "../../../../core/command-io.js";
+import { resolveExistingContractAddress, withResolvedAddress } from "../../../../core/addressing.js";
+import { defaultActorClock } from "../../../../core/outcome-base.js";
 import { forfeitContractCommand } from "../../../../core/forfeit.js";
 import { buildForfeitResponse } from "../../../render/shared.js";
-import { repositoryDirectory } from "../../shared.js";
+import { effectiveDirectory, repositoryDirectory } from "../../shared.js";
 export const handler = async (_stdin, flags) => {
     const cwd = await repositoryDirectory(flags, "forfeit");
-    const address = await resolveContractAddress(cwd, flags.contractId, flags.contractAddressSource);
+    const address = await resolveExistingContractAddress(cwd, flags.contractId, flags.contractAddressSource, effectiveDirectory(flags));
     return await withResolvedAddress(address, async () => buildForfeitResponse({
         ...await forfeitContractCommand({ cwd, contractId: address.binding.commissionId, ...defaultActorClock(), note: flags.reason }),
         address,

package/build/cli/commands/contract/log/handler.js

@@ -1,10 +1,10 @@
-import { resolveContractAddress, withResolvedAddress } from "../../../../core/addressing.js";
+import { resolveExistingContractAddress, withResolvedAddress } from "../../../../core/addressing.js";
 import { readContractLog } from "../../../../core/log.js";
 import { buildLogResponse } from "../../../render/misc.js";
-import { repositoryDirectory } from "../../shared.js";
+import { effectiveDirectory, repositoryDirectory } from "../../shared.js";
 export const handler = async (_stdin, flags) => {
     const cwd = await repositoryDirectory(flags, "log");
-    const address = await resolveContractAddress(cwd, flags.contractId, flags.contractAddressSource);
+    const address = await resolveExistingContractAddress(cwd, flags.contractId, flags.contractAddressSource, effectiveDirectory(flags));
     return await withResolvedAddress(address, async () => {
         const result = await readContractLog({ cwd, contractId: address.binding.commissionId });
         return buildLogResponse({ ...result, address });

package/build/cli/commands/contract/petition/handler.js

@@ -1,16 +1,14 @@
 import { FlowError } from "../../../../flow-error.js";
-import { resolveContractAddress, withResolvedAddress } from "../../../../core/addressing.js";
-import { buildPetitionClaimInput } from "../../../../core/petition.js";
-import { previewPetition } from "../../../../core/petition-preview.js";
-import { petitionKeiyaku } from "../../../../core/petition-run.js";
+import { resolveExistingContractAddress, withResolvedAddress } from "../../../../core/addressing.js";
+import { buildPetitionClaimInput, petitionKeiyaku, previewPetition, } from "../../../../core/settlement/index.js";
 import { buildPetitionClaimResponse, buildPetitionPreviewResponse } from "../../../render/petition.js";
-import { repositoryDirectory } from "../../shared.js";
+import { effectiveDirectory, repositoryDirectory } from "../../shared.js";
 export const handler = async (stdin, flags, signal) => {
     if (flags.json && !flags.dryRun) {
         throw new FlowError("EMPTY_PARAM", "petition --json requires --dry-run");
     }
     const cwd = await repositoryDirectory(flags, "petition");
-    const address = await resolveContractAddress(cwd, flags.contractId, flags.contractAddressSource);
+    const address = await resolveExistingContractAddress(cwd, flags.contractId, flags.contractAddressSource, effectiveDirectory(flags));
     return await withResolvedAddress(address, async () => {
         const input = buildPetitionClaimInput({ cwd, contractId: address.binding.commissionId, stdin, signal, waivePaths: flags.waivePaths });
         if (flags.dryRun) {

package/build/cli/commands/contract/renew/handler.js

@@ -1,10 +1,24 @@
-import { resolveContractAddress } from "../../../../core/addressing.js";
-import { renewKeiyaku } from "../../../../core/renew.js";
-import { buildRenewResponse } from "../../../render/arc.js";
+import { resolveContractAddress, resolveExistingContractAddress } from "../../../../core/addressing.js";
+import { abortRenewKeiyaku, continueRenewKeiyaku, renewKeiyaku } from "../../../../core/renew.js";
+import { buildRenewAbortResponse, buildRenewResponse } from "../../../render/arc.js";
 import { renderCoreResult } from "../../../render/shared.js";
-import { repositoryDirectory } from "../../shared.js";
+import { effectiveDirectory, repositoryDirectory } from "../../shared.js";
 export const handler = async (_stdin, flags) => {
     const cwd = await repositoryDirectory(flags, "renew");
-    const address = await resolveContractAddress(cwd, flags.contractId, flags.contractAddressSource);
-    return renderCoreResult(renewKeiyaku({ cwd, address, waivePaths: flags.waivePaths }), buildRenewResponse);
+    const resolveAddress = flags.renewContinue || flags.renewAbort
+        ? resolveContractAddress
+        : resolveExistingContractAddress;
+    const address = await resolveAddress(cwd, flags.contractId, flags.contractAddressSource, effectiveDirectory(flags));
+    if (flags.renewContinue) {
+        return renderCoreResult(continueRenewKeiyaku({ cwd, address, waivePaths: flags.waivePaths }), buildRenewResponse);
+    }
+    if (flags.renewAbort) {
+        return renderCoreResult(abortRenewKeiyaku({ cwd, address }), buildRenewAbortResponse);
+    }
+    return renderCoreResult(renewKeiyaku({
+        cwd,
+        address,
+        waivePaths: flags.waivePaths,
+        resolveConflicts: flags.renewResolve,
+    }), buildRenewResponse);
 };

package/build/cli/commands/contract/renew/meta.js

@@ -2,16 +2,17 @@ export const meta = {
     command: "renew",
     summary: "Rewrite delivery onto the current base",
     usage: [
-        "keiyaku renew [-C|--cwd DIR] [--repo DIR] [--contract ADDR] [--waive PATH]",
-        "keiyaku @<id> renew [-C|--cwd DIR] [--repo DIR] [--waive PATH]",
+        "keiyaku renew [-C|--cwd DIR] [--repo DIR] [--contract ADDR] [--waive PATH] [--resolve]",
+        "keiyaku @<id> renew --continue [--waive PATH]",
+        "keiyaku @<id> renew --abort",
     ],
     stdin: "none",
-    flags: ["cwd", "repo", "contract", "waive"],
+    flags: ["cwd", "repo", "contract", "waive", "resolve", "continue", "abort"],
     purpose: "Capture receipts, rewrite delivery onto the default branch, then seal the current a0 or open explicit arc and record the renewal.",
     notes: [
         "After an explicit arc closes, refuses loose commits until another arc is open.",
         "Refuses while an Akuma is in flight.",
-        "Conflicts restore the worktree without ledger writes.",
+        "Ordinary conflicts restore the delivery branch and worktree without ledger writes; --resolve opens an owned session for --continue or --abort.",
     ],
     completionRank: 9,
 };

package/build/cli/commands/metadata.js

@@ -0,0 +1,58 @@
+import { meta as bindMeta } from "./contract/bind/meta.js";
+import { meta as arcMeta } from "./contract/arc/meta.js";
+import { meta as callMeta } from "./projection/call/meta.js";
+import { meta as reviveMeta } from "./projection/revive/meta.js";
+import { meta as waitMeta } from "./projection/wait/meta.js";
+import { meta as tellMeta } from "./projection/tell/meta.js";
+import { meta as killMeta } from "./projection/kill/meta.js";
+import { meta as logMeta } from "./contract/log/meta.js";
+import { meta as akumaMeta } from "./akuma/akuma/meta.js";
+import { meta as akumaLsMeta } from "./akuma/list/meta-ls.js";
+import { meta as akumaViewMeta } from "./akuma/view/meta.js";
+import { meta as skillsMeta } from "./skills/skills/meta.js";
+import { meta as skillsInstallMeta } from "./skills/install/meta.js";
+import { meta as amendMeta } from "./contract/amend/meta.js";
+import { meta as renewMeta } from "./contract/renew/meta.js";
+import { meta as petitionMeta } from "./contract/petition/meta.js";
+import { meta as forfeitMeta } from "./contract/forfeit/meta.js";
+import { meta as guideMeta } from "./system/guide/meta.js";
+import { meta as completionMeta } from "./system/completion/meta.js";
+import { meta as statusMeta } from "./projection/status/meta.js";
+import { meta as taskMeta } from "./task/task/meta.js";
+import { meta as taskAddMeta } from "./task/add/meta.js";
+import { meta as taskShowMeta } from "./task/show/meta.js";
+import { meta as taskLsMeta } from "./task/ls/meta.js";
+import { meta as taskStartMeta } from "./task/start/meta.js";
+import { meta as taskStopMeta } from "./task/stop/meta.js";
+import { meta as taskDoneMeta } from "./task/done/meta.js";
+import { meta as taskDropMeta } from "./task/drop/meta.js";
+import { meta as taskUpdateMeta } from "./task/update/meta.js";
+import { meta as taskDoctorMeta } from "./task/doctor/meta.js";
+import { meta as dumpEnvMeta } from "./system/dump-env/meta.js";
+export const COMMAND_METADATA_ORDER = [
+    "bind", "arc", "call", "revive", "wait", "tell", "kill", "log",
+    "akuma", "akuma ls", "akuma view", "skills", "skills install", "amend",
+    "renew", "petition", "forfeit", "guide", "completion", "status", "task",
+    "task add", "task show", "task ls", "task start", "task stop", "task done",
+    "task drop", "task update", "task doctor", "dump-env",
+];
+const COMMAND_METADATA = [
+    bindMeta, arcMeta, callMeta, reviveMeta, waitMeta, tellMeta, killMeta, logMeta,
+    akumaMeta, akumaLsMeta, akumaViewMeta, skillsMeta, skillsInstallMeta, amendMeta,
+    renewMeta, petitionMeta, forfeitMeta, guideMeta, completionMeta, statusMeta,
+    taskMeta, taskAddMeta, taskShowMeta, taskLsMeta, taskStartMeta, taskStopMeta,
+    taskDoneMeta, taskDropMeta, taskUpdateMeta, taskDoctorMeta, dumpEnvMeta,
+];
+export const CLI_COMMAND_METADATA = Object.fromEntries(COMMAND_METADATA.map((meta) => [meta.command, meta]));
+export function getCommandMetadata(command) {
+    return CLI_COMMAND_METADATA[command];
+}
+export function allCommandMetadata() {
+    return COMMAND_METADATA_ORDER.map((command) => CLI_COMMAND_METADATA[command]);
+}
+export function commandParseOrder() {
+    return [...COMMAND_METADATA_ORDER].sort((a, b) => {
+        const tokenDelta = b.split(" ").length - a.split(" ").length;
+        return tokenDelta !== 0 ? tokenDelta : COMMAND_METADATA_ORDER.indexOf(a) - COMMAND_METADATA_ORDER.indexOf(b);
+    });
+}

package/build/cli/commands/projection/call/handler.js

@@ -1,6 +1,6 @@
 import { runCallAndPersist } from "../../../../core/call-persist.js";
-import { projectionDir } from "../../../../core/projection-core.js";
-import { waitForProjection } from "../../../../core/projection-wait.js";
+import { projectionDir } from "../../../../core/projection/index.js";
+import { waitForProjection } from "../../../../core/projection/index.js";
 import { buildCallResponse, renderAdoptedLaunchReceipt } from "../../../render/call.js";
 import { buildWaitResponse } from "../../../render/wait.js";
 import { buildCallInput } from "../../shared.js";
@@ -12,8 +12,8 @@ export const handler = async (stdin, flags, signal) => {
         signal,
         ...(!flags.detach
             ? {
-                onLaunch: ({ address, projection }) => {
-                    process.stdout.write(`${renderAdoptedLaunchReceipt(address, projection.id, projection.alias, projection.previousAliasTarget)}\n`);
+                onLaunch: ({ address, projection, akumaName }) => {
+                    process.stdout.write(`${renderAdoptedLaunchReceipt(address, projection.id, projection.alias, projection.previousAliasTarget, akumaName)}\n`);
                 },
             }
             : {}),
@@ -25,8 +25,9 @@ export const handler = async (stdin, flags, signal) => {
         const projectionRoot = outcome.result.address.repo.kind === "repository"
             ? outcome.result.address.repo.stableRoot
             : flags.cwd ?? process.cwd();
+        const projectionDirectory = await projectionDir(projectionRoot, projection.id);
         return buildWaitResponse(projection.id, await waitForProjection({
-            projectionDirectory: projectionDir(projectionRoot, projection.id),
+            projectionDirectory,
             timeoutMs: flags.timeoutMs,
             signal,
         }), { alias: projection.alias });

package/build/cli/commands/projection/kill/handler.js

@@ -1,37 +1,21 @@
 import { FlowError } from "../../../../flow-error.js";
-import { resolveContractAddress, withResolvedAddress, } from "../../../../core/addressing.js";
-import { projectionDir } from "../../../../core/projection-core.js";
-import { killProjectionGeneration } from "../../../../core/projection-kill.js";
-import { waitForProjection } from "../../../../core/projection-wait.js";
-import { resolveProjectionAddress } from "../../../projection-address.js";
-import { textResponse } from "../../../render/shared.js";
+import { killProjectionGeneration } from "../../../../core/projection/index.js";
+import { waitForProjection } from "../../../../core/projection/index.js";
+import { buildKillAcceptedResponse, buildKillAlreadyClosedResponse } from "../../../render/kill.js";
 import { buildWaitResponse } from "../../../render/wait.js";
-import { projectDirectory, repositoryDirectory } from "../../shared.js";
-export const handler = async (_stdin, flags, signal, positional) => {
-    const cwd = flags.contractId
-        ? await repositoryDirectory(flags, "kill contract addressing")
-        : await projectDirectory(flags, "kill");
+import { resolveProjectionCommandTarget, runProjectionCommand, } from "../shared.js";
+export const handler = async (_stdin, flags, signal, positional) => runProjectionCommand(flags, "kill", async (ctx) => {
     const [projectionAddress] = positional;
     if (!projectionAddress)
         throw new FlowError("EMPTY_PARAM", "kill requires a projection address");
-    const address = flags.contractId ? await resolveContractAddress(cwd, flags.contractId, flags.contractAddressSource) : undefined;
-    const operation = async () => {
-        const projection = await resolveProjectionAddress({
-            cwd,
-            address: projectionAddress,
-            scope: address,
-            verb: "kill",
-        });
-        const directory = projectionDir(cwd, projection.id);
-        const result = killProjectionGeneration(directory);
-        if (result.status === "already-closed") {
-            return textResponse(`· ${projection.id} already closed`);
-        }
-        if (flags.timeoutMs === undefined) {
-            return textResponse(`✓ kill ${projection.id}\n» keiyaku wait ${projection.id}`);
-        }
-        // Accepted with --wait: no acceptance receipt or address preamble.
-        return buildWaitResponse(projection.id, await waitForProjection({ projectionDirectory: directory, timeoutMs: flags.timeoutMs, signal }), { alias: projection.alias });
-    };
-    return address ? await withResolvedAddress(address, operation) : await operation();
-};
+    const projection = await resolveProjectionCommandTarget(ctx, projectionAddress, "kill");
+    const result = killProjectionGeneration(projection.directory);
+    if (result.status === "already-closed") {
+        return buildKillAlreadyClosedResponse(projection.id);
+    }
+    if (flags.timeoutMs === undefined) {
+        return buildKillAcceptedResponse(projection.id);
+    }
+    // Accepted with --wait: no acceptance receipt or address preamble.
+    return buildWaitResponse(projection.id, await waitForProjection({ projectionDirectory: projection.directory, timeoutMs: flags.timeoutMs, signal }), { alias: projection.alias });
+});

package/build/cli/commands/projection/shared.js

@@ -0,0 +1,28 @@
+import { resolveContractAddress, withResolvedAddress, } from "../../../core/addressing.js";
+import { projectionDir } from "../../../core/projection/index.js";
+import { resolveProjectionAddress, } from "../../projection-address.js";
+import { projectDirectory, repositoryDirectory } from "../shared.js";
+/** Resolve cwd + optional contract address, then run the verb under that carrier. */
+export async function runProjectionCommand(flags, verb, operation) {
+    const cwd = flags.contractId
+        ? await repositoryDirectory(flags, `${verb} contract addressing`)
+        : await projectDirectory(flags, verb);
+    const address = flags.contractId
+        ? await resolveContractAddress(cwd, flags.contractId, flags.contractAddressSource)
+        : undefined;
+    const run = () => operation({ cwd, address });
+    return address ? await withResolvedAddress(address, run) : await run();
+}
+export function resolveProjectionCommandAddress(ctx, projectionAddress, verb) {
+    return resolveProjectionAddress({
+        cwd: ctx.cwd,
+        address: projectionAddress,
+        scope: ctx.address,
+        verb,
+    });
+}
+export async function resolveProjectionCommandTarget(ctx, projectionAddress, verb) {
+    const projection = await resolveProjectionCommandAddress(ctx, projectionAddress, verb);
+    const directory = await projectionDir(ctx.cwd, projection.id);
+    return { ...projection, directory };
+}

package/build/cli/commands/projection/status/handler.js

@@ -1,6 +1,6 @@
 import { readKanshiBoard } from "../../../../core/status/board.js";
 import { normalizeTargetRef } from "../../../../core/target-ref.js";
-import { isProjectionId } from "../../../../core/projection-core.js";
+import { isProjectionId } from "../../../../core/projection/index.js";
 import { FlowError } from "../../../../flow-error.js";
 import { renderProjectionFilteredStatus, renderStatusBoard } from "../../../render/status.js";
 import { textResponse } from "../../../render/shared.js";

package/build/cli/commands/projection/tell/handler.js

@@ -1,36 +1,20 @@
 import { FlowError } from "../../../../flow-error.js";
-import { resolveContractAddress, withResolvedAddress, } from "../../../../core/addressing.js";
-import { projectionDir, writeInboxTell } from "../../../../core/projection-core.js";
-import { assertTellEffortSupported, tellProjection } from "../../../../core/projection-wake.js";
-import { waitForProjection } from "../../../../core/projection-wait.js";
-import { resolveProjectionAddress } from "../../../projection-address.js";
+import { assertTellEffortSupported, tellProjection, writeInboxTell } from "../../../../core/projection/index.js";
+import { waitForProjection } from "../../../../core/projection/index.js";
 import { prependAddressReceipt } from "../../../render/address.js";
-import { textResponse } from "../../../render/shared.js";
+import { buildSilentTellResponse } from "../../../render/tell.js";
 import { buildWaitResponse } from "../../../render/wait.js";
-import { projectDirectory, repositoryDirectory } from "../../shared.js";
-export const handler = async (body, flags, signal, positional) => {
-    const cwd = flags.contractId
-        ? await repositoryDirectory(flags, "tell contract addressing")
-        : await projectDirectory(flags, "tell");
+import { resolveProjectionCommandTarget, runProjectionCommand, } from "../shared.js";
+export const handler = async (body, flags, signal, positional) => runProjectionCommand(flags, "tell", async (ctx) => {
     const projectionAddress = positional[0];
     if (!projectionAddress)
         throw new FlowError("EMPTY_PARAM", "tell requires a projection address and message");
-    const address = flags.contractId ? await resolveContractAddress(cwd, flags.contractId, flags.contractAddressSource) : undefined;
-    const operation = async () => {
-        const projection = await resolveProjectionAddress({
-            cwd,
-            address: projectionAddress,
-            scope: address,
-            verb: "tell",
-        });
-        const directory = projectionDir(cwd, projection.id);
-        assertTellEffortSupported(directory, flags.effort);
-        // Mailbox first: do not inspect phase before this immutable write.
-        writeInboxTell(directory, body, Date.now(), { effort: flags.effort });
-        await tellProjection(directory, flags.effort);
-        if (flags.timeoutMs === undefined)
-            return textResponse("");
-        return prependAddressReceipt(buildWaitResponse(projection.id, await waitForProjection({ projectionDirectory: directory, timeoutMs: flags.timeoutMs, signal }), { alias: projection.alias }), address, { projectionId: projection.id, projectionAlias: projection.alias });
-    };
-    return address ? await withResolvedAddress(address, operation) : await operation();
-};
+    const projection = await resolveProjectionCommandTarget(ctx, projectionAddress, "tell");
+    assertTellEffortSupported(projection.directory, flags.effort);
+    // Mailbox first: do not inspect phase before this immutable write.
+    writeInboxTell(projection.directory, body, Date.now(), { effort: flags.effort });
+    await tellProjection(projection.directory, projection.id, flags.effort);
+    if (flags.timeoutMs === undefined)
+        return buildSilentTellResponse();
+    return prependAddressReceipt(buildWaitResponse(projection.id, await waitForProjection({ projectionDirectory: projection.directory, timeoutMs: flags.timeoutMs, signal }), { alias: projection.alias }), ctx.address, { projectionId: projection.id, projectionAlias: projection.alias });
+});

package/build/cli/commands/projection/wait/handler.js

@@ -1,23 +1,46 @@
-import { resolveContractAddress, withResolvedAddress, } from "../../../../core/addressing.js";
-import { projectionDir } from "../../../../core/projection-core.js";
-import { waitForProjection } from "../../../../core/projection-wait.js";
-import { resolveProjectionAddress } from "../../../projection-address.js";
+import { projectionDir } from "../../../../core/projection/index.js";
+import { snapshotCommissionProjectionIds, waitForProjection, waitForProjectionSet } from "../../../../core/projection/index.js";
+import { FlowError } from "../../../../flow-error.js";
 import { prependAddressReceipt } from "../../../render/address.js";
-import { buildWaitResponse } from "../../../render/wait.js";
-import { projectDirectory, repositoryDirectory } from "../../shared.js";
-export const handler = async (_stdin, flags, signal, positional) => {
-    const cwd = flags.contractId
-        ? await repositoryDirectory(flags, "wait contract addressing")
-        : await projectDirectory(flags, "wait");
-    const address = flags.contractId ? await resolveContractAddress(cwd, flags.contractId, flags.contractAddressSource) : undefined;
-    const operation = async () => {
-        const projection = await resolveProjectionAddress({
-            cwd,
-            address: positional[0],
-            scope: address,
-            verb: "wait",
-        });
-        return prependAddressReceipt(buildWaitResponse(projection.id, await waitForProjection({ projectionDirectory: projectionDir(cwd, projection.id), timeoutMs: flags.timeoutMs, signal }), { alias: projection.alias }), address, { projectionId: projection.id, projectionAlias: projection.alias });
-    };
-    return address ? await withResolvedAddress(address, operation) : await operation();
-};
+import { buildProjectionWaitSetResponse, buildWaitResponse } from "../../../render/wait.js";
+import { resolveProjectionCommandAddress, resolveProjectionCommandTarget, runProjectionCommand, } from "../shared.js";
+import { WAIT_SET_SELECTION_ERROR } from "./meta.js";
+export const handler = async (_stdin, flags, signal, positional) => runProjectionCommand(flags, "wait", async (ctx) => {
+    // Selection modes only govern admitted sets with more than one explicit member.
+    if (positional.length === 1) {
+        const projection = await resolveProjectionCommandTarget(ctx, positional[0], "wait");
+        return prependAddressReceipt(buildWaitResponse(projection.id, await waitForProjection({
+            projectionDirectory: projection.directory,
+            timeoutMs: flags.timeoutMs,
+            signal,
+        }), { alias: projection.alias }), ctx.address, { projectionId: projection.id, projectionAlias: projection.alias });
+    }
+    const selected = [];
+    if (positional.length === 0) {
+        if (ctx.address?.binding.kind === "commission") {
+            selected.push(...await snapshotCommissionProjectionIds(ctx.cwd, ctx.address.binding.commissionId));
+        }
+    }
+    else {
+        // Resolve in argument order so multiple bad coordinates have one stable failure.
+        for (const projectionAddress of positional) {
+            selected.push((await resolveProjectionCommandAddress(ctx, projectionAddress, "wait")).id);
+        }
+    }
+    const ids = [...new Set(selected)].sort();
+    if (ids.length === 0) {
+        throw new FlowError("EMPTY_PARAM", "wait commission snapshot contains no projections");
+    }
+    if (!flags.any && !flags.all) {
+        throw new FlowError("EMPTY_PARAM", WAIT_SET_SELECTION_ERROR);
+    }
+    return prependAddressReceipt(buildProjectionWaitSetResponse(await waitForProjectionSet({
+        projections: await Promise.all(ids.map(async (id) => ({
+            id,
+            projectionDirectory: await projectionDir(ctx.cwd, id),
+        }))),
+        selection: flags.any ? "any" : "all",
+        timeoutMs: flags.timeoutMs,
+        signal,
+    })), ctx.address);
+});