create-walle 0.9.21 → 0.9.23

package/template/claude-task-manager/lib/codex-transcript-pager.js

@@ -0,0 +1,51 @@
+'use strict';
+
+function stripAnsi(value) {
+  return String(value || '')
+    .replace(/\x1b\[[0-9;?]*[a-zA-Z]/g, '')
+    .replace(/\x1b\][^\x07\x1b]*(?:\x07|\x1b\\)/g, '')
+    .replace(/\x1b[()][A-Z0-9]/g, '')
+    .replace(/\x1b>[0-9]*[a-zA-Z]/g, '')
+    .replace(/\x1b<[a-zA-Z]/g, '')
+    .replace(/\x1b=[0-9]*/g, '')
+    .replace(/\x1b\s/g, '')
+    .replace(/\r/g, '')
+    .replace(/[\x00-\x08\x0b\x0c\x0e-\x1f\x7f]/g, '');
+}
+
+function normalizeText(value) {
+  return stripAnsi(value)
+    .replace(/\u00a0/g, ' ')
+    .split('\n')
+    .map((line) => line.replace(/[ \t]+/g, ' ').replace(/\s+$/g, ''))
+    .join('\n')
+    .trim();
+}
+
+function normalizeAgentType(value) {
+  const text = String(value || '').trim().toLowerCase();
+  if (!text) return '';
+  if (text === 'codex' || text === 'codex-cli' || text === 'codex_cli' || text === 'codex_cli_rs') return 'codex';
+  return text;
+}
+
+function looksLikeCodexTranscriptPagerSnapshot(agentType, value) {
+  if (normalizeAgentType(agentType) !== 'codex') return false;
+  const text = normalizeText(value);
+  if (!text) return false;
+
+  const compact = text.replace(/[ \t]+/g, ' ');
+  const hasTranscriptHeading = /(?:^|\n)\s*(?:[\/\\]\s*){1,}\s*T\s*R\s*A\s*N\s*S\s*C\s*R\s*I\s*P\s*T\b/i.test(compact)
+    || /(?:^|\n)\s*T\s*R\s*A\s*N\s*S\s*C\s*R\s*I\s*P\s*T\s*(?:[\/\\]\s*){1,}/i.test(compact);
+  const hasQuitInstruction = /\bq\s+to\s+quit\b/i.test(compact);
+  const hasScrollInstruction = /\bj\/k\s+to\s+scroll\b/i.test(compact) || /\bpgup\/pgdn\s+to\s+page\b/i.test(compact);
+  const hasEditInstruction = /\benter\s+to\s+edit\s+message\b/i.test(compact)
+    || /\besc\/.{0,24}\bto\s+edit\s+(?:prev|previous|next)\b/i.test(compact);
+
+  return hasTranscriptHeading && hasQuitInstruction && hasScrollInstruction && hasEditInstruction;
+}
+
+module.exports = {
+  looksLikeCodexTranscriptPagerSnapshot,
+  normalizeText,
+};

package/template/claude-task-manager/lib/codex-zst.js

@@ -0,0 +1,124 @@
+'use strict';
+
+// Newer Codex CLI versions background-compress cold rollouts to
+// `rollout-*.jsonl.zst` and re-materialize the live `.jsonl` on resume.
+// CTM reads rollouts directly, so a compressed archive must be lazily
+// materialized to a disk cache once and then served like any other rollout.
+// Compressed rollouts are cold + immutable by definition — no tail/HWM
+// semantics needed; the cache key embeds mtime+size so a replaced archive
+// re-materializes.
+
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+const zlib = require('zlib');
+const { spawnSync } = require('child_process');
+
+const MAX_COMPRESSED_BYTES = 64 * 1024 * 1024;   // skip absurd archives
+const MAX_OUTPUT_BYTES = 512 * 1024 * 1024;       // decompression bomb guard
+const CACHE_MAX_FILES = 16;
+const CACHE_MAX_BYTES = 1024 * 1024 * 1024;
+
+function isZstRolloutFileName(name) {
+  return /\.jsonl\.zst$/i.test(String(name || ''));
+}
+
+function cacheDir() {
+  if (process.env.CTM_CODEX_ZST_CACHE_DIR) return process.env.CTM_CODEX_ZST_CACHE_DIR;
+  return path.join(os.homedir(), '.walle', 'cache', 'codex-zst');
+}
+
+let _capability = null;
+function zstdCapability() {
+  if (_capability) return _capability;
+  if (typeof zlib.zstdDecompressSync === 'function') { _capability = 'zlib'; return _capability; }
+  try {
+    const probe = spawnSync('zstd', ['--version'], { stdio: 'ignore', timeout: 5000 });
+    if (probe.status === 0) { _capability = 'binary'; return _capability; }
+  } catch { /* not on PATH */ }
+  _capability = 'none';
+  return _capability;
+}
+
+function _decompress(buf) {
+  const cap = zstdCapability();
+  if (cap === 'zlib') return zlib.zstdDecompressSync(buf, { maxOutputLength: MAX_OUTPUT_BYTES });
+  if (cap === 'binary') {
+    const run = spawnSync('zstd', ['-dc'], { input: buf, maxBuffer: MAX_OUTPUT_BYTES, timeout: 120000 });
+    if (run.status === 0 && run.stdout) return run.stdout;
+    throw new Error(`zstd -dc failed: ${String(run.stderr || run.error || 'unknown').slice(0, 200)}`);
+  }
+  const err = new Error('no zstd decompressor (Node >= 22.15 zlib.zstdDecompressSync or the zstd binary required)');
+  err.code = 'NO_ZSTD';
+  throw err;
+}
+
+function _pruneCache(dir) {
+  let entries = [];
+  try {
+    entries = fs.readdirSync(dir)
+      .filter(name => name.endsWith('.jsonl'))
+      .map(name => {
+        const fullPath = path.join(dir, name);
+        try { const st = fs.statSync(fullPath); return { fullPath, size: st.size, mtimeMs: st.mtimeMs }; }
+        catch { return null; }
+      })
+      .filter(Boolean)
+      .sort((a, b) => b.mtimeMs - a.mtimeMs);
+  } catch { return; }
+  let totalBytes = 0;
+  entries.forEach((entry, idx) => {
+    totalBytes += entry.size;
+    if (idx >= CACHE_MAX_FILES || totalBytes > CACHE_MAX_BYTES) {
+      try { fs.unlinkSync(entry.fullPath); } catch { /* concurrent prune */ }
+    }
+  });
+}
+
+// `.zst` → cached decompressed `.jsonl` path; anything else passes through
+// unchanged so callers can call this unconditionally.
+function materializeCodexRollout(filePath) {
+  const p = String(filePath || '');
+  if (!isZstRolloutFileName(p)) return { path: p, ok: true, reason: '' };
+  let st;
+  try { st = fs.statSync(p); } catch { return { path: '', ok: false, reason: 'stat_failed' }; }
+  if (st.size > MAX_COMPRESSED_BYTES) return { path: '', ok: false, reason: 'too_large' };
+  if (zstdCapability() === 'none') return { path: '', ok: false, reason: 'no_zstd' };
+  const dir = cacheDir();
+  const key = `${path.basename(p).replace(/\.zst$/i, '').replace(/\.jsonl$/i, '')}-${Math.round(st.mtimeMs)}-${st.size}.jsonl`;
+  const out = path.join(dir, key);
+  try { if (fs.existsSync(out)) return { path: out, ok: true, reason: 'cache' }; } catch { /* fall through */ }
+  try {
+    fs.mkdirSync(dir, { recursive: true });
+    const decompressed = _decompress(fs.readFileSync(p));
+    const tmp = `${out}.tmp-${process.pid}`;
+    fs.writeFileSync(tmp, decompressed);
+    fs.renameSync(tmp, out);
+    _pruneCache(dir);
+    return { path: out, ok: true, reason: 'decompressed' };
+  } catch (e) {
+    return { path: '', ok: false, reason: `decompress_failed:${String(e.code || e.message || '').slice(0, 80)}` };
+  }
+}
+
+// Drop a `.zst` archive when its live `.jsonl` sibling exists (the
+// resume-rematerialization case — the live file is authoritative).
+function dropZstWithLiveSibling(filePaths) {
+  const list = Array.isArray(filePaths) ? filePaths : [];
+  const inSet = new Set(list);
+  return list.filter(p => {
+    if (!isZstRolloutFileName(p)) return true;
+    const live = p.replace(/\.zst$/i, '');
+    if (inSet.has(live)) return false;
+    try { return !fs.existsSync(live); } catch { return true; }
+  });
+}
+
+module.exports = {
+  isZstRolloutFileName,
+  zstdCapability,
+  materializeCodexRollout,
+  dropZstWithLiveSibling,
+  MAX_COMPRESSED_BYTES,
+  _pruneCache,
+};

package/template/claude-task-manager/lib/coding-agent-models.js

@@ -22,43 +22,130 @@ const CC_ALIAS_MAP = {
 
 const AGENT_MODEL_CACHE_TTL = 5000;
 
+function _normalizeClaudeModelName(value) {
+  if (typeof value !== 'string') return null;
+  const alias = value.replace(/\[.*$/, '').trim().toLowerCase();
+  return CC_ALIAS_MAP[alias] || (alias.startsWith('claude-') ? alias : null);
+}
+
 // Read the actual model used in the most recent assistant turn of a JSONL
 // transcript. This is the source of truth: it reflects what Claude Code
 // actually invoked, immune to alias drift.
-function getClaudeCodeModelFromJsonl(jsonlPath) {
+// Walk a JSONL chunk backwards for the last assistant turn carrying a claude- model id.
+function _scanJsonlForClaudeModelInfo(raw) {
+  const lines = raw.split('\n');
+  for (let i = lines.length - 1; i >= 0; i--) {
+    const line = lines[i];
+    if (!line || line[0] !== '{') continue;
+    // Cheap pre-filter so we don't JSON.parse every user/system line.
+    if (line.indexOf('"model"') === -1) continue;
+    try {
+      const rec = JSON.parse(line);
+      if (!rec || rec.type !== 'assistant') continue;
+      const m = rec && rec.message && rec.message.model;
+      const model = _normalizeClaudeModelName(m);
+      if (model) {
+        const timestampMs = typeof rec.timestamp === 'string' ? Date.parse(rec.timestamp) : NaN;
+        return {
+          model,
+          timestampMs: Number.isFinite(timestampMs) ? timestampMs : 0,
+        };
+      }
+    } catch { /* skip malformed line */ }
+  }
+  return null;
+}
+
+function _scanJsonlForClaudeModel(raw) {
+  const info = _scanJsonlForClaudeModelInfo(raw);
+  return info ? info.model : null;
+}
+
+// Read just the TAIL of the transcript by default: the model lives in the most
+// recent assistant turn, so reading the whole file (an active session's JSONL is
+// 50–100MB) on the main loop just to find the last line was a model-sync boot
+// freeze — getSessionAgentModel runs this for every session on a cold cache.
+const _CLAUDE_JSONL_MODEL_TAIL_BYTES = Math.max(
+  64 * 1024,
+  Number(process.env.CTM_CLAUDE_MODEL_JSONL_TAIL_BYTES) || 512 * 1024
+);
+
+function getClaudeCodeModelInfoFromJsonl(jsonlPath) {
   if (!jsonlPath) return null;
   try {
-    if (!fs.existsSync(jsonlPath)) return null;
-    const raw = fs.readFileSync(jsonlPath, 'utf8');
-    // Walk backwards through lines to find the last assistant turn with a model.
-    const lines = raw.split('\n');
-    for (let i = lines.length - 1; i >= 0; i--) {
-      const line = lines[i];
-      if (!line || line[0] !== '{') continue;
-      // Cheap pre-filter so we don't JSON.parse every user/system line.
-      if (line.indexOf('"model"') === -1) continue;
-      try {
-        const rec = JSON.parse(line);
-        if (!rec || rec.type !== 'assistant') continue;
-        const m = rec && rec.message && rec.message.model;
-        if (typeof m === 'string' && m.startsWith('claude-')) return m;
-      } catch { /* skip malformed line */ }
+    let size;
+    try { size = fs.statSync(jsonlPath).size; } catch { return null; } // missing/unreadable
+    if (size <= _CLAUDE_JSONL_MODEL_TAIL_BYTES) {
+      return _scanJsonlForClaudeModelInfo(fs.readFileSync(jsonlPath, 'utf8'));
     }
+    // Large file: read only the trailing window, dropping the leading partial line
+    // (the tail boundary almost certainly splits one).
+    const fd = fs.openSync(jsonlPath, 'r');
+    let tail;
+    try {
+      const buf = Buffer.allocUnsafe(_CLAUDE_JSONL_MODEL_TAIL_BYTES);
+      const read = fs.readSync(fd, buf, 0, _CLAUDE_JSONL_MODEL_TAIL_BYTES, size - _CLAUDE_JSONL_MODEL_TAIL_BYTES);
+      tail = buf.toString('utf8', 0, read);
+    } finally { fs.closeSync(fd); }
+    const nl = tail.indexOf('\n');
+    const found = _scanJsonlForClaudeModelInfo(nl >= 0 ? tail.slice(nl + 1) : tail);
+    if (found) return found;
+    // Rare: the last assistant-with-model turn is older than the tail window.
+    // Fall back to a full read so we are never LESS correct than before — only the
+    // (uncommon) miss pays the full cost the old code always paid.
+    return _scanJsonlForClaudeModelInfo(fs.readFileSync(jsonlPath, 'utf8'));
   } catch { /* file unreadable */ }
   return null;
 }
 
-function getClaudeCodeModel(homeDir = process.env.HOME) {
+function getClaudeCodeModelFromJsonl(jsonlPath) {
+  const info = getClaudeCodeModelInfoFromJsonl(jsonlPath);
+  return info ? info.model : null;
+}
+
+function getClaudeCodeModelSelection(homeDir = process.env.HOME) {
+  const settingsPath = path.join(homeDir, '.claude', 'settings.json');
   try {
-    const raw = JSON.parse(fs.readFileSync(path.join(homeDir, '.claude', 'settings.json'), 'utf8'));
-    if (!raw.model) return null;
-    const alias = raw.model.replace(/\[.*$/, '').trim().toLowerCase();
-    return CC_ALIAS_MAP[alias] || (alias.startsWith('claude-') ? alias : null);
+    const raw = JSON.parse(fs.readFileSync(settingsPath, 'utf8'));
+    const model = _normalizeClaudeModelName(raw.model);
+    if (!model) return null;
+    let mtimeMs = 0;
+    try { mtimeMs = fs.statSync(settingsPath).mtimeMs || 0; } catch {}
+    return { model, mtimeMs, rawModel: raw.model, settingsPath };
   } catch {
     return null;
   }
 }
 
+function getClaudeCodeModel(homeDir = process.env.HOME) {
+  const selection = getClaudeCodeModelSelection(homeDir);
+  return selection ? selection.model : null;
+}
+
+function shouldPreferClaudeSelectedModel(selection, jsonlInfo) {
+  if (!selection || !selection.model) return false;
+  if (!jsonlInfo || !jsonlInfo.model) return true;
+  if (!selection.mtimeMs || !jsonlInfo.timestampMs) return false;
+  return selection.mtimeMs > (jsonlInfo.timestampMs + 1000);
+}
+
+function _coerceTimeMs(value) {
+  if (!value) return 0;
+  if (typeof value === 'number' && Number.isFinite(value)) return value > 1e12 ? value : value * 1000;
+  const parsed = Date.parse(String(value));
+  return Number.isFinite(parsed) ? parsed : 0;
+}
+
+function getClaudeSessionModelName({ jsonlPath, homeDir = process.env.HOME, sessionActivityMs = 0 } = {}) {
+  const jsonlInfo = getClaudeCodeModelInfoFromJsonl(jsonlPath);
+  const selection = getClaudeCodeModelSelection(homeDir);
+  if (shouldPreferClaudeSelectedModel(selection, jsonlInfo)) {
+    const activityMs = _coerceTimeMs(sessionActivityMs);
+    if (!activityMs || activityMs >= (selection.mtimeMs - 10 * 60 * 1000)) return selection.model;
+  }
+  return (jsonlInfo && jsonlInfo.model) || (selection && selection.model) || null;
+}
+
 function openCodexStateDb(homeDir = process.env.HOME) {
   const Database = require('better-sqlite3');
   const dbPath = path.join(homeDir, '.codex', 'state_5.sqlite');
@@ -147,7 +234,7 @@ function resolveModelToRegistry(modelName) {
   return { model_id: modelName, model_provider: provider };
 }
 
-function createCodingAgentModelSync({ sessions, dbModule, broadcastSessionList }) {
+function createCodingAgentModelSync({ sessions, dbModule, broadcastSessionList, resolveClaudeJsonlPath, resolveAgentModelsOffThread }) {
   const agentModelCache = {};
   let agentModelCacheTime = 0;
 
@@ -156,11 +243,23 @@ function createCodingAgentModelSync({ sessions, dbModule, broadcastSessionList }
     if (!agentType) return null;
 
     const now = Date.now();
+
+    // For claude, resolve the transcript path up front. session.jsonlPath is
+    // only populated by the JSONL file-watcher on a write event, so idle and
+    // freshly-restored sessions lack it even though the transcript on disk
+    // already records the model — leaving the picker stuck on "(detecting…)".
+    // resolveClaudeJsonlPath derives the deterministic path
+    // (~/.claude/projects/<encoded-cwd>/<agentSessionId>.jsonl) so detection
+    // works without waiting for the next write.
+    const claudeJsonlPath = agentType === 'claude'
+      ? (session.jsonlPath || (resolveClaudeJsonlPath ? resolveClaudeJsonlPath(session) : '') || '')
+      : '';
+
     // Per-session cache key for claude too because JSONL fallback is
     // per-session. Codex also includes the matched thread id because it can
     // be discovered after spawn.
     const cacheKey = agentType === 'claude'
-      ? `claude:${session.id}:${session.jsonlPath || ''}`
+      ? `claude:${session.id}:${claudeJsonlPath}`
       : agentType === 'codex'
         ? `codex:${session.id}:${session._claudeSessionId || ''}`
         : agentType;
@@ -172,13 +271,21 @@ function createCodingAgentModelSync({ sessions, dbModule, broadcastSessionList }
     let modelName = null;
     switch (agentType) {
       case 'claude':
-        // Prefer settings.json (alias to CC_ALIAS_MAP) so a `/model` switch in
-        // Claude Code reflects immediately, even before the next assistant
-        // turn writes to JSONL. Fall back to the JSONL transcript when
-        // settings.json is unreadable; that path is also our safety net if
-        // CC_ALIAS_MAP goes stale on a future alias rotation, since JSONL
-        // records the actual model the API resolved.
-        modelName = getClaudeCodeModel() || getClaudeCodeModelFromJsonl(session.jsonlPath);
+        // The JSONL transcript is the historical source of truth because it
+        // records what the API actually resolved on the latest assistant turn.
+        // Claude Code also rewrites settings.json immediately when the user
+        // changes the selected model, before the next assistant turn exists.
+        // Prefer that newer live selection only when its mtime is newer than
+        // the latest assistant turn timestamp; otherwise keep JSONL precedence.
+        modelName = getClaudeSessionModelName({
+          jsonlPath: claudeJsonlPath,
+          sessionActivityMs: Math.max(
+            _coerceTimeMs(session.lastActivity),
+            _coerceTimeMs(session.lastPtyActivity),
+            _coerceTimeMs(session.updatedAt),
+            _coerceTimeMs(session.createdAt)
+          ),
+        });
         break;
       case 'codex':
         modelName = session._claudeSessionId
@@ -248,10 +355,103 @@ function createCodingAgentModelSync({ sessions, dbModule, broadcastSessionList }
     if (changed && typeof broadcastSessionList === 'function') broadcastSessionList();
   }
 
+  // Off-main-loop variant of syncCodingSessionModels. The fs/DB-heavy resolution (claude JSONL
+  // scan + Codex state-DB reads + getCodexThreadTitleById) runs on the read-pool worker via
+  // resolveAgentModelsOffThread; only the small DECIDE/APPLY work (model→registry mapping, the
+  // CTM-DB title decision, mutating the in-memory session) stays on main. On pool
+  // unavailable/timeout (returns null) we SKIP the tick rather than dragging the work back onto
+  // the loop — model/title detection is best-effort UI sugar and converges next tick.
+  async function syncCodingSessionModelsOffThread() {
+    if (typeof resolveAgentModelsOffThread !== 'function') return syncCodingSessionModels();
+    let changed = false;
+    const items = [];
+    const ctx = []; // parallel to items: { session, agentType, wantCodexTitle }
+    for (const [, session] of sessions) {
+      const agentType = detectAgentType(session.cmd);
+      if (!agentType) continue;
+      if (agentType === 'gemini') {
+        // Pure arg-parse + registry map — no fs/DB; resolve inline on main.
+        const model = getSessionAgentModel(session);
+        if (model && session.model_id !== model.model_id) {
+          session.model_id = model.model_id;
+          session.model_provider = model.model_provider;
+          changed = true;
+        }
+        continue;
+      }
+      const claudeJsonlPath = agentType === 'claude'
+        ? (session.jsonlPath || (resolveClaudeJsonlPath ? resolveClaudeJsonlPath(session) : '') || '')
+        : '';
+      // Codex title DECISION runs on main (cheap CTM-DB read). Only the actual Codex-DB title
+      // FETCH is offloaded (wantCodexTitle). Mirrors the sync version's branches exactly.
+      let wantCodexTitle = false;
+      if (agentType === 'codex' && !session._codexTitleSynced) {
+        const existingTitle = dbModule.getSessionTitleNew(session.id);
+        if (existingTitle && existingTitle.userRenamed) {
+          session._codexTitleSynced = true;
+        } else if (!shouldApplyCodexAutoTitle({ session, existingTitle })) {
+          const liveLabel = normalizeTitleText(session.label);
+          if (liveLabel
+            && !isGenericCodingSessionLabel(liveLabel, 'codex')
+            && (!existingTitle || normalizeTitleText(existingTitle.title) !== liveLabel)) {
+            dbModule.setSessionTitleNew(session.id, liveLabel, false);
+            changed = true;
+          }
+          session._codexTitleSynced = true;
+        } else {
+          wantCodexTitle = !!session._claudeSessionId;
+        }
+      }
+      items.push({
+        id: session.id,
+        agentType,
+        claudeJsonlPath,
+        sessionActivityMs: Math.max(
+          _coerceTimeMs(session.lastActivity),
+          _coerceTimeMs(session.lastPtyActivity),
+          _coerceTimeMs(session.updatedAt),
+          _coerceTimeMs(session.createdAt)
+        ),
+        codexThreadId: session._claudeSessionId || null,
+        wantCodexTitle,
+      });
+      ctx.push({ session, agentType, wantCodexTitle });
+    }
+    if (items.length === 0) {
+      if (changed && typeof broadcastSessionList === 'function') broadcastSessionList();
+      return;
+    }
+    const results = await resolveAgentModelsOffThread(items);
+    if (!results) {
+      // Pool unavailable/timeout → skip this tick (do not run the heavy resolve on main).
+      if (changed && typeof broadcastSessionList === 'function') broadcastSessionList();
+      return;
+    }
+    const byId = new Map(results.map((r) => [r.id, r]));
+    for (const { session, agentType, wantCodexTitle } of ctx) {
+      const r = byId.get(session.id);
+      if (!r) continue;
+      const model = resolveModelToRegistry(r.modelName);
+      if (model && session.model_id !== model.model_id) {
+        session.model_id = model.model_id;
+        session.model_provider = model.model_provider;
+        changed = true;
+      }
+      if (agentType === 'codex' && wantCodexTitle && r.codexTitle) {
+        session.label = `Codex: ${r.codexTitle}`;
+        session._codexTitleSynced = true;
+        dbModule.setSessionTitleNew(session.id, session.label, false);
+        changed = true;
+      }
+    }
+    if (changed && typeof broadcastSessionList === 'function') broadcastSessionList();
+  }
+
   return {
     detectAgentType,
     getSessionAgentModel,
     syncCodingSessionModels,
+    syncCodingSessionModelsOffThread,
   };
 }
 
@@ -260,6 +460,9 @@ module.exports = {
   detectAgentType,
   getClaudeCodeModel,
   getClaudeCodeModelFromJsonl,
+  getClaudeCodeModelInfoFromJsonl,
+  getClaudeCodeModelSelection,
+  getClaudeSessionModelName,
   getCodexThreadModel,
   getCodexThreadTitleById,
   getCodexLatestModel,