create-walle 0.10.1 → 0.10.2

package/template/coding-task-manager/lib/claude-markdown-ansi.js

@@ -31,17 +31,14 @@
 // state across the intervening rows exactly as it should, since these rows
 // are painted into the pane in that same order.
 
-const { wrapToCells, truncateToCells, stringCellWidth } = require('./terminal-cell-width');
-const { collectColumnMetrics, computeColumnWidths } = require('./codex-markdown-table');
+const { wrapToCells, truncateToCells } = require('./terminal-cell-width');
+// WP-1 (reader-claude-table-layout-parity-2026-10-25): tables are laid out by Claude Code
+// 2.1.310's own algorithm, ported in this module's sibling -- never by the Codex allocator this
+// file used to borrow (see `emitTable`).
+const { layoutClaudeTable, cardLines, inkWrapLines } = require('./claude-table-layout');
 
 const RESET = '\x1b[0m';
 
-// WP-2 (reader-seam-duplicates): the per-attribute "off" codes this module already closes every
-// inline span with (22 un-bold, 23 un-italicize, 29 un-strike, 39 default fg). A table cell that
-// WRAPS emits one of these at the end of each of its visual lines so a span left open by the
-// wrapped text can never bleed past the `│` that closes the cell into the next column.
-const SPAN_OFF = '\x1b[22;23;29;39m';
-
 function _sgrOpen(codes) {
   const list = (Array.isArray(codes) ? codes : [codes]).filter((c) => c !== undefined && c !== null && c !== '');
   return list.length ? `\x1b[${list.join(';')}m` : '';
@@ -128,85 +125,30 @@ function emitCode(token, cols, indent, style) {
   return lines.map((line) => ' '.repeat(indent) + closeRow(styleRow(truncateToCells(line, width), style.code)));
 }
 
-// Corrected 2026-09-27 (WP-3 live capture, fix round 1): the real screen draws a full
-// box-drawing table (┌─┬─┐ / ├─┼─┤ / └─┴─┘ borders, one space of padding either side of each
-// cell, column width = the widest cell in that column, HEADER cells centered, body cells
-// left-aligned, the whole table indented 2 -- no bold, no other styling on any row, verified
-// from the capture (`basic.capture.json`'s table has zero SGR bytes). Replaces the old
-// "  │  "-joined, unbordered, bold-header rows this renderer invented with no capture to check
-// against.
-function _cellPad(text, width, align) {
-  const total = Math.max(0, width - stringCellWidth(text));
-  if (align === 'center') {
-    const left = Math.floor(total / 2);
-    return ' '.repeat(left) + text + ' '.repeat(total - left);
-  }
-  return text + ' '.repeat(total); // left-align
-}
-
-// WP-2 (reader-seam-duplicates): a table wider than the pane WRAPS its cells inside their own
-// columns instead of truncating the row. Claude itself wraps a wide cell (it never ellipsizes
-// one), so the re-drawn transcript and the live screen now agree. The fitting path below is
-// byte-identical to the pre-WP-2 emitter; only a table that does not fit takes the wrap path,
-// which sizes its columns through the Codex table module's own width allocator (rank cells by
-// kind, shrink the slackiest column first) rather than inventing a second policy.
+// Tables: the layout is Claude Code 2.1.310's OWN (design
+// docs/reader-claude-table-layout-parity-2026-10-25.html -- §3.1 the algorithm read from the
+// binary, §5 the rules R-1..R-8, §9 this site). The port lives in lib/claude-table-layout.js; it
+// decides the form (bordered box or stacked key-value cards), the column widths and every line
+// break, and it was verified byte-identical against three live captures
+// (tests/golden/claude-transcript/table-captures/). This function only renders the cells and
+// prefixes the indent -- no local table policy, because any "nicer" table is content the live
+// screen never had and the seam proof then refuses the join (R-1, R-7).
 function emitTable(token, cols, indent, style) {
-  const headerPlain = (token.header || []).map((c) => inlineText(c.tokens));
-  const headerStyled = (token.header || []).map((c) => emitInline(c.tokens, style));
-  const bodyPlainRows = (token.rows || []).map((row) => row.map((c) => inlineText(c.tokens)));
-  const bodyStyledRows = (token.rows || []).map((row) => row.map((c) => emitInline(c.tokens, style)));
-  const colCount = headerPlain.length;
-  const widths = [];
-  for (let i = 0; i < colCount; i++) {
-    let w = stringCellWidth(headerPlain[i] || '');
-    for (const row of bodyPlainRows) w = Math.max(w, stringCellWidth(row[i] || ''));
-    widths.push(w);
-  }
+  // Cells are rendered through emitInline, so a link prints `label (href)` exactly like Claude's
+  // own `T()`; the port measures widths on that SGR-stripped rendering (R-3 -- never on
+  // inlineText, which drops the href and so under-measures every linked cell).
+  const header = (token.header || []).map((cell) => emitInline(cell.tokens, style));
+  const rows = (token.rows || []).map((row) => row.map((cell) => emitInline(cell.tokens, style)));
+  const layout = layoutClaudeTable({ header, rows, align: token.align }, cols);
+  // R-5: `cols` is the TERMINAL width; `indent` is a prefix on every row and is never subtracted
+  // from it. A bordered table is already inside `cols - 4`; the cards are re-wrapped a second
+  // time by Ink's box at `cols - indent` (D-5), which is what turns a 170-cell card line into the
+  // three painted rows of the tasks capture.
+  const lines = layout.kind === 'bordered'
+    ? layout.lines
+    : inkWrapLines(cardLines(layout, cols, style), cols - indent);
   const pad = ' '.repeat(indent);
-  const budget = Math.max(1, cols - indent);
-  const tableWidth = widths.reduce((sum, w) => sum + w, 0) + 3 * colCount + 1;
-  if (tableWidth <= budget) {
-    const emitRaw = (raw) => pad + closeRow(truncateToCells(raw, budget));
-    const border = (left, mid, right) => emitRaw(left + widths.map((w) => '─'.repeat(w + 2)).join(mid) + right);
-    const dataRow = (styledCells, align) => {
-      const cells = widths.map((w, i) => ` ${_cellPad(styledCells[i] || '', w, align)} `);
-      return emitRaw(`│${cells.join('│')}│`);
-    };
-    const rows = [border('┌', '┬', '┐'), dataRow(headerStyled, 'center')];
-    for (const row of bodyStyledRows) {
-      rows.push(border('├', '┼', '┤'));
-      rows.push(dataRow(row, 'left'));
-    }
-    rows.push(border('└', '┴', '┘'));
-    return rows;
-  }
-
-  // --- wrap path: the table does not fit, so wrap each cell inside its column ---
-  const available = budget - (3 * colCount + 1);
-  const metrics = collectColumnMetrics(headerPlain, bodyPlainRows, colCount, stringCellWidth);
-  let wrapWidths = computeColumnWidths(metrics, available);
-  // Null means even MIN_COLUMN_WIDTH (3) per column cannot fit: fall back to an even split (at
-  // least one cell wide each) rather than dropping columns or truncating.
-  if (!wrapWidths) wrapWidths = new Array(colCount).fill(Math.max(1, Math.floor(available / colCount)));
-  const emitWrappedRaw = (raw) => pad + closeRow(raw);
-  const wrapBorder = (left, mid, right) => emitWrappedRaw(left + wrapWidths.map((w) => '─'.repeat(w + 2)).join(mid) + right);
-  const wrappedRows = (styledCells, align) => {
-    const lines = wrapWidths.map((w, i) => wrapToCells(styledCells[i] || '', w));
-    const height = lines.reduce((max, l) => Math.max(max, l.length), 1);
-    const out = [];
-    for (let k = 0; k < height; k++) {
-      const cells = wrapWidths.map((w, i) => ` ${_cellPad(lines[i][k] || '', w, align)}${SPAN_OFF} `);
-      out.push(emitWrappedRaw(`│${cells.join('│')}│`));
-    }
-    return out;
-  };
-  const rows = [wrapBorder('┌', '┬', '┐'), ...wrappedRows(headerStyled, 'center')];
-  for (const row of bodyStyledRows) {
-    rows.push(wrapBorder('├', '┼', '┤'));
-    rows.push(...wrappedRows(row, 'left'));
-  }
-  rows.push(wrapBorder('└', '┴', '┘'));
-  return rows;
+  return lines.map((line) => pad + closeRow(line));
 }
 
 function emitBlockquote(token, cols, depth, style) {

package/template/coding-task-manager/lib/claude-session-title.js

@@ -6,8 +6,12 @@
 // (this worktree), and is asserted by AC-0d (no `claude-agent-sdk` path ever appears in
 // require.cache after a require() or a call through the `sdk` DI seam).
 //
-// Both exported functions resolve; they never throw — callers get a uniform
+// setClaudeSessionTitle resolves; it never throws — callers get a uniform
 // { state: 'mirrored'|'unsupported'|'failed', reason, error } outcome instead.
+//
+// WP-2 (D-6): the inbound half (readClaudeSessionTitle, an SDK getSessionInfo round-trip whose
+// merged fields conflate CTM tiers) is deleted. The agent's own name now comes from the
+// transcript records CTM already parses — lib/agent-title-apply.js.
 
 const { normalizeSessionTitle } = require('./session-title-signals');
 
@@ -66,32 +70,4 @@ async function setClaudeSessionTitle({ sessionId, title, dir, sdk } = {}) {
   }
 }
 
-async function readClaudeSessionTitle({ sessionId, dir, sdk } = {}) {
-  let resolvedSdk = sdk;
-  if (!resolvedSdk) {
-    try {
-      resolvedSdk = await _loadSdk();
-    } catch (error) {
-      // expected: SDK absent — read has nothing to report, caller treats null as "no data"
-      void error;
-      return null;
-    }
-  }
-  let info;
-  try {
-    info = await resolvedSdk.getSessionInfo(sessionId, dir ? { dir } : undefined);
-  } catch (error) {
-    // expected: read is best-effort — any SDK failure maps to "no data" rather than a throw
-    void error;
-    return null;
-  }
-  if (!info) return null;
-  const aiTitle = (!info.customTitle && info.summary && info.summary !== info.firstPrompt) ? info.summary : '';
-  return {
-    userName: info.customTitle || '',
-    aiTitle,
-    firstPrompt: info.firstPrompt || '',
-  };
-}
-
-module.exports = { setClaudeSessionTitle, readClaudeSessionTitle, _resetSdkCacheForTests };
+module.exports = { setClaudeSessionTitle, _resetSdkCacheForTests };

package/template/coding-task-manager/lib/claude-table-layout.js

@@ -0,0 +1,322 @@
+'use strict';
+
+// Port of Claude Code 2.1.310's Markdown-table layout, read from the installed CLI
+// (the versioned CLI binary under the user's local Claude install, Mach-O arm64; the layout sits at byte
+// offset ~= 243,694,000, the `kind:"vertical"` literal: functions jr / Q / Z / Y / _t / ce,
+// constants Ke=4 _e=3 as=4 Or=200). Design: docs/reader-claude-table-layout-parity-2026-10-25.html
+// §3.1 (the algorithm) and §5 (rules R-1..R-8).
+//
+// WHY THIS EXISTS: the reader re-draws a Claude transcript into rows and then proves the seam
+// against what the live terminal painted. A table the transcript renderer draws differently from
+// the TUI is content the screen never had, and the proof refuses (dup rows / an overlap). So this
+// module reproduces Claude's own layout EXACTLY -- same branch choice, same column widths, same
+// line breaks, same glyphs, same fallback to the stacked key-value "cards", quirks included
+// (R-6: floor rounding in the proportional branch, `max(floor(E*C/W), 3)` in the hard branch,
+// the `> 4` wrapped-line rule, `floor` vertical centring, the 200-row cap). No "improvement" here
+// is a fix; every deviation is a bug (R-1).
+//
+// TWO FORMS: `bordered` (the box, lines carry NO indent and never exceed cols - 4) and `cards`
+// (the vertical key-value form, re-wrapped a second time by Ink's box: see inkWrapLines). The
+// caller (lib/claude-markdown-ansi.js emitTable) prefixes the 2-column message indent and closes
+// each row; `cols` is the TERMINAL width and the indent is never subtracted from it (R-5).
+//
+// VERIFIED against three live captures (golden fixtures under
+// tests/golden/claude-transcript/table-captures/, reproduced byte-for-byte by
+// tests/claude-table-captures.test.js):
+//   lid-options-196  -- session 6ea59930 painted rows 4192-4197, cols 196, hard branch -> cards
+//   tasks-steps-171  -- session 3320adc3 painted rows 493-517, cols 171, proportional -> cards
+//                       (the 170-cell card line re-wrapped at 169 by Ink's box)
+//   inject-ways-196  -- session 7cf57222 painted rows 8396-8408, cols 196, proportional -> bordered
+// There is no runtime switch on the Claude version (R-8): drift is caught by those fixtures.
+
+const { stringCellWidth } = require('./terminal-cell-width');
+
+// wrap-ansi is ESM-only; Node's require(esm) (>= 22.12, the pinned 25.2.1 here) hands back the
+// namespace, so `.default` is the function. Loaded ONCE at module top (D-4).
+const wrapAnsiModule = require('wrap-ansi');
+const wrapAnsi = wrapAnsiModule.default || wrapAnsiModule;
+
+// Claude's own constants, by their de-minified names (Ke / _e / as / Or) plus the rule cap and
+// the version/offset the port was read from (R-8).
+const CLAUDE_TABLE = Object.freeze({
+  MARGIN: 4, // Ke: a bordered table must fit inside cols - 4
+  MIN_COL: 3, // _e: never allocate less than 3 columns to a cell
+  MAX_CELL_LINES: 4, // as: a cell wrapping to MORE lines than this sends the table to cards
+  MAX_ROWS: 200, // Or: rows beyond this are dropped and announced
+  RULE_MAX: 40, // the card separator is '─'.repeat(min(cols - 1, 40))
+  VERSION: '2.1.310',
+});
+
+const SGR_RE = /\x1b\[[0-9;?]*[ -\/]*[@-~]/g;
+
+function stripSgr(text) {
+  return String(text == null ? '' : text).replace(SGR_RE, '');
+}
+
+/**
+ * Claude's `ce(text, width, {hard})`: wrap-ansi with `trimEnd()` first, `{hard, trim:false,
+ * wordWrap:true}`, empty lines dropped, `['']` when nothing is left. `width <= 0` returns the
+ * text untouched (Claude's own early return).
+ */
+function wrapCell(text, width, hard) {
+  const source = String(text == null ? '' : text);
+  if (width <= 0) return [source];
+  const lines = wrapAnsi(source.trimEnd(), width, { hard: !!hard, trim: false, wordWrap: true })
+    .split('\n')
+    .filter((line) => line.length > 0);
+  return lines.length > 0 ? carryExtendedColour(lines) : [''];
+}
+
+// wrap-ansi closes bold / italic / strike and the 16 basic colours at its own line break and re-opens
+// them on the next line, but it has no closer for an EXTENDED colour selector (`38;5;n`, `38;2;r;g;b`):
+// a coloured span that wraps inside a cell stays open past the cell's `│` and paints the border and
+// the neighbouring cell. The live screen never does that -- painted-rows census 2026-10-26: 556 of
+// 556 bordered rows carrying a 256-colour span close it before every border (Ink styles each text
+// node on its own) -- so carry the colour across the break exactly the way wrap-ansi carries the
+// other attributes: close it (`39`) at the end of the line, re-open it at the start of the next.
+function carryExtendedColour(lines) {
+  let open = null;
+  return lines.map((line) => {
+    const prefix = open || '';
+    for (const m of line.matchAll(/\x1b\[([0-9;]*)m/g)) {
+      const codes = m[1] === '' ? [0] : m[1].split(';').map(Number);
+      for (let i = 0; i < codes.length; i += 1) {
+        const code = codes[i];
+        if (code === 38 && codes[i + 1] === 5) { open = `\x1b[38;5;${codes[i + 2]}m`; i += 2; }
+        else if (code === 38 && codes[i + 1] === 2) { open = `\x1b[38;2;${codes.slice(i + 2, i + 5).join(';')}m`; i += 4; }
+        else if (code === 0 || code === 39 || (code >= 30 && code <= 37) || (code >= 90 && code <= 97)) open = null;
+      }
+    }
+    return prefix + line + (open ? '\x1b[39m' : '');
+  });
+}
+
+// Claude's `bgr(text, width, align)` -- pad by VISIBLE width. `center` puts the odd space on the
+// right (floor on the left), `right` pads all on the left, `left` all on the right.
+function pad(text, width, align, strWidth) {
+  const total = Math.max(0, width - strWidth(stripSgr(text)));
+  if (align === 'center') {
+    const left = Math.floor(total / 2);
+    return ' '.repeat(left) + text + ' '.repeat(total - left);
+  }
+  if (align === 'right') return ' '.repeat(total) + text;
+  return text + ' '.repeat(total);
+}
+
+/**
+ * Lay a table out exactly as Claude Code 2.1.310 does.
+ *
+ *   header: ANSI-rendered header cells (emitInline output)   rows: ANSI-rendered body cells
+ *   align:  ('left'|'center'|'right'|null)[]                 cols: terminal columns (p)
+ *
+ * Returns the layout DECISION, never the indented rows:
+ *   { kind:'bordered', widths, hard, branch:'natural'|'proportional'|'hard', lines }
+ *     -- lines carry no indent; the widest is <= cols - 4
+ *   { kind:'cards', branch, reason:'cellLines'|'tooWide'|'headerOnly', headers, rows, truncated }
+ *     -- the vertical form's inputs, before Ink's box wrap (see cardLines/inkWrapLines)
+ */
+function layoutClaudeTable({ header, rows, align } = {}, cols, { strWidth = stringCellWidth } = {}) {
+  const p = Number(cols) || 0;
+  const headerCells = (header || []).map((cell) => String(cell == null ? '' : cell));
+  const everyRow = (rows || []).map((row) => (row || []).map((cell) => String(cell == null ? '' : cell)));
+  const truncated = Math.max(0, everyRow.length - CLAUDE_TABLE.MAX_ROWS);
+  const bodyRows = truncated > 0 ? everyRow.slice(0, CLAUDE_TABLE.MAX_ROWS) : everyRow;
+
+  const K = headerCells.length;
+  if (K === 0) return { kind: 'bordered', widths: [], hard: false, branch: 'natural', lines: [] };
+
+  // R-3: widths come from the SGR-stripped RENDERED cell (a link counts as `label (href)`).
+  // E[c] = the widest whitespace-separated word, H[c] = the widest whole cell, both floored at 3.
+  const wordWidth = (cell) => {
+    const words = stripSgr(cell).split(/\s+/).filter((word) => word.length > 0);
+    if (words.length === 0) return CLAUDE_TABLE.MIN_COL;
+    let widest = CLAUDE_TABLE.MIN_COL;
+    for (const word of words) widest = Math.max(widest, strWidth(word));
+    return widest;
+  };
+  const cellWidth = (cell) => Math.max(strWidth(stripSgr(cell)), CLAUDE_TABLE.MIN_COL);
+
+  const E = headerCells.map((cell, i) => {
+    let width = wordWidth(cell);
+    for (const row of bodyRows) width = Math.max(width, wordWidth(row[i] || ''));
+    return width;
+  });
+  const H = headerCells.map((cell, i) => {
+    let width = cellWidth(cell);
+    for (const row of bodyRows) width = Math.max(width, cellWidth(row[i] || ''));
+    return width;
+  });
+
+  const M = 1 + 3 * K;
+  const C = Math.max(p - M - CLAUDE_TABLE.MARGIN, K * CLAUDE_TABLE.MIN_COL);
+  const W = E.reduce((sum, w) => sum + w, 0);
+  const z = H.reduce((sum, w) => sum + w, 0);
+
+  let hard = false;
+  let branch;
+  let D;
+  if (z <= C) {
+    D = H;
+    branch = 'natural';
+  } else if (W <= C) {
+    // Proportional: hand out the slack in proportion to each column's (natural - minimum) want,
+    // floored (R-6: Claude floors, it does not round).
+    branch = 'proportional';
+    const slack = C - W;
+    const want = H.map((w, i) => w - E[i]);
+    const U = want.reduce((sum, w) => sum + w, 0);
+    D = E.map((w, i) => (U === 0 ? w : w + Math.floor((want[i] / U) * slack)));
+  } else {
+    // Hard: scale every minimum by C/W, never below 3.
+    branch = 'hard';
+    hard = true;
+    const ratio = C / W;
+    D = E.map((w) => Math.max(Math.floor(w * ratio), CLAUDE_TABLE.MIN_COL));
+  }
+
+  // > 4 wrapped lines anywhere -> the whole table becomes cards.
+  let maxLines = 1;
+  for (let i = 0; i < K; i += 1) maxLines = Math.max(maxLines, wrapCell(headerCells[i], D[i], hard).length);
+  for (const row of bodyRows) {
+    for (let i = 0; i < row.length; i += 1) maxLines = Math.max(maxLines, wrapCell(row[i] || '', D[i], hard).length);
+  }
+
+  // The vertical form's inputs: a header-only table has no labels and its one row is the header
+  // (so it draws as unlabeled lines). `headerOnly` names that shape; the bordered attempt still
+  // runs first, exactly as Claude's does (a header-only table that fits stays a box).
+  const cards = (cause) => ({
+    kind: 'cards',
+    branch,
+    reason: bodyRows.length === 0 ? 'headerOnly' : cause,
+    headers: bodyRows.length === 0 ? [] : headerCells.map((cell) => stripSgr(cell).trim()),
+    rows: (bodyRows.length === 0 ? [headerCells] : bodyRows).map((row) => row.slice()),
+    truncated,
+  });
+  if (maxLines > CLAUDE_TABLE.MAX_CELL_LINES) return cards('cellLines');
+
+  const border = (kind) => {
+    const [left, bar, join, right] = {
+      top: ['┌', '─', '┬', '┐'],
+      middle: ['├', '─', '┼', '┤'],
+      bottom: ['└', '─', '┴', '┘'],
+    }[kind];
+    let line = left;
+    D.forEach((width, i) => {
+      line += bar.repeat(width + 2);
+      line += i < D.length - 1 ? join : right;
+    });
+    return line;
+  };
+
+  // One table row -> its bordered lines. Cells are vertically centred with floor((G - n)/2).
+  // Header cells are centred; body cells follow `align[c] ?? 'left'` (both Claude's rules).
+  const drawRow = (cells, isHeader) => {
+    const lines = cells.map((cell, i) => wrapCell(cell || '', D[i], hard));
+    const height = Math.max(...lines.map((l) => l.length), 1);
+    const off = lines.map((l) => Math.floor((height - l.length) / 2));
+    const out = [];
+    for (let r = 0; r < height; r += 1) {
+      let row = '│';
+      for (let c = 0; c < cells.length; c += 1) {
+        const idx = r - off[c];
+        const text = idx >= 0 && idx < lines[c].length ? lines[c][idx] : '';
+        row += ` ${pad(text, D[c], isHeader ? 'center' : ((align && align[c]) || 'left'), strWidth)} │`;
+      }
+      out.push(row);
+    }
+    return out;
+  };
+
+  const lines = [border('top'), ...drawRow(headerCells, true), border('middle')];
+  bodyRows.forEach((row, i) => {
+    lines.push(...drawRow(row, false));
+    if (i < bodyRows.length - 1) lines.push(border('middle'));
+  });
+  lines.push(border('bottom'));
+
+  let widest = 0;
+  for (const line of lines) widest = Math.max(widest, strWidth(stripSgr(line)));
+  if (widest > p - CLAUDE_TABLE.MARGIN) return cards('tooWide');
+
+  if (truncated > 0) lines.push(notShown(truncated));
+  return { kind: 'bordered', widths: D, hard, branch, lines };
+}
+
+// Claude's `lt(n)`: the 200-row cap's footnote.
+function notShown(count) {
+  return `… ${count.toLocaleString()} more ${count === 1 ? 'row' : 'rows'} not shown`;
+}
+
+/**
+ * The vertical form, before Ink's box wrap: one `Bold Header: value` line per non-empty cell,
+ * continuation lines verbatim, a `─`.repeat(min(cols - 1, 40)) rule BETWEEN cards only (never
+ * before the first, never after the last). `style.bold`/`style.boldOff` label the key (Claude
+ * paints `\x1b[1m`…`\x1b[22m`).
+ */
+function cardLines(layout, cols, style) {
+  const m = Number(cols) || 0;
+  const out = [];
+  const rule = '─'.repeat(Math.max(0, Math.min(m - 1, CLAUDE_TABLE.RULE_MAX)));
+  const headers = (layout && layout.headers) || [];
+  for (const row of (layout && layout.rows) || []) {
+    const lines = [];
+    row.forEach((cell, i) => {
+      const label = headers[i] || '';
+      // Claude flattens the cell to one line for the FIRST line, then re-wraps the rest.
+      const flat = String(cell == null ? '' : cell)
+        .trimEnd()
+        .replace(/\n+/g, ' ')
+        .replace(/\s+/g, ' ')
+        .trim();
+      if (!label && !flat) return; // an unlabeled empty cell prints nothing at all
+      const firstWidth = label ? m - stringCellWidth(label) - 3 : m - 1;
+      const contWidth = m - 3;
+      const wrapped = wrapCell(flat, Math.max(firstWidth, 10), false);
+      const head = wrapped[0] || '';
+      const rest = wrapped.length <= 1
+        ? wrapped
+        : [head, ...wrapCell(wrapped.slice(1).map((line) => line.trim()).join(' '), contWidth, false)];
+      lines.push(label
+        ? `${styleSpanText(`${label}:`, style)} ${rest[0] || ''}`
+        : (rest[0] || ''));
+      for (let d = 1; d < rest.length; d += 1) {
+        if (!rest[d].trim()) continue;
+        lines.push(rest[d]);
+      }
+    });
+    if (!lines.length) continue;
+    if (out.length) out.push(rule);
+    out.push(...lines);
+  }
+  if (layout && layout.truncated > 0) {
+    if (out.length) out.push(rule);
+    out.push(notShown(layout.truncated));
+  }
+  return out;
+}
+
+// The card label's own span: open with `style.bold`, close with `style.boldOff` (never a blanket
+// reset, so a caller's surrounding style survives). Kept local so this module stays pure.
+function styleSpanText(text, style) {
+  const open = (style && style.bold) || [];
+  const close = (style && style.boldOff) || [];
+  const openCodes = (Array.isArray(open) ? open : [open]).filter((c) => c !== undefined && c !== null && c !== '');
+  if (!openCodes.length) return text;
+  const closeCodes = (Array.isArray(close) ? close : [close]).filter((c) => c !== undefined && c !== null && c !== '');
+  return `\x1b[${openCodes.join(';')}m${text}${closeCodes.length ? `\x1b[${closeCodes.join(';')}m` : ''}`;
+}
+
+/**
+ * Ink's `<Text wrap="wrap">` inside the 2-column message box: every line is re-wrapped with
+ * `wrapAnsi(line, boxWidth, {trim:false, hard:true})` and split on '\n' (D-5 -- observed: the
+ * tasks capture's 170-cell card line breaks at 169 into `…rubric` / `and` / `0.60 threshold`).
+ */
+function inkWrapLines(lines, boxWidth) {
+  const out = [];
+  for (const line of lines || []) {
+    out.push(...wrapAnsi(String(line == null ? '' : line), boxWidth, { trim: false, hard: true }).split('\n'));
+  }
+  return out;
+}
+
+module.exports = { CLAUDE_TABLE, wrapCell, layoutClaudeTable, cardLines, inkWrapLines };

package/template/coding-task-manager/lib/client-diag-handler.js

@@ -137,6 +137,11 @@ function createClientDiagHandler(deps = {}) {
         toCols: nonNegInt(d.toCols),
         widthPx: nonNegInt(d.widthPx),
         reason: typeof d.reason === 'string' ? d.reason.slice(0, 40) : '',
+        // WP-2 (docs/codex-terminal-geometry-sticky-cols-2026-10-24.html §5): the two
+        // layout facts that make an adoption explainable -- browser viewport width and whether
+        // split view was on. Whitelisted here or the beacon's producer fields would be dropped.
+        viewportWidthPx: nonNegInt(d.viewportWidthPx),
+        split: d.split === true,
       });
       return;
     }

package/template/coding-task-manager/lib/codex-config-guard.js

@@ -105,20 +105,50 @@ function buildCodexTransportOverrideArgs(names, opts = {}) {
   return out;
 }
 
-// Read CODEX_HOME/config.toml and return the override args (best-effort: unreadable/missing → []).
-function codexMcpTransportGuardArgs(codexHome, opts = {}) {
+// Read CODEX_HOME/config.toml (best-effort: unreadable/missing → null). The one sync read both
+// guards share; it is the ledgered main-thread site (docs/main-thread-sync-baseline.json).
+function readCodexConfigToml(codexHome) {
   let text;
   try {
     text = fs.readFileSync(path.join(codexHome || '', 'config.toml'), 'utf8');
   } catch {
-    return [];
+    return null;
   }
+  return text;
+}
+
+// Return the override args (unreadable/missing config → []).
+function codexMcpTransportGuardArgs(codexHome, opts = {}) {
+  const text = readCodexConfigToml(codexHome);
+  if (text === null) return [];
   return buildCodexTransportOverrideArgs(findTransportlessMcpServers(text), opts);
 }
 
+// WP-1 (codex-routed-fork-cold-restore-guard-2026-10-22.html §5 D-2, §9 S-5): the ids a native
+// `codex` config load resolves through `model_providers.get(id)` — Codex merges its built-in
+// providers with this user table. Only the TABLE HEADERS are needed (the values are irrelevant to
+// servability), so this is a line scan, not a TOML parse: `[model_providers.<id>]` and its
+// sub-tables (`[model_providers.<id>.http_headers]`) both name the provider `<id>`; text before a
+// `[model_providers]` header (or after a different table) is never attributed to it. Best-effort
+// exactly like the transport guard: a missing/unreadable config is an empty set, never a throw.
+// `codexHome` is the CODEX_HOME directory (the one that holds config.toml).
+function readModelProviderKeys(codexHome) {
+  const text = readCodexConfigToml(codexHome);
+  if (text === null) return [];
+  const out = [];
+  for (const line of String(text || '').split(/\r?\n/)) {
+    const segs = _tableHeaderSegments(line);
+    if (!segs || segs.length < 2 || _unquote(segs[0]) !== 'model_providers') continue;
+    const key = _unquote(segs[1]);
+    if (key) out.push(key);
+  }
+  return [...new Set(out)];
+}
+
 module.exports = {
   INERT_COMMAND,
   findTransportlessMcpServers,
   buildCodexTransportOverrideArgs,
   codexMcpTransportGuardArgs,
+  readModelProviderKeys,
 };

package/template/coding-task-manager/lib/codex-harness-qualification.js

@@ -43,6 +43,17 @@ const CODEX_CONTROL_ADAPTER = 'codex-app-server-q1';
 const CODEX_COMPACTION_SCHEMA_RECEIPT = 'codex-model-info-comp-hash-nullable-q1';
 const CODEX_PRE_TURN_COMPACTION_SCHEMA = 'codex-pre-turn-compaction-q1';
 
+// Codex's turn_context `cyber_access_program` (protocol/src/turn_input.rs @ rust-v0.163.0) is
+// `standard` when the account's catalog advertises access programs and Daybreak is off
+// (tui/src/daybreak.rs program_for_turn), and core drops any program for a non-OpenAI provider
+// (core/src/cyber_access_program.rs for_provider). Only these values carry no elevated access, so
+// only they may cross to a routed target; daybreak_* and unknown values stay unqualified.
+const NON_ELEVATED_CYBER_ACCESS_PROGRAMS = Object.freeze([null, 'standard']);
+
+function isNonElevatedCyberAccessProgram(value) {
+  return NON_ELEVATED_CYBER_ACCESS_PROGRAMS.includes(value);
+}
+
 // Exact membership (D-4). Never a prefix/range match: '0.162.10' is not '0.162.1'.
 function isQualifiedCodexVersion(version) {
   return typeof version === 'string' && Object.hasOwn(CODEX_QUALIFIED_VERSIONS, version);
@@ -67,5 +78,6 @@ module.exports = {
   CODEX_COMPACTION_SCHEMA_RECEIPT,
   CODEX_PRE_TURN_COMPACTION_SCHEMA,
   isQualifiedCodexVersion,
+  isNonElevatedCyberAccessProgram,
   codexQualification,
 };