@astrosheep/keiyaku 2.9.4 → 2.9.5

package/build/cli/index.js

@@ -5,16 +5,19 @@ import { compileBindDraftFlags } from "../core/draft.js";
 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 { isPetitionDryRunInvocation, parseCliArgs } from "./parse.js";
 import { getCommandMetadata } from "./commands/metadata.js";
 import { loadCommandHandler } from "./commands/registry.js";
 import { shellQuote } from "./render/format.js";
 import { writeSuccessResponse } from "./render/success-response.js";
+import { writeCliOutput } from "./output-stream-error-policy.js";
 function commandRequiresStdin(command) {
-    return getCommandMetadata(command).stdin === "required";
+    const stdin = getCommandMetadata(command).stdin;
+    return stdin.mode === "document" && stdin.selector.required;
 }
 function commandAcceptsOptionalStdin(command) {
-    return getCommandMetadata(command).stdin === "optional";
+    const stdin = getCommandMetadata(command).stdin;
+    return stdin.mode === "document" && !stdin.selector.required;
 }
 function commandSavesFailedStdin(command) {
     return (commandRequiresStdin(command) || commandAcceptsOptionalStdin(command)) && command !== "call";
@@ -67,8 +70,6 @@ function prepareBindInput(stdin, flags) {
     return stdin;
 }
 async function readStdin() {
-    if (process.stdin.isTTY)
-        return "";
     let data = "";
     process.stdin.setEncoding("utf-8");
     for await (const chunk of process.stdin)
@@ -129,12 +130,12 @@ function retryHint(input) {
     if (input.command === "bind") {
         const flagTokens = bindRetryFlagTokens(input.flags);
         const flagPart = flagTokens.length > 0 ? ` ${flagTokens.join(" ")}` : "";
-        return `Retry: keiyaku bind${flagPart} < ${draftArg}`;
+        return `Retry: keiyaku bind${flagPart} - < ${draftArg}`;
     }
     if (input.flags.cwd === undefined) {
-        return `Retry: keiyaku ${input.command} < ${shellQuote(input.draftPath)}`;
+        return `Retry: keiyaku ${input.command} - < ${shellQuote(input.draftPath)}`;
     }
-    return `Retry: keiyaku ${input.command} --cwd ${shellQuote(input.flags.cwd)} < ${draftArg}`;
+    return `Retry: keiyaku ${input.command} --cwd ${shellQuote(input.flags.cwd)} - < ${draftArg}`;
 }
 async function printFailure(error, cwd) {
     const response = await handleCliError({
@@ -142,14 +143,14 @@ async function printFailure(error, cwd) {
         cwd,
         logLabel: "cli",
     });
-    process.stderr.write(`${responseText(response)}\n`);
+    await writeCliOutput(process.stderr, `${responseText(response)}\n`);
 }
 function failureExitCode(error) {
     return error instanceof Error && error.name === "AbortError" ? 130 : 1;
 }
 async function handleFailureAfterStdin(input) {
     if (input.response) {
-        process.stderr.write(`${responseText(input.response)}\n`);
+        await writeCliOutput(process.stderr, `${responseText(input.response)}\n`);
     }
     else {
         await printFailure(input.error ?? new Error("Unknown CLI failure"), input.cwd);
@@ -164,7 +165,7 @@ async function handleFailureAfterStdin(input) {
             content: input.stdin,
         });
         if (draftPath) {
-            process.stderr.write(`\nSaved stdin input to ${draftPath}.\n${retryHint({
+            await writeCliOutput(process.stderr, `\nSaved stdin input to ${draftPath}.\n${retryHint({
                 command: input.command,
                 draftPath,
                 cwd: input.cwd,
@@ -173,7 +174,7 @@ async function handleFailureAfterStdin(input) {
         }
     }
     catch (draftError) {
-        process.stderr.write(`\nFailed to save stdin input: ${asMessage(draftError)}\n`);
+        await writeCliOutput(process.stderr, `\nFailed to save stdin input: ${asMessage(draftError)}\n`);
     }
     return 1;
 }
@@ -182,38 +183,42 @@ async function runResponse(command, flags, stdin, positional) {
     const handler = await loadCommandHandler(command);
     return await handler(stdin, flags, signal, positional);
 }
-function bodyToken(command, positional) {
-    if (isCallCommand(command))
-        return positional[0];
-    if (command === "tell")
-        return positional[1];
-    if (command === "revive")
-        return positional[1];
-    return undefined;
-}
-async function readBodyInput(command, positional, cwd) {
-    if (!commandUsesPromptInput(command))
-        return undefined;
-    const token = bodyToken(command, positional);
-    if (token === undefined) {
-        if (command === "revive")
-            return "";
-        await printFailure(new FlowError("EMPTY_PARAM", `${command} body cannot be empty`), cwd);
-        return undefined;
-    }
-    if (token !== "-") {
-        if (!token.trim()) {
-            await printFailure(new FlowError("EMPTY_PARAM", `${command} body cannot be empty`), cwd);
-            return undefined;
-        }
-        return token;
-    }
-    const stdin = await readStdin();
-    if (!stdin.trim()) {
-        await printFailure(new FlowError("EMPTY_PARAM", `${command} body cannot be empty`), cwd);
+function selectedArgument(parsed) {
+    const stdin = getCommandMetadata(parsed.command).stdin;
+    if (stdin.selector === undefined)
         return undefined;
-    }
-    return stdin;
+    if (stdin.selector.kind === "positional") {
+        return { token: parsed.positional[stdin.selector.index], replace: () => parsed.flags };
+    }
+    const flagName = stdin.selector.name;
+    return {
+        token: parsed.flags[flagName],
+        replace: (value) => ({ ...parsed.flags, [flagName]: value }),
+    };
+}
+async function resolveCliInput(parsed) {
+    const stdinMeta = getCommandMetadata(parsed.command).stdin;
+    const selected = selectedArgument(parsed);
+    const token = selected?.token;
+    const selectsStdin = token === "-";
+    if (selectsStdin && process.stdin.isTTY) {
+        throw new FlowError("EMPTY_PARAM", `${parsed.command} literal '-' requires piped stdin`);
+    }
+    const piped = selectsStdin ? await readStdin() : "";
+    const input = selectsStdin ? piped : token ?? "";
+    if (stdinMeta.selector?.required && token === undefined) {
+        const message = stdinMeta.mode === "document"
+            ? `${parsed.command} requires literal '-' to read Markdown from stdin`
+            : `${parsed.command} body cannot be empty`;
+        throw new FlowError("EMPTY_PARAM", message);
+    }
+    if (token !== undefined && stdinMeta.selector?.rejectBlank && !input.trim()) {
+        const message = stdinMeta.mode === "document"
+            ? `No Markdown input received on stdin.\n\nExample:\n  ${usageExample(parsed.command)}`
+            : `${parsed.command} body cannot be empty`;
+        throw new FlowError("EMPTY_PARAM", message);
+    }
+    return { stdin: input, flags: selected?.replace(input) ?? parsed.flags };
 }
 function usageExample(command) {
     const meta = getCommandMetadata(command);
@@ -229,40 +234,19 @@ export async function runCliCommand(tokens) {
         return isPetitionDryRunInvocation(tokens) ? 2 : 1;
     }
     if (parsed.helpRequested) {
-        process.stdout.write(`${renderCliCommandHelp(resolveCliHelpCommand(parsed.command))}\n`);
+        await writeCliOutput(process.stdout, `${renderCliCommandHelp(resolveCliHelpCommand(parsed.command))}\n`);
         return 0;
     }
     const cwd = parsed.flags.cwd ?? process.cwd();
-    let stdin = "";
-    if (parsed.command === "task add") {
-        if (parsed.positional[0] === "-")
-            stdin = await readStdin();
-        if (!(parsed.positional[0] === "-" ? stdin : parsed.positional[0]).trim()) {
-            await printFailure(new FlowError("EMPTY_PARAM", "task add input cannot be blank"), cwd);
-            return 1;
-        }
-    }
-    else if (parsed.command === "task update" && parsed.flags.taskBody === "-") {
-        stdin = await readStdin();
-    }
-    else if (commandRequiresStdin(parsed.command)) {
-        stdin = await readStdin();
-        if (!stdin.trim()) {
-            await printFailure(new FlowError("EMPTY_PARAM", `No Markdown input received on stdin.\n\nExample:\n  ${usageExample(parsed.command)}`), cwd);
-            return 1;
-        }
-    }
-    else if (commandAcceptsOptionalStdin(parsed.command)) {
-        // Optional stdin: bind prepares domain flags or blank-stdin errors itself;
-        // petition lets an empty body reach the oath gate as OATH_MISSING.
-        stdin = await readStdin();
+    let stdin;
+    try {
+        const resolved = await resolveCliInput(parsed);
+        stdin = resolved.stdin;
+        parsed = { ...parsed, flags: resolved.flags };
     }
-    else {
-        const body = await readBodyInput(parsed.command, parsed.positional, cwd);
-        if (body === undefined && commandUsesPromptInput(parsed.command)) {
-            return 1;
-        }
-        stdin = body ?? "";
+    catch (error) {
+        await printFailure(error, cwd);
+        return 1;
     }
     // Bind dry-run must compile and return before repository/cwd resolution or filesystem effects.
     if (parsed.command === "bind") {
@@ -296,7 +280,7 @@ export async function runCliCommand(tokens) {
     }
     const success = !response.payload || !("error" in response.payload);
     if (success) {
-        writeSuccessResponse(parsed.command, parsed.flags, response);
+        await writeSuccessResponse(parsed.command, parsed.flags, response);
         return response.exitCode ?? 0;
     }
     if (commandRequiresStdin(parsed.command) || (parsed.command === "bind" && !parsed.flags.dryRun)) {
@@ -309,7 +293,7 @@ export async function runCliCommand(tokens) {
             saveStdin: !(parsed.command === "bind" && hasBindDomainFlags(parsed.flags)),
         });
     }
-    process.stderr.write(`${responseText(response)}\n`);
+    await writeCliOutput(process.stderr, `${responseText(response)}\n`);
     return 1;
 }
 export function renderCliCommandHelp(command) {

package/build/cli/output-stream-error-policy.js

@@ -1,3 +1,21 @@
+export function isBrokenPipeError(error) {
+    return (typeof error === "object" &&
+        error !== null &&
+        "code" in error &&
+        error.code === "EPIPE");
+}
+/** Resolve only after Node reports that this chunk has been flushed. */
+export function writeCliOutput(stream, chunk) {
+    return new Promise((resolve, reject) => {
+        stream.write(chunk, (error) => {
+            if (error && !isBrokenPipeError(error)) {
+                reject(error);
+                return;
+            }
+            resolve();
+        });
+    });
+}
 /**
  * Install a process-level broken-pipe policy on each supplied stream.
  * EPIPE is silent; every other emitted value is rethrown unchanged.
@@ -5,12 +23,8 @@
 export function installCliOutputStreamErrorPolicy(...streams) {
     for (const stream of streams) {
         stream.on("error", (error) => {
-            if (typeof error === "object" &&
-                error !== null &&
-                "code" in error &&
-                error.code === "EPIPE") {
+            if (isBrokenPipeError(error))
                 return;
-            }
             throw error;
         });
     }

package/build/cli/parse-flags.js

@@ -99,8 +99,8 @@ export function assignFlag(flags, name, value) {
         case "dry-run":
             flags.dryRun = Boolean(value);
             return;
-        case "waive":
-            flags.waivePaths = [...(flags.waivePaths ?? []), String(value)];
+        case "append-scope":
+            flags.appendScope = [...(flags.appendScope ?? []), String(value)];
             return;
         case "resolve":
             flags.renewResolve = Boolean(value);
@@ -138,9 +138,26 @@ export function assignFlag(flags, name, value) {
         case "json":
             flags.json = Boolean(value);
             return;
+        case "diff-budget": {
+            const parsed = Number(String(value));
+            if (!Number.isSafeInteger(parsed) || parsed < 0) {
+                throw new FlowError("EMPTY_PARAM", "option --diff-budget requires a non-negative safe integer byte count");
+            }
+            flags.auditDiffBudgetBytes = parsed;
+            return;
+        }
         case "done":
             flags.done = Boolean(value);
             return;
+        case "filter":
+            flags.taskFilters = [...(flags.taskFilters ?? []), String(value)];
+            return;
+        case "sort":
+            if (flags.taskSort !== undefined) {
+                throw new FlowError("EMPTY_PARAM", "option --sort may only be specified once");
+            }
+            flags.taskSort = String(value);
+            return;
         case "pri": {
             const raw = String(value);
             if (!/^[0-3]$/.test(raw)) {

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/metadata.js";
+import { commandParseOrder } from "./commands/metadata.js";
 import { TASK_SUBCOMMANDS } from "./types.js";
 export function normalizeContractAddress(raw) {
     const value = raw.startsWith("@") ? raw.slice(1) : raw;
@@ -42,9 +42,6 @@ export function isPetitionDryRunInvocation(tokens) {
     }
     return false;
 }
-export function commandUsesPromptInput(command) {
-    return isCallCommand(command) || command === "tell" || command === "revive";
-}
 export function parseWaitTimeout(value) {
     const matched = /^(?<amount>[1-9][0-9]*)(?<unit>[smh])$/.exec(value);
     if (!matched?.groups) {
@@ -97,9 +94,6 @@ export function commandPositionalRange(command) {
     }
     return { min: 0, max: 0 };
 }
-export function commandRequiresStdin(command) {
-    return getCommandMetadata(command).stdin === "required";
-}
 export function resolveCommand(tokens) {
     if (tokens[0] === "petition" && (tokens[1] === "claim" || tokens[1] === "forfeit")) {
         throw new FlowError("UNKNOWN_COMMAND", `unknown command: petition ${tokens[1]}`);

package/build/cli/parse-selectors.js

@@ -12,6 +12,7 @@ const COMMISSION_SELECTOR_COMMANDS = new Set([
     "renew",
     "petition",
     "forfeit",
+    "audit",
 ]);
 function formatSelectorList(items) {
     if (items.length <= 1) {

package/build/cli/parse.js

@@ -2,11 +2,12 @@ import { FlowError } from "../flow-error.js";
 import { agentNameSchema } from "../config/settings/schema.js";
 import { isResponseArtifactId } from "../core/response-artifact-id.js";
 import { HELP_FLAGS } from "./flags.js";
+import { getCommandMetadata } from "./commands/metadata.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 { commandPositionalRange, 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 { commandPositionalRange, isCallCommand, isPetitionDryRunInvocation, normalizeContractAddress, parseWaitTimeout, } from "./parse-metadata.js";
 export function parseCliArgs(tokens) {
     const { head, payload } = splitAtLiteralBoundary(tokens);
     const flags = {};
@@ -135,13 +136,16 @@ export function parseCliArgs(tokens) {
     if (command === "petition" && flags.json && !flags.dryRun) {
         throw new FlowError("EMPTY_PARAM", "petition --json requires --dry-run");
     }
+    if (command === "petition" && flags.dryRun && (flags.appendScope?.length ?? 0) > 0) {
+        throw new FlowError("EMPTY_PARAM", "petition --dry-run does not accept --append-scope");
+    }
     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");
+        if (flags.renewAbort && (flags.appendScope?.length ?? 0) > 0) {
+            throw new FlowError("EMPTY_PARAM", "renew --abort does not accept --append-scope");
         }
     }
     assertCommissionSelectorAllowed(command, flags);
@@ -184,9 +188,14 @@ export function parseCliArgs(tokens) {
     if (positional.length < positionalRange.min) {
         throw new FlowError("EMPTY_PARAM", `${command} requires ${positionalRange.label ?? "an argument"}`);
     }
-    if (positional.length > positionalRange.max) {
-        const message = commandRequiresStdin(command)
-            ? `${command} reads Markdown from stdin; file path arguments are not supported`
+    const stdin = getCommandMetadata(command).stdin;
+    const documentStdinSelector = stdin.mode === "document"
+        && stdin.selector.kind === "positional"
+        && positional.length === stdin.selector.index + 1
+        && positional[stdin.selector.index] === "-";
+    if (positional.length > positionalRange.max && !documentStdinSelector) {
+        const message = stdin.mode === "document"
+            ? `${command} reads Markdown only through literal '-'; file path arguments are not supported`
             : `${command} does not accept positional arguments`;
         throw new FlowError("EMPTY_PARAM", message);
     }

package/build/cli/projection-address.js

@@ -1,7 +1,7 @@
 import * as fs from "node:fs";
 import * as path from "node:path";
 import { AddressResolutionError, buildObjectResolutionAttempt, } from "../core/addressing.js";
-import { resolveProjectionCoordinate } from "../core/projection/index.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";
@@ -80,6 +80,11 @@ export async function resolveProjectionAddress(input) {
         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/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/misc.js

@@ -5,7 +5,9 @@ import { prependAddressReceipt, renderAddressCarrier } from "./address.js";
 import { commissionSlug } from "../../core/ids.js";
 export function buildErrorResponse(input) {
     const shouldRaiseProtocolError = input.errorType === "runtime_error";
-    const text = buildErrorText(input);
+    const text = input.errorCode === "PROJECTION_INCOMPATIBLE"
+        ? `${colorizeErrorStatus(`${RESPONSE_MARKERS.failure} Failed [${input.errorCode}]`)}\n  ${input.message}`
+        : buildErrorText(input);
     const payload = {
         error: {
             code: input.errorCode,

package/build/cli/render/projection-activity.js

@@ -71,9 +71,19 @@ function summarizeProjectionToolLedger(activity, workspaceRoot) {
 function toolCountSegments(summary) {
     return summary.counts.map(({ semanticClass, count }) => `${count} ${rollupCountLabel(semanticClass)}`);
 }
+function projectionSummarySegments(summary) {
+    const segments = toolCountSegments(summary);
+    if (summary.tokens !== undefined) {
+        segments.push(`${compactTokens(summary.tokens)} tok`);
+    }
+    if (summary.costUsd !== undefined) {
+        segments.push(`$${summary.costUsd.toFixed(2)}`);
+    }
+    return segments;
+}
 export function renderProjectionActivitySummary(activity, input) {
     const summary = summarizeProjectionToolLedger(activity, input.workspaceRoot);
-    const segments = toolCountSegments(summary);
+    const segments = projectionSummarySegments(summary);
     if (segments.length === 0)
         return undefined;
     const spine = input.state === "dead" || input.state === "lost" ? "┆" : "│";
@@ -81,11 +91,7 @@ export function renderProjectionActivitySummary(activity, input) {
 }
 function renderTerminalRollup(activity, input) {
     const summary = summarizeProjectionToolLedger(activity, input.workspaceRoot);
-    const segments = [
-        ...toolCountSegments(summary),
-        ...(summary.tokens === undefined ? [] : [`${compactTokens(summary.tokens)} tok`]),
-        ...(summary.costUsd === undefined ? [] : [`$${summary.costUsd.toFixed(2)}`]),
-    ];
+    const segments = projectionSummarySegments(summary);
     const lines = input.diagnostic
         ? [fitVariableLine(`${elapsedLabel(input.anchorMs, input.diagnostic.at).padStart(TIME_GUTTER_WIDTH)}┆ ${"warning".padEnd(VERB_WIDTH)} `, compactText(input.diagnostic.text), input.maxColumns)]
         : [];