@astrosheep/keiyaku 2.9.3 → 2.9.5

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 { assertProjectionTellable, 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,22 @@ 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);
-    }
+    // Historical projection storage has no current identity to resolve. Tell
+    // still reaches its typed no-mutation refusal instead of exposing storage
+    // parser details or creating a mailbox row.
+    if (input.verb === "tell")
+        assertProjectionTellable(directory);
     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/audit.js

@@ -0,0 +1,121 @@
+import { asMessage, FlowError } from "../../flow-error.js";
+function streamLines(name, result) {
+    const stream = result[name];
+    return [
+        `${name} tail (${stream.truncated ? `truncated, ${stream.omittedBytes} bytes omitted` : "complete, 0 bytes omitted"}):`,
+        stream.tail || "(empty)",
+    ];
+}
+function renderVerification(report) {
+    if (report.verification.status === "not_configured")
+        return ["not configured"];
+    if (report.verification.status === "not_evaluated")
+        return [`not evaluated: ${report.verification.reason}`];
+    if (report.verification.status === "unknown")
+        return [`unknown: ${report.verification.cause.code}: ${report.verification.cause.message}`];
+    const lines = [];
+    for (const result of report.verification.results) {
+        lines.push(`command ${result.label}`, `exec ${result.command}`, `argv ${JSON.stringify(result.argv)}`, `head ${result.head}`);
+        if (result.status === "unverifiable") {
+            lines.push(`not executable: ${result.cause}`, "");
+            continue;
+        }
+        lines.push(`\`\`\`${result.executor}`, result.body, "\`\`\`", `exit ${result.exitCode} · duration ${result.durationMs}ms`, ...streamLines("stdout", result), ...streamLines("stderr", result), "");
+    }
+    return lines;
+}
+function renderScope(report) {
+    if (!report.scope)
+        return ["not evaluated"];
+    return report.scope.flatMap((row) => {
+        const decisive = row.matcher.decisivePattern
+            ? `rule ${row.matcher.decisivePattern.index}:${row.matcher.decisivePattern.pattern} (${row.matcher.decisivePattern.effect})`
+            : `rule none (${row.matcher.outcome})`;
+        const explanations = row.explanations.map((item) => {
+            if (item.kind === "file-rename")
+                return `  explain file rename ${item.from} -> ${item.to} (${item.similarity}%)`;
+            if (item.kind === "symbol-rename")
+                return `  explain symbol rename ${item.from} -> ${item.to} at h${item.hunk} old:${item.oldLine ?? "-"} new:${item.newLine ?? "-"}`;
+            return `  explain import at h${item.hunk} old:${item.oldLine ?? "-"} new:${item.newLine ?? "-"}`;
+        });
+        const residue = row.residue.map((item) => `  residue h${item.hunk} old:${item.oldLine ?? "-"} new:${item.newLine ?? "-"} ${item.kind} ${item.content}`);
+        return [`${row.class} ${row.path} · ${decisive}`, ...explanations, ...residue];
+    });
+}
+function renderReadiness(report) {
+    const readiness = report.readiness;
+    if (!readiness)
+        return ["not evaluated: coordinate race"];
+    return [
+        `delivery residue tracked=${readiness.deliveryResidue.tracked.length} staged=${readiness.deliveryResidue.staged.length} unstaged=${readiness.deliveryResidue.unstaged.length} untracked=${readiness.deliveryResidue.untracked.length}`,
+        `arc open=${readiness.arc.open ?? "none"} max=${readiness.arc.max} fence=${readiness.arc.fence} loose=${readiness.arc.looseCommits.length}`,
+        `renew session=${readiness.renewSession.open ? "open" : "none"}`,
+        `rewrite guard=${readiness.rewriteGuard.liveProjection ? "live projection" : "clear"}`,
+        ...readiness.dependencies.map((item) => `dependency ${item.id} ${item.satisfied ? "satisfied" : `open (${item.state})`}`),
+        `petition state=${readiness.petition.state}${readiness.petition.queue ? ` queue=${readiness.petition.queue.position ?? "?"}/${readiness.petition.queue.length}` : " queue=none"}`,
+    ];
+}
+function omissionLine(omission) {
+    const subject = omission.hunk === null ? "file" : `hunk ${omission.hunk}`;
+    return `omit ${subject} ${omission.path} · ${omission.bytes} bytes · ${omission.reason} · retrieve ${omission.retrieval.argv.map((part) => JSON.stringify(part)).join(" ")}`;
+}
+function renderDiff(report) {
+    if (!report.diff || !report.presentation)
+        return ["not evaluated"];
+    const selected = report.presentation.selected.map((item) => item.content);
+    const omissions = report.presentation.omissions.map(omissionLine);
+    const rows = report.files?.map((file) => `${file.status} ${file.oldPath ? `${file.oldPath} -> ` : ""}${file.path} · +${file.stats.insertions} -${file.stats.deletions} · ${file.class}`) ?? [];
+    return [
+        `${report.diff.stat.filesChanged} files · +${report.diff.stat.insertions} -${report.diff.stat.deletions}`,
+        `budget ${report.presentation.budget.limit} bytes · used ${report.presentation.budget.used} bytes · omissions ${report.presentation.omissions.length}`,
+        ...rows,
+        ...selected,
+        ...omissions,
+    ];
+}
+export function buildAuditResponse(report, json) {
+    const payload = report;
+    if (json)
+        return { text: JSON.stringify(report), payload };
+    const text = [
+        `Audit ${report.contract}`,
+        "",
+        "Coordinates",
+        `ledger ${report.coordinates.ledger.head}`,
+        `delivery ${report.coordinates.delivery.ref} ${report.coordinates.delivery.head} tree ${report.coordinates.delivery.tree}`,
+        `target ${report.coordinates.target.ref} ${report.coordinates.target.head} tree ${report.coordinates.target.tree}`,
+        "",
+        "Criteria",
+        ...report.terms.criteria.map((term) => `criterion ${term}`),
+        ...report.terms.scope.map((term) => `scope ${term}`),
+        ...report.terms.appendScope.map((term) => `append-scope ${term}`),
+        "",
+        "Renew Rehearsal",
+        JSON.stringify(report.rehearsal),
+        "",
+        "Diff",
+        ...renderDiff(report),
+        `counts files=${report.counts.files} selected=${report.counts.selected} omitted=${report.counts.omitted} in-scope=${report.counts.inScope} downgraded=${report.counts.downgraded} violated=${report.counts.violated} findings=${report.counts.findings}`,
+        "",
+        "Scope",
+        ...renderScope(report),
+        "",
+        "Verification",
+        ...renderVerification(report),
+        "Readiness",
+        ...renderReadiness(report),
+        "",
+        "Findings",
+        ...(report.findings.length === 0 ? ["none"] : report.findings.flatMap((finding) => [`${finding.code}: ${finding.detail}`, `Next: ${finding.nextCommand}`])),
+    ].join("\n");
+    return { text, payload };
+}
+export function buildAuditConstructionFailure(error, json) {
+    const cause = { code: error instanceof FlowError ? error.code : "INTERNAL_STATE", message: asMessage(error) };
+    const payload = { audit: { status: "construction_failed", cause } };
+    return {
+        text: json ? JSON.stringify(payload) : `Audit construction failure\n${cause.code}: ${cause.message}`,
+        payload,
+        exitCode: 1,
+    };
+}

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":

package/build/cli/render/errors.js

@@ -6,6 +6,40 @@ 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";
+function renderScopeViolation(evidence) {
+    if (evidence.outcome === "no-positive-match") {
+        return `  ${evidence.path}\n    no positive pattern matched`;
+    }
+    const decisions = evidence.patterns.map((decision) => {
+        const isDecisive = evidence.decisivePattern?.index === decision.index
+            && evidence.decisivePattern?.pattern === decision.pattern;
+        const effectLabel = decision.effect === "exclude" ? "excluded" : "included";
+        if (isDecisive) {
+            return `    ${decision.pattern} → decisive (${effectLabel})`;
+        }
+        return `    ${decision.pattern} → ${effectLabel}`;
+    });
+    return `  ${evidence.path}\n${decisions.join("\n")}`;
+}
+/** CLI face for scope_violation facts. Preserves pre-migration multi-line bytes. */
+export function renderScopeAuditMessage(scope, evidence) {
+    const count = evidence.length;
+    const fileLabel = count === 1 ? "file" : "files";
+    const body = evidence.map(renderScopeViolation).join("\n\n");
+    return [
+        `scope violation — ${count} ${fileLabel} outside declared scope:`,
+        "",
+        body,
+        "",
+        `declared scope: ${scope.join("  ")}`,
+    ].join("\n");
+}
+function renderErrorMessage(error) {
+    if (isFlowError(error) && error.facts?.kind === "scope_violation") {
+        return renderScopeAuditMessage(error.facts.scope, error.facts.violations);
+    }
+    return asMessage(error);
+}
 export function classifyCliError(error) {
     if (isFlowError(error)) {
         return { errorType: "keiyaku_error", errorCode: error.code };
@@ -26,7 +60,7 @@ async function getAvailableActorNames(cwd, fallback) {
     }
 }
 export async function handleCliError(input) {
-    const message = asMessage(input.error);
+    const message = renderErrorMessage(input.error);
     appendDebugLog(`${input.logLabel} error: ${message}`, { cwd: input.cwd, section: "script" });
     const availableActorNames = await getAvailableActorNames(input.cwd, BUILTIN_AGENT_NAMES);
     const hints = pickHintsFromError(input.error, {
@@ -42,6 +76,7 @@ export async function handleCliError(input) {
         message,
         hints,
         review: isFlowError(input.error) ? input.error.review : undefined,
+        facts: isFlowError(input.error) ? input.error.facts : undefined,
         errorType,
         errorCode,
         addressCarrier: addressCarrierFromError(input.error),

package/build/cli/render/format.js

@@ -212,6 +212,10 @@ function truncateStructuredObject(data, parentKey) {
     }
     return truncated;
 }
+/**
+ * Final serialization boundary for command payloads: optional responsePath stamp
+ * plus structured truncation. Callers supply a named *Payload that is JsonObject-compatible.
+ */
 export function buildPayload(data, responsePath) {
     const dataWithPath = responsePath ? { ...data, responsePath } : data;
     const truncatedData = truncateStructuredObject(dataWithPath);

package/build/cli/render/kanshi.js

@@ -4,9 +4,6 @@ function shortHead(hash) {
         return "????????";
     return hash.slice(0, 7);
 }
-function compactWhitespace(value) {
-    return value.replace(/\s+/g, " ").trim();
-}
 function arcSparkline(arcs) {
     if (arcs <= 0)
         return "";
@@ -35,31 +32,28 @@ export function renderKanshiBoard(status) {
     const head = shortHead(status.defaultHead);
     if (status.contracts.length === 0) {
         if (status.targetFilter !== null) {
-            return `現世 ${head} · target ${status.targetFilter}\nno commissions on target ${status.targetFilter}\n`;
+            return `現世 ${head} · target selected\nno commissions on selected target\n`;
         }
         return `現世 ${head} 无在飞契约\n`;
     }
     const header = status.targetFilter !== null
-        ? `現世 ${head} · target ${status.targetFilter}`
+        ? `現世 ${head} · target selected`
         : `現世 ${head}`;
     const lines = [header, ""];
     for (const contract of status.contracts) {
         const glyph = kanshiGlyph(contract);
-        const name = contract.slug;
+        const name = contract.place ? `${contract.slug} @${contract.place}` : contract.slug;
         const spark = arcSparkline(contract.arcs);
         const facts = [];
         const lifecycle = contract.state.state;
         if (lifecycle === "bound" || lifecycle === "active" || lifecycle === "petitioned") {
             facts.push(lifecycle);
         }
-        if (contract.place) {
-            facts.push(`@${contract.place}`);
-        }
-        const arcObjective = compactWhitespace(contract.currentArc.objective || "(no arc objective)");
         const arcMark = contract.currentArc.state === "open"
             ? `a${contract.currentArc.number}+`
             : `a${contract.currentArc.number}`;
-        facts.push(`${arcMark} ${arcObjective}`);
+        facts.push(contract.title);
+        facts.push(arcMark);
         facts.push(`next ${contract.nextStep.detail}`);
         const age = formatAgeMs(contract.lastActiveMs);
         if (age)
@@ -99,7 +93,7 @@ export function renderKanshiBoard(status) {
                 lines.push(`  ! seat ${diagnostic.seat} duplicated with ${diagnostic.with} · ordered by contract id`);
                 continue;
             }
-            lines.push(`  ! target mismatch · petitioned ${diagnostic.petitioned} · derived ${diagnostic.derived}`);
+            lines.push("  ! target mismatch");
         }
     }
     return `${lines.join("\n")}\n`;

package/build/cli/render/kill.js

@@ -0,0 +1,9 @@
+import { textResponse } from "./shared.js";
+/** Default kill acceptance: intent landed; wait is still required for the terminal face. */
+export function buildKillAcceptedResponse(projectionId) {
+    return textResponse(`✓ kill ${projectionId}\n» keiyaku wait ${projectionId}`);
+}
+/** Kill against an already-terminal generation. */
+export function buildKillAlreadyClosedResponse(projectionId) {
+    return textResponse(`· ${projectionId} already closed`);
+}