create-walle 0.10.1 → 0.10.3

package/template/coding-task-manager/lib/broadcast-serialize.js

@@ -83,6 +83,11 @@ function serializeSessionListEnvelope(payload) {
     type: payload?.type,
     restoring: payload?.restoring,
     sessions: Array.isArray(payload?.sessions) ? payload.sessions : [],
+    // Box-owned sessions WP-5: the hub's "a registered box has not delivered its catalog yet" count
+    // rides the sessions frame (server.js _finishBroadcast adds it only when a machine is enabled).
+    // Carry it when present so the off-main path matches the sliced on-main one byte for byte;
+    // a zero-machine envelope stays the exact three-key object it has always been.
+    ...(payload && payload.machinesPending !== undefined ? { machinesPending: payload.machinesPending } : {}),
   });
 }
 
@@ -145,7 +150,8 @@ function createBroadcastPayloadSerializer({
       if (options.isMemoBypass?.(session) || !memo) return null;
       signature += memo.key + '\x1e';
     }
-    return signature + '#' + options.sourceSessions.length;
+    // extraSignature: rows appended AFTER the local snapshot (the machine hub's remote rows).
+    return signature + '#' + options.sourceSessions.length + (options.extraSignature ? '#' + options.extraSignature : '');
   }
 
   function makeRecord(envelope, clients, signature) {

package/template/coding-task-manager/lib/browser-session-broker.js

@@ -1189,6 +1189,7 @@ class BrowserSessionBroker {
     if (this.profileMigration?.ensureProfile) record = await this.profileMigration.ensureProfile(record);
     const existing = await this._boundHandle(record, { required: false });
     if (existing && (typeof this.adapter.isLive !== 'function' || this.adapter.isLive(existing))) return existing;
+    if (existing) await this._dropDeadHandle(record, existing);
     let handle;
     try {
       handle = await this.adapter.open({ contextId: record.contextId, profileDir: record.profileDir,
@@ -1210,7 +1211,7 @@ class BrowserSessionBroker {
     record = await this._ensureProcessOwnership(record, { allowTakeover: true });
     const existing = await this._boundHandle(record, { required: false });
     if (existing && (typeof this.adapter.isLive !== 'function' || this.adapter.isLive(existing))) return record;
-    if (existing) this.handles.delete(record.contextId);
+    if (existing) await this._dropDeadHandle(record, existing);
     let recovered = record;
     if (record.processGeneration !== this.processGeneration || existing || record.status === 'dormant') {
       recovered = {
@@ -1292,6 +1293,13 @@ class BrowserSessionBroker {
     return handle;
   }
 
+  // A handle that is no longer live (lost page, disconnected browser) still owns whatever of its
+  // browser survives; close it rather than just forgetting it.
+  async _dropDeadHandle(record, handle) {
+    if (this.handles.get(record.contextId) === handle) this.handles.delete(record.contextId);
+    await this.adapter.close(handle).catch((error) => this._reportFailure('dead-handle-close', error));
+  }
+
   _rebindLocalHandle(record) {
     const handle = this.handles.get(record.contextId);
     if (!handle) return;

package/template/coding-task-manager/lib/browser-use-adapter.js

@@ -31,6 +31,9 @@ function chromiumChildEnvironment(parentEnvironment = process.env) {
   return environment;
 }
 
+// Chromium ChildProcesses whose group has been reaped, so the exit and close paths reap it once.
+const REAPED = new WeakSet();
+
 class BrowserUseAdapter {
   constructor({
     puppeteer = null,
@@ -84,6 +87,11 @@ class BrowserUseAdapter {
         allowedOrigins: new Set([allowedOrigin, ...allowedOrigins].filter(Boolean)),
         blockedOrigin: '', disconnected: false, lastMainResponseStatus: 0 };
       browser.once('disconnected', () => { handle.disconnected = true; });
+      // A browser lost without close() (crash, external kill) leaves the same helpers behind. Reap on
+      // the main process's exit, never on 'disconnected': the CDP socket drops while Chromium is still
+      // shutting down, and killing its group then loses storage it has not flushed yet.
+      const child = typeof browser.process === 'function' ? browser.process() : null;
+      child?.once?.('exit', () => this._reapBrowserProcess(child, 'browser-exit'));
       page.on('response', (response) => {
         try {
           const request = response.request();
@@ -99,7 +107,7 @@ class BrowserUseAdapter {
       handle.documentGeneration = await this._documentGeneration(handle);
       return handle;
     } catch (error) {
-      await browser.close().catch((closeError) => this._reportFailure('open-cleanup', closeError));
+      await this._closeBrowser(browser, 'open-cleanup');
       throw error;
     }
   }
@@ -628,10 +636,33 @@ class BrowserUseAdapter {
 
   async close(handle) {
     if (!handle?.browser) return;
-    await handle.browser.close().catch((error) => this._reportFailure('browser-close', error));
+    await this._closeBrowser(handle.browser, 'browser-close');
     handle.disconnected = true;
   }
 
+  // browser.close() returns once Chromium's browser process exits, but its renderer/GPU helpers
+  // can outlive it (puppeteer launches Chromium detached, so they share its process group), and
+  // its crashpad handler daemonizes into a group of its own still holding the stdio Chromium
+  // inherited. Either one keeps this process's end of that stdio open: orphaned helpers pile up
+  // and a Node process that should exit never does. Reap the group, then drop our end.
+  async _closeBrowser(browser, operation) {
+    const child = typeof browser.process === 'function' ? browser.process() : null;
+    await browser.close().catch((error) => this._reportFailure(operation, error));
+    this._reapBrowserProcess(child, operation);
+  }
+
+  _reapBrowserProcess(child, operation) {
+    if (!child || REAPED.has(child)) return;
+    REAPED.add(child);
+    if (Number.isSafeInteger(child.pid) && child.pid > 0) {
+      // ESRCH: the group is already empty. EPERM: macOS refuses a group whose members are all zombies
+      // (every member here is this user's Chromium, so it is never a foreign process).
+      try { process.kill(-child.pid, 'SIGKILL'); }
+      catch (error) { if (error?.code !== 'ESRCH' && error?.code !== 'EPERM') this._reportFailure(`${operation}-group`, error); }
+    }
+    for (const stream of child?.stdio || []) stream?.destroy?.();
+  }
+
   _reportFailure(operation, error) {
     const kind = String(error?.code || error?.name || 'unknown').slice(0, 128);
     this.logger?.warn?.(`[browser-use-adapter] ${operation} failed (${kind})`);

package/template/coding-task-manager/lib/build-info.js

@@ -80,10 +80,12 @@ function resetBuildInfoCache() {
 // and process-wide memoization make it a poor fit for "resolve once, fail closed to 'unknown'".
 // Wrapped so ANY failure (no git binary, cwd outside a repo, detached HEAD, timeout, ...) yields
 // 'unknown' rather than throwing — this must never block or delay boot.
-function resolveBootBuildSha(repoRoot, execFileSyncImpl) {
+// `full: true` returns the 40-hex commit: fleet status compares the RUNNING commit against a full
+// target sha (lib/fleet-hub.js), so an abbreviation there reads as "never restarted onto it".
+function resolveBootBuildSha(repoRoot, execFileSyncImpl, { full = false } = {}) {
   try {
     const run = typeof execFileSyncImpl === 'function' ? execFileSyncImpl : execFileSync;
-    const out = run('git', ['rev-parse', '--short', 'HEAD'], {
+    const out = run('git', full ? ['rev-parse', 'HEAD'] : ['rev-parse', '--short', 'HEAD'], {
       cwd: repoRoot || path.resolve(__dirname, '..', '..'),
       encoding: 'utf8',
       stdio: ['ignore', 'pipe', 'ignore'],

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-model-truth.js

@@ -257,20 +257,28 @@ function createClaudeModelTruth({ now = Date.now } = {}) {
 const EMPTY_CLAUDE_TRUTH = Object.freeze({
   selected: null, resolved: null, context1m: false, lastTurn: null, effort: null,
   source: null, observedAtMs: 0, lastTurnAtMs: 0,
+  // WP-1/D-1: the newest REFUSED turn the transcript recorded, as { status, atMs, turnId, requestId },
+  // or null. It is carried for the lead-model switch's failure branch only -- it names no model, so no
+  // consumer of `resolved`/`selected`/`lastTurn`/`effort` may read it as one.
+  lastTurnFailure: null,
 });
 
 /**
- * Assemble the flat truth shape from the two transcript facts a Claude Code JSONL carries
+ * Assemble the flat truth shape from the transcript facts a Claude Code JSONL carries
  * (D-4): the identity record is the verbatim "set to" selection, assistant rows are what
  * actually served. An identity that names no served model ('opusplan') still sets `selected`
  * while `resolved` falls back to the last turn.
+ *
+ * WP-1 adds the third fact: `failure` ({ status, atMs, turnId, requestId } | null) is copied
+ * verbatim and changes nothing else about the shape.
  */
-function truthFromTranscriptFacts(identity, turn) {
+function truthFromTranscriptFacts(identity, turn, failure = null) {
   const truth = {
     ...EMPTY_CLAUDE_TRUTH,
     lastTurn: turn ? turn.model : null,
     lastTurnAtMs: turn ? (turn.observedAtMs || 0) : 0,
     effort: turn ? (turn.effort || null) : null,
+    lastTurnFailure: failure || null,
   };
   const identityNorm = identity ? normalizeClaudeModelId(identity.modelId) : null;
   if (identity) truth.selected = identity.modelId;
@@ -302,6 +310,9 @@ function viewToTruth(view, fallback = EMPTY_CLAUDE_TRUTH) {
     source: resolved ? resolved.source : fallback.source,
     observedAtMs: resolved ? resolved.observedAtMs : fallback.observedAtMs,
     lastTurnAtMs: lastTurn ? lastTurn.observedAtMs : fallback.lastTurnAtMs,
+    // WP-1: the failure provenance is not ledger evidence (the ledger has no slot for it), so it
+    // passes straight through from the transcript facts that produced this view.
+    lastTurnFailure: fallback.lastTurnFailure || null,
   };
 }
 

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