@bli-cockpit/cli 0.2.39 → 0.2.41

package/dist/commands/notes.js

@@ -23,8 +23,8 @@
  *    run has nobody to ask and asking it to guess is worse than the flag it
  *    already typed the command for.
  */
-import { isInteractiveStdin, readLine, writeLine, yesByDefault } from "./cli-io.js";
-import { NOTE_SLOW_UPLOAD_BYTES, noteFileRefusalSentence, readNoteFile, } from "./notes-file.js";
+import { isInteractiveStdin, readLine, readPipedText, writeLine, yesByDefault } from "./cli-io.js";
+import { NOTE_SLOW_UPLOAD_BYTES, decodeTextBytes, noteFileRefusalSentence, readNoteFile, } from "./notes-file.js";
 import { loadPairedSession, towerFailureDetail, towerRequest, } from "../tower-client.js";
 import { readResponseJson } from "../upload-http.js";
 /**
@@ -261,15 +261,24 @@ async function pasteNote(command, door) {
             writeLine(door.io.stderr, `${TAG} file refused ${JSON.stringify({ reason: read.refusal, detail: read.detail })}`);
             return fail(door, read.refusal, sentence);
         }
-        text = read.bytes.toString("utf8");
+        const decoded = decodeTextBytes(read.bytes);
+        if (!decoded.ok) {
+            writeLine(door.io.stderr, `${TAG} file refused ${JSON.stringify({ reason: decoded.reason })}`);
+            return fail(door, decoded.reason, "That file is not text this command can decode (it may be a binary or an unusual encoding). Nothing was sent.");
+        }
+        text = decoded.text;
     }
     else {
         if (isInteractiveStdin(door.io)) {
-            return fail(door, "nothing_piped", "Pipe the note in (`pbpaste | cockpit notes paste` on macOS, "
-                + "`Get-Clipboard | cockpit notes paste` on Windows) or pass --file <path>.");
+            return fail(door, "nothing_piped", "Pass --file <path> (safest on Windows), or pipe the note in "
+                + "(`pbpaste | cockpit notes paste` on macOS; on Windows use PowerShell 7 — "
+                + "Windows PowerShell 5.1 turns non-ASCII into `?` on pipes).");
         }
         try {
-            text = await readAll(door.io.stdin);
+            text = await readPipedText(door.io.stdin, {
+                maxChars: PASTE_MAX_CHARS,
+                overflowMessage: `A pasted note is limited to ${PASTE_MAX_CHARS} characters. Save it to a file and use --file instead.`,
+            });
         }
         catch (error) {
             return fail(door, "paste_too_long", errorText(error));
@@ -284,8 +293,14 @@ async function pasteNote(command, door) {
         form.set("name", command.name);
     if (command.exclude)
         form.set("exclusions", command.exclude);
-    if (text.length >= NOTE_SLOW_UPLOAD_BYTES) {
-        writeLine(door.io.stderr, `Reading ${Math.round(text.length / 1024)} KB of pasted text. This can take a couple of minutes.`);
+    // Bytes, not `.length` (BLI-3482). `NOTE_SLOW_UPLOAD_BYTES` is a BYTE
+    // threshold, and the file path above already compares `bytes.byteLength`
+    // against it; `text.length` counts UTF-16 units, so a note in any non-Latin
+    // script was measured at a third to a half of the size actually being sent
+    // and the "this will take a while" line stayed silent through the wait.
+    const pastedBytes = Buffer.byteLength(text, "utf8");
+    if (pastedBytes >= NOTE_SLOW_UPLOAD_BYTES) {
+        writeLine(door.io.stderr, `Reading ${Math.round(pastedBytes / 1024)} KB of pasted text. This can take a couple of minutes.`);
     }
     const answer = await ask(door, {
         path: "/api/notes/upload",
@@ -302,6 +317,7 @@ async function pasteNote(command, door) {
         note_id: body.noteId ?? null,
         scope: body.scope ?? null,
         chars: text.length,
+        byte_size: pastedBytes,
         named_by_caller: Boolean(command.name),
     })}`);
     if (door.json)
@@ -474,17 +490,6 @@ function sayScope(door, body) {
     writeLine(door.io.stderr, `${TAG} narrowed ${JSON.stringify({ scope: body.scope ?? null, reason: body.degradedBecause })}`);
     writeLine(door.io.stderr, body.degradedNote ?? "This answer is narrower than the browser's.");
 }
-async function readAll(stream) {
-    stream.setEncoding("utf8");
-    let text = "";
-    for await (const chunk of stream) {
-        text += chunk;
-        if (text.length > PASTE_MAX_CHARS) {
-            throw new Error(`A pasted note is limited to ${PASTE_MAX_CHARS} characters. Save it to a file and use --file instead.`);
-        }
-    }
-    return text;
-}
 function errorText(error) {
     return error instanceof Error ? error.message : String(error);
 }

package/dist/commands/public-root.js

@@ -15,7 +15,7 @@ export async function runCockpitCli(argv, io) {
   }
 
   if (command === "--version" || command === "-V" || command === "version") {
-    writeLine(io?.stdout ?? process.stdout, "0.2.39");
+    writeLine(io?.stdout ?? process.stdout, "0.2.41");
     return 0;
   }
 

package/dist/commands/scout-render.js

@@ -15,12 +15,15 @@
  * **A bounded read says so.** The server returns at most 8 cards and 12
  * signals; when there are more, `truncationLines` prints how many. A quiet
  * board and a truncated board must never look alike.
+ *
+ * **Styling arrives as an argument, never as a global.** `styled` says whether
+ * this run's stdout is a terminal that asked for colour (BLI-3482); `scout.ts`
+ * decides it once with `colorEnabled(io)` and the layout stays deterministic.
  */
-const DIM = "\x1b[2m";
-const RESET = "\x1b[0m";
+import { dim } from "./cli-io.js";
 // ------------------------------------------------------------------ rendering
 /** The whole board as terminal lines, in the page's three sections and order. */
-export function renderScoutBoard(payload) {
+export function renderScoutBoard(payload, styled) {
     const board = payload.board ?? {};
     const lines = payload.lines ?? {};
     const out = [];
@@ -35,7 +38,7 @@ export function renderScoutBoard(payload) {
     }
     else {
         for (const card of experiments)
-            out.push(...renderExperiment(card));
+            out.push(...renderExperiment(card, styled));
     }
     const settled = board.settled ?? [];
     if (settled.length > 0) {
@@ -51,14 +54,14 @@ export function renderScoutBoard(payload) {
     }
     else {
         for (const signal of signals)
-            out.push(...renderSignal(signal));
+            out.push(...renderSignal(signal, styled));
     }
     const truncation = truncationLines(board);
     if (truncation.length > 0)
         out.push("", ...truncation);
     return out;
 }
-function renderExperiment(card) {
+function renderExperiment(card, styled) {
     const sourceCount = card.sourceCount ?? 0;
     const head = [
         shortId(card.id ?? ""),
@@ -74,23 +77,25 @@ function renderExperiment(card) {
     if (card.claimSummary)
         out.push(`    ${card.claimSummary}`);
     if (card.title)
-        out.push(dim(`    ${card.title}`));
+        out.push(dim(`    ${card.title}`, styled));
     for (const row of card.crossref ?? []) {
-        if (row.person)
-            out.push(dim(`    On your team · ${row.person} · ${row.observedPattern ?? ""}`));
+        if (row.person) {
+            out.push(dim(`    On your team · ${row.person} · ${row.observedPattern ?? ""}`, styled));
+        }
     }
     if (card.expectedPayoff)
-        out.push(dim(`    Worth trying · ${card.expectedPayoff}`));
+        out.push(dim(`    Worth trying · ${card.expectedPayoff}`, styled));
     for (const source of card.sources ?? []) {
-        if (source.title)
-            out.push(dim(`    ${source.title} · ${source.source ?? ""} · ${source.url ?? ""}`));
+        if (source.title) {
+            out.push(dim(`    ${source.title} · ${source.source ?? ""} · ${source.url ?? ""}`, styled));
+        }
     }
     return out;
 }
-function renderSignal(signal) {
+function renderSignal(signal, styled) {
     const out = [`  ⏺ ${signal.title ?? "untitled"} · ${dayStamp(signal.gatheredAt)}`];
     if (signal.synopsis)
-        out.push(dim(`    ${signal.synopsis}`));
+        out.push(dim(`    ${signal.synopsis}`, styled));
     const foot = [
         signal.source,
         signal.evidenceStrength ?? undefined,
@@ -99,7 +104,7 @@ function renderSignal(signal) {
         signal.url,
     ].filter((part) => Boolean(part));
     if (foot.length > 0)
-        out.push(dim(`    ${foot.join(" · ")}`));
+        out.push(dim(`    ${foot.join(" · ")}`, styled));
     return out;
 }
 /**
@@ -164,9 +169,6 @@ export function shortId(id) {
 function dayStamp(iso) {
     return iso ? iso.slice(0, 10) : "";
 }
-function dim(text) {
-    return `${DIM}${text}${RESET}`;
-}
 function indent(text) {
     return `  ${text}`;
 }

package/dist/commands/scout.js

@@ -16,7 +16,7 @@
  * as the page is; moving a card is super_admin whichever surface asks, and a
  * refusal never costs a person the board.
  */
-import { writeLine } from "./cli-io.js";
+import { colorEnabled, writeLine } from "./cli-io.js";
 import { renderScoutBoard, resolveExperimentRef, refusalSentence, shortId, truncationLines, } from "./scout-render.js";
 import { loadPairedSession, towerFailureDetail, towerJsonRequest, } from "../tower-client.js";
 /** The dashboard route caps nothing here, but a board read should never hang a shell. */
@@ -49,7 +49,7 @@ export async function runScout(command, io) {
             writeLine(io.stdout, JSON.stringify({ ok: true, audience: payload.audience ?? null, windowDays: payload.windowDays ?? board.windowDays ?? null, board, lines }));
         }
         else {
-            for (const line of renderScoutBoard(payload))
+            for (const line of renderScoutBoard(payload, colorEnabled(io)))
                 writeLine(io.stdout, line);
         }
         writeLine(io.stderr, `[scout cli] board read ${JSON.stringify({
@@ -78,7 +78,7 @@ export async function runScout(command, io) {
         }
         else {
             writeLine(io.stderr, sentence);
-            for (const line of renderScoutBoard(payload))
+            for (const line of renderScoutBoard(payload, colorEnabled(io)))
                 writeLine(io.stdout, line);
         }
         return 1;
@@ -119,7 +119,7 @@ export async function runScout(command, io) {
         if (applied.httpStatus === 403) {
             writeLine(io.stderr, "Deciding a Scout card is a super_admin action; reading the board is not.");
         }
-        for (const line of renderScoutBoard(payload))
+        for (const line of renderScoutBoard(payload, colorEnabled(io)))
             writeLine(io.stdout, line);
         return 1;
     }

package/dist/commands/sessions.js

@@ -71,9 +71,16 @@ export async function runSessions(command, io) {
             reason: sidecar.skipped_reason,
         })),
     }));
+    // BLI-3483: the scanners have always counted the folders and files they
+    // could not read, and this command has always thrown those counts away
+    // except for one field in `--json`. So "No sessions observed" was printed on
+    // a machine where the scan had been blocked from looking — the operator's
+    // one diagnostic tool answering the question with the failure removed.
+    const readFailures = countReadFailures(codex, claude);
     if (command.json) {
         writeLine(io.stdout, JSON.stringify({
             window,
+            read_failures: readFailures,
             ...(codex
                 ? { codex: { counts: codex.counts, sessions: codexRows } }
                 : {}),
@@ -101,10 +108,47 @@ export async function runSessions(command, io) {
         }
     }
     if (codexRows.length === 0 && claudeRows.length === 0) {
-        writeLine(io.stdout, "No sessions observed in the scan window.");
+        writeLine(io.stdout, readFailures.total > 0
+            ? `No sessions listed, but ${readFailures.total} read failure(s) mean the scan could not see everywhere — this is not proof there were none.`
+            : "No sessions observed in the scan window.");
+    }
+    if (readFailures.total > 0) {
+        for (const line of readFailureLines(readFailures)) {
+            writeLine(io.stdout, line);
+        }
     }
     return 0;
 }
+/**
+ * Everything the two scanners looked at and could not read. Counts only — the
+ * project-dir slug encodes a local path and never leaves this machine.
+ */
+function countReadFailures(codex, claude) {
+    const failures = {
+        codex_directory_read_failed: codex?.directory_read_failed_count ?? 0,
+        codex_stat_failed: codex?.stat_failed_count ?? 0,
+        codex_secret_path_skipped: codex?.secret_path_skipped_count ?? 0,
+        claude_project_dir_read_failed: claude?.project_dir_read_failed_count ?? 0,
+        claude_project_dirs_skipped: claude?.project_dirs_skipped ?? 0,
+        claude_session_stat_failed: claude?.session_stat_failed_count ?? 0,
+        claude_sidecar_dir_read_failed: claude?.sidecar_dir_read_failed_count ?? 0,
+        claude_sidecar_stat_failed: claude?.sidecar_stat_failed_count ?? 0,
+    };
+    return {
+        total: Object.values(failures).reduce((sum, count) => sum + count, 0),
+        ...failures,
+    };
+}
+function readFailureLines(failures) {
+    const named = Object.entries(failures)
+        .filter(([field, count]) => field !== "total" && Number(count) > 0)
+        .map(([field, count]) => `  ${field}: ${count}`);
+    return [
+        `read failures during this scan (${failures.total}) — sessions under these are not listed:`,
+        ...named,
+        "  a permission wall is the usual cause; on macOS grant Full Disk Access, on Windows check the folder ACL",
+    ];
+}
 /** `--all`, an explicit `--since-days` capped at pairing, or the default window. */
 async function sessionsScanWindow(command, now) {
     if (command.all) {

package/dist/commands/settings-render.js

@@ -8,7 +8,12 @@
  * Every one of these is defensive about shape on purpose. These bodies come off
  * the wire from a dashboard that may be a release ahead or behind the installed
  * CLI, and a missing field should cost one line of output, not the command.
+ *
+ * Columns are padded in SCREEN CELLS, not UTF-16 code units (BLI-3482) — a
+ * display name written in another script is exactly the row where `padEnd`
+ * silently stops lining up.
  */
+import { padEndDisplay } from "./text-width.js";
 const INDENT = "  ";
 function text(value, fallback = "—") {
     if (typeof value === "string" && value.trim())
@@ -82,7 +87,7 @@ export function renderTeamMembers(body) {
     for (const person of people) {
         const standing = text(person.standing, "");
         const name = text(person.displayName, text(person.email));
-        lines.push(`${INDENT}${name.padEnd(28)} ${text(person.role, "—").padEnd(20)} ${standing}`);
+        lines.push(`${INDENT}${padEndDisplay(name, 28)} ${padEndDisplay(text(person.role, "—"), 20)} ${standing}`);
         if (typeof person.userId === "string") {
             lines.push(`${INDENT}${INDENT}id ${person.userId}`);
         }
@@ -101,7 +106,7 @@ export function renderSwitches(body) {
         const options = Array.isArray(entry.options)
             ? entry.options.map((option) => text(record(option).value)).join(" | ")
             : "";
-        return `${INDENT}${text(entry.key).padEnd(24)} ${text(entry.value).padEnd(12)} (${text(entry.source)}${options ? `; choices: ${options}` : ""})`;
+        return `${INDENT}${padEndDisplay(text(entry.key), 24)} ${padEndDisplay(text(entry.value), 12)} (${text(entry.source)}${options ? `; choices: ${options}` : ""})`;
     });
     if (typeof body.readFailureReason === "string") {
         lines.push(`${INDENT}values could not be read: ${body.readFailureReason}`);
@@ -114,7 +119,7 @@ export function renderModelRouting(body) {
         `${INDENT}memory  ${text(body.memoryEffectiveLabel)} (${text(body.memorySource)}${typeof body.memoryVia === "string" ? ` via ${body.memoryVia}` : ""})`,
     ];
     for (const slot of list(body.displaySlots)) {
-        lines.push(`${INDENT}${text(slot.name).padEnd(24)} ${text(slot.currentLabel)} — set in code (${text(slot.pointer)})`);
+        lines.push(`${INDENT}${padEndDisplay(text(slot.name), 24)} ${text(slot.currentLabel)} — set in code (${text(slot.pointer)})`);
     }
     if (typeof body.readFailureReason === "string") {
         lines.push(`${INDENT}settings could not be read: ${body.readFailureReason}`);
@@ -132,6 +137,6 @@ export function renderEnvBlobs(body) {
     const blobs = list(body.blobs);
     if (blobs.length === 0)
         return [`${INDENT}no env files stored`];
-    return blobs.map((blob) => `${INDENT}${text(blob.project).padEnd(12)} ${text(blob.file_name).padEnd(16)} ` +
+    return blobs.map((blob) => `${INDENT}${padEndDisplay(text(blob.project), 12)} ${padEndDisplay(text(blob.file_name), 16)} ` +
         `updated ${text(blob.updated_at)}  id ${text(blob.id)}`);
 }

package/dist/commands/settings.js

@@ -213,6 +213,12 @@ async function setModels(command, tower, io) {
         return 0;
     }
     writeLine(io.stdout, `Saved: ${asList(body.saved).join(", ") || "nothing"}.`);
+    // BLI-3481: the save succeeded but the belt pre-flight could not reach the
+    // provider, so nobody has checked that the model just chosen will accept
+    // Tower's tool belt. A bare "Saved." there would be a silent success.
+    if (typeof body.warning === "string" && body.warning.length > 0) {
+        writeLine(io.stderr, body.warning);
+    }
     return 0;
 }
 // ── env files ─────────────────────────────────────────────────────────
@@ -239,8 +245,9 @@ async function setEnvBlob(command, tower, io) {
         const failure = {
             reason: "content_not_piped",
             detail: "settings env set reads the file from stdin. Pipe it in: " +
-                "`cat <path> | cockpit settings env set --project <project> --file <name> --content-stdin` " +
-                "(PowerShell: `Get-Content <path> -Raw | cockpit settings env set …`).",
+                "`cat <path> | cockpit settings env set --project <project> --file <name> --content-stdin`. " +
+                "On Windows use PowerShell 7 (`pwsh`): `Get-Content <path> -Raw | cockpit settings env set …` — " +
+                "Windows PowerShell 5.1 turns non-ASCII into `?` on pipes.",
         };
         return writeCommandFailure(io, command.json, failure);
     }

package/dist/commands/text-width.js

@@ -0,0 +1,108 @@
+/**
+ * How wide a string is ON SCREEN, in terminal cells (BLI-3482).
+ *
+ * `"".length` counts UTF-16 code units, which is the wrong number twice over
+ * for a column: an emoji costs two units and draws two cells, a CJK ideograph
+ * costs one unit and draws two, and a combining accent costs one unit and draws
+ * nothing. Padding by `.length` therefore ragged-edges any table whose cells are
+ * not plain ASCII — the failure a person sees is a column that no longer lines
+ * up, on exactly the rows that carry a name or a title in another script.
+ *
+ * This is a deliberately small wcwidth, not the real one, and its limits are
+ * honest:
+ *
+ * - The wide ranges below are the common East Asian Wide/Fullwidth blocks plus
+ *   the main emoji planes. Ambiguous-width characters (box drawing, `⏺`, Greek,
+ *   Cyrillic) are counted as ONE cell, which is what a Western-locale terminal
+ *   draws; a CJK-locale terminal may draw some of them as two.
+ * - A ZWJ emoji sequence (👨‍👩‍👧) is measured as the sum of its parts, so it
+ *   over-counts on terminals that draw the whole cluster in two cells. Nothing
+ *   here inspects grapheme clusters; that needs `Intl.Segmenter` and a real
+ *   emoji table, which is more machinery than a column deserves.
+ * - U+FE0F (emoji presentation) is counted as zero, so a text-default symbol
+ *   promoted to emoji presentation is under-counted by one.
+ *
+ * Every one of those errors costs alignment, never content: nothing in this
+ * file may drop, cut or reorder text.
+ */
+/** SGR colour sequences occupy no cells, so they are removed before counting. */
+// eslint-disable-next-line no-control-regex
+const ANSI_SGR = /\x1b\[[0-9;]*m/gu;
+/** Zero-cell code points: combining marks, joiners, variation selectors. */
+const ZERO_WIDTH = [
+    [0x0300, 0x036f], // combining diacritical marks
+    [0x0483, 0x0489],
+    [0x0591, 0x05bd],
+    [0x0610, 0x061a],
+    [0x064b, 0x065f],
+    [0x0670, 0x0670],
+    [0x06d6, 0x06dc],
+    [0x0e31, 0x0e31],
+    [0x0e34, 0x0e3a],
+    [0x0e47, 0x0e4e],
+    [0x1ab0, 0x1aff], // combining diacritical marks extended
+    [0x1dc0, 0x1dff], // combining diacritical marks supplement
+    [0x200b, 0x200f], // zero-width space through RTL mark (incl. ZWNJ, ZWJ)
+    [0x20d0, 0x20f0], // combining marks for symbols
+    [0xfe00, 0xfe0f], // variation selectors
+    [0xfe20, 0xfe2f], // combining half marks
+    [0xfeff, 0xfeff], // byte-order mark
+];
+/** Two-cell code points: the common Wide / Fullwidth blocks and emoji planes. */
+const WIDE = [
+    [0x1100, 0x115f], // Hangul Jamo
+    [0x2e80, 0x303e], // CJK radicals, Kangxi, CJK symbols and punctuation
+    [0x3041, 0x33ff], // Hiragana, Katakana, Bopomofo, Hangul Compatibility Jamo
+    [0x3400, 0x4dbf], // CJK Unified Ideographs Extension A
+    [0x4e00, 0x9fff], // CJK Unified Ideographs
+    [0xa000, 0xa4cf], // Yi
+    [0xa960, 0xa97f], // Hangul Jamo Extended-A
+    [0xac00, 0xd7a3], // Hangul syllables
+    [0xf900, 0xfaff], // CJK compatibility ideographs
+    [0xfe10, 0xfe19], // vertical forms
+    [0xfe30, 0xfe6f], // CJK compatibility forms
+    [0xff00, 0xff60], // fullwidth forms
+    [0xffe0, 0xffe6], // fullwidth signs
+    [0x1f300, 0x1f64f], // misc symbols and pictographs, emoticons
+    [0x1f680, 0x1f6ff], // transport and map symbols
+    [0x1f900, 0x1f9ff], // supplemental symbols and pictographs
+    [0x20000, 0x3fffd], // CJK Unified Ideographs Extensions B onward
+];
+function inRanges(code, ranges) {
+    for (const [low, high] of ranges) {
+        if (code < low)
+            return false; // ranges are ascending
+        if (code <= high)
+            return true;
+    }
+    return false;
+}
+/** Cells one code point draws: 0 for combining/invisible, 2 for wide, else 1. */
+export function codePointWidth(code) {
+    if (code === 0x0a || code === 0x0d)
+        return 0;
+    if (code < 0x20 || (code >= 0x7f && code < 0xa0))
+        return 0; // control characters
+    if (inRanges(code, ZERO_WIDTH))
+        return 0;
+    if (inRanges(code, WIDE))
+        return 2;
+    return 1;
+}
+/** Cells a string draws, ignoring any SGR colour sequences inside it. */
+export function displayWidth(text) {
+    let total = 0;
+    for (const character of text.replace(ANSI_SGR, "")) {
+        total += codePointWidth(character.codePointAt(0) ?? 0);
+    }
+    return total;
+}
+/**
+ * `padEnd` that counts cells instead of code units. Like `padEnd`, a string
+ * already at or past the column is returned untouched — a column is a minimum,
+ * never a limit, because cutting a cell to fit loses content.
+ */
+export function padEndDisplay(text, width) {
+    const missing = width - displayWidth(text);
+    return missing > 0 ? `${text}${" ".repeat(missing)}` : text;
+}

package/dist/commands/tower-command.js

@@ -17,7 +17,7 @@
  * - **stdout belongs to `--json`.** Every operational line goes to stderr, which
  *   launchd captures; a `--json` run puts exactly one object on stdout.
  */
-import { writeLine } from "./cli-io.js";
+import { readPipedText, writeLine } from "./cli-io.js";
 import { loadPairedSession, towerFailureDetail, towerJsonRequest, } from "../tower-client.js";
 /** Client-side ceiling. These routes are small reads and writes, not turns. */
 const REQUEST_DEADLINE_MS = 30_000;
@@ -101,12 +101,11 @@ export function parseModelKey(key) {
     }
     return { provider: key.slice(0, separator), model: key.slice(separator + 1) };
 }
-/** Reads piped stdin whole. Used only for env content, which is never echoed. */
+/**
+ * Reads piped stdin whole, BOM-stripped (BLI-3480 — PowerShell redirection
+ * writes one, and stored verbatim it makes the first env line unreachable).
+ * Used only for env content, which is never echoed.
+ */
 export async function readAllStdin(stream) {
-    stream.setEncoding("utf8");
-    let text = "";
-    for await (const chunk of stream) {
-        text += chunk;
-    }
-    return text;
+    return readPipedText(stream);
 }

package/dist/commands/workbook-render.js

@@ -10,11 +10,18 @@
  * summarises, reorders or paraphrases — it wraps, and it strips the emphasis
  * markers a reader did not ask for. `--markdown` bypasses this file entirely
  * and prints the server's bytes, which is what lets this layout be opinionated.
+ *
+ * Two things arrive as arguments rather than being read from the process, so
+ * these functions stay pure and their tests stay deterministic (BLI-3482):
+ * `width` (the wrap column) and `styled` (whether stdout is a terminal that
+ * asked for colour — `workbook.ts` decides it once with `colorEnabled(io)`).
+ * Columns are measured in SCREEN CELLS via `displayWidth`, not in UTF-16 code
+ * units, so a table whose cells carry CJK or emoji still lines up.
  */
-const DIM = "\x1b[2m";
-const RESET = "\x1b[0m";
+import { dim } from "./cli-io.js";
+import { displayWidth, padEndDisplay } from "./text-width.js";
 /** One compartment per project, its documents underneath, addressed as typed. */
-export function renderShelf(projects, width) {
+export function renderShelf(projects, width, styled) {
     const docs = projects.reduce((count, project) => count + (project.docs?.length ?? 0), 0);
     const out = [
         `WORKBOOK · ${projects.length} project${projects.length === 1 ? "" : "s"} · ${docs} document${docs === 1 ? "" : "s"}`,
@@ -27,25 +34,25 @@ export function renderShelf(projects, width) {
             out.push(`  ⏺ cockpit workbook ${project.slug ?? ""} ${doc.slug ?? ""}`);
             out.push(`    ${doc.title ?? ""} · ${doc.kind ?? ""}`);
             if (doc.line) {
-                out.push(...wrap(doc.line, width - 4).map((line) => dim(`    ${line}`)));
+                out.push(...wrap(doc.line, width - 4).map((line) => dim(`    ${line}`, styled)));
             }
-            out.push(dim(`    ${[doc.author, doc.date].filter(Boolean).join(" · ")}`));
+            out.push(dim(`    ${[doc.author, doc.date].filter(Boolean).join(" · ")}`, styled));
         }
     }
     return out;
 }
 /** The document's own header, then its blocks laid out for `width`. */
-export function renderDocText(payload, markdown, width) {
+export function renderDocText(payload, markdown, width, styled) {
     const doc = payload.doc ?? {};
     const out = [];
     if (doc.title)
         out.push(...wrap(doc.title.toUpperCase(), width));
     const meta = [doc.kind, payload.project?.title, doc.author, doc.date].filter(Boolean);
     if (meta.length > 0)
-        out.push(...wrap(meta.join(" · "), width).map((line) => dim(line)));
+        out.push(...wrap(meta.join(" · "), width).map((line) => dim(line, styled)));
     if (out.length > 0)
         out.push("");
-    out.push(...renderMarkdownText(markdown, width));
+    out.push(...renderMarkdownText(markdown, width, styled));
     return out;
 }
 /**
@@ -54,7 +61,7 @@ export function renderDocText(payload, markdown, width) {
  * paragraphs — so there is no "unknown block" case to guess at; anything else
  * falls through as a wrapped paragraph rather than being dropped.
  */
-export function renderMarkdownText(markdown, width) {
+export function renderMarkdownText(markdown, width, styled) {
     const out = [];
     for (const block of markdown.split("\n\n")) {
         const text = block.trim();
@@ -80,7 +87,7 @@ export function renderMarkdownText(markdown, width) {
                 .map((line) => plain(line.replace(/^>\s?/, "")))
                 .join(" ")
                 .trim();
-            out.push(...wrap(quote, width - 4).map((line) => dim(`    ${line}`)));
+            out.push(...wrap(quote, width - 4).map((line) => dim(`    ${line}`, styled)));
             continue;
         }
         if (text.startsWith("- ")) {
@@ -102,6 +109,11 @@ export function renderMarkdownText(markdown, width) {
  * width, each row is printed as `header: cell` lines instead — narrower, and
  * still every cell. Dropping columns to fit is never an option: a table with a
  * column missing looks complete and is not.
+ *
+ * Column sizes are SCREEN CELLS (BLI-3482). `.length` counts UTF-16 units, so a
+ * name in Japanese under-padded by one cell per character and a column of
+ * emoji over-padded by one — the fits/does-not-fit decision was measured in
+ * the same wrong unit, which is how a table that fits chose the narrow layout.
  */
 function renderTable(block, width) {
     const rows = block
@@ -121,12 +133,12 @@ function renderTable(block, width) {
     const columns = Math.max(...rows.map((cells) => cells.length));
     const widths = [];
     for (let index = 0; index < columns; index += 1) {
-        widths.push(Math.max(...rows.map((cells) => (cells[index] ?? "").length)));
+        widths.push(Math.max(...rows.map((cells) => displayWidth(cells[index] ?? ""))));
     }
     const tableWidth = widths.reduce((sum, value) => sum + value, 0) + 2 * (columns - 1);
     if (tableWidth <= width) {
         return rows.map((cells) => cells
-            .map((cell, index) => cell.padEnd(index === columns - 1 ? 0 : (widths[index] ?? 0)))
+            .map((cell, index) => padEndDisplay(cell, index === columns - 1 ? 0 : (widths[index] ?? 0)))
             .join("  ")
             .trimEnd());
     }
@@ -160,7 +172,10 @@ export function sectionSlice(markdown, sections, sectionId) {
     return blocks.slice(start, end).join("\n\n").trim();
 }
 // ----------------------------------------------------------------- small parts
-/** Greedy word wrap. A word longer than the column keeps its own line, uncut. */
+/**
+ * Greedy word wrap, measured in screen cells. A word longer than the column
+ * keeps its own line, uncut.
+ */
 export function wrap(text, width) {
     const limit = Math.max(20, width);
     const words = text.split(/\s+/u).filter(Boolean);
@@ -168,17 +183,22 @@ export function wrap(text, width) {
         return [];
     const lines = [];
     let line = "";
+    let lineWidth = 0;
     for (const word of words) {
+        const wordWidth = displayWidth(word);
         if (!line) {
             line = word;
+            lineWidth = wordWidth;
             continue;
         }
-        if (line.length + 1 + word.length <= limit) {
+        if (lineWidth + 1 + wordWidth <= limit) {
             line = `${line} ${word}`;
+            lineWidth += 1 + wordWidth;
         }
         else {
             lines.push(line);
             line = word;
+            lineWidth = wordWidth;
         }
     }
     lines.push(line);
@@ -190,7 +210,4 @@ function plain(text) {
         .replace(/\*\*(.+?)\*\*/gu, "$1")
         .replace(/\*(.+?)\*/gu, "$1")
         .replace(/\\\|/gu, "|");
-}
-function dim(text) {
-    return `${DIM}${text}${RESET}`;
 }