@giovannijecha/jecode 0.8.5 → 0.8.7

package/dist/tui/components/tool.js

@@ -1,210 +1,56 @@
-// A compact execution trace: state and identity on one semantic rail,
-// bounded evidence below, and motion that never enters durable state.
-import { fitSegs, hasColor, plainLen, row } from "../../ui/render.js";
-import { graphemeCeiling, graphemeFloor } from "../../text-boundary.js";
+// Target-first execution records, connected to bounded, expandable evidence.
+import { plainLen, row } from "../../ui/render.js";
 import { toolDuration } from "../../duration.js";
-import { breathe, easeInOut, easeOut, interval, mix, TOOL_BIRTH_MS, TOOL_LEADER_MAX_MS, TOOL_ROW_ARRIVAL_MS, } from "../motion.js";
-import { transcriptLead } from "../transcript-grammar.js";
-const OUTPUT_ROWS = 8;
-const LIVE_OUTPUT_ROWS = 6;
-const DIFF_ROWS = 15;
-const TOOL_NAME_COLS = 12;
-const TOOL_COLUMNS_AT = 64;
-const SPINNER_MS = 80;
-const SPINNER = ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"];
+import { toolEvidence, renderDetail } from "./tool-evidence.js";
+import { connector, connectorInk, runningTool, stateInk, stateMark } from "./tool-motion.js";
 export function renderTool(block, width, pal, context = {}) {
     const now = context.now ?? Date.now();
-    const shown = visibleDetails(block);
-    const ink = stateInk(block, pal, context, now);
-    const nameInk = birthInk(pal.ink.bright, pal.ink.dim, context, now);
+    const clock = { ...context, now };
+    const evidence = toolEvidence(block);
+    const active = runningTool(block);
+    const elapsed = active ? toolDuration(Math.max(0, now - block.startedAt), true)
+        : block.durationMs === undefined ? "" : toolDuration(block.durationMs);
+    const mark = stateMark(block);
+    // The separate change summary already carries these exact counts.
+    const repeatedCount = evidence.counts !== "" && block.right.startsWith(`${evidence.counts} · `);
+    const outcome = repeatedCount ? block.right.slice(evidence.counts.length + 3) : block.right;
+    const result = [`${mark}${outcome === "" ? "" : ` ${outcome}`}`, elapsed].filter(Boolean).join(" · ");
+    const hasEvidence = evidence.details.length > 0;
+    const name = { text: block.name, fg: pal.ink.dim };
+    const right = [{ text: result, fg: stateInk(block, pal) }];
+    const separateStatus = plainLen([name, ...right]) + (hasEvidence ? 2 : 3) + 3 > width;
+    const summaryAt = separateStatus ? 3 : 2;
+    const detailStart = summaryAt + (evidence.summary === "" ? 0 : 1);
+    const length = hasEvidence ? detailStart + evidence.details.length + 1 : summaryAt;
     const left = [
-        ...transcriptLead(width, { text: stateGlyph(block, context, now), fg: ink, bold: true }),
-        { text: toolName(block, width), fg: nameInk, bold: true },
-        ...(block.target === "" ? [] : [{ text: `  ${block.target}`, fg: pal.technical }]),
+        ...connector(hasEvidence || separateStatus ? "│ " : "└─ ", block, pal, clock, 1, length),
+        name,
     ];
-    const right = resultSegments(block, pal, context, now);
-    const leader = movingLeader(width, left, right, pal, context, now);
-    return [
+    const rows = [
         ...(context.continues === true ? [] : [""]),
-        row(width, leader === undefined ? left : [...left, leader], right),
-        ...shown.map(({ detail, sourceIndex }) => renderDetail(detail, block.tone, width, pal, context.reducedMotion === true ? undefined : context.motion?.rowsAt[sourceIndex ?? -1], now)),
+        row(width, [
+            ...connector("┌ ", block, pal, clock, 0, length),
+            { text: block.target || block.name, fg: pal.technical },
+        ]),
+        separateStatus ? row(width, left)
+            : row(Math.min(width, plainLen([...left, ...right]) + 3), left, right),
     ];
-}
-function visibleDetails(block) {
-    const all = block.body ?? [];
-    if (block.expanded === true || all.length === 0) {
-        return all.map((detail, sourceIndex) => ({ detail, sourceIndex }));
-    }
-    if (all.every((detail) => detail.kind === "out")) {
-        const limit = block.tone === "pending" ? LIVE_OUTPUT_ROWS : OUTPUT_ROWS;
-        if (all.length <= limit)
-            return all.map((detail, sourceIndex) => ({ detail, sourceIndex }));
-        const hidden = all.length - limit;
-        const note = block.tone === "pending"
-            ? `… ${all.length} lines so far`
-            : `… ${hidden} earlier lines · ctrl+o expand`;
-        return [
-            { detail: { kind: "gap", text: note } },
-            ...all.slice(-limit).map((detail, index) => ({
-                detail,
-                sourceIndex: all.length - limit + index,
-            })),
-        ];
-    }
-    // A compact transcript audits what changed rather than repeating unchanged
-    // source. One budget covers writes and edits, with both ends retained.
-    const changed = all
-        .map((detail, sourceIndex) => ({ detail, sourceIndex }))
-        .filter(({ detail }) => detail.kind === "add" || detail.kind === "del");
-    if (changed.length <= DIFF_ROWS)
-        return changed;
-    const leading = Math.ceil(DIFF_ROWS / 2);
-    const trailing = DIFF_ROWS - leading;
-    const hidden = changed.length - DIFF_ROWS;
-    return [
-        ...changed.slice(0, leading),
-        {
-            detail: {
-                kind: "gap",
-                text: `… ${hidden} more changed ${hidden === 1 ? "line" : "lines"} · ctrl+o expand`,
-            },
-        },
-        ...changed.slice(-trailing),
-    ];
-}
-function renderDetail(detail, tone, width, pal, arrivedAt, now) {
-    const rail = transcriptLead(width, { text: "│", fg: pal.rule });
-    if (detail.kind === "out") {
-        const base = tone === "fail" || failureLine(detail.text) ? pal.ink.removed : pal.ink.muted;
-        return row(width, [
-            ...rail,
-            { text: detail.text === "" ? " " : detail.text, fg: arrivalInk(base, pal, arrivedAt, now) },
-        ]);
-    }
-    if (detail.kind === "gap") {
-        return row(width, [
-            ...rail,
-            { text: detail.text, fg: arrivalInk(pal.ink.dim, pal, arrivedAt, now), italic: true },
-        ]);
-    }
-    const number = detail.kind === "add" ? detail.newLine : detail.oldLine;
-    const sign = detail.kind === "add" ? "+" : detail.kind === "del" ? "-" : " ";
-    const base = detail.kind === "add"
-        ? pal.ink.added
-        : detail.kind === "del"
-            ? pal.ink.removed
-            : pal.ink.dim;
-    const fg = arrivalInk(base, pal, arrivedAt, now);
-    const tint = detail.kind === "add"
-        ? pal.surface.added
-        : detail.kind === "del"
-            ? pal.surface.removed
-            : undefined;
-    return row(width, [
-        ...rail,
-        { text: sign, fg, bold: detail.kind !== "keep" },
-        { text: `${String(number ?? "").padStart(4)} `, fg: pal.ink.dim },
-        ...emphasized(detail.text, detail.emphasis, fg, tint),
-    ]);
-}
-function emphasized(text, emphasis, fg, bg) {
-    if (emphasis === undefined || emphasis.length <= 0)
-        return [{ text, fg }];
-    const requestedStart = Math.max(0, Math.min(text.length, emphasis.start));
-    const requestedEnd = Math.max(requestedStart, Math.min(text.length, requestedStart + emphasis.length));
-    const start = graphemeFloor(text, requestedStart);
-    const end = graphemeCeiling(text, requestedEnd);
-    if (start === end)
-        return [{ text, fg }];
-    return [
-        ...(start === 0 ? [] : [{ text: text.slice(0, start), fg }]),
-        { text: text.slice(start, end), fg, bg, bold: true },
-        ...(end === text.length ? [] : [{ text: text.slice(end), fg }]),
-    ];
-}
-function toolName(block, width) {
-    if (width < TOOL_COLUMNS_AT || block.target === "")
-        return block.name;
-    return block.name.padEnd(TOOL_NAME_COLS);
-}
-function stateGlyph(block, context, now) {
-    if (block.tone === "pending") {
-        if (block.startedAt === undefined || block.right !== "running")
-            return "○";
-        if (context.reducedMotion === true)
-            return "○";
-        return SPINNER[Math.floor(now / SPINNER_MS) % SPINNER.length] ?? "○";
-    }
-    if (block.tone === "fail")
-        return hasColor() ? "●" : "×";
-    if (block.tone === "deny")
-        return "○";
-    return hasColor() ? "●" : "✓";
-}
-function resultSegments(block, pal, context, now) {
-    const status = block.right;
-    const duration = liveDuration(block, now);
-    if (status === "" && duration === "")
-        return [];
-    const ink = resultInk(block, pal, context, now);
-    return [
-        ...(status === "" ? [] : [{ text: status, fg: ink }]),
-        ...(duration === "" ? [] : [{ text: `${status === "" ? "" : " · "}${duration}`, fg: pal.ink.dim }]),
-    ];
-}
-function liveDuration(block, now) {
-    if (block.tone === "pending" && block.startedAt !== undefined && block.right === "running") {
-        return toolDuration(Math.max(0, now - block.startedAt), true);
-    }
-    return block.durationMs === undefined ? "" : toolDuration(block.durationMs);
-}
-function stateInk(block, pal, context, now) {
-    if (block.tone === "fail")
-        return pal.ink.removed;
-    if (block.tone === "deny")
-        return pal.ink.attention;
-    if (block.tone === "pending") {
-        if (block.startedAt === undefined || context.reducedMotion === true)
-            return pal.ink.attention;
-        return mix(pal.ink.attention, pal.accent, breathe(now));
-    }
-    return pal.ink.added;
-}
-function resultInk(block, pal, context, now) {
-    return block.tone === "ok" ? pal.ink.muted : stateInk(block, pal, context, now);
-}
-function birthInk(final, initial, context, now) {
-    if (context.reducedMotion === true || context.motion === undefined)
-        return final;
-    return mix(initial, final, easeOut(interval(now, context.motion.bornAt, TOOL_BIRTH_MS)));
-}
-function arrivalInk(base, pal, arrivedAt, now) {
-    if (arrivedAt === undefined)
-        return base;
-    return mix(pal.ink.bright, base, easeOut(interval(now, arrivedAt, TOOL_ROW_ARRIVAL_MS)));
-}
-function movingLeader(width, left, right, pal, context, now) {
-    if (context.reducedMotion === true || context.motion === undefined || right.length === 0)
-        return undefined;
-    const progress = interval(now, context.motion.bornAt, TOOL_LEADER_MAX_MS);
-    if (progress >= 1)
-        return undefined;
-    const fittedRight = fitSegs(right, width);
-    const gap = width - plainLen(left) - plainLen(fittedRight) - 1;
-    if (gap < 9)
-        return undefined;
-    const cells = Array.from({ length: gap }, () => " ");
-    const travelCells = gap - 2;
-    const trail = Math.min(7, travelCells);
-    const travel = travelCells + trail;
-    const head = Math.floor(easeInOut(progress) * travel) - trail;
-    for (let offset = 0; offset < trail; offset++) {
-        const at = head + offset;
-        if (at >= 0 && at < travelCells)
-            cells[at + 1] = "·";
-    }
-    return { text: cells.join(""), fg: pal.rule };
-}
-function failureLine(line) {
-    return line.startsWith("✖") || line.startsWith("×") || line.includes("AssertionError") || /\bfailed\b/i.test(line);
+    if (separateStatus)
+        rows.push(row(width, [
+            ...connector(hasEvidence ? "│ " : "└─ ", block, pal, clock, 2, length),
+            ...right,
+        ]));
+    if (!hasEvidence)
+        return rows;
+    if (evidence.summary !== "")
+        rows.push(row(width, [
+            ...connector("│ ", block, pal, clock, summaryAt, length),
+            { text: evidence.summary, fg: pal.ink.muted },
+        ]));
+    rows.push(...evidence.details.map((detail, index) => renderDetail(detail, block.tone, width, pal, block.expanded ? pal.rule : connectorInk(block, pal, clock, detailStart + index, length))));
+    rows.push(row(width, [
+        ...connector("└─", block, pal, clock, length - 1, length),
+        { text: evidence.note === "" ? "" : ` ${evidence.note}`, fg: pal.ink.dim },
+    ]));
+    return rows;
 }

package/dist/tui/frame.js

@@ -5,11 +5,15 @@
 // writing it: a full repaint at streaming speed flickers and floods the pipe.
 // So the painter keeps the last frame and emits the difference.
 import { CSI } from "../ui/render.js";
-import { CURSOR, SYNC, write } from "./screen.js";
-export function painter() {
+import { CURSOR, SYNC, write, outputReady, onDrain } from "./screen.js";
+export function painter(output = { write, ready: outputReady, onReady: onDrain }) {
     let previous = [];
     return {
         paint(rows, cursor) {
+            // The last accepted frame remains the diff base. The host redraws current
+            // state on drain, so stale intermediate frames never form another queue.
+            if (!output.ready())
+                return;
             let out = SYNC.begin + CURSOR.hide;
             const height = Math.max(rows.length, previous.length);
             for (let i = 0; i < height; i++) {
@@ -24,10 +28,11 @@ export function painter() {
             previous = rows.slice();
             // One write, so a terminal that ignores the synchronization hint still
             // gets the frame as a single arrival rather than a row at a time.
-            write(out + SYNC.end);
+            output.write(out + SYNC.end);
         },
         invalidate() {
             previous = [];
         },
+        onReady: (handler) => output.onReady(handler),
     };
 }

package/dist/tui/help.js

@@ -3,6 +3,7 @@ import { row } from "../ui/render.js";
 import { textWidth } from "../ui/width.js";
 const CONTROL_WIDTH = 18;
 const CONTROLS = [
+    { key: "/", description: "open commands, also while working" },
     { key: "up / down", description: "move through menus or history" },
     { key: "left / right", description: "move cursor or change a value" },
     { key: "ctrl+left / right", description: "move cursor by word" },
@@ -10,8 +11,8 @@ const CONTROLS = [
     { key: "enter / tab", description: "select, send/steer · complete" },
     { key: "alt+enter", description: "insert a new line" },
     { key: "esc", description: "close UI or interrupt work" },
-    { key: "ctrl+c", description: "interrupt work or exit" },
-    { key: "ctrl+o", description: "toggle reasoning or tool details" },
+    { key: "ctrl+c", description: "cancel menu, interrupt work or exit" },
+    { key: "ctrl+o", description: "expand/collapse reasoning or evidence" },
     { key: "wheel / pgup/dn", description: "scroll the transcript" },
     { key: "ctrl+l", description: "redraw the screen" },
 ];

package/dist/tui/picker-layout.js

@@ -0,0 +1,44 @@
+// Bounded Ribbon composition; filtering and selection remain in picker.ts.
+import { row } from "../ui/render.js";
+import { menuText, renderMenu } from "./components/menu.js";
+import { promptCursor, promptLine } from "./components/prompt.js";
+export function layoutPicker(picker, found, width, pal, maxRows) {
+    const budget = Math.max(0, maxRows);
+    const queryRows = picker.searchable && budget >= 2 ? 1 : 0;
+    const titleRows = picker.title.length > 0 && budget - queryRows >= 2 ? 1 : 0;
+    const controlRows = budget - queryRows - titleRows >= 2 ? 1 : 0;
+    let contextRoom = Math.max(0, budget - queryRows - titleRows - controlRows - 1);
+    const target = menuText(picker.right ?? "", width, Math.min(2, contextRoom));
+    contextRoom -= target.length;
+    const note = menuText(picker.description ?? picker.footer ?? "", width, Math.min(2, contextRoom));
+    const prefix = titleRows + target.length + note.length + queryRows;
+    const menu = renderMenu(found.map(({ option, index }) => ({ ...option, selected: index === picker.index })), width, pal, {
+        maxRows: budget - prefix - controlRows,
+        visible: picker.visible ?? 6,
+        overflow: picker.overflow,
+    });
+    const progress = found.length > menu.last - menu.first || picker.searchable
+        ? `${found.length === 0 ? "0" : `${menu.first + 1}–${menu.last}`} / ${found.length}` +
+            (found.length === picker.options.length ? "" : ` · ${picker.options.length} total`)
+        : "";
+    const query = picker.query ?? "";
+    const cursor = queryRows === 0 ? undefined : {
+        row: prefix - 1,
+        col: promptCursor(query, query.length, width, { right: progress }).col,
+    };
+    if (pal === undefined)
+        return { rows: [], cursor };
+    const controls = picker.controls ?? (picker.adjust
+        ? "↑↓ move · ←→ change · esc close" : "↑↓ move · enter select · esc close");
+    return {
+        rows: [
+            ...(titleRows === 0 ? [] : [row(width, picker.title, queryRows > 0 || progress === "" ? [] : [{ text: progress, fg: pal.ink.dim }])]),
+            ...[...target, ...note].map((text) => row(width, [{ text, fg: pal.ink.muted }])),
+            ...(queryRows === 0 ? [] : [promptLine(query, query.length, width, pal, {
+                    placeholder: "type to filter", right: progress,
+                }).row]),
+            ...menu.rows,
+            ...(controlRows === 0 ? [] : [row(width, [{ text: controls, fg: pal.ink.dim }])]),
+        ], cursor,
+    };
+}

package/dist/tui/picker.js

@@ -1,9 +1,7 @@
 // One interaction model for every terminal selector.
-import { row } from "../ui/render.js";
-import { elide, graphemes } from "../ui/width.js";
+import { graphemes } from "../ui/width.js";
 import { assertPromptAppend } from "../input-boundary.js";
-import { menuWindow, renderMenuRows } from "./components/menu.js";
-import { promptCursor, promptLine } from "./components/prompt.js";
+import { layoutPicker } from "./picker-layout.js";
 const WINDOW = 6;
 export function move(picker, step) {
     const shown = matches(picker);
@@ -53,74 +51,12 @@ export function byKey(picker, text) {
     const found = picker.options.findIndex((option) => option.key === typed);
     return found === -1 ? undefined : found;
 }
-export function panel(picker, width, pal, maxRows = (picker.visible ?? WINDOW) + 3) {
-    return layout(picker, width, pal, maxRows).rows;
+export function panel(picker, width, pal, maxRows = (picker.visible ?? WINDOW) + 6) {
+    return layoutPicker(picker, matches(picker), width, pal, maxRows).rows;
 }
 /** Caret for the shared query row, relative to the unframed picker body. */
-export function caret(picker, width, maxRows = (picker.visible ?? WINDOW) + 3) {
-    return layout(picker, width, undefined, maxRows).cursor;
-}
-function layout(picker, width, pal, maxRows) {
-    const found = matches(picker);
-    const note = picker.description ?? picker.footer;
-    const hasTitle = picker.title.length > 0;
-    const fixed = (hasTitle ? 1 : 0) +
-        (note === undefined ? 0 : 1) +
-        (picker.searchable === true ? 1 : 0);
-    const optionRoom = Math.max(1, Math.min(picker.visible ?? WINDOW, maxRows - fixed));
-    const selectedAt = Math.max(0, found.findIndex((entry) => entry.index === picker.index));
-    const { first, last } = menuWindow(found.length, selectedAt, optionRoom);
-    const shown = found.slice(first, last);
-    const colors = pal;
-    const options = colors === undefined
-        ? []
-        : shown.length === 0
-            ? [row(width, [{ text: "no matches", fg: colors.ink.muted }])]
-            : renderMenuRows(shown.map(({ option, index }) => ({
-                label: option.label,
-                description: option.description,
-                hint: option.hint,
-                value: option.value,
-                adjustable: option.adjustable,
-                selected: index === picker.index,
-            })), width, colors);
-    const progress = found.length > shown.length || picker.searchable === true
-        ? `${found.length === 0 ? "0" : `${first + 1}–${first + shown.length}`} / ${found.length}` +
-            (found.length === picker.options.length ? "" : ` · ${picker.options.length} total`)
-        : "";
-    const titleRight = hasTitle
-        ? picker.right ?? (picker.searchable === true ? undefined : progress)
-        : undefined;
-    const visibleTitleRight = titleRight === undefined
-        ? undefined
-        : elide(titleRight, Math.max(1, Math.floor(width * 0.55)));
-    const queryRow = picker.searchable === true && colors !== undefined
-        ? promptLine(picker.query ?? "", (picker.query ?? "").length, width, colors, {
-            placeholder: "type to filter",
-            right: progress,
-        })
-        : undefined;
-    const queryCursor = picker.searchable === true
-        ? promptCursor(picker.query ?? "", (picker.query ?? "").length, width, { right: progress })
-        : undefined;
-    const queryOffset = (hasTitle ? 1 : 0) + (note === undefined ? 0 : 1);
-    return {
-        rows: colors === undefined
-            ? []
-            : [
-                ...(hasTitle
-                    ? [row(width, picker.title, visibleTitleRight === undefined || visibleTitleRight === ""
-                            ? []
-                            : [{ text: visibleTitleRight, fg: colors.ink.dim }])]
-                    : []),
-                ...(note === undefined ? [] : [row(width, [{ text: note, fg: colors.ink.muted }])]),
-                ...(queryRow === undefined ? [] : [queryRow.row]),
-                ...options,
-            ],
-        cursor: picker.searchable === true
-            ? { row: queryOffset, col: queryCursor?.col ?? 0 }
-            : undefined,
-    };
+export function caret(picker, width, maxRows = (picker.visible ?? WINDOW) + 6) {
+    return layoutPicker(picker, matches(picker), width, undefined, maxRows).cursor;
 }
 export function heading(label, about, pal) {
     return [
@@ -128,7 +64,7 @@ export function heading(label, about, pal) {
         { text: about, fg: pal.ink.fg },
     ];
 }
-function matches(picker) {
+export function matches(picker) {
     const query = (picker.query ?? "").trim().toLocaleLowerCase();
     return picker.options.flatMap((option, index) => {
         const haystack = `${option.label} ${option.hint ?? ""} ${option.value ?? ""}`.toLocaleLowerCase();

package/dist/tui/screen.js

@@ -50,6 +50,13 @@ export function size() {
 export function write(text) {
     process.stdout.write(text);
 }
+export function outputReady() {
+    return !process.stdout.writableNeedDrain;
+}
+export function onDrain(handler) {
+    process.stdout.on("drain", handler);
+    return () => { process.stdout.off("drain", handler); };
+}
 export function enter(reducedMotion = false) {
     if (active)
         return;

package/dist/tui/session-view.js

@@ -14,7 +14,6 @@ export function controllerOptions(session, contextPolicy, tools = session.tools,
         contextPolicy,
         effort: session.config.effort,
         requestIdentity: requestIdentityForSession(session),
-        maxModelRequests: session.config.maxModelRequests,
         toolContext: { root: session.config.root },
         ...(steering === undefined ? {} : { steering }),
     };

package/dist/tui/tool-details.js

@@ -0,0 +1,135 @@
+// Semantic tool evidence built from arguments, previews, and results.
+import { graphemes } from "../text-boundary.js";
+import { condense, diff } from "../ui/diff.js";
+/** Unchanged rows kept either side of a change. */
+const CONTEXT = 2;
+/** The argument worth showing: the thing the call acts on. */
+export function toolTarget(input) {
+    const { path, command } = input;
+    if (typeof command === "string")
+        return command;
+    if (typeof path === "string")
+        return path;
+    const rest = JSON.stringify(input);
+    return rest === "{}" ? "" : rest;
+}
+/**
+ * What the call is about to do, drawn before it is allowed to do it.
+ *
+ * The tool is asked first, because only it knows what is already on disk: a
+ * write against an existing file is a replacement, and showing it as a page of
+ * additions hides exactly the part worth approving. The fallback diffs what is
+ * in the arguments, which is all there is when a tool has nothing to say.
+ */
+export function previewDetails(call, look) {
+    if (look !== undefined)
+        return changes(look.before, look.after);
+    const input = call.input;
+    if (call.name === "write_file" && typeof input.content === "string") {
+        return changes("", input.content);
+    }
+    if (call.name === "edit_file" && typeof input.old_text === "string") {
+        return changes(input.old_text, typeof input.new_text === "string" ? input.new_text : "");
+    }
+    return undefined;
+}
+/** Two texts as the rows of their difference, unchanged runs summed up. */
+function changes(before, after) {
+    let oldLine = 1;
+    let newLine = 1;
+    const rows = [];
+    for (const changed of condense(diff(before, after), CONTEXT)) {
+        if (changed.kind === "gap") {
+            rows.push({ kind: "gap", text: `… ${changed.skipped} unchanged` });
+            oldLine += changed.skipped;
+            newLine += changed.skipped;
+            continue;
+        }
+        if (changed.kind === "keep") {
+            rows.push({ kind: "keep", text: tabs(changed.text), oldLine, newLine });
+            oldLine++;
+            newLine++;
+            continue;
+        }
+        if (changed.kind === "del") {
+            rows.push({ kind: "del", text: tabs(changed.text), oldLine });
+            oldLine++;
+            continue;
+        }
+        rows.push({ kind: "add", text: tabs(changed.text), newLine });
+        newLine++;
+    }
+    emphasizePairs(rows);
+    return rows.length === 0 ? undefined : rows;
+}
+function emphasizePairs(rows) {
+    for (let index = 0; index < rows.length - 1; index++) {
+        const removed = rows[index];
+        const added = rows[index + 1];
+        if (removed?.kind !== "del" || added?.kind !== "add")
+            continue;
+        if (rows[index - 1]?.kind === "del" || rows[index + 2]?.kind === "add")
+            continue;
+        const removedClusters = graphemes(removed.text);
+        const addedClusters = graphemes(added.text);
+        let prefix = 0;
+        let start = 0;
+        while (prefix < removedClusters.length &&
+            prefix < addedClusters.length &&
+            removedClusters[prefix] === addedClusters[prefix]) {
+            start += removedClusters[prefix].length;
+            prefix++;
+        }
+        let suffix = 0;
+        let removedSuffix = 0;
+        let addedSuffix = 0;
+        while (suffix < removedClusters.length - prefix &&
+            suffix < addedClusters.length - prefix &&
+            removedClusters[removedClusters.length - 1 - suffix] ===
+                addedClusters[addedClusters.length - 1 - suffix]) {
+            removedSuffix += removedClusters[removedClusters.length - 1 - suffix].length;
+            addedSuffix += addedClusters[addedClusters.length - 1 - suffix].length;
+            suffix++;
+        }
+        while (suffix > 0 &&
+            (!wordBoundary(removed.text, removedSuffix) || !wordBoundary(added.text, addedSuffix))) {
+            removedSuffix -= removedClusters[removedClusters.length - suffix].length;
+            addedSuffix -= addedClusters[addedClusters.length - suffix].length;
+            suffix--;
+        }
+        const removedLength = removed.text.length - start - removedSuffix;
+        const addedLength = added.text.length - start - addedSuffix;
+        if (removedLength > 0)
+            removed.emphasis = { start, length: removedLength };
+        if (addedLength > 0)
+            added.emphasis = { start, length: addedLength };
+    }
+}
+function wordBoundary(text, suffix) {
+    const at = text.length - suffix;
+    if (at <= 0 || at >= text.length)
+        return true;
+    return /\w/.test(text[at - 1]) !== /\w/.test(text[at]);
+}
+/** What the call left behind, for the calls whose output is worth a look. */
+export function producedDetails(call, output) {
+    if (call.name === "run_command")
+        return outputDetails(output, "out");
+    // A read or a listing is already summed up on the right of its own row, and
+    // the model is about to say what was in it. Printing it twice helps nobody.
+    return undefined;
+}
+export function outputDetails(text, kind) {
+    const rows = split(text).map((line) => ({ kind, text: tabs(line) }));
+    return rows.length === 0 ? undefined : rows;
+}
+function split(text) {
+    const lines = text.replace(/\r\n?/g, "\n").split("\n");
+    while (lines.length > 0 && lines[lines.length - 1] === "")
+        lines.pop();
+    return lines.map(tabs);
+}
+// A tab is a width the terminal decides and the row measurement cannot see.
+function tabs(line) {
+    return line.replace(/\t/g, "  ");
+}

package/dist/tui/transcript-grammar.js

@@ -1,4 +1,4 @@
-// One semantic margin shared by the user cue and executable tool evidence.
+// Content padding for user surfaces, notices, and tool evidence markers.
 const GUTTER = 2;
 export function transcriptGutter(_width) {
     return GUTTER;