@astrosheep/keiyaku 2.9.6 → 2.9.8

package/build/cli/render/kanshi.js

@@ -45,8 +45,8 @@ export function renderKanshiBoard(status) {
         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") {
+        const lifecycle = contract.state.state === "active" ? "open" : contract.state.state;
+        if (lifecycle === "bound" || lifecycle === "open" || lifecycle === "petitioned") {
             facts.push(lifecycle);
         }
         const arcMark = contract.currentArc.state === "open"

package/build/cli/render/line-width.js

@@ -54,6 +54,39 @@ export function truncateColumns(value, maxColumns) {
     }
     return `${output}…`;
 }
+/** Truncate descriptive command text in the middle while retaining both ends. */
+export function truncateMiddleColumns(value, maxColumns) {
+    if (maxColumns <= 0)
+        return "";
+    if (displayColumns(value) <= maxColumns)
+        return value;
+    if (maxColumns === 1)
+        return "…";
+    const budget = maxColumns - 1;
+    const leftBudget = Math.ceil(budget / 2);
+    const rightBudget = Math.floor(budget / 2);
+    let left = "";
+    let width = 0;
+    for (const character of value) {
+        const next = characterColumns(character);
+        if (width + next > leftBudget)
+            break;
+        left += character;
+        width += next;
+    }
+    const chars = [...value];
+    let right = "";
+    width = 0;
+    for (let index = chars.length - 1; index >= 0; index -= 1) {
+        const character = chars[index];
+        const next = characterColumns(character);
+        if (width + next > rightBudget)
+            break;
+        right = character + right;
+        width += next;
+    }
+    return `${left}…${right}`;
+}
 export function resolveLineColumns(stream = process.stdout) {
     return stream.isTTY === true && Number.isInteger(stream.columns) && stream.columns > 0
         ? stream.columns

package/build/cli/render/path-prefix-compaction.js

@@ -0,0 +1,131 @@
+const PREFIX_MARKER = "⋯";
+const MIN_FOLDED_PREFIX_LENGTH = 8;
+export const PATH_PREVIEW_BODY_ROWS = 7;
+/** Render one exact pattern/path without giving display punctuation matcher meaning. */
+export function renderExactPath(value) {
+    if (!requiresQuoting(value))
+        return value;
+    return `"${[...value].map(escapeQuotedCharacter).join("")}"`;
+}
+/** Fold one qualifying directory prefix while retaining row order and exact suffixes. */
+export function foldPathRows(values) {
+    const rendered = values.map(renderExactPath);
+    const plainIndexes = values
+        .map((value, index) => renderExactPath(value) === value ? index : -1)
+        .filter((index) => index >= 0);
+    const prefix = bestSharedDirectoryPrefix(values, plainIndexes);
+    if (!prefix)
+        return { rows: rendered };
+    const foldedIndexes = new Set(plainIndexes.filter((index) => values[index].startsWith(prefix)));
+    return {
+        prefix,
+        rows: values.map((value, index) => foldedIndexes.has(index) ? `${PREFIX_MARKER}${value.slice(prefix.length)}` : rendered[index]),
+    };
+}
+/** Render one overlap fact as two labeled exact pattern rows. */
+export function renderPatternPair(leftLabel, leftPattern, rightLabel, rightPattern) {
+    const folded = foldPathRows([leftPattern, rightPattern]);
+    const labelWidth = Math.max(leftLabel.length, rightLabel.length) + 2;
+    return [
+        ...(folded.prefix ? [`${PREFIX_MARKER} = ${folded.prefix}`] : []),
+        `${leftLabel.padEnd(labelWidth)}${folded.rows[0]}`,
+        `${rightLabel.padEnd(labelWidth)}${folded.rows[1]}`,
+    ];
+}
+/** Render a bounded path snapshot; declarations consume the same row budget as paths. */
+export function renderPathPreview(snapshot, bodyRows = PATH_PREVIEW_BODY_ROWS) {
+    const plan = planPathPreview(snapshot.preview, Math.max(0, bodyRows));
+    const omitted = Math.max(0, snapshot.count - plan.visibleCount);
+    return [
+        `scope · ${snapshot.count} pattern${snapshot.count === 1 ? "" : "s"}`,
+        ...(plan.prefix ? [`${PREFIX_MARKER} = ${plan.prefix}`] : []),
+        ...plan.rows,
+        ...(omitted > 0 ? [`+${omitted} more patterns`] : []),
+    ];
+}
+function planPathPreview(preview, bodyRows) {
+    const fullValues = preview.slice(0, bodyRows);
+    if (fullValues.length < bodyRows) {
+        return { ...foldPathRows(fullValues), visibleCount: fullValues.length };
+    }
+    const chargedValues = preview.slice(0, Math.max(0, bodyRows - 1));
+    const chargedFold = foldPathRows(chargedValues);
+    if (chargedFold.prefix) {
+        return { ...chargedFold, visibleCount: chargedValues.length };
+    }
+    return { rows: fullValues.map(renderExactPath), visibleCount: fullValues.length };
+}
+function requiresQuoting(value) {
+    if (value.length === 0 || /^\s|\s$/u.test(value))
+        return true;
+    return value.includes("\\")
+        || value.includes('"')
+        || value.includes(PREFIX_MARKER)
+        || [...value].some(isControlCharacter);
+}
+function isControlCharacter(character) {
+    const codePoint = character.codePointAt(0);
+    return codePoint <= 0x1f || (codePoint >= 0x7f && codePoint <= 0x9f);
+}
+function escapeQuotedCharacter(character) {
+    if (character === "\\")
+        return "\\\\";
+    if (character === '"')
+        return '\\"';
+    const codePoint = character.codePointAt(0);
+    const named = new Map([
+        [0x07, "\\a"],
+        [0x08, "\\b"],
+        [0x09, "\\t"],
+        [0x0a, "\\n"],
+        [0x0b, "\\v"],
+        [0x0c, "\\f"],
+        [0x0d, "\\r"],
+    ]).get(codePoint);
+    if (named)
+        return named;
+    if (!isControlCharacter(character))
+        return character;
+    return [...Buffer.from(character, "utf8")]
+        .map((byte) => `\\${byte.toString(8).padStart(3, "0")}`)
+        .join("");
+}
+function bestSharedDirectoryPrefix(values, plainIndexes) {
+    let best;
+    for (let left = 0; left < plainIndexes.length; left += 1) {
+        for (let right = left + 1; right < plainIndexes.length; right += 1) {
+            const prefix = sharedDirectoryPrefix(values[plainIndexes[left]], values[plainIndexes[right]]);
+            if (!prefix || prefix.length < MIN_FOLDED_PREFIX_LENGTH)
+                continue;
+            const members = plainIndexes.filter((index) => values[index].startsWith(prefix));
+            const common = members
+                .slice(1)
+                .reduce((current, index) => sharedDirectoryPrefix(current, values[index]) ?? "", values[members[0]]);
+            if (common.length < MIN_FOLDED_PREFIX_LENGTH)
+                continue;
+            const candidate = {
+                prefix: common,
+                count: members.length,
+                first: members[0],
+                score: common.length * (members.length - 1),
+            };
+            if (!best
+                || candidate.score > best.score
+                || (candidate.score === best.score && candidate.count > best.count)
+                || (candidate.score === best.score && candidate.count === best.count && candidate.first < best.first)
+                || (candidate.score === best.score && candidate.count === best.count && candidate.first === best.first
+                    && candidate.prefix < best.prefix)) {
+                best = candidate;
+            }
+        }
+    }
+    return best?.prefix;
+}
+function sharedDirectoryPrefix(left, right) {
+    let sharedLength = 0;
+    const maximum = Math.min(left.length, right.length);
+    while (sharedLength < maximum && left[sharedLength] === right[sharedLength])
+        sharedLength += 1;
+    const slash = left.lastIndexOf("/", sharedLength - 1);
+    return slash >= 0 ? left.slice(0, slash + 1) : undefined;
+}

package/build/cli/render/petition.js

@@ -4,6 +4,10 @@ import { assembleResponse, buildPayload, buildSection, formatMaybe, formatWarnin
 import { DIFF_OVERVIEW_SECTION_TITLE, RESPONSE_MARKERS, WARNING_SECTION_TITLE } from "./response-style.js";
 import { INFO_COMMIT_MAX_CHARS, INFO_PLEA_MAX_CHARS, } from "./shared.js";
 import { prependAddressReceipt } from "./address.js";
+/** Public consequence for a completed renew phase of petition --renew. */
+export function renderPetitionRenewedConsequence(input) {
+    return `renewed onto ${input.newBase.slice(0, 8)} · ${input.sealed?.receipts.length ?? 0} receipts replayed`;
+}
 function formatPetitionSealSource(source) {
     return source.arc === null
         ? `no open arc · fence ${source.fence}`

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

@@ -1,10 +1,11 @@
 import { compactText } from "./compact-text.js";
-import { fitAffixedLine, fitVariableLine, resolveLineColumns } from "./line-width.js";
+import { displayColumns, fitVariableLine, resolveLineColumns, truncateMiddleColumns } from "./line-width.js";
 import { presentFoldedToolActivity, } from "./tool-presentation.js";
 import { presentLedgerPath, summarizeToolLedger } from "./tool-ledger-rollup.js";
-const TIME_GUTTER_WIDTH = 6;
+const TIME_GUTTER_WIDTH = 5;
 const VERB_WIDTH = 7;
 const SILENCE_THRESHOLD_MS = 60_000;
+const TIMELINE_GAP_MARKER = "⋮";
 export function formatTimelineDuration(ms) {
     const totalSeconds = Math.max(0, Math.floor(ms / 1_000));
     if (totalSeconds < 60)
@@ -33,6 +34,48 @@ function elapsedLabel(anchorMs, at) {
         return "now";
     return formatTimelineDuration(Math.max(0, anchorMs - eventMs));
 }
+export function formatWallClock(at) {
+    const value = new Date(at);
+    if (!Number.isFinite(value.getTime()))
+        return "  :  │";
+    return `${String(value.getHours()).padStart(2, "0")}:${String(value.getMinutes()).padStart(2, "0")}│`;
+}
+function commonPrefix(left, right) {
+    const a = [...left];
+    const b = [...right];
+    let index = 0;
+    while (index < a.length && index < b.length && a[index] === b[index])
+        index += 1;
+    return a.slice(0, index).join("");
+}
+function compressedPrefix(prefix) {
+    const points = [...prefix];
+    if (points.length < 24)
+        return undefined;
+    let cut = -1;
+    for (let index = points.length - 1; index >= 0; index -= 1) {
+        if (points[index] === " ") {
+            cut = index;
+            break;
+        }
+    }
+    if (cut < 0)
+        return undefined;
+    const stable = points.slice(0, cut).join("");
+    const stablePoints = [...stable];
+    if (stablePoints.length < 24)
+        return undefined;
+    return {
+        text: `${stablePoints.slice(0, 10).join("")}…${stablePoints.slice(-14).join("")}`,
+        resumeAt: cut + 1,
+    };
+}
+function timelineGutter(label, spine) {
+    return label || `${"".padStart(TIME_GUTTER_WIDTH)}${spine}`;
+}
+function renderTimelineGap(omittedEventCount, maxColumns) {
+    return fitVariableLine(`${timelineGutter("", TIMELINE_GAP_MARKER)} `, `${omittedEventCount} more`, maxColumns);
+}
 function compactTokens(value) {
     if (value < 1_000)
         return String(value);
@@ -92,22 +135,28 @@ export function renderProjectionActivitySummary(activity, input) {
 function renderTerminalRollup(activity, input) {
     const summary = summarizeProjectionToolLedger(activity, input.workspaceRoot);
     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)]
+    const rows = input.diagnostic
+        ? [{
+                kind: "diagnostic",
+                line: fitVariableLine(`${elapsedLabel(input.anchorMs, input.diagnostic.at).padStart(TIME_GUTTER_WIDTH)}┆ ${"warning".padEnd(VERB_WIDTH)} `, compactText(input.diagnostic.text), input.maxColumns),
+            }]
         : [];
     const endPrefix = `${"end".padStart(TIME_GUTTER_WIDTH)}└`;
-    lines.push(segments.length > 0
-        ? fitVariableLine(`${endPrefix} `, segments.join(" · "), input.maxColumns)
-        : endPrefix);
+    rows.push({
+        kind: "end-anchor",
+        line: segments.length > 0
+            ? fitVariableLine(`${endPrefix} `, segments.join(" · "), input.maxColumns)
+            : endPrefix,
+    });
     for (const file of summary.files) {
         const repeat = file.count > 1 ? ` ×${file.count}` : "";
         const diffstat = file.diffstat ? ` +${file.diffstat.additions} −${file.diffstat.deletions}` : "";
-        lines.push(fitVariableLine("", `${file.path}${repeat}${diffstat}`, input.maxColumns));
+        rows.push({ kind: "file", line: fitVariableLine("", `${file.path}${repeat}${diffstat}`, input.maxColumns) });
     }
     if (summary.hiddenFileCount > 0) {
-        lines.push(fitVariableLine("", `… ${summary.hiddenFileCount} more files`, input.maxColumns));
+        rows.push({ kind: "file", line: fitVariableLine("", `… ${summary.hiddenFileCount} more files`, input.maxColumns) });
     }
-    return { lines, hasMutationFiles: summary.files.length > 0 };
+    return { rows, hasMutationFiles: summary.files.length > 0 };
 }
 function timelineEntries(activity) {
     const entries = [];
@@ -124,26 +173,42 @@ function timelineEntries(activity) {
 }
 export function renderProjectionActivity(activity, input) {
     const lines = [];
+    const rowKinds = [];
     let priorAtMs;
+    let priorOrder;
+    let priorMinute;
+    let priorCompletedRan;
     let hasEndAnchor = false;
     let lastRunningTool;
     const maxColumns = input.maxColumns ?? resolveLineColumns();
     const entries = timelineEntries(activity);
+    const pushRow = (line, kind) => {
+        lines.push(line);
+        rowKinds.push(kind);
+        return true;
+    };
     for (let index = 0; index < entries.length; index += 1) {
         const entry = entries[index];
         const atMs = Date.parse(entry.at);
+        if (priorOrder !== undefined && entry.order > priorOrder + 1) {
+            pushRow(renderTimelineGap(entry.order - priorOrder - 1, maxColumns), "activity");
+        }
+        priorOrder = entry.order;
         if (entry.kind === "clock") {
             if (Number.isFinite(atMs))
                 priorAtMs = atMs;
             continue;
         }
         if (priorAtMs !== undefined && Number.isFinite(atMs) && atMs - priorAtMs >= SILENCE_THRESHOLD_MS) {
-            lines.push(fitVariableLine(`${"".padStart(TIME_GUTTER_WIDTH)}┆ `, `${formatTimelineDuration(atMs - priorAtMs)} pass in silence`, maxColumns));
+            pushRow(fitVariableLine(`${"".padStart(TIME_GUTTER_WIDTH)}┆ `, `${formatTimelineDuration(atMs - priorAtMs)} pass in silence`, maxColumns), "silence");
         }
         if (Number.isFinite(atMs))
             priorAtMs = atMs;
         const row = entry.row;
-        const label = row.kind === "turn" ? "" : elapsedLabel(input.anchorMs, row.at);
+        const minute = row.kind === "turn" ? "" : formatWallClock(row.at);
+        const label = row.kind === "turn" || minute === priorMinute ? "" : minute;
+        if (minute)
+            priorMinute = minute;
         const spine = row.kind === "turn"
             ? "├"
             : input.state === "dead" || input.state === "lost"
@@ -159,27 +224,41 @@ export function renderProjectionActivity(activity, input) {
                         ? "unresolved"
                         : "running";
             const presentation = presentFoldedToolActivity(row, { state: activityState, ...(duration ? { duration } : {}) }, (value) => presentLedgerPath(value, input.workspaceRoot) ?? value);
-            const fixed = `${label.padStart(TIME_GUTTER_WIDTH)}${spine} ${(presentation.semanticClass === "run" ? "ran" : presentation.semanticClass).padEnd(VERB_WIDTH)} `;
-            lines.push(fitAffixedLine(fixed, presentation.variableText, presentation.fixedSuffix, maxColumns));
+            const fixed = `${timelineGutter(label, spine)} ${(presentation.semanticClass === "run" ? "ran" : presentation.semanticClass).padEnd(VERB_WIDTH)} `;
+            let variable = presentation.variableText;
+            if (row.state === "completed" && priorCompletedRan !== undefined) {
+                const common = commonPrefix(priorCompletedRan, variable);
+                const prefix = compressedPrefix(common);
+                if (prefix) {
+                    variable = `${prefix.text} ${[...variable].slice(prefix.resumeAt).join("")}`;
+                }
+            }
+            priorCompletedRan = row.state === "completed" ? presentation.variableText : undefined;
+            const budget = Math.max(0, maxColumns - displayColumns(fixed) - displayColumns(presentation.fixedSuffix));
+            pushRow(`${fixed}${truncateMiddleColumns(variable, budget)}${presentation.fixedSuffix}`, "activity");
             continue;
         }
         if (row.kind === "said") {
-            lines.push(fitVariableLine(`${label.padStart(TIME_GUTTER_WIDTH)}${spine} ${"said".padEnd(VERB_WIDTH)} `, `“${compactText(row.text)}”`, maxColumns));
+            priorCompletedRan = undefined;
+            pushRow(fitVariableLine(`${timelineGutter(label, spine)} ${"said".padEnd(VERB_WIDTH)} `, `“${compactText(row.text)}”`, maxColumns), "activity");
         }
         else if (row.kind === "thought") {
+            priorCompletedRan = undefined;
             const text = `${compactText(row.text)}${row.truncated && !row.text.endsWith("…") ? "…" : ""}`;
             const duration = formatActionDuration(row.durationMs);
-            lines.push(fitVariableLine(`${label.padStart(TIME_GUTTER_WIDTH)}${spine} ${"thought".padEnd(VERB_WIDTH)} `, `${duration ? `${duration} — ` : ""}“${text}”`, maxColumns));
+            pushRow(fitVariableLine(`${timelineGutter(label, spine)} ${"thought".padEnd(VERB_WIDTH)} `, `${duration ? `${duration} — ` : ""}“${text}”`, maxColumns), "activity");
         }
         else if (row.kind === "warning") {
-            lines.push(fitVariableLine(`${label.padStart(TIME_GUTTER_WIDTH)}${spine} ${"warning".padEnd(VERB_WIDTH)} `, warningText(row), maxColumns));
+            priorCompletedRan = undefined;
+            pushRow(fitVariableLine(`${timelineGutter(label, spine)} ${"warning".padEnd(VERB_WIDTH)} `, warningText(row), maxColumns), "activity");
         }
         else {
+            priorCompletedRan = undefined;
             const usage = row.inputTokens !== undefined && row.outputTokens !== undefined
                 ? ` · ${compactTokens(row.inputTokens)}▸${compactTokens(row.outputTokens)} tok`
                 : "";
             const cost = row.costUsd !== undefined ? ` · $${row.costUsd.toFixed(2)}` : "";
-            lines.push(fitVariableLine(`${"".padStart(TIME_GUTTER_WIDTH)}├ `, `turn ${row.turn}${usage}${cost}`, maxColumns));
+            pushRow(fitVariableLine(`${"".padStart(TIME_GUTTER_WIDTH)}├ `, `turn ${row.turn}${usage}${cost}`, maxColumns), "activity");
         }
     }
     for (const row of activity.pinned) {
@@ -189,9 +268,9 @@ export function renderProjectionActivity(activity, input) {
     if (input.showPlan && activity.plan) {
         const planAtMs = Date.parse(activity.plan.at);
         if (priorAtMs !== undefined && Number.isFinite(planAtMs) && planAtMs - priorAtMs >= SILENCE_THRESHOLD_MS) {
-            lines.push(fitVariableLine(`${"".padStart(TIME_GUTTER_WIDTH)}┆ `, `${formatTimelineDuration(planAtMs - priorAtMs)} pass in silence`, maxColumns));
+            pushRow(fitVariableLine(`${"".padStart(TIME_GUTTER_WIDTH)}┆ `, `${formatTimelineDuration(planAtMs - priorAtMs)} pass in silence`, maxColumns), "silence");
         }
-        lines.push(renderPlan(activity.plan, maxColumns));
+        pushRow(renderPlan(activity.plan, maxColumns), "plan");
     }
     let hasMutationFiles = false;
     if (["returned", "dead", "lost", "dismissed"].includes(input.state)) {
@@ -201,12 +280,15 @@ export function renderProjectionActivity(activity, input) {
             ...(input.terminalDiagnostic ? { diagnostic: input.terminalDiagnostic } : {}),
             maxColumns,
         });
-        lines.push(...rollup.lines);
+        for (const row of rollup.rows) {
+            pushRow(row.line, row.kind);
+        }
         hasEndAnchor = true;
         hasMutationFiles = rollup.hasMutationFiles;
     }
     return {
         lines,
+        rowKinds,
         ...(lastRunningTool ? { lastRunningTool } : {}),
         hasEndAnchor,
         hasMutationFiles,

package/build/cli/render/shared.js

@@ -3,6 +3,7 @@ import { commissionSlug, formatCommissionCoordinate } from "../../core/ids.js";
 import { assembleResponse, buildSection, DISPLAY_TEXT_MAX_CHARS, FORMAT_LIST_MAX_ITEM_CHARS, FORMAT_LIST_MAX_ITEMS, formatMaybe, formatWarnings, shellQuote, truncateForDisplay, } from "./format.js";
 import { WARNING_SECTION_TITLE } from "./response-style.js";
 import { prependAddressReceipt } from "./address.js";
+import { renderPathPreview, renderPatternPair } from "./path-prefix-compaction.js";
 export function textResponse(text) {
     const payload = {};
     return {
@@ -24,18 +25,26 @@ export function buildBindDraftResponse(draftPath) {
     const payload = { draftPath };
     return coreTextResponse(`Draft saved to ${draftPath}.`, payload);
 }
+export function buildBindPreviewResponse(result) {
+    const overlapWarnings = renderScopeOverlapWarnings(result.scopeOverlaps);
+    const payload = {
+        id: result.id,
+        canonicalDraft: result.canonicalDraft,
+        target: result.target,
+        place: result.place,
+        workspace: result.workspace,
+        after: result.after,
+        warnings: overlapWarnings,
+        scopeOverlaps: result.scopeOverlaps,
+    };
+    return {
+        ...coreTextResponse(result.canonicalDraft, payload),
+        ...(overlapWarnings.length > 0 ? { stderr: ["Warnings:", ...overlapWarnings].join("\n") } : {}),
+    };
+}
 export function buildBindResponse(result, cwd) {
     void cwd;
-    const overlapsByCounterparty = new Map();
-    for (const overlap of result.scopeOverlaps) {
-        const counterparty = overlap.contracts[1];
-        const group = overlapsByCounterparty.get(counterparty);
-        if (group)
-            group.push(overlap);
-        else
-            overlapsByCounterparty.set(counterparty, [overlap]);
-    }
-    const overlapWarnings = [...overlapsByCounterparty.entries()].map(([contractId, overlaps]) => renderScopeOverlapGroup(commissionSlug(contractId), overlaps));
+    const overlapWarnings = renderScopeOverlapWarnings(result.scopeOverlaps);
     const place = result.place;
     const payload = {
         id: result.id,
@@ -54,16 +63,30 @@ export function buildBindResponse(result, cwd) {
         ...(overlapWarnings.length > 0 ? ["Warnings:", ...overlapWarnings] : []),
     ].join("\n"), payload);
 }
+function renderScopeOverlapWarnings(overlaps) {
+    const overlapsByCounterparty = new Map();
+    for (const overlap of overlaps) {
+        const counterparty = overlap.contracts[1];
+        const group = overlapsByCounterparty.get(counterparty);
+        if (group)
+            group.push(overlap);
+        else
+            overlapsByCounterparty.set(counterparty, [overlap]);
+    }
+    return [...overlapsByCounterparty.entries()].map(([contractId, overlaps]) => renderScopeOverlapGroup(commissionSlug(contractId), overlaps));
+}
 function renderScopeOverlapGroup(contractAddr, overlaps) {
-    const pairs = overlaps.map((overlap) => {
+    const nextAddr = commissionSlug(overlaps[0].contracts[0]);
+    const pairs = overlaps.flatMap((overlap) => {
         const [nextPattern, existingPattern] = overlap.patterns;
+        const patternPair = renderPatternPair(nextAddr, nextPattern, contractAddr, existingPattern);
         const evidence = overlap.kind === "potential"
-            ? "potential; no current tracked path proves it"
-            : `concrete; ${overlap.paths.count} current tracked path${overlap.paths.count === 1 ? "" : "s"}: ${overlap.paths.preview.join(", ")}${overlap.paths.truncated ? ", …" : ""}`;
-        return `  ${nextPattern} × ${existingPattern} (${evidence})`;
+            ? ["potential · no current tracked path proves it"]
+            : renderPathPreview(overlap.paths);
+        return [...patternPair, ...evidence].map((line) => `  ${line}`);
     });
     return [
-        `▲ scope overlap with ${contractAddr}:`,
+        `▲ overlap ${nextAddr} ↔ ${contractAddr}`,
         ...pairs,
         `  consider --after ${contractAddr}`,
     ].join("\n");

package/build/cli/render/status.js

@@ -74,7 +74,7 @@ function renderProjectionOmission(board) {
         const count = board.omitted?.byState[state] ?? 0;
         return count > 0 ? [`${count} ${state}`] : [];
     });
-    return `  · +${board.omitted.total} historical projections not shown (${counts.join(" · ")}) — keiyaku status --all`;
+    return `  · +${board.omitted.total} historical projections not shown (${counts.join(" · ")})`;
 }
 function renderProjectionAge(row) {
     const duration = formatAgeMs(row.durationMs) ?? "?";
@@ -170,15 +170,18 @@ export function renderProjectionFilteredStatus(board, projectionId) {
     if (!row)
         return `${heading}\nno projections on projection ${projectionId}\n`;
     if (row.state === "failed" || row.terminalFailure) {
-        // Same face bytes as wait; CLI success write supplies the final newline.
-        return renderTerminalFailureFace(projectionId, row.terminalFailure).join("\n");
+        const lines = [...renderTerminalFailureFace(projectionId, row.terminalFailure), "", `» keiyaku wait ${projectionId}`];
+        return lines.join("\n");
     }
     const lines = [heading, "", ...renderProjectionRow(row), ""];
     if (row.observation.compatibility === "incompatible") {
         return `${lines.join("\n")}\n`;
     }
-    if (!isTerminalProjectionStatus(row))
-        lines.push(`» ${formatTellCommand(projectionId, '"..."')}`);
+    if (isTerminalProjectionStatus(row)) {
+        lines.push(`» keiyaku wait ${projectionId}`);
+        return lines.join("\n");
+    }
+    lines.push(`» ${formatTellCommand(projectionId, '"..."')}`);
     lines.push(`» keiyaku wait ${projectionId}`);
     return `${lines.join("\n")}\n`;
 }

package/build/cli/render/success-response.js

@@ -62,6 +62,8 @@ export async function writeSuccessResponse(command, flags, response) {
     if (command === "bind" && flags.dryRun) {
         // Canonical Markdown already ends with exactly one newline.
         await writeCliOutput(process.stdout, responseText(response));
+        if (response.stderr)
+            await writeCliOutput(process.stderr, `${response.stderr}\n`);
         return;
     }
     if (command !== "revive") {

package/build/cli/render/tool-presentation.js

@@ -53,9 +53,9 @@ export function presentToolActivity(input) {
     }
     else if (input.state === "running") {
         if (message)
-            variableText = `${primary} — …${message}`;
+            variableText = `${primary} — ${message}`;
         else
-            fixedSuffix = " — still running…";
+            fixedSuffix = ` — ${input.duration ?? "0s"}…`;
     }
     else if (input.result?.status === "error") {
         if (input.result.exitCode !== undefined) {
@@ -70,7 +70,7 @@ export function presentToolActivity(input) {
             fixedSuffix = ` — +${input.result.diffstat.additions} −${input.result.diffstat.deletions}`;
     }
     else if (input.call.kind === "run") {
-        fixedSuffix = ` — done${input.duration ? ` ${input.duration}` : ""}`;
+        fixedSuffix = input.duration ? ` — ${input.duration}` : "";
     }
     else if (input.call.kind === "other") {
         fixedSuffix = " — done";