create-walle 0.10.0 → 0.10.1

package/template/coding-task-manager/lib/codex-history-terminal-renderer.js

@@ -31,6 +31,8 @@
 //   blob"; we still guard internally so one bad row can't sink the whole render.
 
 const { takeMarkdownTable, isTableRowLine } = require('./codex-markdown-table');
+const { createListTracker } = require('./codex-markdown-lists');
+const { isLocalPathLikeLink, renderLocalLinkTarget } = require('./codex-local-links');
 
 const STYLE_TABLE_VERSION = 2;
 
@@ -340,14 +342,15 @@ function renderTextBlock(text, cols, style) {
   });
 }
 
-function stripMarkdownInline(text) {
+// `ctx` is the render opts: `ctx.cwd` is the rollout session cwd the local-link rule shortens under.
+function stripMarkdownInline(text, ctx) {
   let s = String(text == null ? '' : text);
-  // Terminal projection: keep the information, remove Markdown control syntax.
-  s = s.replace(/!\[([^\]]*)\]\(([^)\s]+)(?:\s+"[^"]*")?\)/g, (_m, alt, url) => {
-    const label = String(alt || 'image').trim() || 'image';
-    return `${label} (${url})`;
-  });
-  s = s.replace(/\[([^\]]+)\]\(([^)\s]+)(?:\s+"[^"]*")?\)/g, (_m, label, url) => `${label} (${url})`);
+  // Terminal projection: keep the information, remove Markdown control syntax. A local path-like
+  // destination draws Codex's display target (`local_links.rs`): `label (target)`, or `target` alone
+  // when the label is blank; every other destination keeps its URL.
+  const dest = (url) => (isLocalPathLikeLink(url) ? (renderLocalLinkTarget(url, ctx && ctx.cwd) || url) : url);
+  s = s.replace(/!\[([^\]]*)\]\(([^)\s]+)(?:\s+"[^"]*")?\)/g, (_m, alt, url) => `${String(alt || 'image').trim() || 'image'} (${dest(url)})`);
+  s = s.replace(/\[([^\]]*)\]\(([^)\s]+)(?:\s+"[^"]*")?\)/g, (_m, label, url) => (String(label).trim() ? `${label} (${dest(url)})` : dest(url)));
   s = s.replace(/<((?:https?:|file:)[^>\s]+)>/g, '$1');
   s = s.replace(/`([^`\n]+)`/g, '$1');
   s = s.replace(/\*\*\*([^*\n][\s\S]*?[^*\n])\*\*\*/g, '$1');
@@ -366,13 +369,13 @@ function isMarkdownTableSeparator(line) {
   return /^\|?\s*:?-{3,}:?\s*(\|\s*:?-{3,}:?\s*)+\|?$/.test(s);
 }
 
-function formatMarkdownTableRow(line) {
+function formatMarkdownTableRow(line, ctx) {
   const raw = String(line || '').trim();
   const inner = raw.replace(/^\|/, '').replace(/\|$/, '');
-  return inner.split('|').map((cell) => stripMarkdownInline(cell.trim())).join('  |  ');
+  return inner.split('|').map((cell) => stripMarkdownInline(cell.trim(), ctx)).join('  |  ');
 }
 
-function renderMarkdownTextBlock(text, cols, style) {
+function renderMarkdownTextBlock(text, cols, style, ctx) {
   const prefix = style.prefix || '';
   const prefixW = strWidth(prefix);
   const baseBodySgr = style.bodySgr || [];
@@ -397,8 +400,12 @@ function renderMarkdownTextBlock(text, cols, style) {
   };
 
   const rawLines = String(text == null ? '' : text).replace(/\t/g, '    ').split('\n');
+  const lists = createListTracker();
   for (let lineIndex = 0; lineIndex < rawLines.length; lineIndex += 1) {
     const line = rawLines[lineIndex].replace(/\r$/, '');
+    // Fed for EVERY line (a blank line does not close the container stack, and a non-list line can
+    // be a continuation paragraph of the innermost item); fenced content is verbatim, never a list.
+    const item = inFence ? null : lists.consume(line);
     const fence = line.match(/^\s*(```+|~~~+)/);
     if (fence) {
       inFence = !inFence;
@@ -408,47 +415,39 @@ function renderMarkdownTextBlock(text, cols, style) {
       emitWrapped(line, [SGR.fgGray], { indent: 2, hang: 2 });
       continue;
     }
+    if (item && item.marker) {
+      // R-1: the marker already carries its own column, so indent 0 and the absolute hang; the
+      // message prefix (`• ` on the first row, `  ` after) is still applied by emitWrapped.
+      emitWrapped(item.marker + stripMarkdownInline(item.text, ctx), baseBodySgr, { indent: item.indent, hang: item.hang });
+      continue;
+    }
     if (!line.trim()) {
       out.push('');
       continue;
     }
     const heading = line.match(/^\s{0,3}#{1,6}\s+(.+?)\s*#*\s*$/);
     if (heading) {
-      emitWrapped(stripMarkdownInline(heading[1]), [SGR.bold]);
+      emitWrapped(stripMarkdownInline(heading[1], ctx), [SGR.bold]);
       continue;
     }
     const quote = line.match(/^\s{0,3}>\s?(.*)$/);
     if (quote) {
-      emitWrapped('| ' + stripMarkdownInline(quote[1]), [SGR.dim], { hang: 2 });
+      emitWrapped('| ' + stripMarkdownInline(quote[1], ctx), [SGR.dim], { hang: 2 });
       continue;
     }
-    const tbl = takeMarkdownTable(rawLines, lineIndex, { width: cols - prefixW, indent: prefixW, lead: prefixPending ? stylize(prefix, style.prefixSgr) : null, strWidth, stylize, isSeparator: isMarkdownTableSeparator, strip: stripMarkdownInline, codes: { bold: [SGR.bold], dim: [SGR.dim], body: baseBodySgr } });
+    const tbl = takeMarkdownTable(rawLines, lineIndex, { width: cols - prefixW, indent: prefixW, lead: prefixPending ? stylize(prefix, style.prefixSgr) : null, strWidth, stylize, isSeparator: isMarkdownTableSeparator, strip: (cell) => stripMarkdownInline(cell, ctx), codes: { bold: [SGR.bold], dim: [SGR.dim], body: baseBodySgr } });
     if (tbl) { lineIndex = tbl.nextIndex - 1; out.push(...tbl.rows); prefixPending = false; continue; }
     if (isMarkdownTableSeparator(line)) continue;
     const tableRow = isTableRowLine(line);
     if (tableRow) {
-      emitWrapped(formatMarkdownTableRow(line), baseBodySgr, { hang: 4 });
-      continue;
-    }
-    const unordered = line.match(/^(\s*)([-*+])\s+(.+)$/);
-    if (unordered) {
-      const indent = Math.min(8, Math.floor(unordered[1].length / 2) * 2);
-      const marker = '- ';
-      emitWrapped(marker + stripMarkdownInline(unordered[3]), baseBodySgr, { indent, hang: indent + strWidth(marker) });
-      continue;
-    }
-    const ordered = line.match(/^(\s*)(\d{1,4}[.)])\s+(.+)$/);
-    if (ordered) {
-      const indent = Math.min(8, Math.floor(ordered[1].length / 2) * 2);
-      const marker = ordered[2] + ' ';
-      emitWrapped(marker + stripMarkdownInline(ordered[3]), baseBodySgr, { indent, hang: indent + strWidth(marker) });
+      emitWrapped(formatMarkdownTableRow(line, ctx), baseBodySgr, { hang: 4 });
       continue;
     }
     if (/^\s{0,3}([-*_])(?:\s*\1){2,}\s*$/.test(line)) {
       emitWrapped('─'.repeat(Math.max(8, Math.min(40, cols - prefixW))), [SGR.dim]);
       continue;
     }
-    emitWrapped(stripMarkdownInline(line), baseBodySgr);
+    emitWrapped(stripMarkdownInline(item ? item.text : line, ctx), baseBodySgr, item ? { indent: item.indent, hang: item.hang } : {}); // a list item's continuation paragraph hangs at its level
   }
 
   return out;
@@ -524,8 +523,9 @@ function jsonToolResultPreview(text, cols, style) {
   ].join('\n');
 }
 
-// Returns { lines: string[], known: boolean } for one message.
-function renderMessage(msg, cols, table, { fullHistory = false } = {}) {
+// Returns { lines: string[], known: boolean } for one message. `ctx` is the render opts (its cwd
+// drives the local-link display target).
+function renderMessage(msg, cols, table, { fullHistory = false, ctx } = {}) {
   const meta = messageMeta(msg);
   const kind = meta && meta.kind ? meta.kind : null;
   const role = msg && msg.role;
@@ -533,7 +533,7 @@ function renderMessage(msg, cols, table, { fullHistory = false } = {}) {
   // Plain assistant / user text (no structured kind).
   if (!kind) {
     if (role === 'user') return { lines: renderTextBlock(String(msg.text || ''), cols, table.user), known: true };
-    if (role === 'assistant') return { lines: renderMarkdownTextBlock(String(msg.text || ''), cols, table.assistant), known: true };
+    if (role === 'assistant') return { lines: renderMarkdownTextBlock(String(msg.text || ''), cols, table.assistant, ctx), known: true };
     return { lines: [], known: false };
   }
 
@@ -715,7 +715,7 @@ function renderOneMessage(msg, cols, table, fullHistory, ctx) {
     const meta = messageMeta(msg);
     kind = (meta && meta.kind) || (msg.role === 'user' ? 'user' : msg.role === 'assistant' ? 'assistant' : 'text');
     rendered = (table.owned === true && owned.renderOwnedMessage(msg, cols, table, ctx))
-      || renderMessage(msg, cols, table, { fullHistory: fullHistory === true });
+      || renderMessage(msg, cols, table, { fullHistory: fullHistory === true, ctx });
   } catch { rendered = { lines: [], known: false }; } // one bad row must never sink the whole history
   return { kind, rendered };
 }

package/template/coding-task-manager/lib/codex-local-links.js

@@ -0,0 +1,267 @@
+'use strict';
+
+// Port of codex-rs/tui/src/markdown_render/local_links.rs (plus the `#L..` fragment helper at
+// codex-rs/utils/string/src/lib.rs:73-104).
+//
+// Codex keeps a local link's label and ALSO shows its target, shortening an absolute destination
+// relative to the session working directory when that path lies strictly underneath it. A local
+// link therefore draws as `label (target)`, or as `target` alone when the label is blank. Rows CTM
+// paints must equal the rows the live Codex screen paints, so this is a display rule, not a
+// filesystem lookup: it never resolves files, symlinks or the frontend home, and it never collapses
+// `.` / `..`.
+//
+// Names follow the Rust 1:1 in camelCase. `renderLocalLinkTarget` returns null only for a `file://`
+// URL that does not parse into a local path; plain path-like input always yields a target.
+
+/** Path-like destinations: `file://`, absolute, `~/`, `./`, `../`, `\\`, or `X:/` / `X:\`. */
+function isLocalPathLikeLink(destUrl) {
+  const value = String(destUrl == null ? '' : destUrl);
+  return value.startsWith('file://') || value.startsWith('/') || value.startsWith('~/')
+    || value.startsWith('./') || value.startsWith('../') || value.startsWith('\\\\')
+    || /^[A-Za-z]:[\\/]/.test(value);
+}
+
+/** Trailing `:line`, `:line:col` or `:a-b` run (an en dash is accepted, as in Codex's regex). */
+const COLON_LOCATION_SUFFIX_RE = /:\d+(?::\d+)?(?:[-\u2013]\d+(?::\d+)?)?$/;
+/** `L12`, `L12C3`, `L12-L14`, `L12C3-L14C9` — a markdown `#L..` location fragment. */
+const HASH_LOCATION_SUFFIX_RE = /^L\d+(?:C\d+)?(?:-L\d+(?:C\d+)?)?$/;
+const HEX_PAIR_RE = /^[0-9A-Fa-f]{2}$/;
+
+/**
+ * A local link's display target, or null when a `file://` URL does not parse into a local path.
+ * The path is normalized and shortened relative to `cwd` when it lies strictly under it; the
+ * location suffix (`#L..` normalised to `:line[:col]`) is appended back.
+ */
+function renderLocalLinkTarget(destUrl, cwd) {
+  const parsed = parseLocalLinkTarget(destUrl);
+  if (!parsed) return null;
+  let rendered = displayLocalLinkPath(parsed[0], cwd);
+  if (parsed[1] != null) rendered += parsed[1];
+  return rendered;
+}
+
+/** Split a local-link destination into `[normalizedPathText, locationSuffixOrNull]`, or null. */
+function parseLocalLinkTarget(destUrl) {
+  const dest = String(destUrl == null ? '' : destUrl);
+  if (dest.startsWith('file://')) {
+    let url;
+    try { url = new URL(dest); } catch { return null; } // an unparseable file:// URL has no target
+    // `PathUri::parse(&url[..Position::AfterPath])`: the query and fragment are not part of the path.
+    const pathText = pathUriNativePath(`${url.protocol}//${url.host}${url.pathname}`);
+    if (pathText == null) return null;
+    const fragment = url.hash === '' ? null : url.hash.slice(1);
+    const locationSuffix = fragment == null ? null : normalizeHashLocationSuffixFragment(fragment);
+    return [normalizeLocalLinkPathText(pathText), locationSuffix];
+  }
+
+  let pathText = dest;
+  let locationSuffix = null;
+  // Prefer `#L..` when both forms are present so `path#L10` is not misread as a path ending in `:10`.
+  const hash = dest.lastIndexOf('#');
+  if (hash >= 0) {
+    const normalized = normalizeHashLocationSuffixFragment(dest.slice(hash + 1));
+    if (normalized != null) { pathText = dest.slice(0, hash); locationSuffix = normalized; }
+  }
+  if (locationSuffix == null) {
+    const suffix = extractColonLocationSuffix(pathText);
+    if (suffix != null) { pathText = pathText.slice(0, pathText.length - suffix.length); locationSuffix = suffix; }
+  }
+  return [normalizeLocalLinkPathText(urlDecode(pathText)), locationSuffix];
+}
+
+/** `#L12`-style fragment -> `:12[:3][-14[:9]]`, or null when the fragment is not a location. */
+function normalizeHashLocationSuffixFragment(fragment) {
+  const text = String(fragment == null ? '' : fragment);
+  return HASH_LOCATION_SUFFIX_RE.test(text) ? normalizeMarkdownHashLocationSuffix(`#${text}`) : null;
+}
+
+/** `codex_utils_string::normalize_markdown_hash_location_suffix` (`#L74C3-L76C9` -> `:74:3-76:9`). */
+function normalizeMarkdownHashLocationSuffix(suffix) {
+  const text = String(suffix == null ? '' : suffix);
+  if (!text.startsWith('#')) return null;
+  const fragment = text.slice(1);
+  const dash = fragment.indexOf('-');
+  const start = parseMarkdownHashLocationPoint(dash < 0 ? fragment : fragment.slice(0, dash));
+  if (!start) return null;
+  let normalized = `:${start.line}`;
+  if (start.column != null) normalized += `:${start.column}`;
+  if (dash >= 0) {
+    const end = parseMarkdownHashLocationPoint(fragment.slice(dash + 1));
+    if (!end) return null;
+    normalized += `-${end.line}`;
+    if (end.column != null) normalized += `:${end.column}`;
+  }
+  return normalized;
+}
+
+function parseMarkdownHashLocationPoint(point) {
+  const text = String(point == null ? '' : point);
+  if (!text.startsWith('L')) return null;
+  const rest = text.slice(1);
+  const column = rest.indexOf('C');
+  return column < 0 ? { line: rest, column: null } : { line: rest.slice(0, column), column: rest.slice(column + 1) };
+}
+
+/** A trailing `:line[:col][-line[:col]]` run at the very end of a plain path-like string. */
+function extractColonLocationSuffix(pathText) {
+  const matched = COLON_LOCATION_SUFFIX_RE.exec(String(pathText == null ? '' : pathText));
+  return matched ? matched[0] : null;
+}
+
+/**
+ * Local-path display normalisation: forward slashes everywhere, and UNC-style `\\server\share`
+ * rewritten to `//server/share` so the prefix checks below see one stable spelling.
+ */
+function normalizeLocalLinkPathText(pathText) {
+  const text = String(pathText == null ? '' : pathText);
+  if (text.startsWith('\\\\')) return `//${text.slice(2).replace(/\\/g, '/').replace(/^\/+/, '')}`;
+  return text.replace(/\\/g, '/');
+}
+
+function isAbsoluteLocalLinkPath(pathText) {
+  const text = String(pathText == null ? '' : pathText);
+  return text.startsWith('/') || text.startsWith('//') || /^[A-Za-z]:\//.test(text);
+}
+
+/** Trim trailing separators without destroying root semantics (`/`, `//`, `C:/` stay intact). */
+function trimTrailingLocalPathSeparator(pathText) {
+  const text = String(pathText == null ? '' : pathText);
+  if (text === '/' || text === '//' || /^[A-Za-z]:\/$/.test(text)) return text;
+  return text.replace(/\/+$/, '');
+}
+
+/** The part of `pathText` strictly under `cwdText`, without a leading slash; null when it is not. */
+function stripLocalPathPrefix(pathText, cwdText) {
+  const path = trimTrailingLocalPathSeparator(pathText);
+  const cwd = trimTrailingLocalPathSeparator(cwdText);
+  if (path === cwd) return null; // the path IS the cwd: keep it whole rather than render an empty target
+  if (cwd === '/' || cwd === '//') return path.startsWith('/') ? path.slice(1) : null;
+  if (!path.startsWith(cwd)) return null;
+  const rest = path.slice(cwd.length);
+  return rest.startsWith('/') ? rest.slice(1) : null;
+}
+
+/** Relative paths (including `~/...`) stay relative; absolute paths prefer the cwd-relative form. */
+function displayLocalLinkPath(pathText, cwd) {
+  const path = normalizeLocalLinkPathText(pathText);
+  if (!isAbsoluteLocalLinkPath(path)) return path;
+  if (typeof cwd === 'string') {
+    const stripped = stripLocalPathPrefix(path, normalizeLocalLinkPathText(cwd));
+    if (stripped != null) return stripped;
+  }
+  return path;
+}
+
+// --- PathUri (codex-rs/utils/path-uri): only what a `file://` link destination needs ---
+
+/** The native path a `file:` URI names, or null when it is not a usable local path URI. */
+function pathUriNativePath(uri) {
+  let url;
+  try { url = new URL(uri); } catch { return null; }
+  if (url.protocol !== 'file:') return null;
+  if (url.username !== '' || url.password !== '' || url.port !== '') return null;
+  // A decoded NUL cannot be a native path (Codex rejects it the same way).
+  if (decodeBinaryUtf8(url.pathname).includes('\u0000')) return null;
+  const host = url.hostname === 'localhost' ? '' : url.hostname; // a localhost authority is dropped
+  const pathname = host === '' ? withNormalizedWindowsDriveLetter(url.pathname) : url.pathname;
+  const segments = pathSegments(pathname);
+  const rendered = inferPathConvention(host, segments) === 'windows'
+    ? renderWindowsPath(host, segments) : renderPosixPath(host, segments);
+  return rendered == null ? `file://${host}${pathname}` : rendered; // fallback: the canonical URI text
+}
+
+function pathSegments(pathname) {
+  const path = String(pathname);
+  return path.startsWith('/') ? path.slice(1).split('/') : path.split('/');
+}
+
+/** Uppercase a leading `c:` drive segment so later comparison is stable across spellings. */
+function withNormalizedWindowsDriveLetter(pathname) {
+  const matched = /^(\/*)([^/]*)([\s\S]*)$/.exec(String(pathname));
+  if (!matched) return pathname;
+  const [, slashes, drive, rest] = matched;
+  if (!isWindowsDriveUriSegment(drive) || !/^[a-z]/.test(drive)) return pathname;
+  return `${slashes}${drive[0].toUpperCase()}${drive.slice(1)}${rest}`;
+}
+
+function isWindowsDriveUriSegment(segment) {
+  const text = String(segment == null ? '' : segment);
+  return /^[A-Za-z]:$/.test(text) || /^[A-Za-z]%3[Aa]$/.test(text);
+}
+
+/** An authority means Windows (UNC); otherwise a leading drive segment does, else POSIX. */
+function inferPathConvention(host, segments) {
+  if (host !== '') return 'windows';
+  const first = segments.find((segment) => segment !== '');
+  return first != null && isWindowsDriveUriSegment(first) ? 'windows' : 'posix';
+}
+
+function renderPosixPath(host, segments) {
+  if (host !== '') return null; // a UNC authority cannot be spelled as a POSIX path
+  return segments.map((segment) => `/${decodeNativeSegment(segment)}`).join('');
+}
+
+function renderWindowsPath(host, segments) {
+  let rendered;
+  let rest;
+  if (host !== '') {
+    // `file://server/share/file` -> `\\server\share\file`; the share name must be present.
+    if (!segments.length) return null;
+    const share = decodeNativeSegment(segments[0]);
+    if (share === '') return null;
+    rendered = `\\\\${host}\\${share}`;
+    rest = segments.slice(1);
+  } else {
+    // Without an authority Windows needs a drive root: `file:///C:/src` -> `C:\src`.
+    if (!segments.length) return null;
+    const drive = decodeNativeSegment(segments[0]);
+    if (!/^[A-Za-z]:$/.test(drive)) return null;
+    rendered = drive;
+    rest = segments.slice(1);
+  }
+  for (const segment of rest) rendered += `\\${decodeNativeSegment(segment)}`;
+  // `file:///C:` and `file:///C:/` both name the drive root, never the drive-relative `C:`.
+  return /^[A-Za-z]:$/.test(rendered) ? `${rendered}\\` : rendered;
+}
+
+/** `urlencoding::decode_binary` + lossy UTF-8: a URI path segment as native path text. */
+function decodeNativeSegment(segment) {
+  return decodeBinaryUtf8(segment);
+}
+
+/** `urlencoding::decode`: percent-decoding that fails (and keeps the input) on invalid UTF-8. */
+function urlDecode(text) {
+  const decoded = decodeBinaryUtf8(text, true);
+  return decoded == null ? String(text) : decoded;
+}
+
+function decodeBinaryUtf8(text, strict = false) {
+  const bytes = [];
+  const value = String(text == null ? '' : text);
+  for (let index = 0; index < value.length; index += 1) {
+    const pair = value[index] === '%' ? value.slice(index + 1, index + 3) : '';
+    if (HEX_PAIR_RE.test(pair)) { bytes.push(parseInt(pair, 16)); index += 2; continue; }
+    const codePoint = value.codePointAt(index);
+    const character = String.fromCodePoint(codePoint);
+    if (character.length === 2) index += 1; // a surrogate pair is one code point
+    for (const byte of Buffer.from(character, 'utf8')) bytes.push(byte);
+  }
+  const buffer = Buffer.from(bytes);
+  if (!strict) return buffer.toString('utf8');
+  try { return new TextDecoder('utf-8', { fatal: true }).decode(buffer); } catch { return null; }
+}
+
+module.exports = {
+  isLocalPathLikeLink,
+  renderLocalLinkTarget,
+  // Exported for the ported Codex test table (same functions, same behaviour).
+  _internal: {
+    parseLocalLinkTarget,
+    displayLocalLinkPath,
+    normalizeLocalLinkPathText,
+    trimTrailingLocalPathSeparator,
+    stripLocalPathPrefix,
+    extractColonLocationSuffix,
+    normalizeMarkdownHashLocationSuffix,
+  },
+};

package/template/coding-task-manager/lib/codex-markdown-lists.js

@@ -0,0 +1,160 @@
+'use strict';
+
+// Codex list markers, at parity with what the TUI paints, ported from
+//   codex-rs/tui/src/markdown_render.rs             start_item (:1014-1090), prefix_spans (:2535-2565)
+//   codex-rs/tui/src/markdown_render/task_lists.rs  task_list_marker
+//   codex-rs/tui/src/markdown_render_tests.rs       list_unordered_single / list_nested / nested_five_levels_mixed_lists / ...
+//
+// Why this module exists: the reader joins CTM's rendered rows to the rows the live Codex screen
+// actually shows, by identity of the row text. Codex draws unordered items as `• ` (PR #47322, on
+// by default) and nests by a FIXED 4-column step, while the first CTM renderer drew `- ` indented by
+// floor(spaces/2)*2 — so every list row missed the join and the reader drew it twice.
+//
+// The two facts that make the port non-obvious:
+//   * depth is the list nesting level; `width = depth*4 - 3`. The marker of an item at depth d is
+//     ONLY its own marker: prefix_spans skips every list context except the innermost, so an outer
+//     level contributes nothing to a nested row (no cumulative indent).
+//   * depth is NOT floor(spaces/2). It comes from a CommonMark container stack over the source
+//     lines; each open level remembers its item's CONTENT column, and a list line either opens a
+//     deeper level, lands as a sibling, or closes levels.
+//
+// Pure: no DOM, no clock, no I/O. Same input => same output. Tabs are already expanded to 4 spaces
+// by the caller (renderMarkdownTextBlock does this before the line loop).
+
+const BULLET = '•';
+const UNCHECKED = '☐';
+const CHECKED = '☑';
+
+// Codex nests by a fixed 4-column step (markdown_render.rs:1042: `width = depth * 4 - 3`).
+const HANG_STEP = 4;
+
+// `- x` / `* x` / `+ x` and `1. x` / `1) x`. The content must be non-blank, so a bare rule or a
+// lone marker keeps falling through to the renderer's paragraph path exactly as before.
+const BULLET_LINE = /^( *)([-*+])( +)(\S.*)$/;
+const ORDERED_LINE = /^( *)(\d{1,4})([.)])( +)(\S.*)$/;
+// A GFM task checkbox, right after the marker (task_lists.rs:8-24). `[X]` counts as checked.
+const TASK = /^\[([ xX])\](?: |$)/;
+
+// `width` for a depth (markdown_render.rs:1042): depth 1 => 1, depth 2 => 5, depth 3 => 9 ...
+function markerWidthFor(depth) {
+  return depth * HANG_STEP - 3;
+}
+
+// The column a wrapped (continuation) row of this item hangs at (markdown_render.rs:1057-1061):
+// unordered `width + 1`, ordered `width + 2` whatever the digit count. A task item hangs at its whole
+// marker's display width instead (itemOf).
+function hangFor(entry) {
+  return entry.width + (entry.ordered ? 2 : 1);
+}
+
+// markdown_render.rs:1043-1056 + task_lists.rs:15-19: the task checkbox REPLACES a trailing `• `
+// and keeps an ordered `N. ` prefix.
+function markerFor(entry, index) {
+  const glyph = entry.task ? (entry.checked ? CHECKED : UNCHECKED) : BULLET;
+  if (!entry.ordered) return ' '.repeat(Math.max(0, entry.width - 1)) + glyph + ' ';
+  return String(index).padStart(entry.width) + '. ' + (entry.task ? glyph + ' ' : '');
+}
+
+// Builds the row a list item paints: the marker (which already carries its own leading columns)
+// plus the source text. `indent` is 0 for an item row because the marker string holds its column,
+// and `hang` is the absolute continuation column. The caller adds the message prefix in front
+// (rule R-1.6) and strips inline markdown from `text` alone, so the marker never joins a match.
+function itemOf(entry, index, text) {
+  const marker = markerFor(entry, index);
+  // A task item hangs at its WHOLE marker's display width (task_lists.rs:22), so `10. ☐ ` hangs 6;
+  // every char of a marker is one column wide.
+  return { marker, text, indent: 0, hang: entry.task ? marker.length : hangFor(entry) };
+}
+
+// A tracker owns the CommonMark container stack for one text block. `consume(line)` must be called
+// with EVERY source line, in order, including blank ones: a blank line does not close the stack,
+// and a non-list line may be a continuation paragraph of the innermost item.
+function createListTracker() {
+  const stack = []; // innermost last; each entry = { ordered, task, checked, width, contentCol, next }
+
+  const push = (fields) => {
+    const entry = {
+      ordered: fields.ordered,
+      task: fields.task,
+      checked: fields.checked,
+      width: markerWidthFor(stack.length + 1),
+      contentCol: fields.contentCol,
+      next: fields.next,
+    };
+    stack.push(entry);
+    return entry;
+  };
+
+  return {
+    // -> null when the line is not a list item (or a continuation of one); otherwise the row
+    //    { marker, text, indent, hang } the renderer draws. `marker` is '' for a continuation row.
+    consume(rawLine) {
+      const line = String(rawLine == null ? '' : rawLine);
+      if (!line.trim()) return null; // a blank line does not close (R-1.5)
+
+      const bullet = BULLET_LINE.exec(line);
+      const ordered = bullet ? null : ORDERED_LINE.exec(line);
+
+      if (!bullet && !ordered) {
+        const top = stack[stack.length - 1];
+        const indent = line.length - line.replace(/^ */, '').length;
+        if (top && indent >= top.contentCol) {
+          // A non-blank, non-list line indented to the item's content column continues that item,
+          // rendered at the level's hang (R-1.5).
+          const hang = hangFor(top);
+          return { marker: '', text: line.trim(), indent: hang, hang };
+        }
+        stack.length = 0; // any other non-blank line closes every level
+        return null;
+      }
+
+      const markerIndent = (bullet ? bullet[1] : ordered[1]).length;
+      // The marker LENGTH is `-` (1) or `N.` (digits + the bracket) — the checkbox is not part of
+      // it, so `- [ ] a` still has content column 2.
+      const markerLen = bullet ? 1 : ordered[2].length + 1;
+      const gap = (bullet ? bullet[3] : ordered[4]).length;
+      const contentCol = markerIndent + markerLen + gap;
+      const content = bullet ? bullet[4] : ordered[5];
+      const task = TASK.exec(content);
+      const isOrdered = !bullet;
+      const text = task ? content.slice(task[0].length) : content;
+      const fields = {
+        ordered: isOrdered,
+        task: !!task,
+        checked: !!task && task[1] !== ' ',
+        contentCol,
+        next: isOrdered ? Number(ordered[2]) : 0,
+      };
+
+      const top = stack[stack.length - 1];
+      let entry;
+      if (top && markerIndent >= top.contentCol) {
+        entry = push(fields); // deeper than the innermost item's content -> a nested level
+      } else {
+        // Pop while the marker column sits left of the content column of the level BELOW the top.
+        while (stack.length >= 2 && markerIndent < stack[stack.length - 2].contentCol) stack.pop();
+        const sibling = stack[stack.length - 1];
+        if (!sibling || sibling.ordered !== isOrdered) {
+          // A sibling of the other type starts a NEW list at this depth; its numbering restarts
+          // from its own first source number.
+          if (sibling) stack.pop();
+          entry = push(fields);
+        } else {
+          entry = sibling; // same list: keep the level, refresh the per-item task state
+          entry.task = fields.task;
+          entry.checked = fields.checked;
+        }
+      }
+
+      let index = 0;
+      if (entry.ordered) {
+        index = entry.next; // counts from the list's first source number, per sibling
+        entry.next += 1;
+      }
+
+      return itemOf(entry, index, text);
+    },
+  };
+}
+
+module.exports = { createListTracker };

package/template/coding-task-manager/lib/codex-native-history-prefix.js

@@ -191,6 +191,10 @@ function findCanonicalRolloutsByFilenameId(threadId, storageRoots) {
         const candidate = path.join(dir, entry.name);
         if (entry.isDirectory()) { stack.push({ dir: candidate, depth: depth + 1 }); continue; }
         if (!entry.isFile() || sessionHistory.codexRolloutIdFromPath(candidate).toLowerCase() !== wanted) continue;
+        // Codex rust-v0.163.0 rollout/src/compression.rs should_skip_compressed_sibling: one rollout is
+        // one physical file, and a `.jsonl.zst` is hidden while its plain `.jsonl` exists (Codex
+        // compresses an idle thread, then appends to a re-materialized plain file beside the stale copy).
+        if (candidate.endsWith('.jsonl.zst') && transcriptSource.statTranscriptSync(candidate.slice(0, -'.zst'.length)).exists) continue;
         const info = transcriptSource.statTranscriptSync(candidate);
         if (!info.exists) throw Object.assign(new Error('native history candidate changed during lookup'), { code: 'native_history_lineage_changed' });
         let canonical;