@astrosheep/keiyaku 1.0.0 → 1.0.2

package/build/cli/index.js

@@ -1,19 +1,20 @@
 import * as path from "node:path";
+import * as fs from "node:fs/promises";
 import { FlowError, asMessage } from "../flow-error.js";
 import { writeDraftArtifact } from "./draft-artifact.js";
 import { amendKeiyaku } from "../core/amend.js";
 import { arcKeiyaku, buildArcInput } from "../core/arc.js";
 import { bindContract } from "../core/bind.js";
 import { buildAmendInput, defaultActorClock } from "../core/command-io.js";
-import { resolveContractAddress } from "../core/context.js";
+import { AddressResolutionError, buildResolutionAttempt, resolveContractAddress, withResolvedAddress, } from "../core/addressing.js";
 import { forfeitContractCommand } from "../core/forfeit.js";
 import { readContractLog } from "../core/log.js";
 import { buildPetitionClaimInput } from "../core/petition.js";
 import { petitionKeiyaku } from "../core/petition-run.js";
 import { renewKeiyaku } from "../core/renew.js";
-import { readKanshiBoard } from "../core/status.js";
-import { runSummonAndPersist } from "../core/summon-persist.js";
-import { resolveResumePath } from "../core/transcripts.js";
+import { normalizeTargetRef, readKanshiBoard } from "../core/status.js";
+import { runCallAndPersist } from "../core/call-persist.js";
+import { locateResponseArtifact } from "../core/transcripts.js";
 import { renderEnvExample } from "../config/env-keys.js";
 import { assertSettingsKnobUsable, loadKeiyakuSettings } from "../config/settings.js";
 import { handleCliError } from "./render/errors.js";
@@ -21,121 +22,209 @@ import { renderStatusBoard } from "./render/status.js";
 import { VERSION } from "../generated/version.js";
 import { FLAG_SPECS } from "./flags.js";
 import { renderAkumaList, renderAkumaShow } from "./commands/akuma.js";
-import { loadAkumaCatalog } from "../config/akuma-loader.js";
+import { loadAkumaCatalogV2 } from "../config/akuma-loader_v2.js";
 import { renderCompletionCandidates, renderCompletionScript } from "./completion.js";
 import { CLI_COMMAND_METADATA, buildKeiyakuGuide, missingSubcommandError, renderCliCommandHelp as renderCliCommandHelpText, renderCliHelp as renderCliHelpText, } from "./help.js";
-import { commandUsesPromptInput, isSummonCommand, parseCliArgs } from "./parse.js";
+import { commandUsesPromptInput, isCallCommand, parseCliArgs } from "./parse.js";
 import { buildAmendResponse, buildArcResponse, buildRenewResponse } from "./render/arc.js";
 import { buildLogResponse } from "./render/misc.js";
 import { buildPetitionClaimResponse } from "./render/petition.js";
-import { buildBindDraftResponse, buildBindResponse, buildForfeitResponse, renderCoreResult, textResponse } from "./render/shared.js";
-import { buildSummonResponse } from "./render/summon.js";
-import { projectionDir, resolveProjectionPrefix, writeInboxTell } from "../core/projection-core.js";
-import { assertTellEffortSupported, resumeProjectionOverride, tellProjection } from "../core/projection-wake.js";
-import { renderTellReceipt } from "./render/tell.js";
+import { shellQuote } from "./render/format.js";
+import { buildBindDraftResponse, buildBindResponse, buildForfeitResponse, formatCallNextAction, renderCoreResult, textResponse } from "./render/shared.js";
+import { buildCallResponse, renderAdoptedLaunchReceipt } from "./render/call.js";
+import { projectionDir, writeInboxTell } from "../core/projection-core.js";
+import { assertTellEffortSupported, tellProjection } from "../core/projection-wake.js";
+import { resolveProjectionAddress } from "./projection-address.js";
+import { waitForProjection } from "../core/projection-wait.js";
+import { buildWaitResponse } from "./render/wait.js";
+import { prependAddressReceipt, renderResolvedAddressReceipt } from "./render/address.js";
 import { installOfficialSkills } from "./skills-install.js";
-const SUMMON_INPUT_HINTS = [
-    "Summon input can be a prompt argument, `-` to read stdin, or omitted to read stdin.",
-    "Use `keiyaku summon NAME \"prompt\"`, `keiyaku summon NAME - < prompt.md`, or `keiyaku resume RESPONSE_PATH \"prompt\"`.",
+import { isGitRepo } from "../git/branches.js";
+import { stableRepoRoot } from "../core/worktree-path.js";
+const CALL_INPUT_HINTS = [
+    "Call input can be a prompt argument, `-` to read stdin, or omitted to read stdin.",
+    "Use `keiyaku call NAME \"prompt\"`, `keiyaku call NAME - < prompt.md`, or `keiyaku revive ARTIFACT_ID`.",
 ];
-function titleFromSummonPrompt(prompt) {
+function titleFromCallPrompt(prompt) {
     const firstLine = prompt
         .split(/\r?\n/)
         .map((line) => line.trim())
         .find((line) => line.length > 0);
     if (!firstLine)
-        return "Summon";
-    return firstLine.replace(/^#+\s*/, "").slice(0, 80) || "Summon";
+        return "Call";
+    return firstLine.replace(/^#+\s*/, "").slice(0, 80) || "Call";
 }
-function buildSummonInput(content, flags) {
+function repositoryCoordinateFromAddress(address) {
+    return address?.repo.kind === "repository" ? address.repo.stableRoot : undefined;
+}
+function buildCallInput(content, flags, mode = "call") {
     const cwd = flags.cwd ?? process.cwd();
     const task = content.trim();
     if (!task) {
-        throw new FlowError("EMPTY_PARAM", "summon requires a prompt argument, `-` with stdin, or prompt text on stdin.", {
-            hints: SUMMON_INPUT_HINTS,
+        throw new FlowError("EMPTY_PARAM", "call requires a prompt argument, `-` with stdin, or prompt text on stdin.", {
+            hints: CALL_INPUT_HINTS,
         });
     }
     return {
         cwd,
-        title: titleFromSummonPrompt(task),
+        repo: flags.repo,
+        mode,
+        contractId: flags.contractId,
+        contractAddressSource: flags.contractAddressSource,
+        title: titleFromCallPrompt(task),
         task,
-        agent: flags.agent,
+        agent: flags.akuma,
         model: flags.model,
         effort: flags.effort,
-        resumePath: flags.resumePath,
         incognito: flags.incognito,
         bare: flags.bare,
+        detach: flags.detach,
     };
 }
-function resumePrompt(stdin) {
+function revivePrompt(stdin) {
     return stdin.trim() ? stdin : "Continue from the previous response.";
 }
 function commandSpec(command, run) {
     return { ...CLI_COMMAND_METADATA[command], run };
 }
+function effectiveDirectory(flags) {
+    return flags.cwd ?? process.cwd();
+}
+async function repositoryDirectory(flags) {
+    const candidate = flags.repo ?? effectiveDirectory(flags);
+    if (!(await isGitRepo(candidate))) {
+        if (flags.contractId) {
+            const asTyped = flags.contractAddressSource === "at-address"
+                ? `@${flags.contractId}`
+                : flags.contractId;
+            throw new AddressResolutionError("EMPTY_PARAM", `${asTyped} is a commission address, but ${candidate} has no repository ledger; contract addressing requires a ledger`, buildResolutionAttempt({
+                repo: { kind: "user" },
+                workdir: effectiveDirectory(flags),
+                spelling: {
+                    asTyped,
+                    source: flags.contractAddressSource ?? "explicit-flag",
+                },
+            }));
+        }
+        throw new FlowError("NOT_GIT_REPO", `${candidate} is not a git repository`);
+    }
+    return flags.repo ? await stableRepoRoot(candidate) : candidate;
+}
+async function projectDirectory(flags) {
+    if (flags.repo)
+        return await repositoryDirectory(flags);
+    return effectiveDirectory(flags);
+}
 const CLI_COMMAND_SPECS = {
     bind: commandSpec("bind", async (stdin, flags) => {
-        const cwd = flags.cwd ?? process.cwd();
+        const cwd = await repositoryDirectory(flags);
         if (flags.draftOnly) {
             return buildBindDraftResponse(await writeDraftArtifact({ cwd, title: "bind-draft", content: stdin }));
         }
         const result = await bindContract({
-            cwd, draft: stdin, ...defaultActorClock(), workspace: flags.worktree ? "worktree" : "here",
+            cwd, draft: stdin, ...defaultActorClock(), workspace: "worktree",
             after: flags.after ?? [], exclusive: flags.exclusive,
+            onProgress: (line) => {
+                process.stdout.write(`${line}\n`);
+            },
         });
         return buildBindResponse(result, cwd);
     }),
-    arc: commandSpec("arc", async (stdin, flags) => renderCoreResult(arcKeiyaku(buildArcInput(stdin, flags.cwd ?? process.cwd())), buildArcResponse)),
-    summon: commandSpec("summon", async (stdin, flags, signal) => {
-        const outcome = await runSummonAndPersist({ ...buildSummonInput(stdin, flags), signal });
-        return buildSummonResponse(outcome.result, { responsePath: outcome.responsePath });
+    arc: commandSpec("arc", async (stdin, flags) => {
+        const parsed = buildArcInput(stdin, effectiveDirectory(flags), flags.waivePaths, flags.contractId, flags.contractAddressSource);
+        const cwd = await repositoryDirectory(flags);
+        return renderCoreResult(arcKeiyaku({ ...parsed, cwd }), buildArcResponse);
     }),
-    ask: commandSpec("ask", async (stdin, flags, signal) => CLI_COMMAND_SPECS.summon.run(stdin, flags, signal, [])),
-    resume: commandSpec("resume", async (stdin, flags, signal, positional) => {
-        const cwd = flags.cwd ?? process.cwd();
-        if (flags.projection) {
-            if (positional.length > 0)
-                throw new FlowError("EMPTY_PARAM", "resume --projection cannot be combined with a response artifact path");
-            const resolved = resolveProjectionPrefix(cwd, flags.projection);
-            if (resolved.status !== "resolved")
-                throw new FlowError("EMPTY_PARAM", `projection not resolved: ${flags.projection}`);
-            const result = resumeProjectionOverride(projectionDir(cwd, resolved.id), undefined, flags.effort);
-            if (result === "active")
-                throw new FlowError("EMPTY_PARAM", "projection is active; use keiyaku tell instead");
-            if (result === "done")
-                throw new FlowError("EMPTY_PARAM", "projection is done; use keiyaku tell instead");
-            return textResponse(`Projection ${resolved.id} recovery started.\n`);
+    call: commandSpec("call", async (stdin, flags, signal) => {
+        const outcome = await runCallAndPersist({
+            ...buildCallInput(stdin, flags, "call"),
+            signal,
+            ...(!flags.detach
+                ? {
+                    onLaunch: ({ address, projection }) => {
+                        process.stdout.write(`${renderAdoptedLaunchReceipt(address, projection.id)}\n`);
+                    },
+                }
+                : {}),
+        });
+        if (outcome.result.foregroundWait && outcome.result.projection) {
+            return buildWaitResponse(outcome.result.projection.id, outcome.result.foregroundWait);
         }
-        const resumePath = await resolveResumePath(cwd, positional[0]);
-        return CLI_COMMAND_SPECS.summon.run(resumePrompt(stdin), { ...flags, cwd, resumePath }, signal, []);
+        return buildCallResponse(outcome.result, {
+            responsePath: outcome.responsePath,
+            artifactId: outcome.artifactId,
+            addressPlacement: flags.detach ? "stdout" : "none",
+        });
+    }),
+    revive: commandSpec("revive", async (stdin, flags, signal, positional) => {
+        const cwd = effectiveDirectory(flags);
+        const artifactCwd = await projectDirectory(flags);
+        const artifactId = positional[0];
+        const responseStoreCwd = await isGitRepo(artifactCwd) ? await stableRepoRoot(artifactCwd) : await fs.realpath(artifactCwd);
+        const artifact = await locateResponseArtifact(responseStoreCwd, artifactId);
+        let executionCwd;
+        let repo;
+        if (artifact.provenance.authority.kind === "repository") {
+            executionCwd = responseStoreCwd;
+            repo = responseStoreCwd;
+        }
+        else {
+            if (!("workdir" in artifact.provenance.evidence)) {
+                throw new FlowError("INVALID_RESPONSE_PATH", `Invalid response artifact '${artifactId}': field 'provenance.evidence.workdir' is missing.`);
+            }
+            executionCwd = artifact.provenance.evidence.workdir;
+            repo = undefined;
+        }
+        const outcome = await runCallAndPersist({
+            ...buildCallInput(revivePrompt(stdin), { ...flags, cwd: executionCwd, repo }, "revive"),
+            reviveArtifact: artifact,
+            signal,
+        });
+        return buildCallResponse(outcome.result, { responsePath: outcome.responsePath, artifactId: outcome.artifactId, addressPlacement: "footer" });
+    }),
+    wait: commandSpec("wait", async (_stdin, flags, signal, positional) => {
+        const cwd = flags.contractId ? await repositoryDirectory(flags) : await projectDirectory(flags);
+        const address = flags.contractId ? await resolveContractAddress(cwd, flags.contractId, flags.contractAddressSource) : undefined;
+        const operation = async () => {
+            const projectionId = resolveProjectionAddress(cwd, positional[0], address?.binding.commissionId);
+            return prependAddressReceipt(buildWaitResponse(projectionId, await waitForProjection({ projectionDirectory: projectionDir(cwd, projectionId), timeoutMs: flags.timeoutMs, signal })), address, { projectionId });
+        };
+        return address ? await withResolvedAddress(address, operation) : await operation();
     }),
     tell: commandSpec("tell", async (_stdin, flags, _signal, positional) => {
-        const cwd = flags.cwd ?? process.cwd();
+        const cwd = flags.contractId ? await repositoryDirectory(flags) : await projectDirectory(flags);
         const [prefix, message] = positional;
         if (!prefix || !message)
             throw new FlowError("EMPTY_PARAM", "tell requires a projection and message");
-        const resolved = resolveProjectionPrefix(cwd, prefix);
-        if (resolved.status !== "resolved")
-            throw new FlowError("EMPTY_PARAM", `projection not resolved: ${prefix}`);
-        const directory = projectionDir(cwd, resolved.id);
-        assertTellEffortSupported(directory, flags.effort);
-        // Mailbox first: do not inspect phase before this immutable write.
-        writeInboxTell(directory, message, Date.now(), { effort: flags.effort });
-        return textResponse(renderTellReceipt(resolved.id, tellProjection(directory, flags.effort)));
+        const address = flags.contractId ? await resolveContractAddress(cwd, flags.contractId, flags.contractAddressSource) : undefined;
+        const operation = async () => {
+            const projectionId = resolveProjectionAddress(cwd, prefix, address?.binding.commissionId);
+            const directory = projectionDir(cwd, projectionId);
+            assertTellEffortSupported(directory, flags.effort);
+            // Mailbox first: do not inspect phase before this immutable write.
+            writeInboxTell(directory, message, Date.now(), { effort: flags.effort });
+            await tellProjection(directory, flags.effort);
+            return textResponse("");
+        };
+        return address ? await withResolvedAddress(address, operation) : await operation();
     }),
-    log: commandSpec("log", async (_stdin, flags, _signal, positional) => {
-        const cwd = flags.cwd ?? process.cwd();
-        const contractId = await resolveContractAddress(cwd, flags.contractId ?? positional[0]);
-        return renderCoreResult(readContractLog({ cwd, contractId }), buildLogResponse);
+    log: commandSpec("log", async (_stdin, flags) => {
+        const cwd = await repositoryDirectory(flags);
+        const address = await resolveContractAddress(cwd, flags.contractId, flags.contractAddressSource);
+        return await withResolvedAddress(address, async () => {
+            const result = await readContractLog({ cwd, contractId: address.binding.commissionId });
+            return buildLogResponse({ ...result, address });
+        });
     }),
     akuma: commandSpec("akuma", async () => { throw missingSubcommandError("akuma", CLI_COMMAND_METADATA.akuma.subcommands ?? []); }),
     "akuma list": commandSpec("akuma list", async (_stdin, flags) => {
-        const loaded = await loadKeiyakuSettings(flags.cwd ?? process.cwd());
+        const cwd = await projectDirectory(flags);
+        const loaded = await loadKeiyakuSettings(cwd);
         // Role markers need settings pointers; catalog consumers keep legacy agents disease actionable.
         assertSettingsKnobUsable(loaded, "agents");
         assertSettingsKnobUsable(loaded, "default");
         assertSettingsKnobUsable(loaded, "reviewer");
-        return textResponse(renderAkumaList(await loadAkumaCatalog(flags.cwd ?? process.cwd()), loaded.knobs));
+        return textResponse(renderAkumaList(await loadAkumaCatalogV2(cwd), loaded.providerInstances, loaded.knobs));
     }),
     "akuma ls": commandSpec("akuma ls", async (_stdin, flags, signal, positional) => CLI_COMMAND_SPECS["akuma list"].run(_stdin, flags, signal, positional)),
     "akuma show": commandSpec("akuma show", async (_stdin, flags, _signal, positional) => {
@@ -143,48 +232,64 @@ const CLI_COMMAND_SPECS = {
         if (!name) {
             throw new FlowError("EMPTY_PARAM", "akuma show requires an Akuma name");
         }
-        const loaded = await loadKeiyakuSettings(flags.cwd ?? process.cwd());
+        const cwd = await projectDirectory(flags);
+        const loaded = await loadKeiyakuSettings(cwd);
         // Role markers need settings pointers; catalog consumers keep legacy agents disease actionable.
         assertSettingsKnobUsable(loaded, "agents");
         assertSettingsKnobUsable(loaded, "default");
         assertSettingsKnobUsable(loaded, "reviewer");
-        return textResponse(renderAkumaShow(await loadAkumaCatalog(flags.cwd ?? process.cwd()), loaded.knobs, name));
+        return textResponse(renderAkumaShow(await loadAkumaCatalogV2(cwd), loaded.providerInstances, loaded.knobs, name));
     }),
     skills: commandSpec("skills", async () => { throw missingSubcommandError("skills", CLI_COMMAND_METADATA.skills.subcommands ?? []); }),
     "skills install": commandSpec("skills install", async (_stdin, flags) => {
         const result = await installOfficialSkills(flags.force);
         return textResponse([
-            "Installed official Keiyaku skill:",
-            ...result.targets.map((target) => `- ${target.path} -> ${result.source} (${target.status})`),
+            "Installed official Keiyaku skills:",
+            ...result.targets.map((target) => `- ${target.path} -> ${target.source} (${target.status})`),
             ...(result.warnings.length > 0 ? ["", "## Warning", ...result.warnings.map((warning) => `- ${warning}`)] : []),
         ].join("\n"));
     }),
-    amend: commandSpec("amend", async (stdin, flags) => renderCoreResult(amendKeiyaku(buildAmendInput(stdin, flags.cwd ?? process.cwd())), buildAmendResponse)),
+    amend: commandSpec("amend", async (stdin, flags) => {
+        const parsed = buildAmendInput(stdin, effectiveDirectory(flags), flags.contractId, flags.contractAddressSource);
+        const cwd = await repositoryDirectory(flags);
+        return renderCoreResult(amendKeiyaku({ ...parsed, cwd }), buildAmendResponse);
+    }),
     renew: commandSpec("renew", async (_stdin, flags) => {
-        const cwd = flags.cwd ?? process.cwd();
-        const contractId = await resolveContractAddress(cwd, flags.contractId);
-        return renderCoreResult(renewKeiyaku({ cwd, contractId }), buildRenewResponse);
+        const cwd = await repositoryDirectory(flags);
+        const address = await resolveContractAddress(cwd, flags.contractId, flags.contractAddressSource);
+        return renderCoreResult(renewKeiyaku({ cwd, address, waivePaths: flags.waivePaths }), buildRenewResponse);
     }),
     petition: commandSpec("petition", async (stdin, flags, signal) => {
-        const cwd = flags.cwd ?? process.cwd();
-        const contractId = await resolveContractAddress(cwd, flags.contractId);
-        const input = buildPetitionClaimInput({ cwd, contractId, stdin, signal });
-        return renderCoreResult(petitionKeiyaku(input), (result) => buildPetitionClaimResponse(result, input));
+        const cwd = await repositoryDirectory(flags);
+        const address = await resolveContractAddress(cwd, flags.contractId, flags.contractAddressSource);
+        return await withResolvedAddress(address, async () => {
+            const input = buildPetitionClaimInput({ cwd, contractId: address.binding.commissionId, stdin, signal, waivePaths: flags.waivePaths });
+            return buildPetitionClaimResponse({ ...await petitionKeiyaku(input), address }, input);
+        });
     }),
     forfeit: commandSpec("forfeit", async (_stdin, flags) => {
-        const cwd = flags.cwd ?? process.cwd();
-        const contractId = await resolveContractAddress(cwd, flags.contractId);
-        return buildForfeitResponse(await forfeitContractCommand({ cwd, contractId, ...defaultActorClock(), note: flags.reason }));
+        const cwd = await repositoryDirectory(flags);
+        const address = await resolveContractAddress(cwd, flags.contractId, flags.contractAddressSource);
+        return await withResolvedAddress(address, async () => buildForfeitResponse({
+            ...await forfeitContractCommand({ cwd, contractId: address.binding.commissionId, ...defaultActorClock(), note: flags.reason }),
+            address,
+        }));
     }),
     guide: commandSpec("guide", async () => textResponse(buildKeiyakuGuide(VERSION))),
     completion: commandSpec("completion", async (_stdin, flags) => {
-        const cwd = flags.cwd ?? process.cwd();
+        const cwd = await projectDirectory(flags);
         if (flags.complete) {
             return textResponse(await renderCompletionCandidates({ cwd, word: flags.word, previous: flags.previous }));
         }
         return textResponse(renderCompletionScript(flags.shell));
     }),
-    status: commandSpec("status", async (_stdin, flags) => textResponse(renderStatusBoard(await readKanshiBoard(flags.cwd ?? process.cwd(), Date.now())))),
+    status: commandSpec("status", async (_stdin, flags) => {
+        // Status is read-only and must open outside Git. projectDirectory still
+        // honors --repo as a repository coordinate when the operator names one.
+        const cwd = await projectDirectory(flags);
+        const target = flags.target === undefined ? undefined : normalizeTargetRef(flags.target);
+        return textResponse(renderStatusBoard(await readKanshiBoard(cwd, Date.now(), target === undefined ? undefined : { target })));
+    }),
     "dump-env": commandSpec("dump-env", async () => textResponse(renderEnvExample())),
 };
 function getCliCommandSpec(command) {
@@ -194,7 +299,7 @@ function commandRequiresStdin(command) {
     return getCliCommandSpec(command).stdin === "required";
 }
 function commandSavesFailedStdin(command) {
-    return commandRequiresStdin(command) && command !== "summon";
+    return commandRequiresStdin(command) && command !== "call";
 }
 async function readStdin() {
     if (process.stdin.isTTY)
@@ -219,9 +324,25 @@ function responseData(response) {
         return {};
     return payload;
 }
+function isCallProjectionFacts(value) {
+    if (value === null || typeof value !== "object" || Array.isArray(value))
+        return false;
+    const facts = value;
+    return typeof facts.id === "string"
+        && (facts.phase === "active" || facts.phase === "done" || facts.phase === "failed"
+            || facts.phase === "dismissed" || facts.phase === "lost" || facts.phase === "quiescent");
+}
 function conversationalFooter(response) {
     const data = responseData(response);
     const lines = [];
+    if (response.address) {
+        const projection = data.projection;
+        const projectionFacts = isCallProjectionFacts(projection) ? projection : undefined;
+        const receiptArtifactId = typeof data.revivedArtifactId === "string"
+            ? data.revivedArtifactId
+            : typeof data.artifactId === "string" ? data.artifactId : undefined;
+        lines.push(renderResolvedAddressReceipt(response.address, { artifactId: receiptArtifactId, projectionId: projectionFacts?.id }));
+    }
     const responsePath = typeof data.responsePath === "string" ? data.responsePath : undefined;
     const agent = typeof data.agent === "string" ? data.agent : undefined;
     const meta = data.meta && typeof data.meta === "object" && !Array.isArray(data.meta) ? data.meta : undefined;
@@ -230,15 +351,28 @@ function conversationalFooter(response) {
         lines.push(`Saved to ${responsePath}.`);
     }
     if (agent) {
-        lines.push(`Agent: ${agent}`);
+        lines.push(`Akuma: ${agent}`);
     }
     if (warnings.length > 0) {
         lines.push("Warnings:", ...warnings.map((warning) => `- ${warning}`));
     }
+    if (typeof data.summary === "string") {
+        const projection = data.projection;
+        const projectionFacts = isCallProjectionFacts(projection) ? projection : undefined;
+        const artifactId = typeof data.artifactId === "string" ? data.artifactId : undefined;
+        lines.push(formatCallNextAction({
+            projection: projectionFacts,
+            artifactId,
+            repositoryCoordinate: repositoryCoordinateFromAddress(response.address),
+        }));
+    }
     return lines.join("\n");
 }
 function writeSuccessResponse(command, response) {
-    if (command !== "ask" && command !== "resume") {
+    // Successful tell is always silent: zero stdout bytes, even if text regresses.
+    if (command === "tell")
+        return;
+    if (command !== "revive") {
         process.stdout.write(`${responseText(response)}\n`);
         return;
     }
@@ -259,11 +393,6 @@ async function saveFailedStdin(input) {
         content: input.content,
     });
 }
-function shellQuote(value) {
-    if (/^[A-Za-z0-9_./:@%+=,-]+$/.test(value))
-        return value;
-    return `'${value.replace(/'/g, "'\\''")}'`;
-}
 function retryHint(command, draftPath, cwd, cwdFlag) {
     if (!cwdFlag) {
         return `Retry: keiyaku ${command} < ${shellQuote(draftPath)}`;
@@ -279,6 +408,9 @@ async function printFailure(error, cwd) {
     });
     process.stderr.write(`${responseText(response)}\n`);
 }
+function failureExitCode(error) {
+    return error instanceof Error && error.name === "AbortError" ? 130 : 1;
+}
 async function handleFailureAfterStdin(input) {
     if (input.response) {
         process.stderr.write(`${responseText(input.response)}\n`);
@@ -309,9 +441,9 @@ async function runResponse(command, flags, stdin, positional) {
     return await getCliCommandSpec(command).run(stdin, flags, signal, positional);
 }
 function positionalPrompt(command, positional) {
-    if (isSummonCommand(command))
+    if (isCallCommand(command))
         return positional[0];
-    if (command === "resume")
+    if (command === "revive")
         return positional[1];
     return undefined;
 }
@@ -323,11 +455,11 @@ async function readPromptInput(command, positional, cwd) {
         return prompt;
     const stdin = await readStdin();
     if (!stdin.trim()) {
-        if (command === "resume") {
+        if (command === "revive") {
             return "";
         }
         await printFailure(new FlowError("EMPTY_PARAM", `${command} requires a prompt argument, \`-\` with stdin, or prompt text on stdin.`, {
-            hints: SUMMON_INPUT_HINTS,
+            hints: CALL_INPUT_HINTS,
         }), cwd);
         return undefined;
     }
@@ -385,12 +517,12 @@ export async function runCliCommand(tokens) {
             });
         }
         await printFailure(error, cwd);
-        return 1;
+        return failureExitCode(error);
     }
     const success = !response.payload || !("error" in response.payload);
     if (success) {
         writeSuccessResponse(parsed.command, response);
-        return 0;
+        return response.exitCode ?? 0;
     }
     if (commandRequiresStdin(parsed.command)) {
         return await handleFailureAfterStdin({