@astrosheep/keiyaku 2.9.2 → 2.9.4

package/build/cli/index.js

@@ -6,11 +6,10 @@ import { handleCliError } from "./render/errors.js";
 import { FLAG_SPECS } from "./flags.js";
 import { renderCliCommandHelp as renderCliCommandHelpText, renderCliHelp as renderCliHelpText, } from "./help.js";
 import { commandUsesPromptInput, isCallCommand, isPetitionDryRunInvocation, parseCliArgs } from "./parse.js";
-import { getCommandMetadata, loadCommandHandler } from "./commands/registry.js";
-import { repositoryCoordinateFromAddress } from "./commands/shared.js";
+import { getCommandMetadata } from "./commands/metadata.js";
+import { loadCommandHandler } from "./commands/registry.js";
 import { shellQuote } from "./render/format.js";
-import { formatCallNextAction } from "./render/shared.js";
-import { renderResolvedAddressReceipt } from "./render/address.js";
+import { writeSuccessResponse } from "./render/success-response.js";
 function commandRequiresStdin(command) {
     return getCommandMetadata(command).stdin === "required";
 }
@@ -59,6 +58,10 @@ function prepareBindInput(stdin, flags) {
         throw new FlowError("EMPTY_PARAM", "--dry-run requires --place, --objective, --scope, and --checks");
     }
     if (!nonblankStdin) {
+        // --task may supply name/objective defaults; core merges and reports missing sections.
+        if (flags.bindTaskIds !== undefined && flags.bindTaskIds.length > 0) {
+            return "";
+        }
         throw new FlowError("EMPTY_PARAM", `No Markdown input received on stdin.\n\nExample:\n  ${usageExample("bind")}`);
     }
     return stdin;
@@ -80,77 +83,6 @@ function makeAbortSignal() {
 function responseText(response) {
     return response.text;
 }
-function responseData(response) {
-    const payload = response.payload;
-    if (!payload || typeof payload !== "object" || Array.isArray(payload) || "error" in payload)
-        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;
-    const warnings = Array.isArray(meta?.warnings) ? meta.warnings.filter((warning) => typeof warning === "string") : [];
-    if (responsePath) {
-        lines.push(`Saved to ${responsePath}.`);
-    }
-    if (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, flags, response) {
-    // Plain tell is always silent; tell --wait owns the ordinary wait response.
-    if (command === "tell" && flags.timeoutMs === undefined)
-        return;
-    if (command === "bind" && flags.dryRun) {
-        // Canonical Markdown already ends with exactly one newline.
-        process.stdout.write(responseText(response));
-        return;
-    }
-    if (command !== "revive") {
-        process.stdout.write(`${responseText(response)}\n`);
-        return;
-    }
-    const data = responseData(response);
-    const answer = typeof data.summary === "string" ? data.summary.trim() : responseText(response).trim();
-    const footer = conversationalFooter(response);
-    process.stdout.write(`${answer}\n`);
-    if (footer) {
-        process.stderr.write(`${footer}\n`);
-    }
-}
 async function saveFailedStdin(input) {
     if (!input.content.trim())
         return undefined;
@@ -160,12 +92,49 @@ async function saveFailedStdin(input) {
         content: input.content,
     });
 }
-function retryHint(command, draftPath, cwd, cwdFlag) {
-    if (!cwdFlag) {
-        return `Retry: keiyaku ${command} < ${shellQuote(draftPath)}`;
+/**
+ * Rebuild bind flags for a failed-stdin retry in deterministic shell-safe order.
+ * Order follows bind usage/parse authority: cwd, repo, after, exclusive,
+ * draft-only, task. Domain-flag bind does not save stdin, so place/objective/
+ * scope/checks are not reconstructed. --dry-run never reaches this path.
+ */
+function bindRetryFlagTokens(flags) {
+    const tokens = [];
+    if (flags.cwd !== undefined) {
+        tokens.push("--cwd", shellQuote(flags.cwd));
+    }
+    if (flags.repo !== undefined) {
+        tokens.push("--repo", shellQuote(flags.repo));
+    }
+    for (const after of flags.after ?? []) {
+        tokens.push("--after", shellQuote(after));
+    }
+    if (flags.exclusive === true) {
+        tokens.push("--exclusive");
+    }
+    if (flags.draftOnly === true) {
+        tokens.push("--draft-only");
+    }
+    if (flags.bindTaskIds !== undefined) {
+        for (const taskId of flags.bindTaskIds) {
+            tokens.push("--task", shellQuote(taskId));
+        }
     }
-    const absoluteDraftPath = path.resolve(cwd, draftPath);
-    return `Retry: keiyaku ${command} --cwd ${shellQuote(cwdFlag)} < ${shellQuote(absoluteDraftPath)}`;
+    return tokens;
+}
+function retryHint(input) {
+    const draftArg = input.flags.cwd === undefined
+        ? shellQuote(input.draftPath)
+        : shellQuote(path.resolve(input.cwd, input.draftPath));
+    if (input.command === "bind") {
+        const flagTokens = bindRetryFlagTokens(input.flags);
+        const flagPart = flagTokens.length > 0 ? ` ${flagTokens.join(" ")}` : "";
+        return `Retry: keiyaku bind${flagPart} < ${draftArg}`;
+    }
+    if (input.flags.cwd === undefined) {
+        return `Retry: keiyaku ${input.command} < ${shellQuote(input.draftPath)}`;
+    }
+    return `Retry: keiyaku ${input.command} --cwd ${shellQuote(input.flags.cwd)} < ${draftArg}`;
 }
 async function printFailure(error, cwd) {
     const response = await handleCliError({
@@ -195,7 +164,12 @@ async function handleFailureAfterStdin(input) {
             content: input.stdin,
         });
         if (draftPath) {
-            process.stderr.write(`\nSaved stdin input to ${draftPath}.\n${retryHint(input.command, draftPath, input.cwd, input.cwdFlag)}\n`);
+            process.stderr.write(`\nSaved stdin input to ${draftPath}.\n${retryHint({
+                command: input.command,
+                draftPath,
+                cwd: input.cwd,
+                flags: input.flags,
+            })}\n`);
         }
     }
     catch (draftError) {
@@ -309,9 +283,9 @@ export async function runCliCommand(tokens) {
             return await handleFailureAfterStdin({
                 error,
                 cwd,
-                cwdFlag: parsed.flags.cwd,
                 command: parsed.command,
                 stdin,
+                flags: parsed.flags,
                 saveStdin: !(parsed.command === "bind" && hasBindDomainFlags(parsed.flags)),
             });
         }
@@ -329,9 +303,9 @@ export async function runCliCommand(tokens) {
         return await handleFailureAfterStdin({
             response,
             cwd,
-            cwdFlag: parsed.flags.cwd,
             command: parsed.command,
             stdin,
+            flags: parsed.flags,
             saveStdin: !(parsed.command === "bind" && hasBindDomainFlags(parsed.flags)),
         });
     }

package/build/cli/missing-subcommand.js

@@ -0,0 +1,7 @@
+import { FlowError } from "../flow-error.js";
+export function formatSubcommandList(subcommands) {
+    return subcommands.length < 2 ? (subcommands[0] ?? "") : `${subcommands.slice(0, -1).join(", ")} or ${subcommands.at(-1)}`;
+}
+export function missingSubcommandError(name, subcommands) {
+    return new FlowError("EMPTY_PARAM", `${name} requires subcommand: ${formatSubcommandList(subcommands)}`);
+}

package/build/cli/parse-flags.js

@@ -1,5 +1,5 @@
 import { FlowError } from "../flow-error.js";
-import { getCommandMetadata } from "./commands/registry.js";
+import { getCommandMetadata } from "./commands/metadata.js";
 import { BOOLEAN_FLAGS, CONTROL_FLAGS, SHORT_FLAG_ALIASES, VALUE_FLAGS, } from "./flags.js";
 import { normalizeContractAddress, parseWaitTimeout } from "./parse-metadata.js";
 function allowedFlagsForParse(command) {
@@ -85,10 +85,7 @@ export function assignFlag(flags, name, value) {
             flags.bindChecks = String(value);
             return;
         case "task":
-            if (flags.bindTaskId !== undefined) {
-                throw new FlowError("EMPTY_PARAM", "option --task may only be specified once");
-            }
-            flags.bindTaskId = String(value);
+            flags.bindTaskIds = [...(flags.bindTaskIds ?? []), String(value)];
             return;
         case "after":
             flags.after = [...(flags.after ?? []), String(value)];
@@ -105,6 +102,15 @@ export function assignFlag(flags, name, value) {
         case "waive":
             flags.waivePaths = [...(flags.waivePaths ?? []), String(value)];
             return;
+        case "resolve":
+            flags.renewResolve = Boolean(value);
+            return;
+        case "continue":
+            flags.renewContinue = Boolean(value);
+            return;
+        case "abort":
+            flags.renewAbort = Boolean(value);
+            return;
         case "shell":
             flags.shell = String(value);
             return;
@@ -120,6 +126,9 @@ export function assignFlag(flags, name, value) {
         case "all":
             flags.all = Boolean(value);
             return;
+        case "any":
+            flags.any = Boolean(value);
+            return;
         case "target":
             if (flags.target !== undefined) {
                 throw new FlowError("EMPTY_PARAM", "option --target may only be specified once");

package/build/cli/parse-metadata.js

@@ -1,6 +1,6 @@
 import { FlowError } from "../flow-error.js";
 import { HELP_FLAGS, SHORT_FLAG_ALIASES, VALUE_FLAGS } from "./flags.js";
-import { commandParseOrder, getCommandMetadata } from "./commands/registry.js";
+import { commandParseOrder, getCommandMetadata } from "./commands/metadata.js";
 import { TASK_SUBCOMMANDS } from "./types.js";
 export function normalizeContractAddress(raw) {
     const value = raw.startsWith("@") ? raw.slice(1) : raw;
@@ -75,7 +75,7 @@ export function commandPositionalRange(command) {
         return { min: 1, max: 2, label: "<ARTIFACT> [BODY|-]" };
     }
     if (command === "wait") {
-        return { min: 1, max: 1, label: "<projection-address>" };
+        return { min: 0, max: Number.MAX_SAFE_INTEGER, label: "<projection-address>" };
     }
     if (command === "kill") {
         return { min: 1, max: 1, label: "<projection-address>" };
@@ -86,7 +86,7 @@ export function commandPositionalRange(command) {
     if (command === "task add") {
         return { min: 1, max: 1, label: "<BODY|->" };
     }
-    if (command === "task view" || command === "task start" || command === "task drop") {
+    if (command === "task show" || command === "task start" || command === "task drop") {
         return { min: 1, max: 1, label: "<ID>" };
     }
     if (command === "task update") {

package/build/cli/parse-selectors.js

@@ -56,7 +56,7 @@ export function assertProjectionSelectorPresent(command, flags, atTokens, contra
         ? atTokens[0] ?? `@${flags.contractId}`
         : `--contract ${contractFlagRaws[0] ?? flags.contractId}`;
     const message = `${command} requires a projection id or alias; ${selectorSpelling} only limits projection lookup, so add the projection address`;
-    if (command === "wait" && restLength + payloadLength === 0) {
+    if (command === "wait" && restLength + payloadLength === 0 && !flags.any && !flags.all) {
         throw new FlowError("EMPTY_PARAM", message);
     }
     if (command === "tell" && restLength === 0) {

package/build/cli/parse.js

@@ -5,6 +5,7 @@ import { HELP_FLAGS } from "./flags.js";
 import { assertAllowedFlag, assignFlag, BOOLEAN_FLAGS, CONTROL_FLAGS, parseFlagName, readValueFlag, SHORT_FLAG_ALIASES, VALUE_FLAGS, } from "./parse-flags.js";
 import { commandPositionalRange, commandRequiresStdin, isCallCommand, resolveCommand, splitAtLiteralBoundary, TASK_SUBCOMMANDS, } from "./parse-metadata.js";
 import { applyCommissionSelector, assertCommissionSelectorAllowed, assertProjectionSelectorPresent, } from "./parse-selectors.js";
+import { WAIT_SET_SELECTION_ERROR } from "./commands/projection/wait/meta.js";
 export { commandPositionalRange, commandUsesPromptInput, isCallCommand, isPetitionDryRunInvocation, normalizeContractAddress, parseWaitTimeout, } from "./parse-metadata.js";
 export function parseCliArgs(tokens) {
     const { head, payload } = splitAtLiteralBoundary(tokens);
@@ -120,6 +121,9 @@ export function parseCliArgs(tokens) {
     if (command === "task ls" && flags.all && flags.done) {
         throw new FlowError("EMPTY_PARAM", "task ls cannot combine --all and --done");
     }
+    if (command === "wait" && flags.any && flags.all) {
+        throw new FlowError("EMPTY_PARAM", WAIT_SET_SELECTION_ERROR);
+    }
     if (command === "task update" && flags.taskParent !== undefined && flags.taskNoParent) {
         throw new FlowError("EMPTY_PARAM", "task update cannot combine --parent and --no-parent");
     }
@@ -131,9 +135,26 @@ export function parseCliArgs(tokens) {
     if (command === "petition" && flags.json && !flags.dryRun) {
         throw new FlowError("EMPTY_PARAM", "petition --json requires --dry-run");
     }
+    if (command === "renew") {
+        const recoveryModes = [flags.renewResolve, flags.renewContinue, flags.renewAbort].filter(Boolean).length;
+        if (recoveryModes > 1) {
+            throw new FlowError("EMPTY_PARAM", "renew accepts only one of --resolve, --continue, or --abort");
+        }
+        if (flags.renewAbort && (flags.waivePaths?.length ?? 0) > 0) {
+            throw new FlowError("EMPTY_PARAM", "renew --abort does not accept --waive");
+        }
+    }
     assertCommissionSelectorAllowed(command, flags);
     assertProjectionSelectorPresent(command, flags, atTokens, contractFlagRaws, rest.length, payload.length);
     const positional = [...rest, ...payload];
+    if (command === "wait") {
+        if (positional.length === 0 && !flags.contractId) {
+            throw new FlowError("EMPTY_PARAM", "wait requires <projection-address>");
+        }
+        if (positional.length > 1 && !flags.any && !flags.all) {
+            throw new FlowError("EMPTY_PARAM", WAIT_SET_SELECTION_ERROR);
+        }
+    }
     if (isCallCommand(command)) {
         if (flags.akuma) {
             if (positional.length > 1) {

package/build/cli/projection-address.js

@@ -1,11 +1,10 @@
 import * as fs from "node:fs";
 import * as path from "node:path";
 import { AddressResolutionError, buildObjectResolutionAttempt, } from "../core/addressing.js";
-import { resolveProjectionCoordinate } from "../core/projection-coordinate.js";
-import { isProjectionId, projectionDir } from "../core/projection-core.js";
-import { isProjectionAlias, readProjectionAlias } from "../core/projection-alias.js";
-import { readProjectionIdentity } from "../core/projection-identity.js";
-import { isProjectionGenerationSchemaV1Residue } from "../core/projection/generation/store.js";
+import { resolveProjectionCoordinate } from "../core/projection/index.js";
+import { isProjectionId, projectionDir } from "../core/projection/index.js";
+import { isProjectionAlias, readProjectionAlias } from "../core/projection/index.js";
+import { readProjectionIdentity } from "../core/projection/index.js";
 import { isResponseArtifactId } from "../core/response-artifact-id.js";
 import { isErrnoException } from "../errno.js";
 function isRealDirectory(directory) {
@@ -41,7 +40,7 @@ export async function resolveProjectionAddress(input) {
         });
     }
     else {
-        const coordinate = resolveProjectionCoordinate(input.cwd);
+        const coordinate = await resolveProjectionCoordinate(input.cwd);
         repo = coordinate.authority.kind === "repository"
             ? { kind: "repository", stableRoot: coordinate.authority.stableRoot }
             : { kind: "user" };
@@ -70,21 +69,17 @@ export async function resolveProjectionAddress(input) {
     else {
         if (!isProjectionAlias(input.address))
             throw new AddressResolutionError("EMPTY_PARAM", `projection alias ${input.address} has no match ${suffix}`, attempt);
-        const target = readProjectionAlias(physicalRoot, input.address);
+        const target = await readProjectionAlias(physicalRoot, input.address);
         if (!target)
             throw new AddressResolutionError("EMPTY_PARAM", `projection alias ${input.address} has no match ${suffix}`, attempt);
         id = target;
         alias = input.address;
     }
-    const directory = projectionDir(physicalRoot, id);
+    const directory = await projectionDir(physicalRoot, id);
     if (!isRealDirectory(directory)) {
         const subject = alias ? `projection alias ${alias} points to missing projection ${id}` : `projection ${id}`;
         throw new AddressResolutionError("EMPTY_PARAM", `${subject} has no match ${suffix}`, attempt);
     }
-    if (isProjectionGenerationSchemaV1Residue(directory)) {
-        const subject = alias ? `projection alias ${alias} points to missing projection ${id}` : `projection ${id}`;
-        throw new AddressResolutionError("EMPTY_PARAM", `${subject} has no match ${suffix}`, attempt);
-    }
     let identity;
     try {
         identity = readProjectionIdentity(directory);

package/build/cli/render/address.js

@@ -1,18 +1,18 @@
-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";
-    }
-}
+import { formatCommissionCoordinate } from "../../core/ids.js";
 function isCommissionAddress(address) {
     return address.binding.kind === "commission";
 }
+function projectionSegment(facts) {
+    if (!facts.projectionId)
+        return undefined;
+    return facts.projectionAlias
+        ? `projection ${facts.projectionId} (${facts.projectionAlias})`
+        : `projection ${facts.projectionId}`;
+}
+/**
+ * Human-facing address receipt. Contract coordinates are `<slug> @<place>` or `<slug>`;
+ * Opaque contract identity, branch ref, binding source, and repo path stay in payload/carrier.
+ */
 export function renderResolvedAddressReceipt(address, facts = {}) {
     if (!isCommissionAddress(address)) {
         if (address.binding.kind === "unbound") {
@@ -22,43 +22,50 @@ export function renderResolvedAddressReceipt(address, facts = {}) {
             return [
                 "Unbound",
                 "no active commission",
-                `repo ${address.repo.stableRoot}`,
                 `workdir ${address.workdir}`,
                 facts.artifactId ? `artifact ${facts.artifactId}` : undefined,
-                facts.projectionId ? `projection ${facts.projectionId}${facts.projectionAlias ? ` (${facts.projectionAlias})` : ""}` : undefined,
+                projectionSegment(facts),
             ].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}${facts.projectionAlias ? ` (${facts.projectionAlias})` : ""}` : undefined,
+            projectionSegment(facts),
         ].filter((part) => part !== undefined).join(" · ");
     }
+    const place = address.place.display;
+    if (facts.akumaName) {
+        if (!facts.projectionId)
+            throw new Error("commissioned call receipt requires projection id");
+        return `call ${facts.akumaName} · ${formatCommissionCoordinate({
+            commissionId: address.binding.commissionId,
+            place,
+        })} · projection ${facts.projectionId} · out there`;
+    }
     return [
-        address.place.display ? `Bound @${address.place.display}` : "Bound",
-        `commission ${address.binding.commissionId}`,
-        `repo ${address.repo.stableRoot}`,
-        `target ${address.target.branch}`,
+        formatCommissionCoordinate({
+            commissionId: address.binding.commissionId,
+            place,
+        }),
         facts.artifactId ? `artifact ${facts.artifactId}` : undefined,
-        facts.projectionId ? `projection ${facts.projectionId}${facts.projectionAlias ? ` (${facts.projectionAlias})` : ""}` : undefined,
-        `via ${sourceLabel(address)}`,
+        projectionSegment(facts),
     ].filter((part) => part !== undefined).join(" · ");
 }
 function renderAttemptCandidate(candidate) {
+    const coordinate = formatCommissionCoordinate({
+        commissionId: candidate.commissionId,
+        place: candidate.place,
+    });
+    const objectiveLine = candidate.objective.split(/\r?\n/, 1)[0]?.trim() ?? "";
+    const objective = objectiveLine.length > 60
+        ? `${objectiveLine.slice(0, 60)}…`
+        : objectiveLine;
     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,
+        coordinate,
+        objective || undefined,
+        candidate.commissionId,
     ].filter((part) => part !== undefined).join(" · ");
 }
 function isCommissionResolutionAttempt(attempt) {
@@ -67,20 +74,17 @@ function isCommissionResolutionAttempt(attempt) {
 export function renderResolutionAttemptPreamble(attempt) {
     if (!isCommissionResolutionAttempt(attempt)) {
         return [
-            attempt.repo.kind === "repository" ? `At repo ${attempt.repo.stableRoot}` : "At no repository",
             attempt.scope ? `scope ${attempt.scope.asTyped}` : undefined,
-        ].filter((part) => part !== undefined).join(" · ");
+        ].filter((part) => part !== undefined).join(" · ") || "resolution failed";
     }
     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(" · ");
+    return parts.filter((part) => part !== undefined).join(" · ") || "resolution failed";
 }
 export function renderAddressCarrier(carrier, facts = {}) {
     return "expected" in carrier

package/build/cli/render/arc.js

@@ -1,7 +1,8 @@
+import { renderSealDiffSection } from "../../core/transcripts.js";
 import { shortCommitHash } from "../../git/commits.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 { appendPersistenceSummary, CONTENT_SECTION_TITLE, HINTS_LIST_MAX_ITEMS, HINTS_SECTION_TITLE, 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)
@@ -15,25 +16,27 @@ function sealLines(result) {
 }
 export function buildArcResponse(result) {
     const { status: _status, address: _address, ...resultData } = result;
+    const diff = renderSealDiffSection(result.sealed, "working tree untouched");
+    const payload = { ...resultData, diff };
     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 }));
     const infoSection = buildSection(INFO_SECTION_TITLE, [
-        ...formatMaybe("Title", result.title, INFO_BRANCH_MAX_CHARS),
+        ...formatMaybe("Title", result.title),
         ...formatMaybe("Objective", result.objective, INFO_PLEA_MAX_CHARS),
         ...formatMaybe("Brief", result.brief, INFO_PLEA_MAX_CHARS),
         ...formatMaybe("Ledger Commit", result.ledgerCommit, INFO_COMMIT_MAX_CHARS),
-        ...formatMaybe(BRANCH_LABEL, result.currentBranch, INFO_BRANCH_MAX_CHARS),
-        ...formatMaybe("Base Branch", result.baseBranch, INFO_BRANCH_MAX_CHARS),
     ]);
     const summaryLine = appendPersistenceSummary(result.summary, result.responsePath);
     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),
+        text: assembleResponse(`${RESPONSE_MARKERS.arc} Arc Opened (a${result.arc})`, summaryLine, [summarySection, infoSection, buildSection(DIFF_OVERVIEW_SECTION_TITLE, diff), warningSection, hintsSection].filter((section) => section !== null)),
+        payload: buildPayload(payload, result.responsePath),
     }, result.address);
 }
 export function buildRenewResponse(result) {
     const { status: _status, address: _address, ...resultData } = result;
+    const diff = renderSealDiffSection(result.sealed, "nothing sealed");
+    const payload = { ...resultData, diff };
     const infoSection = buildSection(INFO_SECTION_TITLE, [
         ...formatMaybe("Old Base", result.oldBase, INFO_COMMIT_MAX_CHARS),
         ...formatMaybe("New Base", result.newBase, INFO_COMMIT_MAX_CHARS),
@@ -42,22 +45,31 @@ export function buildRenewResponse(result) {
         ...formatMaybe("Ledger Head", result.ledgerHead, INFO_COMMIT_MAX_CHARS),
         ...formatList("Seal", sealLines(result)),
     ]);
+    const warningSection = buildSection(WARNING_SECTION_TITLE, formatWarnings(result.meta?.warnings ?? []));
     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),
+        text: assembleResponse(`${RESPONSE_MARKERS.arc} Renewed`, appendPersistenceSummary(result.summary, result.responsePath), [buildSection(CONTENT_SECTION_TITLE, diff), infoSection, warningSection].filter((section) => section !== null)),
+        payload: buildPayload(payload, result.responsePath),
     }, result.address);
 }
+export function buildRenewAbortResponse(result) {
+    const payload = {
+        contractId: result.contractId,
+        oldHead: result.oldHead,
+        recoveryCleanup: result.recoveryCleanup,
+        summary: result.summary,
+    };
+    return prependAddressReceipt({ text: result.summary, payload }, result.address);
+}
 export function buildAmendResponse(result) {
     const { status: _status, address: _address, ...resultData } = result;
+    const payload = resultData;
     const renderedLedgerCommit = shortCommitHash(result.ledgerCommit);
     const infoSection = buildSection(INFO_SECTION_TITLE, [
         ...formatMaybe("Amendment", String(result.amendmentNumber), INFO_COMMIT_MAX_CHARS),
-        ...formatMaybe(BRANCH_LABEL, result.currentBranch, INFO_BRANCH_MAX_CHARS),
-        ...formatMaybe("Base Branch", result.baseBranch, INFO_BRANCH_MAX_CHARS),
         ...formatMaybe("Ledger Commit", renderedLedgerCommit, INFO_COMMIT_MAX_CHARS),
     ]);
     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),
+        text: assembleResponse(`${RESPONSE_MARKERS.arc} Amended`, `Amended contract ledger with Amendment ${result.amendmentNumber} [${renderedLedgerCommit}].`, [buildSection(CONTENT_SECTION_TITLE, result.summary), infoSection].filter((section) => section !== null)),
+        payload: buildPayload(payload),
     }, result.address);
 }

package/build/cli/render/call.js

@@ -2,9 +2,13 @@ import { assembleResponse, buildPayload, buildSection, formatMaybe, formatWarnin
 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, alias, previousAliasTarget) {
+export function renderAdoptedLaunchReceipt(address, projectionId, alias, previousAliasTarget, akumaName) {
     return [
-        renderResolvedAddressReceipt(address, { projectionId, ...(alias ? { projectionAlias: alias } : {}) }),
+        renderResolvedAddressReceipt(address, {
+            projectionId,
+            ...(alias ? { projectionAlias: alias } : {}),
+            ...(akumaName ? { akumaName } : {}),
+        }),
         ...(alias ? [`alias ${alias} → ${projectionId}`] : []),
         ...(alias && previousAliasTarget ? [`(moved from ${previousAliasTarget}, still running)`] : []),
         ...projectionRejoinHintLines(alias ?? projectionId),
@@ -15,14 +19,15 @@ export function buildCallResponse(result, input) {
         if (!result.projection)
             throw new Error("launched call response requires projection facts");
         const { session: _session, evidenceCwd: _evidenceCwd, address: _address, foregroundWait: _foregroundWait, ...responseData } = result;
+        const payload = responseData;
         const output = {
             text: input.addressPlacement === "stdout"
-                ? renderAdoptedLaunchReceipt(result.address, result.projection.id, result.projection.alias, result.projection.previousAliasTarget)
+                ? renderAdoptedLaunchReceipt(result.address, result.projection.id, result.projection.alias, result.projection.previousAliasTarget, result.agent ?? input.agent)
                 : [
                     ...(result.projection.alias ? [`alias ${result.projection.alias} → ${result.projection.id}`] : []),
                     ...projectionRejoinHintLines(result.projection.alias ?? result.projection.id),
                 ].join("\n"),
-            payload: buildPayload(responseData),
+            payload: buildPayload(payload),
         };
         switch (input.addressPlacement) {
             case "stdout":
@@ -49,9 +54,10 @@ export function buildCallResponse(result, input) {
         repositoryCoordinate,
     })}`;
     const { session: _session, evidenceCwd: _evidenceCwd, address: _address, foregroundWait: _foregroundWait, ...responseData } = result;
+    const payload = responseData;
     const output = {
         text,
-        payload: buildPayload(responseData, input.responsePath),
+        payload: buildPayload(payload, input.responsePath),
     };
     switch (input.addressPlacement) {
         case "stdout":