@astrosheep/keiyaku 1.0.0 → 1.0.2

package/build/cli/parse.js

@@ -1,8 +1,13 @@
 import { FlowError } from "../flow-error.js";
 import { agentNameSchema } from "../config/settings.js";
 import { BOOLEAN_FLAGS, CONTROL_FLAGS, HELP_FLAGS, SHORT_FLAG_ALIASES, VALUE_FLAGS, } from "./flags.js";
-import { EFFORT_LEVELS } from "../keiyaku.js";
-const ADDRESSABLE_COMMANDS = new Set([
+/** Commands that may carry an explicit commission selector (@ or --contract). */
+const COMMISSION_SELECTOR_COMMANDS = new Set([
+    "arc",
+    "amend",
+    "call",
+    "wait",
+    "tell",
     "log",
     "renew",
     "petition",
@@ -11,9 +16,9 @@ const ADDRESSABLE_COMMANDS = new Set([
 const CLI_COMMAND_ORDER = [
     "bind",
     "arc",
-    "summon",
-    "ask",
-    "resume",
+    "call",
+    "revive",
+    "wait",
     "tell",
     "log",
     "akuma list",
@@ -32,26 +37,27 @@ const CLI_COMMAND_ORDER = [
     "dump-env",
 ];
 const COMMAND_FLAGS = {
-    bind: ["cwd", "worktree", "after", "exclusive", "draft-only"],
-    arc: ["cwd"],
-    summon: ["cwd", "agent", "model", "effort", "incognito", "bare"],
-    ask: ["cwd", "agent", "model", "effort", "incognito", "bare"],
-    resume: ["cwd", "model", "effort", "projection"],
-    tell: ["cwd", "effort"],
-    log: ["cwd"],
+    // contract is parseable on bind only so the mouth can reject it with bind-specific copy.
+    bind: ["cwd", "repo", "contract", "after", "exclusive", "draft-only"],
+    arc: ["cwd", "repo", "contract", "waive"],
+    call: ["cwd", "repo", "contract", "akuma", "model", "effort", "incognito", "bare", "detach"],
+    revive: ["cwd", "repo", "model", "effort"],
+    wait: ["cwd", "repo", "contract", "timeout"],
+    tell: ["cwd", "repo", "contract", "effort"],
+    log: ["cwd", "repo", "contract"],
     akuma: [],
-    "akuma ls": ["cwd"],
-    "akuma list": ["cwd"],
-    "akuma show": ["cwd"],
+    "akuma ls": ["cwd", "repo"],
+    "akuma list": ["cwd", "repo"],
+    "akuma show": ["cwd", "repo"],
     skills: [],
     "skills install": ["force"],
-    amend: ["cwd"],
-    renew: ["cwd"],
-    petition: ["cwd"],
-    forfeit: ["cwd", "reason"],
+    amend: ["cwd", "repo", "contract"],
+    renew: ["cwd", "repo", "contract", "waive"],
+    petition: ["cwd", "repo", "contract", "waive"],
+    forfeit: ["cwd", "repo", "contract", "reason"],
     guide: [],
-    completion: ["cwd", "shell", "word", "previous", "complete"],
-    status: ["cwd"],
+    completion: ["cwd", "repo", "shell", "word", "previous", "complete"],
+    status: ["cwd", "repo", "target"],
     "dump-env": [],
 };
 const STDIN_COMMANDS = new Set(["bind", "arc", "amend"]);
@@ -62,22 +68,37 @@ export function normalizeContractAddress(raw) {
     }
     return value.trim();
 }
-export function isSummonCommand(command) {
-    return command === "summon" || command === "ask";
+export function isCallCommand(command) {
+    return command === "call";
 }
 export function commandUsesPromptInput(command) {
-    return isSummonCommand(command) || command === "resume";
+    return isCallCommand(command) || command === "revive";
+}
+export function parseWaitTimeout(value) {
+    const matched = /^(?<amount>[1-9][0-9]*)(?<unit>[smh])$/.exec(value);
+    if (!matched?.groups) {
+        throw new FlowError("EMPTY_PARAM", "wait timeout must use <positive integer><s|m|h>, for example 45s, 5m, or 2h (maximum 24h)");
+    }
+    const amount = Number(matched.groups.amount);
+    const multiplier = matched.groups.unit === "s" ? 1_000 : matched.groups.unit === "m" ? 60_000 : 3_600_000;
+    const timeoutMs = amount * multiplier;
+    if (!Number.isSafeInteger(timeoutMs) || timeoutMs > 24 * 3_600_000) {
+        throw new FlowError("EMPTY_PARAM", "wait timeout must use <positive integer><s|m|h>, for example 45s, 5m, or 2h (maximum 24h)");
+    }
+    return timeoutMs;
 }
 export function commandPositionalRange(command) {
     if (command === "akuma show")
         return { min: 1, max: 1, label: "<name>" };
     if (command === "log")
-        return { min: 0, max: 1, label: "[@id]" };
-    if (command === "resume")
-        return { min: 0, max: 2, label: "<response-path>" };
+        return { min: 0, max: 0, label: "" };
+    if (command === "revive")
+        return { min: 1, max: 1, label: "<artifact-id>" };
+    if (command === "wait")
+        return { min: 1, max: 1, label: "<short-id>" };
     if (command === "tell")
         return { min: 2, max: 2, label: "<projection> <message>" };
-    if (isSummonCommand(command))
+    if (isCallCommand(command))
         return { min: 0, max: 1 };
     return { min: 0, max: 0 };
 }
@@ -95,20 +116,27 @@ function assignFlag(flags, name, value) {
         case "cwd":
             flags.cwd = String(value);
             return;
-        case "agent":
-            flags.agent = String(value);
+        case "repo":
+            flags.repo = String(value);
+            return;
+        case "contract":
+            flags.contractId = normalizeContractAddress(String(value));
+            flags.contractAddressSource = "explicit-flag";
+            return;
+        case "akuma":
+            flags.akuma = String(value);
             return;
         case "projection":
             flags.projection = String(value);
             return;
+        case "timeout":
+            flags.timeoutMs = parseWaitTimeout(String(value));
+            return;
         case "model":
             flags.model = String(value);
             return;
         case "effort": {
             const effort = String(value);
-            if (!EFFORT_LEVELS.includes(effort)) {
-                throw new FlowError("INVALID_EFFORT_OVERRIDE", `Invalid effort override '${effort}'. Expected low, medium, high, or max.`);
-            }
             flags.effort = effort;
             return;
         }
@@ -118,12 +146,12 @@ function assignFlag(flags, name, value) {
         case "bare":
             flags.bare = Boolean(value);
             return;
+        case "detach":
+            flags.detach = Boolean(value);
+            return;
         case "draft-only":
             flags.draftOnly = Boolean(value);
             return;
-        case "worktree":
-            flags.worktree = Boolean(value);
-            return;
         case "exclusive":
             flags.exclusive = Boolean(value);
             return;
@@ -139,6 +167,9 @@ function assignFlag(flags, name, value) {
         case "dry-run":
             flags.dryRun = Boolean(value);
             return;
+        case "waive":
+            flags.waivePaths = [...(flags.waivePaths ?? []), String(value)];
+            return;
         case "shell":
             flags.shell = String(value);
             return;
@@ -151,6 +182,12 @@ function assignFlag(flags, name, value) {
         case "complete":
             flags.complete = Boolean(value);
             return;
+        case "target":
+            if (flags.target !== undefined) {
+                throw new FlowError("EMPTY_PARAM", "option --target may only be specified once");
+            }
+            flags.target = String(value);
+            return;
         default:
             throw new FlowError("EMPTY_PARAM", `unknown option: --${name}`);
     }
@@ -178,47 +215,94 @@ function resolveCommand(tokens) {
         throw new FlowError("EMPTY_PARAM", "command cannot be empty");
     throw new FlowError("UNKNOWN_COMMAND", `unknown command: ${head ?? ""}`.trim());
 }
-export function parseCliArgs(tokens) {
-    let contractId;
-    if (tokens[0]?.startsWith("@")) {
-        contractId = normalizeContractAddress(tokens[0]);
-        tokens = tokens.slice(1);
-    }
-    const { command, rest } = resolveCommand(tokens);
-    if (contractId && !ADDRESSABLE_COMMANDS.has(command)) {
-        throw new FlowError("EMPTY_PARAM", `contract address @${contractId} is not valid for ${command}`);
+function splitAtLiteralBoundary(tokens) {
+    const boundary = tokens.indexOf("--");
+    if (boundary === -1)
+        return { head: tokens, payload: [] };
+    return { head: tokens.slice(0, boundary), payload: tokens.slice(boundary + 1) };
+}
+function readValueFlag(name, token, eq, tokens, index) {
+    // --target alone owns emptiness in core; empty remains a supplied value.
+    // Other value flags keep the historical requires-a-value rejection.
+    if (eq !== -1) {
+        const value = token.slice(eq + 1);
+        if (value === "" && name !== "target") {
+            throw new FlowError("EMPTY_PARAM", `option --${name} requires a value`);
+        }
+        return { value, nextIndex: index };
     }
-    if (rest.some((token) => HELP_FLAGS.has(token))) {
-        return { command, flags: contractId ? { contractId } : {}, positional: [], helpRequested: true };
+    const value = tokens[index + 1];
+    if (value === undefined || value === "--" || value.startsWith("--")) {
+        throw new FlowError("EMPTY_PARAM", `option --${name} requires a value`);
     }
-    if (command === "akuma") {
-        throw new FlowError("EMPTY_PARAM", "akuma requires subcommand: list, ls, or show");
+    if (value === "" && name !== "target") {
+        throw new FlowError("EMPTY_PARAM", `option --${name} requires a value`);
     }
-    if (command === "skills") {
-        throw new FlowError("EMPTY_PARAM", "skills requires subcommand: install");
+    // Short-flag values may begin with @; they are flag values, not commission tokens.
+    return { value, nextIndex: index + 1 };
+}
+function commissionConflictMessage(atForm, contractForm) {
+    return `commission address supplied twice: ${atForm} and --contract ${contractForm}; use exactly one form`;
+}
+function noteContractFlag(flags, raw, previousRaw) {
+    if (previousRaw !== undefined || flags.contractId !== undefined) {
+        throw new FlowError("EMPTY_PARAM", `commission address supplied twice: --contract ${previousRaw ?? flags.contractId} and --contract ${raw}; use exactly one form`);
     }
-    const flags = contractId ? { contractId } : {};
-    const positional = [];
-    for (let index = 0; index < rest.length; index += 1) {
-        const token = rest[index];
-        if (token.startsWith("@") && ADDRESSABLE_COMMANDS.has(command)) {
-            if (flags.contractId) {
-                throw new FlowError("EMPTY_PARAM", `${command} accepts at most one contract address`);
+    assignFlag(flags, "contract", raw);
+    return raw;
+}
+export function parseCliArgs(tokens) {
+    const { head, payload } = splitAtLiteralBoundary(tokens);
+    const flags = {};
+    const free = [];
+    const seenFlagNames = new Set();
+    let atContractId;
+    let atToken;
+    let contractFlagRaw;
+    let helpRequested = false;
+    for (let index = 0; index < head.length; index += 1) {
+        const token = head[index];
+        if (HELP_FLAGS.has(token)) {
+            helpRequested = true;
+            continue;
+        }
+        if (token.startsWith("@")) {
+            if (atContractId !== undefined) {
+                throw new FlowError("EMPTY_PARAM", "command accepts at most one contract address");
             }
-            flags.contractId = normalizeContractAddress(token);
+            atToken = token;
+            atContractId = normalizeContractAddress(token);
             continue;
         }
         if (/^-[A-Za-z]$/.test(token)) {
-            const name = SHORT_FLAG_ALIASES[token.slice(1)];
+            const short = token.slice(1);
+            const name = SHORT_FLAG_ALIASES[short];
             if (!name) {
                 throw new FlowError("EMPTY_PARAM", `unknown option: ${token}`);
             }
-            assertAllowedFlag(command, name);
-            assignFlag(flags, name, true);
-            continue;
+            seenFlagNames.add(name);
+            if (VALUE_FLAGS.has(name)) {
+                const value = head[index + 1];
+                if (value === undefined || value === "--" || /^--/.test(value) || (/^-[A-Za-z]$/.test(value) && SHORT_FLAG_ALIASES[value.slice(1)])) {
+                    throw new FlowError("EMPTY_PARAM", `option -${short} requires a value`);
+                }
+                index += 1;
+                if (name === "contract") {
+                    contractFlagRaw = noteContractFlag(flags, value, contractFlagRaw);
+                }
+                else {
+                    assignFlag(flags, name, value);
+                }
+                continue;
+            }
+            if (BOOLEAN_FLAGS.has(name)) {
+                assignFlag(flags, name, true);
+                continue;
+            }
+            throw new FlowError("EMPTY_PARAM", `unknown option: ${token}`);
         }
         if (!token.startsWith("--")) {
-            positional.push(token);
+            free.push(token);
             continue;
         }
         const eq = token.indexOf("=");
@@ -226,15 +310,16 @@ export function parseCliArgs(tokens) {
         if (!CONTROL_FLAGS.has(name)) {
             throw new FlowError("EMPTY_PARAM", `unknown option: --${name}`);
         }
-        assertAllowedFlag(command, name);
+        seenFlagNames.add(name);
         if (VALUE_FLAGS.has(name)) {
-            const value = eq === -1 ? rest[++index] : token.slice(eq + 1);
-            if (!value || value.startsWith("--")) {
-                if (name === "effort")
-                    throw new FlowError("INVALID_EFFORT_OVERRIDE", "Effort override requires one of: low, medium, high, max.");
-                throw new FlowError("EMPTY_PARAM", `option --${name} requires a value`);
+            const { value, nextIndex } = readValueFlag(name, token, eq, head, index);
+            index = nextIndex;
+            if (name === "contract") {
+                contractFlagRaw = noteContractFlag(flags, value, contractFlagRaw);
+            }
+            else {
+                assignFlag(flags, name, value);
             }
-            assignFlag(flags, name, value);
             continue;
         }
         if (BOOLEAN_FLAGS.has(name)) {
@@ -244,10 +329,44 @@ export function parseCliArgs(tokens) {
             assignFlag(flags, name, true);
         }
     }
-    if (isSummonCommand(command)) {
-        if (flags.agent) {
+    if (atContractId !== undefined && flags.contractId !== undefined) {
+        throw new FlowError("EMPTY_PARAM", commissionConflictMessage(atToken ?? `@${atContractId}`, contractFlagRaw ?? flags.contractId));
+    }
+    if (atContractId !== undefined) {
+        flags.contractId = atContractId;
+        flags.contractAddressSource = "at-address";
+    }
+    const { command, rest } = resolveCommand(free);
+    if (helpRequested) {
+        return {
+            command,
+            flags: flags.contractId ? { contractId: flags.contractId, contractAddressSource: flags.contractAddressSource, ...(flags.cwd ? { cwd: flags.cwd } : {}), ...(flags.repo ? { repo: flags.repo } : {}) } : {
+                ...(flags.cwd ? { cwd: flags.cwd } : {}),
+                ...(flags.repo ? { repo: flags.repo } : {}),
+            },
+            positional: [],
+            helpRequested: true,
+        };
+    }
+    if (command === "akuma") {
+        throw new FlowError("EMPTY_PARAM", "akuma requires subcommand: list, ls, or show");
+    }
+    if (command === "skills") {
+        throw new FlowError("EMPTY_PARAM", "skills requires subcommand: install");
+    }
+    for (const name of seenFlagNames) {
+        assertAllowedFlag(command, name);
+    }
+    if (flags.contractId !== undefined && !COMMISSION_SELECTOR_COMMANDS.has(command)) {
+        throw new FlowError("EMPTY_PARAM", command === "bind"
+            ? `bind creates a commission and does not accept @${flags.contractId}; use -C/--cwd to select the repository`
+            : `contract address @${flags.contractId} is not valid for ${command}`);
+    }
+    const positional = [...rest, ...payload];
+    if (isCallCommand(command)) {
+        if (flags.akuma) {
             if (positional.length > 1) {
-                throw new FlowError("EMPTY_PARAM", `${command} accepts at most one prompt argument when --agent is used`);
+                throw new FlowError("EMPTY_PARAM", `${command} accepts at most one prompt argument when --akuma is used`);
             }
         }
         else {
@@ -259,7 +378,7 @@ export function parseCliArgs(tokens) {
             if (!parsedName.success) {
                 throw new FlowError("EMPTY_PARAM", `${command} requires a valid agent name before the optional prompt`);
             }
-            flags.agent = parsedName.data;
+            flags.akuma = parsedName.data;
             positional.shift();
             if (positional.length > 1) {
                 throw new FlowError("EMPTY_PARAM", `${command} accepts at most one prompt argument after the agent name`);

package/build/cli/projection-address.js

@@ -0,0 +1,11 @@
+import { resolveProjectionPrefix } from "../core/projection-core.js";
+import { FlowError } from "../flow-error.js";
+export function resolveProjectionAddress(cwd, prefix, contractId) {
+    const resolved = resolveProjectionPrefix(cwd, prefix, contractId);
+    if (resolved.status === "resolved")
+        return resolved.id;
+    if (resolved.status === "none") {
+        throw new FlowError("EMPTY_PARAM", `projection not resolved${contractId ? ` within @${contractId}` : ""}: ${prefix}`);
+    }
+    throw new FlowError("EMPTY_PARAM", `projection address is ambiguous${contractId ? ` within @${contractId}` : ""}: ${prefix}; candidates:\n${resolved.candidates.join("\n")}`);
+}

package/build/cli/render/address.js

@@ -0,0 +1,88 @@
+function sourceLabel(address) {
+    return sourceName(address.spelling.source);
+}
+function sourceName(source) {
+    switch (source) {
+        case "at-address": return "explicit @";
+        case "explicit-flag": return "explicit --contract";
+        case "worktree-presented": return "worktree cwd";
+        case "sole-active": return "only active commission";
+        case "artifact-provenance": return "artifact provenance";
+    }
+}
+function isCommissionAddress(address) {
+    return address.binding.kind === "commission";
+}
+export function renderResolvedAddressReceipt(address, facts = {}) {
+    if (!isCommissionAddress(address)) {
+        if (address.binding.kind === "unbound") {
+            if (address.repo.kind !== "repository") {
+                throw new Error("unbound address receipt requires repository authority");
+            }
+            return [
+                "Unbound",
+                "no active commission",
+                `repo ${address.repo.stableRoot}`,
+                `workdir ${address.workdir}`,
+                facts.artifactId ? `artifact ${facts.artifactId}` : undefined,
+                facts.projectionId ? `projection ${facts.projectionId}` : undefined,
+            ].filter((part) => part !== undefined).join(" · ");
+        }
+        const repository = address.repo.kind === "repository"
+            ? `repo ${address.repo.stableRoot}`
+            : "no repository";
+        return [
+            "Bare",
+            "no contract",
+            repository,
+            `workdir ${address.workdir}`,
+            facts.artifactId ? `artifact ${facts.artifactId}` : undefined,
+            facts.projectionId ? `projection ${facts.projectionId}` : undefined,
+        ].filter((part) => part !== undefined).join(" · ");
+    }
+    return [
+        address.place.display ? `Bound @${address.place.display}` : "Bound",
+        `commission ${address.binding.commissionId}`,
+        `repo ${address.repo.stableRoot}`,
+        `target ${address.target.branch}`,
+        facts.artifactId ? `artifact ${facts.artifactId}` : undefined,
+        facts.projectionId ? `projection ${facts.projectionId}` : undefined,
+        `via ${sourceLabel(address)}`,
+    ].filter((part) => part !== undefined).join(" · ");
+}
+function renderAttemptCandidate(candidate) {
+    return [
+        candidate.place ? `@${candidate.place}` : undefined,
+        candidate.name,
+        candidate.objective,
+        `target ${candidate.target.branch}`,
+        `commission ${candidate.commissionId}`,
+        `lifecycle ${candidate.lifecycle.state}`,
+        candidate.matchedBy ? `matched by ${candidate.matchedBy}` : undefined,
+    ].filter((part) => part !== undefined).join(" · ");
+}
+export function renderResolutionAttemptPreamble(attempt) {
+    const parts = [
+        attempt.repo.kind === "repository" ? `At repo ${attempt.repo.stableRoot}` : "At no repository",
+        attempt.spelling ? `address ${attempt.spelling.asTyped}` : undefined,
+        attempt.candidates.length > 0
+            ? `candidates ${attempt.candidates.map(renderAttemptCandidate).join("; ")}`
+            : undefined,
+        attempt.spelling ? `via ${sourceName(attempt.spelling.source)}` : undefined,
+        attempt.inference.length > 0 ? `inference ${attempt.inference.join("; ")}` : undefined,
+    ];
+    return parts.filter((part) => part !== undefined).join(" · ");
+}
+export function renderAddressCarrier(carrier, facts = {}) {
+    return "expected" in carrier
+        ? renderResolutionAttemptPreamble(carrier)
+        : renderResolvedAddressReceipt(carrier, facts);
+}
+export function prependAddressReceipt(output, address, facts = {}) {
+    if (!address)
+        return output;
+    return { ...output, address, text: `${renderResolvedAddressReceipt(address, facts)}\n${output.text}` };
+}
+export function carryAddress(output, address) {
+    return { ...output, address };
+}

package/build/cli/render/arc.js

@@ -2,6 +2,7 @@ import { shortCommitHash } from "../../core/render.js";
 import { assembleResponse, buildPayload, buildSection, formatHints, formatList, formatMaybe, formatWarnings, } from "./format.js";
 import { DIFF_OVERVIEW_SECTION_TITLE, RESPONSE_MARKERS, WARNING_SECTION_TITLE } from "./response-style.js";
 import { appendPersistenceSummary, BRANCH_LABEL, CONTENT_SECTION_TITLE, HINTS_LIST_MAX_ITEMS, HINTS_SECTION_TITLE, INFO_BRANCH_MAX_CHARS, INFO_COMMIT_MAX_CHARS, INFO_PLEA_MAX_CHARS, INFO_SECTION_TITLE, } from "./shared.js";
+import { prependAddressReceipt } from "./address.js";
 function sealLines(result) {
     if (!result.sealed)
         return ["nothing sealed"];
@@ -13,7 +14,7 @@ function sealLines(result) {
     ];
 }
 export function buildArcResponse(result) {
-    const { status: _status, ...resultData } = result;
+    const { status: _status, address: _address, ...resultData } = result;
     const summarySection = buildSection(CONTENT_SECTION_TITLE, sealLines(result));
     const warningSection = buildSection(WARNING_SECTION_TITLE, formatWarnings(result.meta?.warnings ?? []));
     const hintsSection = buildSection(HINTS_SECTION_TITLE, formatHints(result.meta?.hints ?? [], { maxItems: HINTS_LIST_MAX_ITEMS }));
@@ -26,15 +27,14 @@ export function buildArcResponse(result) {
         ...formatMaybe("Base Branch", result.baseBranch, INFO_BRANCH_MAX_CHARS),
     ]);
     const summaryLine = appendPersistenceSummary(result.summary, result.responsePath);
-    return {
+    return prependAddressReceipt({
         text: assembleResponse(`${RESPONSE_MARKERS.arc} Arc Opened (a${result.arc})`, summaryLine, [summarySection, infoSection, buildSection(DIFF_OVERVIEW_SECTION_TITLE, result.diff), warningSection, hintsSection].filter((section) => section !== null)),
         payload: buildPayload(resultData, result.responsePath),
-    };
+    }, result.address);
 }
 export function buildRenewResponse(result) {
-    const { status: _status, ...resultData } = result;
+    const { status: _status, address: _address, ...resultData } = result;
     const infoSection = buildSection(INFO_SECTION_TITLE, [
-        ...formatMaybe("Contract", result.contractId, INFO_BRANCH_MAX_CHARS),
         ...formatMaybe("Old Base", result.oldBase, INFO_COMMIT_MAX_CHARS),
         ...formatMaybe("New Base", result.newBase, INFO_COMMIT_MAX_CHARS),
         ...formatMaybe("Old Head", result.oldHead, INFO_COMMIT_MAX_CHARS),
@@ -42,13 +42,13 @@ export function buildRenewResponse(result) {
         ...formatMaybe("Ledger Head", result.ledgerHead, INFO_COMMIT_MAX_CHARS),
         ...formatList("Seal", sealLines(result)),
     ]);
-    return {
+    return prependAddressReceipt({
         text: assembleResponse(`${RESPONSE_MARKERS.arc} Renewed`, appendPersistenceSummary(result.summary, result.responsePath), [buildSection(CONTENT_SECTION_TITLE, result.diff), infoSection].filter((section) => section !== null)),
         payload: buildPayload(resultData, result.responsePath),
-    };
+    }, result.address);
 }
 export function buildAmendResponse(result) {
-    const { status: _status, ...resultData } = result;
+    const { status: _status, address: _address, ...resultData } = result;
     const renderedLedgerCommit = shortCommitHash(result.ledgerCommit);
     const infoSection = buildSection(INFO_SECTION_TITLE, [
         ...formatMaybe("Amendment", String(result.amendmentNumber), INFO_COMMIT_MAX_CHARS),
@@ -56,8 +56,8 @@ export function buildAmendResponse(result) {
         ...formatMaybe("Base Branch", result.baseBranch, INFO_BRANCH_MAX_CHARS),
         ...formatMaybe("Ledger Commit", renderedLedgerCommit, INFO_COMMIT_MAX_CHARS),
     ]);
-    return {
+    return prependAddressReceipt({
         text: assembleResponse(`${RESPONSE_MARKERS.arc} Amended`, `Amended contract ledger on '${result.currentBranch}' with Amendment ${result.amendmentNumber} [${renderedLedgerCommit}].`, [buildSection(CONTENT_SECTION_TITLE, result.summary), infoSection].filter((section) => section !== null)),
         payload: buildPayload(resultData),
-    };
+    }, result.address);
 }

package/build/cli/render/call.js

@@ -0,0 +1,59 @@
+import { assembleResponse, buildPayload, buildSection, formatMaybe, formatWarnings } from "./format.js";
+import { WARNING_SECTION_TITLE } from "./response-style.js";
+import { CONTENT_SECTION_TITLE, formatPersistenceSummary, formatCallCompletionHeading, formatCallNextAction, INFO_AKUMA_MAX_CHARS, projectionRejoinHintLines, } from "./shared.js";
+import { carryAddress, prependAddressReceipt, renderResolvedAddressReceipt } from "./address.js";
+export function renderAdoptedLaunchReceipt(address, projectionId) {
+    return [
+        renderResolvedAddressReceipt(address, { projectionId }),
+        ...projectionRejoinHintLines(projectionId),
+    ].join("\n");
+}
+export function buildCallResponse(result, input) {
+    if (result.state === "launched") {
+        if (!result.projection)
+            throw new Error("launched call response requires projection facts");
+        const { session: _session, evidenceCwd: _evidenceCwd, address: _address, foregroundWait: _foregroundWait, ...responseData } = result;
+        const output = {
+            text: input.addressPlacement === "stdout"
+                ? renderAdoptedLaunchReceipt(result.address, result.projection.id)
+                : projectionRejoinHintLines(result.projection.id).join("\n"),
+            payload: buildPayload(responseData),
+        };
+        switch (input.addressPlacement) {
+            case "stdout":
+                return { ...output, address: result.address };
+            case "footer":
+                return carryAddress(output, result.address);
+            case "none":
+                return output;
+        }
+    }
+    const infoLines = [
+        ...formatMaybe("Akuma", result.agent ?? input.agent, INFO_AKUMA_MAX_CHARS),
+    ];
+    const summarySection = buildSection(CONTENT_SECTION_TITLE, result.summary);
+    const warningSection = buildSection(WARNING_SECTION_TITLE, formatWarnings(result.meta?.warnings ?? []));
+    const persistedSummary = formatPersistenceSummary(input.responsePath);
+    const response = assembleResponse(formatCallCompletionHeading(result.projection) ?? "", persistedSummary, [summarySection, warningSection].filter((s) => s !== null), infoLines);
+    const repositoryCoordinate = result.address.repo.kind === "repository"
+        ? result.address.repo.stableRoot
+        : undefined;
+    const text = `${response.trimStart()}\n\n${formatCallNextAction({
+        projection: result.projection,
+        artifactId: input.artifactId,
+        repositoryCoordinate,
+    })}`;
+    const { session: _session, evidenceCwd: _evidenceCwd, address: _address, foregroundWait: _foregroundWait, ...responseData } = result;
+    const output = {
+        text,
+        payload: buildPayload(responseData, input.responsePath),
+    };
+    switch (input.addressPlacement) {
+        case "stdout":
+            return prependAddressReceipt(output, result.address, { artifactId: result.artifactId, projectionId: result.projection?.id });
+        case "footer":
+            return carryAddress(output, result.address);
+        case "none":
+            return output;
+    }
+}

package/build/cli/render/compact-text.js

@@ -0,0 +1,3 @@
+export function compactText(value) {
+    return value.replace(/\s+/g, " ").trim();
+}

package/build/cli/render/errors.js

@@ -1,9 +1,10 @@
 import { asMessage, isFlowError, pickHintsFromError } from "../../flow-error.js";
 import { assertSettingsKnobUsable, loadKeiyakuSettings } from "../../config/settings.js";
-import { loadAkumaCatalog } from "../../config/akuma-loader.js";
+import { loadAkumaCatalogV2 } from "../../config/akuma-loader_v2.js";
 import { appendDebugLog } from "../../telemetry/debug-log.js";
 import { ACTOR_IDENTITY, TOOL_NAMES, BUILTIN_AGENT_NAMES } from "../../keiyaku.js";
 import { buildErrorResponse } from "./misc.js";
+import { addressCarrierFromError } from "../../core/addressing.js";
 export function classifyCliError(error) {
     if (isFlowError(error)) {
         return { errorType: "keiyaku_error", errorCode: error.code };
@@ -17,7 +18,7 @@ async function getAvailableActorNames(cwd, fallback) {
     try {
         const loaded = await loadKeiyakuSettings(cwd);
         assertSettingsKnobUsable(loaded, "agents");
-        return Object.keys((await loadAkumaCatalog(cwd)).definitions);
+        return Object.keys((await loadAkumaCatalogV2(cwd)).selected);
     }
     catch {
         return [...fallback];
@@ -42,5 +43,6 @@ export async function handleCliError(input) {
         review: isFlowError(input.error) ? input.error.review : undefined,
         errorType,
         errorCode,
+        addressCarrier: addressCarrierFromError(input.error),
     });
 }