@astrosheep/keiyaku 2.9.6 → 2.9.7

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

@@ -1,5 +1,5 @@
 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;
@@ -33,6 +33,45 @@ 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 compactTokens(value) {
     if (value < 1_000)
         return String(value);
@@ -92,22 +131,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,11 +169,19 @@ function timelineEntries(activity) {
 }
 export function renderProjectionActivity(activity, input) {
     const lines = [];
+    const rowKinds = [];
     let priorAtMs;
+    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);
@@ -138,12 +191,15 @@ export function renderProjectionActivity(activity, input) {
             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 +215,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 +259,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 +271,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 { compactPathPreview, compactPatternPair } 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,13 +63,26 @@ 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 [nextPattern, existingPattern] = overlap.patterns;
+        const patternPair = compactPatternPair(nextPattern, 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})`;
+            : `concrete; ${overlap.paths.count} current tracked path${overlap.paths.count === 1 ? "" : "s"}: ${compactPathPreview(overlap.paths.preview)}${overlap.paths.truncated ? ", …" : ""}`;
+        return `  ${patternPair} (${evidence})`;
     });
     return [
         `▲ scope overlap with ${contractAddr}:`,

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

package/build/cli/render/wait.js

@@ -3,6 +3,27 @@ import { displayColumns, resolveLineColumns, truncateColumns } from "./line-widt
 import { formatTellCommand, projectionRejoinHintLines, textResponse } from "./shared.js";
 import { renderTerminalFailureFace } from "./terminal-failure.js";
 const WAIT_HEADER_MAX_COLUMNS = 60;
+const WAIT_BODY_MAX_ROWS = 10;
+const WAIT_ROW_PRIORITY = {
+    "end-anchor": 100,
+    "storage-diagnostic": 90,
+    diagnostic: 90,
+    tell: 80,
+    summary: 70,
+    activity: 60,
+    plan: 55,
+    liveness: 50,
+    silence: 65,
+    file: 20,
+};
+/** One owner admits every wait-body row, then restores presentation order. */
+export function selectWaitBodyRows(rows, limit = WAIT_BODY_MAX_ROWS) {
+    const selected = rows
+        .slice()
+        .sort((left, right) => WAIT_ROW_PRIORITY[right.kind] - WAIT_ROW_PRIORITY[left.kind] || left.order - right.order)
+        .slice(0, limit);
+    return selected.sort((left, right) => left.order - right.order);
+}
 function shortAddress(projectionId) {
     return /\/([0-9a-f]{8})$/.exec(projectionId)?.[1] ?? projectionId;
 }
@@ -26,29 +47,10 @@ function isTerminalPhase(phase) {
     return ["done", "failed", "killed", "dismissed"].includes(phase);
 }
 function waitStateText(snapshot) {
-    switch (snapshot.phase) {
-        case "active":
-        case "quiescent": {
-            const pulse = snapshot.activityAgeMs === undefined ? "unknown" : formatTimelineDuration(snapshot.activityAgeMs);
-            return `pulse ${pulse} · breathing ${formatTimelineDuration(snapshot.durationMs)}`;
-        }
-        case "minting":
-            return `starting · lived ${formatTimelineDuration(snapshot.durationMs)}`;
-        case "startup-timeout":
-            return `startup timed out · lived ${formatTimelineDuration(snapshot.durationMs)}`;
-        case "unknown":
-            return `state unknown · observed ${formatTimelineDuration(snapshot.durationMs)}`;
-        case "done":
-            return `returned · lived ${formatTimelineDuration(snapshot.durationMs)}`;
-        case "failed":
-            return `dead · lived ${formatTimelineDuration(snapshot.durationMs)}`;
-        case "killed":
-            return "killed";
-        case "dismissed":
-            return "dismissed";
-        case "lost":
-            return `no pulse ${snapshot.activityAgeMs === undefined ? "unknown" : formatTimelineDuration(snapshot.activityAgeMs)}`;
-    }
+    const idle = snapshot.activityAgeMs === undefined
+        ? formatTimelineDuration(snapshot.durationMs)
+        : formatTimelineDuration(snapshot.activityAgeMs);
+    return `up ${formatTimelineDuration(snapshot.durationMs)} · idle ${idle}`;
 }
 function projectionIdentityParts(projectionId) {
     const match = /^(.*)\/([0-9a-f]{8})$/.exec(projectionId);
@@ -56,8 +58,7 @@ function projectionIdentityParts(projectionId) {
 }
 function waitHeader(projectionId, akuma, snapshot, outputColumns) {
     const maxColumns = Math.min(WAIT_HEADER_MAX_COLUMNS, outputColumns);
-    const tellSuffix = snapshot.tellsWaiting > 0 ? ` · ${snapshot.tellsWaiting} tells waiting` : "";
-    const state = `${waitStateText(snapshot)}${tellSuffix}`;
+    const state = waitStateText(snapshot);
     const identity = projectionIdentityParts(projectionId);
     // Slug often mirrors the Akuma name; print once when they are the same fact.
     const description = identity.slug && akuma && identity.slug === akuma
@@ -69,6 +70,14 @@ function waitHeader(projectionId, akuma, snapshot, outputColumns) {
     const dashCount = Math.max(1, maxColumns - displayColumns(`${prefix}  ${state}`));
     return `${prefix} ${"─".repeat(dashCount)} ${state}`;
 }
+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 suffix = ` · undelivered ${formatTimelineDuration(Number.isFinite(age) ? age : 0)}`;
+        return `${fixed}${truncateColumns(`“${tell.text}”`, Math.max(0, maxColumns - displayColumns(fixed) - displayColumns(suffix)))}${suffix}`;
+    });
+}
 function ledgerHint(projectionId, snapshot) {
     const file = snapshot.eventLedgerFile ?? "events.jsonl";
     return `· ledger: .keiyaku/projection/${projectionId}/${file}`;
@@ -136,7 +145,11 @@ function unknownResponse(projectionId, akuma, snapshot, maxColumns) {
         ...(snapshot.workspaceRoot ? { workspaceRoot: snapshot.workspaceRoot } : {}),
         maxColumns,
     });
-    const historicalLines = rendered.lines.map((line) => line.replace(/[┆├]/, "│"));
+    const historicalLines = selectWaitBodyRows(rendered.lines.map((line, index) => ({
+        kind: rendered.rowKinds[index] ?? "activity",
+        line,
+        order: index,
+    }))).map((row) => row.line.replace(/[┆├]/, "│"));
     return {
         ...textResponse([
             `? ${akuma} · projection: ${projectionId} · unknown`,
@@ -186,7 +199,7 @@ export function buildWaitResponse(projectionId, result, options = {}) {
         && (result.terminalSnapshot || isTerminalPhase(result.snapshot.phase))
         ? { ...result.snapshot, phase: "active" }
         : result.snapshot;
-    const maxColumns = options.maxColumns ?? resolveLineColumns();
+    const maxColumns = Math.min(120, options.maxColumns ?? resolveLineColumns());
     if (result.state === "terminal" && result.verdict.state === "killed") {
         return {
             ...textResponse(`× killed ${projectionId}`),
@@ -203,6 +216,14 @@ export function buildWaitResponse(projectionId, result, options = {}) {
     if (state === "returned") {
         return returnedResponse(projectionId, result);
     }
+    const tells = pendingTellLines(snapshot, maxColumns);
+    const summary = ["running", "stalled", "unknown"].includes(state)
+        ? renderProjectionActivitySummary(snapshot.activity, {
+            state,
+            ...(snapshot.workspaceRoot ? { workspaceRoot: snapshot.workspaceRoot } : {}),
+            maxColumns,
+        })
+        : undefined;
     const rendered = renderProjectionActivity(snapshot.activity, {
         anchorMs: snapshot.observedAtMs,
         state,
@@ -210,28 +231,27 @@ export function buildWaitResponse(projectionId, result, options = {}) {
         ...(snapshot.workspaceRoot ? { workspaceRoot: snapshot.workspaceRoot } : {}),
         maxColumns,
     });
-    const storageDiagnostics = (snapshot.eventDiagnostics ?? []).map((diagnostic) => `‼ ${diagnostic.kind} · ${diagnostic.detail}`);
-    const lines = [
-        waitHeader(projectionId, result.pact.akuma, snapshot, maxColumns),
-        ...storageDiagnostics,
-        ...rendered.lines,
-    ]
-        .map((line) => truncateColumns(line, maxColumns));
-    if (rendered.lines.length === 0 && state === "running") {
-        lines.push("   not a word out of it yet — pulse is steady");
+    let order = 0;
+    const bodyPlan = [];
+    for (const diagnostic of snapshot.eventDiagnostics ?? []) {
+        bodyPlan.push({ kind: "storage-diagnostic", line: `‼ ${diagnostic.kind} · ${diagnostic.detail}`, order: order++ });
     }
-    // Live/timeout observation faces keep the bounded activity window and add the
-    // existing compact rollup after those rows. Terminal faces already own end└
-    // and must not duplicate it; returned response-only faces never reach here.
-    if (!rendered.hasEndAnchor) {
-        const summary = renderProjectionActivitySummary(snapshot.activity, {
-            state,
-            ...(snapshot.workspaceRoot ? { workspaceRoot: snapshot.workspaceRoot } : {}),
-            maxColumns,
-        });
-        if (summary) {
-            lines.push(summary);
-        }
+    rendered.lines.forEach((line, index) => {
+        bodyPlan.push({ kind: rendered.rowKinds[index] ?? "activity", line, order: order++ });
+    });
+    for (const line of tells)
+        bodyPlan.push({ kind: "tell", line, order: order++ });
+    if (rendered.lines.length === 0 && tells.length === 0 && state === "running") {
+        bodyPlan.push({ kind: "liveness", line: "   not a word out of it yet — idle", order: order++ });
+    }
+    if (!rendered.hasEndAnchor && summary) {
+        bodyPlan.push({ kind: "summary", line: summary, order: order++ });
+    }
+    const bodyLines = selectWaitBodyRows(bodyPlan).map((row) => truncateColumns(row.line, maxColumns));
+    const lines = [waitHeader(projectionId, result.pact.akuma, snapshot, maxColumns), ...bodyLines];
+    const pendingTellCount = snapshot.tells.totals.undelivered;
+    if (pendingTellCount > 0) {
+        lines.push(`${pendingTellCount} tell${pendingTellCount === 1 ? "" : "s"} undelivered`);
     }
     const nextActions = state === "running" && options.runningActions === false
         ? []

package/build/cli/subagent-guard.js

@@ -11,6 +11,9 @@ function isSubagentSafeCommand(args) {
         const subcommand = args[1];
         return subcommand === "list" || subcommand === "show" || SUBAGENT_SAFE_FLAGS.has(subcommand ?? "");
     }
+    if (head === "task") {
+        return args[1] === "log" || SUBAGENT_SAFE_FLAGS.has(args[1] ?? "");
+    }
     return ((head !== undefined && SUBAGENT_SAFE_COMMANDS.has(head)) ||
         (args.length === 1 && head !== undefined && SUBAGENT_SAFE_FLAGS.has(head)));
 }

package/build/cli/types.js

@@ -1 +1 @@
-export const TASK_SUBCOMMANDS = ["add", "show", "ls", "start", "stop", "done", "drop", "update", "doctor"];
+export const TASK_SUBCOMMANDS = ["add", "show", "ls", "log", "start", "stop", "done", "drop", "update", "doctor"];

package/build/core/bind.js

@@ -3,12 +3,12 @@ import { assertSettingsKnobUsable } from "../config/settings/disease.js";
 import { loadKeiyakuSettings } from "../config/settings/loader.js";
 import { FlowError } from "../flow-error.js";
 import { activeLedgerRef, appendEntry, appendWithRetry, readLedger } from "./ledger.js";
-import { describeMissingBindSections, materializeBindDraft, mergeBindDraft, missingBindDraftSections, parseBindDraft, parsePartialBindDraft, renderMissingBindSectionsTemplate, } from "./draft.js";
-import { assertValidContractId, buildContractId } from "./ids.js";
-import { registerScope, releaseScope } from "./registry.js";
+import { describeMissingBindSections, materializeBindDraft, mergeBindDraft, missingBindDraftSections, parseBindDraft, parsePartialBindDraft, renderBindDraft, renderMissingBindSectionsTemplate, } from "./draft.js";
+import { assertValidContractId, buildContractId, isCommissionId } from "./ids.js";
+import { previewScopeRegistration, registerScope, releaseScope } from "./registry.js";
 import { resolveDefaultBranch } from "./status/drift.js";
 import { normalizeTargetRef } from "./target-ref.js";
-import { reconcileTaskForfeit, settleTaskBoardForBind } from "./task/index.js";
+import { previewTaskBoardForBind, reconcileTaskForfeit, settleTaskBoardForBind } from "./task/index.js";
 import { bootstrapEntryDataFromObservation, isBootstrapSuccess, runWorktreeBootstrap, } from "./worktree-bootstrap.js";
 import { contractWorktreePathFromBind, stableRepoRoot } from "./worktree-path.js";
 import { allocateWorktreePlace, cleanupCreatedBindResources, createContractBranch, defaultCreateWorktree, materializeContractView, resolveTreeRoot, } from "./bind-workspace.js";
@@ -138,6 +138,99 @@ export function composeTaskBindDraft(input) {
     }
     return materializeBindDraft(merged);
 }
+async function validateBindAfter(cwd, after) {
+    const unique = new Set();
+    for (const contractId of after) {
+        if (unique.has(contractId)) {
+            throw new FlowError("INVALID_TARGET", `contract ${contractId} selected more than once by --after`);
+        }
+        unique.add(contractId);
+        if (!isCommissionId(contractId)) {
+            throw new FlowError("INVALID_TARGET", `after contract ${contractId} is not a valid contract id`);
+        }
+        if (!await readLedger(cwd, contractId)) {
+            throw new FlowError("INVALID_TARGET", `after contract ${contractId} does not exist`);
+        }
+    }
+}
+/**
+ * The common read-only bind admission candidate. Mutation uses this candidate
+ * before task settlement; preview stops after it has observed all admission
+ * facts and rendered the canonical draft.
+ */
+async function admitBindCandidate(input, draft) {
+    const id = buildContractId({ name: draft.name, nowMs: input.nowMs, randomBytes: input.randomBytes });
+    await assertValidContractId(input.cwd, id);
+    await validateBindAfter(input.cwd, input.after);
+    const provisionalEntry = makeBindEntry({
+        id,
+        at: new Date(input.nowMs).toISOString(),
+        actor: input.actor,
+        draft,
+        // Preview never writes the task-board commit. The current target head is
+        // sufficient for its read-only provisional entry and worktree coordinate.
+        base: input.base,
+        target: input.target,
+        after: input.after,
+        workspace: input.workspace,
+        place: input.place,
+        bootstrap: input.bootstrapPlan,
+    });
+    const tree = await resolveTreeRoot(input.cwd, input.workspace, id, provisionalEntry);
+    const scopeOverlaps = await previewScopeRegistration(input.cwd, {
+        contractId: id,
+        scope: draft.scope,
+        tree,
+        exclusive: input.exclusive,
+    });
+    return {
+        id,
+        draft,
+        canonicalDraft: renderBindDraft(draft),
+        target: input.target,
+        place: input.workspace === "worktree" ? input.place ?? null : null,
+        workspace: input.workspace,
+        after: input.after,
+        scopeOverlaps,
+    };
+}
+export async function previewBindContract(input) {
+    const isTaskBound = input.taskIds !== undefined && input.taskIds.length > 0;
+    const ordinaryDraft = !isTaskBound ? parseBindDraft(input.draft) : undefined;
+    const workspace = input.workspace ?? "here";
+    const defaultBranch = await resolveDefaultBranch(input.cwd);
+    if (!defaultBranch) {
+        throw new FlowError("INTERNAL_STATE", "cannot bind: no default branch");
+    }
+    const target = normalizeTargetRef(defaultBranch.branch);
+    const loadedSettings = await loadKeiyakuSettings(input.cwd);
+    let bootstrapPlan;
+    if (workspace === "worktree") {
+        assertSettingsKnobUsable(loadedSettings, "worktreeBootstrap");
+        bootstrapPlan = resolvedBootstrapPlan(loadedSettings.knobs?.worktreeBootstrap);
+    }
+    const randomBytes = input.randomBytes?.(0) ?? randomBytesDefault();
+    const place = workspace === "worktree" ? await allocateWorktreePlace(input.cwd, randomBytes) : undefined;
+    const taskAdmission = isTaskBound
+        ? await previewTaskBoardForBind({ cwd: input.cwd, taskIds: input.taskIds })
+        : { tasks: [] };
+    const draft = isTaskBound
+        ? composeTaskBindDraft({ task: taskAdmission.tasks[0], draft: input.draft })
+        : ordinaryDraft;
+    return await admitBindCandidate({
+        cwd: input.cwd,
+        actor: input.actor,
+        nowMs: input.nowMs,
+        after: input.after ?? [],
+        exclusive: input.exclusive,
+        workspace,
+        randomBytes,
+        base: defaultBranch.head,
+        target,
+        bootstrapPlan,
+        place,
+    }, draft);
+}
 export async function bindContract(input) {
     const isTaskBound = input.taskIds !== undefined && input.taskIds.length > 0;
     const ordinaryDraft = !isTaskBound ? parseBindDraft(input.draft) : undefined;
@@ -161,8 +254,20 @@ export async function bindContract(input) {
         let settlement;
         try {
             const prepare = async (draft) => {
-                const id = buildContractId({ name: draft.name, nowMs: input.nowMs, randomBytes });
-                await assertValidContractId(input.cwd, id);
+                const candidate = await admitBindCandidate({
+                    cwd: input.cwd,
+                    actor: input.actor,
+                    nowMs: input.nowMs,
+                    after: input.after ?? [],
+                    exclusive: input.exclusive,
+                    workspace,
+                    randomBytes,
+                    base: defaultBranch.head,
+                    target,
+                    bootstrapPlan,
+                    place,
+                }, draft);
+                const id = candidate.id;
                 const ref = activeLedgerRef(id);
                 return {
                     contractId: id,

package/build/core/draft.js

@@ -204,7 +204,7 @@ export function renderMissingBindSectionsTemplate(missing) {
             continue;
         }
         if (section === "scope") {
-            lines.push("## Scope", "```", "<pattern>", "<another-pattern>", "```");
+            lines.push("## Scope", "~~~", "<pattern>", "<another-pattern>", "~~~");
             continue;
         }
         lines.push("## Checks", "- <verification>");