create-walle 0.9.11 → 0.9.13

package/template/claude-task-manager/session-integrity.js

@@ -10,15 +10,116 @@
 //   3. Wrong mapping: CTM tab's agent_session_id points to wrong JSONL file
 //   4. Orphan file: JSONL file on disk has no corresponding DB row
 //   5. Duplicate claim: Multiple DB rows claim the same agent_session_id
-//   6. Timestamp drift: DB created_at is significantly off from file birthtime
+//   6. Timestamp drift: DB created_at is significantly off from JSONL timestamp
 
 const fs = require('fs');
 const path = require('path');
+const claudeDesktopSessions = require('./lib/claude-desktop-sessions');
 
 const CLAUDE_PROJECTS_DIR = path.join(process.env.HOME, '.claude', 'projects');
 
 // --- Detection ---
 
+function dbTimestampFromIso(value) {
+  if (!value) return '';
+  const ms = new Date(value).getTime();
+  if (!Number.isFinite(ms)) return '';
+  return new Date(ms).toISOString().replace('T', ' ').replace(/\.\d+Z$/, '');
+}
+
+function parseDbTimestampMs(value) {
+  if (!value) return NaN;
+  const str = String(value).trim();
+  if (!str) return NaN;
+  const hasZone = /(?:Z|[+-]\d\d:?\d\d)$/.test(str);
+  return new Date(hasZone ? str : str.replace(' ', 'T') + 'Z').getTime();
+}
+
+function isLowSignalIntegrityUserText(text) {
+  const s = String(text || '').trim();
+  if (!s) return true;
+  if (/^\[Request interrupted\b/i.test(s)) return true;
+  if (/^\[(?:request\s+)?interrupted\b/i.test(s)) return true;
+  if (/^<command-(?:message|name)>/i.test(s)) return true;
+  return false;
+}
+
+function normalizedWordSet(text) {
+  return new Set(String(text || '')
+    .replace(/<[^>]+>/g, ' ')
+    .replace(/[^a-zA-Z0-9\s]/g, ' ')
+    .toLowerCase()
+    .split(/\s+/)
+    .filter(w => w.length > 3));
+}
+
+function wordSimilarity(a, b) {
+  const aWords = normalizedWordSet(a);
+  const bWords = normalizedWordSet(b);
+  if (aWords.size <= 3 || bWords.size <= 3) return null;
+  let overlap = 0;
+  for (const w of aWords) if (bWords.has(w)) overlap++;
+  return overlap / Math.min(aWords.size, bWords.size);
+}
+
+function textFromUserEntry(entry) {
+  if (!entry || entry.type !== 'user' || entry.message?.role !== 'user') return '';
+  const c = entry.message.content;
+  if (typeof c === 'string') return c;
+  if (Array.isArray(c)) return c.filter(b => b && b.type === 'text').map(b => b.text || '').join('\n');
+  return '';
+}
+
+function readJsonlHeaderSignals(filePath, stat, {
+  maxBytes = 128 * 1024,
+  maxUserMessages = 5,
+} = {}) {
+  const result = { timestamp: '', rawTimestamp: '', userMessages: [] };
+  let fallbackTimestamp = '';
+  let fd = null;
+  try {
+    const sourcePath = claudeDesktopSessions.sourcePathForStat(filePath);
+    fd = fs.openSync(sourcePath, 'r');
+    const buf = Buffer.alloc(Math.min(stat.size || 0, maxBytes));
+    const bytesRead = fs.readSync(fd, buf, 0, buf.length, 0);
+    const chunk = buf.toString('utf8', 0, bytesRead);
+    const lines = chunk.split('\n');
+    for (const line of lines) {
+      if (!line.trim()) continue;
+      try {
+        const entry = JSON.parse(line);
+        if (!fallbackTimestamp && entry.timestamp) fallbackTimestamp = entry.timestamp;
+        const text = textFromUserEntry(entry);
+        if (text && !isLowSignalIntegrityUserText(text)) {
+          if (!result.timestamp && entry.timestamp) result.timestamp = entry.timestamp;
+          result.userMessages.push(text);
+          if (result.userMessages.length >= maxUserMessages && result.timestamp) break;
+        }
+      } catch {
+        if (!fallbackTimestamp) {
+          const ts = line.match(/"timestamp"\s*:\s*"([^"]+)"/);
+          if (ts) fallbackTimestamp = ts[1];
+        }
+      }
+    }
+  } catch {
+    // Integrity checks are advisory; unreadable files are handled elsewhere.
+  } finally {
+    if (fd !== null) {
+      try { fs.closeSync(fd); } catch {}
+    }
+  }
+  result.rawTimestamp = fallbackTimestamp;
+  if (!result.timestamp) result.timestamp = fallbackTimestamp;
+  return result;
+}
+
+function getJsonlHeaderSignals(file) {
+  if (!file) return { timestamp: '', userMessages: [] };
+  if (!file._headerSignals) file._headerSignals = readJsonlHeaderSignals(file.filePath, file.stat);
+  return file._headerSignals;
+}
+
 /**
  * Run a full integrity check between the sessions DB and JSONL files on disk.
  * Returns an array of issue objects, each with { type, severity, sessionId, details, suggestion }.
@@ -55,9 +156,10 @@ function detectMismatches(db, getAllSessionFiles) {
   const fileIndex = {}; // uuid -> { filePath, stat, projectEntry }
   try {
     for (const { filePath, projectEntry } of getAllSessionFiles()) {
-      const uuid = path.basename(filePath).replace(/\.jsonl(\.bak)?$/, '');
+      const virtual = claudeDesktopSessions.parseVirtualSessionPath(filePath);
+      const uuid = virtual ? virtual.sessionId : path.basename(filePath).replace(/\.jsonl(\.bak)?$/, '');
       try {
-        const stat = fs.statSync(filePath);
+        const stat = fs.statSync(claudeDesktopSessions.sourcePathForStat(filePath));
         fileIndex[uuid] = { filePath, stat, projectEntry };
       } catch {}
     }
@@ -119,21 +221,30 @@ function detectMismatches(db, getAllSessionFiles) {
       }
     }
 
-    // Check 3: Timestamp drift (created_at vs file birthtime)
-    if (row.created_at && file.stat.birthtime) {
-      const dbMs = new Date(row.created_at.replace(' ', 'T') + 'Z').getTime();
-      const fileMs = file.stat.birthtime.getTime();
+    // Check 3: Timestamp drift (created_at vs JSONL timestamp)
+    // Filesystem birthtime is not reliable for Claude JSONL sessions: Dropbox,
+    // restores, rsync/copy, and fresh dev databases can all make birthtime mean
+    // "when this file arrived here", not "when the conversation started".
+    const headerSignals = getJsonlHeaderSignals(file);
+    if (row.created_at && headerSignals.timestamp) {
+      const dbMs = parseDbTimestampMs(row.created_at);
+      const fileMs = new Date(headerSignals.timestamp).getTime();
+      const rawMs = headerSignals.rawTimestamp ? new Date(headerSignals.rawTimestamp).getTime() : NaN;
       const drift = Math.abs(dbMs - fileMs);
-      if (drift > 300000) { // >5 minutes off
+      const rawDrift = Math.abs(dbMs - rawMs);
+      const matchesRawStart = Number.isFinite(rawMs) && rawDrift <= 300000;
+      if (Number.isFinite(dbMs) && Number.isFinite(fileMs) && drift > 300000 && !matchesRawStart) { // >5 minutes off
         issues.push({
           type: 'timestamp_drift', severity: 'info', sessionId: sid,
           details: {
             file_id: expectedFileId,
             db_created_at: row.created_at,
-            file_birthtime: file.stat.birthtime.toISOString(),
+            file_created_at: dbTimestampFromIso(headerSignals.timestamp),
+            file_timestamp: headerSignals.timestamp,
+            raw_file_timestamp: headerSignals.rawTimestamp || '',
             drift_seconds: Math.round(drift / 1000),
           },
-          suggestion: 'Timestamps are significantly off — may indicate wrong file mapping.',
+          suggestion: 'DB created_at differs from the JSONL conversation timestamp.',
         });
       }
     }
@@ -151,7 +262,7 @@ function detectMismatches(db, getAllSessionFiles) {
           // Prefix-copy rescue: if candidate's JSONL prefix contains a known
           // sibling sessionId, treat as lineage and skip.
           let prefixRescue = false;
-          if (row.jsonl_path && fs.existsSync(row.jsonl_path)) {
+          if (row.jsonl_path && !claudeDesktopSessions.isVirtualSessionPath(row.jsonl_path) && fs.existsSync(row.jsonl_path)) {
             const known = knownAgentIdsForTab(db, row.id);
             const prefixIds = readPrefixSessionIds(row.jsonl_path);
             for (const pid of prefixIds) {
@@ -176,7 +287,7 @@ function detectMismatches(db, getAllSessionFiles) {
         // Backward-compat: slug empty in DB. Try reading the JSONL directly
         // so we don't miss the detection just because backfill hasn't caught up.
         const canonical = canonicalSlugForTab(db, row.id);
-        if (canonical && fs.existsSync(row.jsonl_path)) {
+        if (canonical && !claudeDesktopSessions.isVirtualSessionPath(row.jsonl_path) && fs.existsSync(row.jsonl_path)) {
           const hdr = readFirstSlug(row.jsonl_path);
           if (hdr && hdr.slug && hdr.slug !== canonical) {
             const known = knownAgentIdsForTab(db, row.id);
@@ -209,42 +320,24 @@ function detectMismatches(db, getAllSessionFiles) {
     // the mapping is likely wrong.
     if (row.first_message && row.first_message.length > 20) {
       try {
-        const fd = fs.openSync(file.filePath, 'r');
-        const buf = Buffer.alloc(Math.min(file.stat.size, 32768));
-        const bytesRead = fs.readSync(fd, buf, 0, buf.length, 0);
-        fs.closeSync(fd);
-        const chunk = buf.toString('utf8', 0, bytesRead);
-        const lines = chunk.split('\n');
-        let fileFirstMsg = '';
-        for (const line of lines) {
-          if (!line.trim()) continue;
-          try {
-            const entry = JSON.parse(line);
-            if (entry.type === 'user' && entry.message?.role === 'user') {
-              const c = entry.message.content;
-              fileFirstMsg = typeof c === 'string' ? c
-                : Array.isArray(c) ? (c.find(b => b.type === 'text')?.text || '') : '';
-              if (fileFirstMsg) break;
-            }
-          } catch {}
-        }
-        if (fileFirstMsg && fileFirstMsg.length > 20) {
-          // Compare using word overlap — strip common boilerplate
-          const normalize = (s) => s.replace(/<[^>]+>/g, ' ').replace(/[^a-zA-Z0-9\s]/g, ' ').toLowerCase().split(/\s+/).filter(w => w.length > 3);
-          const dbWords = new Set(normalize(row.first_message));
-          const fileWords = new Set(normalize(fileFirstMsg));
-          if (dbWords.size > 3 && fileWords.size > 3) {
-            let overlap = 0;
-            for (const w of dbWords) if (fileWords.has(w)) overlap++;
-            const similarity = overlap / Math.min(dbWords.size, fileWords.size);
-            if (similarity < 0.1) { // <10% word overlap = likely wrong mapping
+        const fileUserMessages = getJsonlHeaderSignals(file).userMessages
+          .filter(m => m && m.length > 20)
+          .slice(0, 5);
+        if (fileUserMessages.length > 0) {
+          const similarities = fileUserMessages
+            .map(m => ({ text: m, score: wordSimilarity(row.first_message, m) }))
+            .filter(s => s.score !== null);
+          if (similarities.length > 0) {
+            similarities.sort((a, b) => b.score - a.score);
+            const best = similarities[0];
+            if (best.score < 0.1) { // <10% word overlap = likely wrong mapping
               issues.push({
                 type: 'wrong_mapping', severity: 'error', sessionId: sid,
                 details: {
                   file_id: expectedFileId,
                   db_first_message: row.first_message.slice(0, 100),
-                  file_first_message: fileFirstMsg.slice(0, 100),
-                  word_similarity: Math.round(similarity * 100) + '%',
+                  file_first_message: best.text.slice(0, 100),
+                  word_similarity: Math.round(best.score * 100) + '%',
                 },
                 suggestion: 'Content mismatch — DB row may be linked to wrong JSONL file.',
               });
@@ -346,9 +439,10 @@ function recoverMismatches(db, issues, getAllSessionFiles) {
   const fileIndex = {};
   try {
     for (const { filePath, projectEntry } of getAllSessionFiles()) {
-      const uuid = path.basename(filePath).replace(/\.jsonl(\.bak)?$/, '');
+      const virtual = claudeDesktopSessions.parseVirtualSessionPath(filePath);
+      const uuid = virtual ? virtual.sessionId : path.basename(filePath).replace(/\.jsonl(\.bak)?$/, '');
       try {
-        const stat = fs.statSync(filePath);
+        const stat = fs.statSync(claudeDesktopSessions.sourcePathForStat(filePath));
         fileIndex[uuid] = { filePath, stat, projectEntry };
       } catch {}
     }
@@ -425,12 +519,12 @@ function recoverMismatches(db, issues, getAllSessionFiles) {
       }
 
       case 'timestamp_drift': {
-        // Fix timestamp from file birthtime
-        const fileId = issue.details.file_id;
-        const file = fileIndex[fileId];
-        if (!file) { result.skipped++; break; }
+        // Fix timestamp from JSONL timestamp. Do not use filesystem birthtime:
+        // it changes under copy/sync/restore and caused fresh dev DBs to
+        // rewrite conversation chronology to the wrong date.
+        const ts = issue.details?.file_created_at;
+        if (!ts) { result.skipped++; break; }
         try {
-          const ts = file.stat.birthtime.toISOString().replace('T', ' ').replace(/\.\d+Z$/, '');
           db.prepare('UPDATE ctm_sessions SET created_at = ?, updated_at = datetime(\'now\') WHERE id = ?')
             .run(ts, issue.sessionId);
           result.fixed++;
@@ -531,7 +625,7 @@ function recoverMismatches(db, issues, getAllSessionFiles) {
             if (stRow && stRow.agent_session_id === badAgent) {
               db.prepare('UPDATE startup_tasks SET agent_session_id = ? WHERE ctm_session_id = ?').run(rescue.agent_session_id, ctmId);
             }
-            if (badRow && badRow.jsonl_path && fs.existsSync(badRow.jsonl_path)) {
+            if (badRow && badRow.jsonl_path && fs.existsSync(claudeDesktopSessions.sourcePathForStat(badRow.jsonl_path))) {
               const existingCtm = db.prepare('SELECT id FROM ctm_sessions WHERE id = ?').get(badAgent);
               if (!existingCtm) {
                 db.prepare("INSERT OR IGNORE INTO ctm_sessions (id, provider, created_at, updated_at) VALUES (?, 'claude', datetime('now'), datetime('now'))").run(badAgent);
@@ -564,6 +658,34 @@ function recoverMismatches(db, issues, getAllSessionFiles) {
 
 // --- Telemetry Reporting ---
 
+const INTEGRITY_ISSUE_TELEMETRY_TTL_MS = 60 * 60 * 1000;
+const _lastIntegrityIssueTelemetry = new Map();
+
+function integrityIssueTelemetryKey(issue) {
+  const details = issue && issue.details && typeof issue.details === 'object'
+    ? Object.keys(issue.details).sort().map(k => `${k}:${String(issue.details[k]).slice(0, 80)}`).join('|')
+    : String(issue?.details || '');
+  return [
+    issue?.type || 'unknown',
+    issue?.severity || 'unknown',
+    issue?.sessionId || '',
+    details,
+  ].join(':');
+}
+
+function shouldReportIntegrityIssue(issue, now = Date.now()) {
+  const key = integrityIssueTelemetryKey(issue);
+  const last = _lastIntegrityIssueTelemetry.get(key) || 0;
+  if (now - last < INTEGRITY_ISSUE_TELEMETRY_TTL_MS) return false;
+  _lastIntegrityIssueTelemetry.set(key, now);
+  if (_lastIntegrityIssueTelemetry.size > 1000) {
+    for (const [k, ts] of _lastIntegrityIssueTelemetry) {
+      if (now - ts > INTEGRITY_ISSUE_TELEMETRY_TTL_MS) _lastIntegrityIssueTelemetry.delete(k);
+    }
+  }
+  return true;
+}
+
 /**
  * Report integrity check results to telemetry with full debug context.
  */
@@ -588,7 +710,7 @@ function reportToTelemetry(telemetry, issues, recovery) {
 
   // Detail events for errors and warnings (not info — too noisy)
   const serious = issues.filter(i => i.severity === 'error' || i.severity === 'critical');
-  for (const issue of serious.slice(0, 20)) { // Cap to prevent flood
+  for (const issue of serious.filter(issue => shouldReportIntegrityIssue(issue)).slice(0, 20)) { // Cap to prevent flood
     telemetry.track('session_integrity_issue', {
       type: issue.type,
       severity: issue.severity,
@@ -659,8 +781,13 @@ function runIntegrityCheck(opts) {
   const issues = detectMismatches(db, getAllSessionFiles);
 
   let recovery = null;
-  if (autoRecover && issues.some(i => i.severity !== 'info')) {
-    recovery = recoverMismatches(db, issues, getAllSessionFiles);
+  if (autoRecover) {
+    const recoverable = issues.filter(i =>
+      i.severity !== 'info' || i.type === 'stale_metadata' || i.type === 'timestamp_drift'
+    );
+    if (recoverable.length > 0) {
+      recovery = recoverMismatches(db, recoverable, getAllSessionFiles);
+    }
   }
 
   // Additionally run the relink audit to surface tab↔JSONL cross-contamination.

package/template/claude-task-manager/session-utils.js

@@ -2,6 +2,8 @@
 const fs = require('fs');
 const path = require('path');
 const os = require('os');
+const walleTranscript = require('./lib/walle-transcript');
+const claudeDesktopSessions = require('./lib/claude-desktop-sessions');
 
 function decodeProjectEntry(entry) {
   if (!entry.startsWith('-')) return entry;
@@ -23,7 +25,70 @@ function decodeProjectEntry(entry) {
   return solve(1, '/' + parts[0]) || '/' + parts.join('/');
 }
 
+function inferModelProvider(modelId) {
+  if (!modelId || modelId.startsWith('<')) return '';
+  if (modelId.startsWith('claude-')) return 'anthropic';
+  if (modelId.startsWith('codex-')) return 'openai';
+  if (modelId.startsWith('gemini-')) return 'google';
+  if (modelId.startsWith('gpt-') || modelId.startsWith('o1-') || modelId.startsWith('o3-') || modelId.startsWith('o4-')) return 'openai';
+  if (modelId.startsWith('deepseek-')) return 'deepseek';
+  return 'unknown';
+}
+
+function messageText(messageOrContent) {
+  if (!messageOrContent) return '';
+  const content = messageOrContent.content !== undefined ? messageOrContent.content : messageOrContent;
+  return walleTranscript.extractText(content);
+}
+
+function pushWalleSessionFiles(results) {
+  const sessionsDir = walleTranscript.defaultSessionsDir(process.env);
+  let files;
+  try { files = fs.readdirSync(sessionsDir); } catch { return; }
+  const fileSet = new Set(files);
+  for (const file of files) {
+    if (!file.endsWith('.jsonl') && !file.endsWith('.jsonl.bak')) continue;
+    if (file.endsWith('.jsonl.bak') && fileSet.has(file.replace(/\.bak$/, ''))) continue;
+    const filePath = path.join(sessionsDir, file);
+    let stat;
+    try { stat = fs.statSync(filePath); } catch { continue; }
+    if (!stat.isFile()) continue;
+    results.push({
+      filePath,
+      projectPath: sessionsDir,
+      projectEntry: walleTranscript.WALLE_PROJECT_ENTRY,
+      sessionId: file.replace(/\.jsonl(\.bak)?$/, ''),
+    });
+  }
+}
+
+async function pushWalleSessionFilesAsync(results) {
+  const sessionsDir = walleTranscript.defaultSessionsDir(process.env);
+  let files;
+  try { files = await fsp.readdir(sessionsDir); } catch { return; }
+  const fileSet = new Set(files);
+  for (const file of files) {
+    if (!file.endsWith('.jsonl') && !file.endsWith('.jsonl.bak')) continue;
+    if (file.endsWith('.jsonl.bak') && fileSet.has(file.replace(/\.bak$/, ''))) continue;
+    const filePath = path.join(sessionsDir, file);
+    let stat;
+    try { stat = await fsp.stat(filePath); } catch { continue; }
+    if (!stat.isFile()) continue;
+    results.push({
+      filePath,
+      projectPath: sessionsDir,
+      projectEntry: walleTranscript.WALLE_PROJECT_ENTRY,
+      sessionId: file.replace(/\.jsonl(\.bak)?$/, ''),
+    });
+  }
+}
+
 function parseSessionFile(filePath, projectPath, projectEntry) {
+  if (projectEntry === claudeDesktopSessions.DESKTOP_PROJECT_ENTRY ||
+      claudeDesktopSessions.isVirtualSessionPath(filePath)) {
+    return claudeDesktopSessions.parseSessionFile(filePath, projectPath, projectEntry);
+  }
+
   const fileStat = fs.statSync(filePath);
   const modifiedAt = fileStat.mtime.toISOString();
   const sessionId = path.basename(filePath).replace(/\.jsonl(\.bak)?$/, '');
@@ -50,6 +115,7 @@ function parseSessionFile(filePath, projectPath, projectEntry) {
   let allUserMessages = [];
   let modelId = '';
   let modelProvider = '';
+  let agent = 'claude';
 
   // Claude Code users can issue `/rename Foo bar` as a user message to
   // re-label the session. Upstream claude-code-history-viewer uses this
@@ -59,26 +125,28 @@ function parseSessionFile(filePath, projectPath, projectEntry) {
   for (const line of lines) {
     try {
       const entry = JSON.parse(line);
+      const isWalle = entry.provider === 'walle' || entry.type === 'walle_part';
+      if (isWalle) agent = 'walle';
+      if (entry.type === 'session_meta' && isWalle) {
+        sessionCwd = entry.cwd || sessionCwd;
+        timestamp = entry.timestamp || timestamp;
+        version = entry.version || version;
+        gitBranch = entry.gitBranch || gitBranch;
+        if (!modelId && entry.modelId) modelId = entry.modelId;
+        if (!modelProvider && entry.modelProvider) modelProvider = entry.modelProvider;
+        continue;
+      }
       // Capture slug from any row that has it (Claude Code writes it on most rows).
       // slug is the conversation-level identifier that persists across --resume boundaries.
       if (!slug && typeof entry.slug === 'string' && entry.slug) slug = entry.slug;
       // Extract model from assistant entries (JSONL has "model" inside entry.message)
-      const entryModel = entry.message?.model || entry.model;
+      const entryModel = entry.message?.model || entry.model || entry.modelId;
       if (!modelId && entryModel && !entryModel.startsWith('<')) {
         modelId = entryModel;
-        if (modelId.startsWith('claude-')) modelProvider = 'anthropic';
-        else if (modelId.startsWith('codex-')) modelProvider = 'openai';
-        else if (modelId.startsWith('gemini-')) modelProvider = 'google';
-        else if (modelId.startsWith('gpt-') || modelId.startsWith('o1-') || modelId.startsWith('o3-') || modelId.startsWith('o4-')) modelProvider = 'openai';
-        else modelProvider = 'unknown';
+        modelProvider = entry.modelProvider || inferModelProvider(modelId);
       }
       if (entry.type === 'user' && entry.message?.role === 'user') {
-        const content = entry.message.content;
-        const text = typeof content === 'string'
-          ? content
-          : Array.isArray(content)
-            ? (content.find(c => c.type === 'text')?.text || '')
-            : '';
+        const text = messageText(entry.message);
         userMsgCount++;
         if (text) {
           allUserMessages.push(text.slice(0, 200));
@@ -98,18 +166,27 @@ function parseSessionFile(filePath, projectPath, projectEntry) {
           version = entry.version || version;
           gitBranch = entry.gitBranch || gitBranch;
         }
+      } else if (entry.type === 'user' && entry.provider === 'walle' && typeof entry.content === 'string') {
+        const text = entry.content;
+        userMsgCount++;
+        if (text) {
+          allUserMessages.push(text.slice(0, 200));
+          lastUserContent = text.slice(0, 200);
+        }
+        if (!firstUserMessage && text) {
+          firstUserMessage = text.slice(0, 200);
+          sessionCwd = entry.cwd || sessionCwd;
+          timestamp = entry.timestamp || timestamp;
+          version = entry.version || version;
+          gitBranch = entry.gitBranch || gitBranch;
+        }
       } else if (entry.type === 'assistant' && entry.message?.role === 'assistant') {
         if (!firstAssistantText) {
-          const content = entry.message.content;
-          if (Array.isArray(content)) {
-            for (const block of content) {
-              if (block.type === 'text' && block.text) {
-                firstAssistantText = block.text.slice(0, 200);
-                break;
-              }
-            }
-          }
+          const text = messageText(entry.message);
+          if (text) firstAssistantText = text.slice(0, 200);
         }
+      } else if (entry.type === 'assistant' && entry.provider === 'walle' && typeof entry.content === 'string') {
+        if (!firstAssistantText && entry.content) firstAssistantText = entry.content.slice(0, 200);
       }
     } catch {
       // JSON.parse failed — line may be truncated (e.g. 1MB+ image block cut off
@@ -169,6 +246,9 @@ function parseSessionFile(filePath, projectPath, projectEntry) {
     hostname: os.hostname(),
     modelId,
     modelProvider,
+    model: modelId,
+    agent,
+    jsonlPath: filePath,
   };
 }
 
@@ -176,26 +256,28 @@ function getAllSessionFiles() {
   const claudeProjectsDir = path.join(process.env.HOME, '.claude', 'projects');
   const results = [];
 
-  if (!fs.existsSync(claudeProjectsDir)) return results;
-
-  for (const projectEntry of fs.readdirSync(claudeProjectsDir)) {
-    const projectDir = path.join(claudeProjectsDir, projectEntry);
-    let stat;
-    try { stat = fs.statSync(projectDir); } catch { continue; }
-    if (!stat.isDirectory()) continue;
+  if (fs.existsSync(claudeProjectsDir)) {
+    for (const projectEntry of fs.readdirSync(claudeProjectsDir)) {
+      const projectDir = path.join(claudeProjectsDir, projectEntry);
+      let stat;
+      try { stat = fs.statSync(projectDir); } catch { continue; }
+      if (!stat.isDirectory()) continue;
 
-    const projectPath = decodeProjectEntry(projectEntry);
-    let files;
-    try { files = fs.readdirSync(projectDir); } catch { continue; }
+      const projectPath = decodeProjectEntry(projectEntry);
+      let files;
+      try { files = fs.readdirSync(projectDir); } catch { continue; }
 
-    const fileSet = new Set(files);
-    for (const file of files) {
-      if (!file.endsWith('.jsonl') && !file.endsWith('.jsonl.bak')) continue;
-      if (file.endsWith('.jsonl.bak') && fileSet.has(file.replace(/\.bak$/, ''))) continue;
-      const filePath = path.join(projectDir, file);
-      results.push({ filePath, projectPath, projectEntry });
+      const fileSet = new Set(files);
+      for (const file of files) {
+        if (!file.endsWith('.jsonl') && !file.endsWith('.jsonl.bak')) continue;
+        if (file.endsWith('.jsonl.bak') && fileSet.has(file.replace(/\.bak$/, ''))) continue;
+        const filePath = path.join(projectDir, file);
+        results.push({ filePath, projectPath, projectEntry, sessionId: file.replace(/\.jsonl(\.bak)?$/, '') });
+      }
     }
   }
+  pushWalleSessionFiles(results);
+  for (const entry of claudeDesktopSessions.listSessionFileEntries()) results.push(entry);
   return results;
 }
 
@@ -206,10 +288,8 @@ async function getAllSessionFilesAsync() {
   const claudeProjectsDir = path.join(process.env.HOME, '.claude', 'projects');
   const results = [];
 
-  try { await fsp.access(claudeProjectsDir); } catch { return results; }
-
   let projectEntries;
-  try { projectEntries = await fsp.readdir(claudeProjectsDir); } catch { return results; }
+  try { projectEntries = await fsp.readdir(claudeProjectsDir); } catch { projectEntries = []; }
 
   for (const projectEntry of projectEntries) {
     const projectDir = path.join(claudeProjectsDir, projectEntry);
@@ -226,9 +306,11 @@ async function getAllSessionFilesAsync() {
       if (!file.endsWith('.jsonl') && !file.endsWith('.jsonl.bak')) continue;
       if (file.endsWith('.jsonl.bak') && fileSet.has(file.replace(/\.bak$/, ''))) continue;
       const filePath = path.join(projectDir, file);
-      results.push({ filePath, projectPath, projectEntry });
+      results.push({ filePath, projectPath, projectEntry, sessionId: file.replace(/\.jsonl(\.bak)?$/, '') });
     }
   }
+  await pushWalleSessionFilesAsync(results);
+  for (const entry of claudeDesktopSessions.listSessionFileEntries()) results.push(entry);
   return results;
 }
 

package/template/claude-task-manager/workers/state-detectors/codex.js

@@ -11,9 +11,12 @@
 const { baseDetector, stripAnsi } = require('./base');
 
 const CODEX_STATUS_FRAGMENT_RE = /^[\s\d•◦·∙●○WwOoRrKkIiNnGg]+$/u;
+const CODEX_BUSY_STATUS_LINE_RE = /^(?:working(?:\s*\([^)]*\))?(?:\s*[•◦·∙●○]\s*esc\s+to\s+interrupt)?|(?:working\s*)?esc\s+to\s+interrupt)$/iu;
 const CODEX_BUSY_WORD = 'working';
+const CODEX_BUSY_HINT_RE = /esc\s+to\s+interrupt/i;
 
 function hasCodexBusyStatusFragment(text) {
+  if (CODEX_BUSY_HINT_RE.test(String(text || ''))) return true;
   const letters = String(text || '').toLowerCase().replace(/[^a-z]/g, '');
   if (letters.length < 3) return false;
   if (letters.includes(CODEX_BUSY_WORD)) return true;
@@ -35,8 +38,8 @@ function isCursorAddressedRedraw(data) {
 function isCodexStatusRedraw(data) {
   const stripped = stripAnsi(data).trim();
   return (
-    stripped.length <= 80 &&
-    CODEX_STATUS_FRAGMENT_RE.test(stripped) &&
+    stripped.length <= 160 &&
+    (CODEX_STATUS_FRAGMENT_RE.test(stripped) || CODEX_BUSY_STATUS_LINE_RE.test(stripped)) &&
     isCursorAddressedRedraw(data)
   );
 }

package/template/package.json

@@ -1,6 +1,6 @@
 {
   "name": "walle",
-  "version": "0.9.11",
+  "version": "0.9.13",
   "private": true,
   "description": "Wall-E — your personal digital twin",
   "scripts": {