@astrosheep/keiyaku 2.9.7 → 2.9.8

package/build/agents/harness/event-persistence.js

@@ -1,4 +1,4 @@
-import { AGENT_ACTIVITY_MAX_CHANGES, AGENT_EVENT_TEXT_MAX_CHARS, AGENT_UNKNOWN_PAYLOAD_MAX_CHARS, } from "./events.js";
+import { AGENT_ACTIVITY_MAX_CHANGES, AGENT_DONE_FINAL_MESSAGE_PERSISTENCE_PREVIEW_MAX_CHARS, AGENT_EVENT_TEXT_MAX_CHARS, AGENT_UNKNOWN_PAYLOAD_MAX_CHARS, } from "./events.js";
 import { EXEC_EVENT_BUFFER_HARD_CAP } from "./event-channel.js";
 export function createTruncationMarker(envelope = {
     seq: EXEC_EVENT_BUFFER_HARD_CAP,
@@ -23,10 +23,10 @@ export function overflowMarkerFromDropped(dropped) {
         turn: dropped.turn,
     });
 }
-function truncateText(value) {
+function truncateText(value, limit = AGENT_EVENT_TEXT_MAX_CHARS) {
     return {
-        value: value.slice(0, AGENT_EVENT_TEXT_MAX_CHARS),
-        truncated: value.length > AGENT_EVENT_TEXT_MAX_CHARS,
+        value: value.slice(0, limit),
+        truncated: value.length > limit,
     };
 }
 /** Bound unknown native payloads before they enter the projection event stream. */
@@ -186,7 +186,9 @@ function normalizeBodyForPersistence(body) {
             return { body: { ...body, text: text.value }, truncated: text.truncated };
         }
         case "done": {
-            const finalMessage = body.finalMessage === undefined ? undefined : truncateText(body.finalMessage);
+            const finalMessage = body.finalMessage === undefined
+                ? undefined
+                : truncateText(body.finalMessage, AGENT_DONE_FINAL_MESSAGE_PERSISTENCE_PREVIEW_MAX_CHARS);
             return {
                 body: { ...body, ...(finalMessage ? { finalMessage: finalMessage.value } : {}) },
                 truncated: finalMessage?.truncated ?? false,

package/build/agents/harness/events.js

@@ -1,10 +1,11 @@
 import { z } from "zod";
-export const AGENT_EVENT_TEXT_MAX_CHARS = 4_096;
+export const AGENT_EVENT_TEXT_MAX_CHARS = 16_384;
+export const AGENT_DONE_FINAL_MESSAGE_PERSISTENCE_PREVIEW_MAX_CHARS = 65_536;
 export const AGENT_THOUGHT_TEXT_MAX_CHARS = 4_000;
 export const AGENT_PLAN_MAX_ITEMS = 64;
 export const AGENT_PLAN_ITEM_TEXT_MAX_CHARS = 200;
 export const AGENT_ACTIVITY_MAX_CHANGES = 32;
-export const AGENT_UNKNOWN_PAYLOAD_MAX_CHARS = 4_096;
+export const AGENT_UNKNOWN_PAYLOAD_MAX_CHARS = AGENT_EVENT_TEXT_MAX_CHARS;
 export const activityCallSchema = z.discriminatedUnion("kind", [
     z.object({ kind: z.literal("run"), command: z.string(), description: z.string().optional() }).strict(),
     z.object({

package/build/agents/providers/codex-app-server/adapter.js

@@ -243,7 +243,12 @@ export async function startCodexAppServer(prompt, cwd, options = {}) {
             builderDiagnostic = (text) => builder.emit({ type: "diagnostic", text });
             emitTurnStarted = () => builder.emit({ type: "turn", phase: "started" });
             const env = buildSubagentEnv(options.env);
-            server = new CodexAppServerProcess(executable, env, options.codexHome, options.onEvidence, (text) => builder.emit({ type: "diagnostic", text }));
+            server = new CodexAppServerProcess(executable, env, {
+                cwd,
+                codexHome: options.codexHome,
+                onEvidence: options.onEvidence,
+                onEvidenceDiagnostic: (text) => builder.emit({ type: "diagnostic", text }),
+            });
             const { turnCompleted } = createCodexAppServerTurnMonitor({
                 server,
                 builder,

package/build/agents/providers/codex-app-server/session.js

@@ -3,8 +3,6 @@ import { emitProviderEvidence, sha256Utf8 } from "../../harness/runtime.js";
 import { coerceString } from "../../harness/runtime.js";
 import { CODEX_APP_SERVER_PROVIDER } from "./identity.js";
 export class CodexAppServerProcess {
-    onEvidence;
-    onEvidenceDiagnostic;
     child;
     pending = new Map();
     notificationListeners = new Set();
@@ -17,15 +15,18 @@ export class CodexAppServerProcess {
     gracefulClose;
     forceClose;
     codexHome;
-    constructor(executable, env, codexHome, onEvidence, onEvidenceDiagnostic) {
-        this.onEvidence = onEvidence;
-        this.onEvidenceDiagnostic = onEvidenceDiagnostic;
-        this.codexHome = codexHome;
+    onEvidence;
+    onEvidenceDiagnostic;
+    constructor(executable, env, options) {
+        this.codexHome = options.codexHome;
+        this.onEvidence = options.onEvidence;
+        this.onEvidenceDiagnostic = options.onEvidenceDiagnostic;
         const spawnEnv = {
             ...env,
-            ...(codexHome ? { CODEX_HOME: codexHome } : {}),
+            ...(options.codexHome ? { CODEX_HOME: options.codexHome } : {}),
         };
         this.child = spawn(executable, ["app-server", "--listen", "stdio://"], {
+            cwd: options.cwd,
             env: spawnEnv,
             stdio: ["pipe", "pipe", "pipe"],
         });

package/build/agents/selector.js

@@ -77,7 +77,18 @@ export async function selectSubagent(agentName, cwd) {
         throw new FlowError("INVALID_SETTINGS", `Akuma '${selected}' references missing provider instance '${instanceName}'.`);
     }
     if (!("instance" in providerCandidate) || providerCandidate.instance === undefined) {
-        throw new FlowError("INVALID_SETTINGS", `Akuma '${selected}' references invalid provider instance '${instanceName}': ${providerCandidate.reason}`);
+        const source = providerCandidate.source === "global" ? "global" : "local";
+        throw new FlowError("INVALID_SETTINGS", `Akuma '${selected}' references invalid provider instance '${instanceName}': ${providerCandidate.reason}`, {
+            facts: {
+                kind: "invalid_settings",
+                diseases: [{
+                        source,
+                        coordinate: providerCandidate.coordinate,
+                        knob: "providers",
+                        reason: providerCandidate.reason,
+                    }],
+            },
+        });
     }
     const providerInstance = providerCandidate.instance;
     const adapter = providerInstance.kind;

package/build/cli/commands/akuma/view/handler.js

@@ -2,19 +2,12 @@ import { FlowError } from "../../../../flow-error.js";
 import { assertSettingsKnobUsable } from "../../../../config/settings/disease.js";
 import { loadKeiyakuSettings } from "../../../../config/settings/loader.js";
 import { loadAkumaCatalog } from "../../../../config/akuma-loader.js";
-import { readProjectionStatusBoard } from "../../../../core/projection/index.js";
+import { readAkumaNonterminalProjectionStatus } from "../../../../core/projection/index.js";
 import { isResponseArtifactId } from "../../../../core/response-artifact-id.js";
 import { textResponse } from "../../../render/shared.js";
 import { renderProjectionStatusSection } from "../../../render/status.js";
 import { projectDirectory } from "../../shared.js";
 import { renderAkumaShow, renderAkumaView } from "../../akuma.js";
-const NONTERMINAL_PROJECTION_STATES = new Set([
-    "minting",
-    "startup-timeout",
-    "unknown",
-    "out",
-    "lost",
-]);
 export const handler = async (_stdin, flags, _signal, positional) => {
     const [name] = positional;
     if (!name)
@@ -28,8 +21,7 @@ export const handler = async (_stdin, flags, _signal, positional) => {
     assertSettingsKnobUsable(loaded, "default");
     assertSettingsKnobUsable(loaded, "reviewer");
     const profile = renderAkumaShow(await loadAkumaCatalog(cwd), loaded.providerInstances, loaded.knobs, name).trimEnd();
-    const projectionStatus = await readProjectionStatusBoard(cwd, Date.now(), { showAll: true });
-    const rows = (projectionStatus?.rows ?? []).filter((row) => row.akuma === name && NONTERMINAL_PROJECTION_STATES.has(row.state));
-    const projections = renderProjectionStatusSection({ rows }).trimEnd();
+    const projectionStatus = await readAkumaNonterminalProjectionStatus(cwd, Date.now(), name);
+    const projections = renderProjectionStatusSection(projectionStatus).trimEnd();
     return textResponse(renderAkumaView(profile, projections));
 };

package/build/cli/commands/contract/amend/handler.js

@@ -5,7 +5,7 @@ import { buildAmendResponse } from "../../../render/arc.js";
 import { renderCoreResult } from "../../../render/shared.js";
 import { effectiveDirectory, repositoryDirectory } from "../../shared.js";
 export const handler = async (stdin, flags) => {
-    const parsed = buildAmendInput(stdin, effectiveDirectory(flags), flags.contractId, flags.contractAddressSource);
+    const parsed = buildAmendInput(stdin, effectiveDirectory(flags), flags.contractId, flags.contractAddressSource, flags.appendScope);
     const cwd = await repositoryDirectory(flags, "amend");
     const address = await resolveExistingContractAddress(cwd, flags.contractId, flags.contractAddressSource, effectiveDirectory(flags));
     return renderCoreResult(amendKeiyaku({

package/build/cli/commands/contract/amend/meta.js

@@ -2,11 +2,11 @@ export const meta = {
     command: "amend",
     summary: "Record an amendment",
     usage: [
-        "keiyaku amend [-C|--cwd DIR] [--repo DIR] [--contract ADDR] - < amendment.md",
-        "keiyaku @addr amend [-C|--cwd DIR] [--repo DIR] - < amendment.md",
+        "keiyaku amend [-C|--cwd DIR] [--repo DIR] [--contract ADDR] [--append-scope PATTERN] - < amendment.md",
+        "keiyaku @addr amend [-C|--cwd DIR] [--repo DIR] [--append-scope PATTERN] - < amendment.md",
     ],
     stdin: { mode: "document", selector: { kind: "positional", index: 0, required: true, rejectBlank: true } },
-    flags: ["cwd", "repo", "contract"],
-    purpose: "Append a prose amendment and optional Scope Append gitignore-pattern delta.",
+    flags: ["cwd", "repo", "contract", "append-scope"],
+    purpose: "Append a prose amendment and one optional ordered scope-pattern delta from --append-scope or Scope Append.",
     completionRank: 8,
 };

package/build/cli/commands/projection/status/handler.js

@@ -6,6 +6,10 @@ import { renderProjectionFilteredStatus, renderStatusBoard } from "../../../rend
 import { textResponse } from "../../../render/shared.js";
 import { projectDirectory, repositoryDirectory } from "../../shared.js";
 export const handler = async (_stdin, flags, _signal, positional) => {
+    const [projectionId] = positional;
+    if (projectionId !== undefined && !isProjectionId(projectionId)) {
+        throw new FlowError("EMPTY_PARAM", `invalid projection id: ${projectionId}`);
+    }
     // Status is read-only and must open outside Git. projectDirectory still
     // honors --repo as a repository coordinate when the operator names one.
     const cwd = flags.target === undefined
@@ -14,12 +18,9 @@ export const handler = async (_stdin, flags, _signal, positional) => {
     const target = flags.target === undefined ? undefined : normalizeTargetRef(flags.target);
     const board = await readKanshiBoard(cwd, Date.now(), {
         ...(target === undefined ? {} : { target }),
-        showAllProjections: flags.all === true || positional.length === 1,
+        ...(projectionId === undefined ? {} : { projectionId }),
     });
-    const [projectionId] = positional;
     if (projectionId === undefined)
         return textResponse(renderStatusBoard(board));
-    if (!isProjectionId(projectionId))
-        throw new FlowError("EMPTY_PARAM", `invalid projection id: ${projectionId}`);
     return textResponse(renderProjectionFilteredStatus(board, projectionId));
 };

package/build/cli/commands/projection/status/meta.js

@@ -1,9 +1,9 @@
 export const meta = {
     command: "status",
     summary: "Show the Kanshi board",
-    usage: ["keiyaku status [PROJECTION] [-C|--cwd DIR] [--repo DIR] [--target REF] [--all]"],
+    usage: ["keiyaku status [PROJECTION] [-C|--cwd DIR] [--repo DIR] [--target REF]"],
     stdin: { mode: "argument" },
-    flags: ["cwd", "repo", "target", "all"],
+    flags: ["cwd", "repo", "target"],
     purpose: "Read the Kanshi board or filter it to one projection without mutation.",
     completionRank: 14,
 };

package/build/cli/commands/task/add/meta.js

@@ -1,11 +1,19 @@
+const TASK_ADD_USAGE_PREFIX = "keiyaku task add [-C|--cwd DIR] [--needs ID]... [--parent ID] [--from ID]... [--pri 0-3]";
 export const meta = {
     command: "task add",
     summary: "Add a task",
-    usage: ["keiyaku task add [-C|--cwd DIR] [--needs ID] [--parent ID] [--from ID] [--pri 0-3] <BODY|->"],
+    usage: [
+        `${TASK_ADD_USAGE_PREFIX} <BODY>`,
+        `${TASK_ADD_USAGE_PREFIX} - < task.md`,
+    ],
     stdin: {
         mode: "argument",
         selector: { kind: "positional", index: 0, required: true, rejectBlank: true },
     },
     flags: ["cwd", "needs", "parent", "from", "pri"],
     purpose: "Create a lightweight task from a title and optional body.",
+    notes: [
+        "<BODY> and literal - are mutually exclusive body selectors. Use literal - with stdin for multiline prose.",
+        "Only literal - reads stdin; unselected piped bytes are ignored and never change a literal <BODY>.",
+    ],
 };

package/build/cli/commands/task/shared.js

@@ -17,7 +17,8 @@ export function parseTaskAddInput(input) {
     if (!input.trim())
         throw new FlowError("EMPTY_PARAM", "task add input cannot be blank");
     const lines = input.split(/\r?\n/);
-    const title = lines[0]?.trim() ?? "";
+    const firstLine = lines[0]?.startsWith("# ") ? lines[0].slice(2) : lines[0];
+    const title = firstLine?.trim() ?? "";
     if (!title)
         throw new FlowError("EMPTY_PARAM", "task title cannot be blank");
     if (lines.length > 1 && lines[1].trim() !== "") {

package/build/cli/completion.js

@@ -19,6 +19,10 @@ function topLevelCommands() {
 function subcommandsFor(parent) {
     return [...(getCommandMetadata(parent).subcommands ?? [])];
 }
+function topLevelOptionsFor(command) {
+    const metadata = allCommandMetadata().find((meta) => meta.command === command && !command.includes(" "));
+    return metadata ? metadata.flags.map((flag) => `--${flag}`) : [];
+}
 function filterPrefix(items, word) {
     return items.filter((item) => item.startsWith(word));
 }
@@ -50,6 +54,10 @@ export async function renderCompletionCandidates(input) {
     if (input.previous === "--filter") {
         return filterPrefix([TASK_FILTER_COMPLETION], word).join("\n");
     }
+    const options = input.previous ? topLevelOptionsFor(input.previous) : [];
+    if (options.length > 0) {
+        return filterPrefix(options, word).join("\n");
+    }
     return filterPrefix(topLevelCommands(), word).join("\n");
 }
 export function renderCompletionScript(shell = "bash") {

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/path-prefix-compaction.js

@@ -1,88 +1,131 @@
-const MIN_COMPACTION_SAVINGS = 4;
-const SAFE_PATTERN_COMPONENT = /^[A-Za-z0-9._*?\[\]-]+$/;
-const SAFE_CONCRETE_PATH_COMPONENT = /^[A-Za-z0-9._-]+$/;
-/** Compact one displayed pattern-pair without merging distinct overlap facts. */
-export function compactPatternPair(left, right) {
-    const literal = `${left} × ${right}`;
-    const leftParts = safePatternComponents(left);
-    const rightParts = safePatternComponents(right);
-    if (!leftParts || !rightParts)
-        return literal;
-    let sharedCount = 0;
-    const maximumShared = Math.min(leftParts.length, rightParts.length) - 1;
-    while (sharedCount < maximumShared && leftParts[sharedCount] === rightParts[sharedCount]) {
-        sharedCount += 1;
-    }
-    if (sharedCount === 0)
-        return literal;
-    const prefix = leftParts.slice(0, sharedCount).join("/");
-    const compacted = `${prefix}/{${leftParts.slice(sharedCount).join("/")} × ${rightParts.slice(sharedCount).join("/")}}`;
-    return savesEnough(literal, compacted) ? compacted : literal;
+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("")}"`;
 }
-/** Compact a concrete preview through a stable slash-component trie when unambiguous. */
-export function compactPathPreview(paths) {
-    const literal = paths.join(", ");
-    if (paths.length < 2)
-        return literal;
-    const components = paths.map(safeConcretePathComponents);
-    if (components.some((parts) => !parts))
-        return literal;
-    const trie = createTrie();
-    for (const parts of components)
-        insertPath(trie, parts);
-    if (hasTerminalBranch(trie))
-        return literal;
-    if (!hasSharedDirectoryPrefix(trie))
-        return literal;
-    const compacted = renderTrie(trie);
-    return savesEnough(literal, compacted) ? compacted : literal;
+/** 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]),
+    };
 }
-function safePatternComponents(value) {
-    return safeSlashComponents(value, SAFE_PATTERN_COMPONENT);
+/** 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]}`,
+    ];
 }
-function safeConcretePathComponents(value) {
-    return safeSlashComponents(value, SAFE_CONCRETE_PATH_COMPONENT);
+/** 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 safeSlashComponents(value, safeComponent) {
-    const parts = value.split("/");
-    if (parts.length === 0 || parts.some((part) => part === "." || part === ".." || !safeComponent.test(part))) {
-        return null;
+function planPathPreview(preview, bodyRows) {
+    const fullValues = preview.slice(0, bodyRows);
+    if (fullValues.length < bodyRows) {
+        return { ...foldPathRows(fullValues), visibleCount: fullValues.length };
     }
-    return parts;
-}
-function createTrie() {
-    return { terminal: false, children: new Map() };
-}
-function insertPath(node, parts) {
-    let current = node;
-    for (const part of parts) {
-        let child = current.children.get(part);
-        if (!child) {
-            child = createTrie();
-            current.children.set(part, child);
-        }
-        current = child;
+    const chargedValues = preview.slice(0, Math.max(0, bodyRows - 1));
+    const chargedFold = foldPathRows(chargedValues);
+    if (chargedFold.prefix) {
+        return { ...chargedFold, visibleCount: chargedValues.length };
     }
-    current.terminal = true;
+    return { rows: fullValues.map(renderExactPath), visibleCount: fullValues.length };
 }
-function hasTerminalBranch(node) {
-    if (node.terminal && node.children.size > 0)
+function requiresQuoting(value) {
+    if (value.length === 0 || /^\s|\s$/u.test(value))
         return true;
-    return [...node.children.values()].some(hasTerminalBranch);
+    return value.includes("\\")
+        || value.includes('"')
+        || value.includes(PREFIX_MARKER)
+        || [...value].some(isControlCharacter);
 }
-function hasSharedDirectoryPrefix(node, isRoot = true) {
-    if (!isRoot && node.children.size > 1)
-        return true;
-    return [...node.children.values()].some((child) => hasSharedDirectoryPrefix(child, false));
+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 renderTrie(node) {
-    const entries = [...node.children.entries()].map(([part, child]) => {
-        if (child.children.size === 0)
-            return part;
-        return `${part}/${renderTrie(child)}`;
-    });
-    return entries.length === 1 ? entries[0] : `{${entries.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 savesEnough(literal, compacted) {
-    return literal.length - compacted.length >= MIN_COMPACTION_SAVINGS;
+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/projection-activity.js

@@ -2,9 +2,10 @@ import { compactText } from "./compact-text.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)
@@ -72,6 +73,9 @@ function compressedPrefix(prefix) {
 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);
@@ -171,6 +175,7 @@ export function renderProjectionActivity(activity, input) {
     const lines = [];
     const rowKinds = [];
     let priorAtMs;
+    let priorOrder;
     let priorMinute;
     let priorCompletedRan;
     let hasEndAnchor = false;
@@ -185,6 +190,10 @@ export function renderProjectionActivity(activity, input) {
     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;

package/build/cli/render/shared.js

@@ -3,7 +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 { compactPathPreview, compactPatternPair } from "./path-prefix-compaction.js";
+import { renderPathPreview, renderPatternPair } from "./path-prefix-compaction.js";
 export function textResponse(text) {
     const payload = {};
     return {
@@ -76,16 +76,17 @@ function renderScopeOverlapWarnings(overlaps) {
     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 = compactPatternPair(nextPattern, existingPattern);
+        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"}: ${compactPathPreview(overlap.paths.preview)}${overlap.paths.truncated ? ", …" : ""}`;
-        return `  ${patternPair} (${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/wait.js

@@ -73,7 +73,7 @@ function waitHeader(projectionId, akuma, snapshot, outputColumns) {
 function pendingTellLines(snapshot, maxColumns) {
     return snapshot.tells.window.map((tell) => {
         const age = Math.max(0, snapshot.observedAtMs - Date.parse(tell.createdAt));
-        const fixed = `${"".padStart(6)}│ ${"tell".padEnd(7)} `;
+        const fixed = `${"".padStart(5)}│ ${"tell".padEnd(7)} `;
         const suffix = ` · undelivered ${formatTimelineDuration(Number.isFinite(age) ? age : 0)}`;
         return `${fixed}${truncateColumns(`“${tell.text}”`, Math.max(0, maxColumns - displayColumns(fixed) - displayColumns(suffix)))}${suffix}`;
     });