create-walle 0.9.13 → 0.9.15

package/template/claude-task-manager/public/js/message-renderer.js

@@ -15,13 +15,16 @@
  *   - classifyMessage(m, stripped, isToolOnly) — 'key'|'normal'|'self-thought'|'summary'
  *   - renderReviewMsg(m, i, msgType?)   — Review row HTML string
  *   - renderSelfThoughtMsg(m, i, stripped) — single-self-thought collapsed group HTML
- *   - renderSelfThoughtItem(m, i, stripped) — inner item inside a multi-step thought-group
- *   - groupMessages(messages)           — pre-render grouping for Review
- *   - renderGroup(g)                    — render one group from groupMessages
- *   - _buildCollapsible(label, color, preview, bodyEl) — Conversation tab DOM helper
- *   - renderConversationEvent(evt)      — Conversation row DOM element
- *   - refreshConversationActivityGroup(group) — recompute grouped tool UI
- *
+	 *   - renderSelfThoughtItem(m, i, stripped) — inner item inside a multi-step thought-group
+	 *   - groupMessages(messages)           — pre-render grouping for Review
+	 *   - renderGroup(g)                    — render one group from groupMessages
+	 *   - groupMessagesIntoTurns(messages)  — user prompt + nested response groups
+	 *   - renderReviewTurn(turn)            — Review turn HTML string
+	 *   - _buildCollapsible(label, color, preview, bodyEl) — Conversation tab DOM helper
+	 *   - renderConversationEvent(evt)      — Conversation row DOM element
+	 *   - createConversationTurn(evt, opts) — Conversation prompt-turn DOM
+	 *   - refreshConversationActivityGroup(group) — recompute grouped tool UI
+	 *
  * Depends on global escHtml (defined in index.html). Since the renderer
  * functions are only invoked AFTER the page's body scripts run, escHtml
  * is available at call time even though message-renderer.js loads first.
@@ -219,10 +222,161 @@
     return parts.slice(0, max).join(' · ') + ` · +${parts.length - max}`;
   }
 
-  function _previewFromText(text, max = 90) {
-    const s = String(text || '').replace(/\n/g, ' ').trim();
-    return s.length > max ? s.slice(0, max) + '…' : s;
-  }
+	  function _previewFromText(text, max = 90) {
+	    const s = String(text || '').replace(/\n/g, ' ').trim();
+	    return s.length > max ? s.slice(0, max) + '…' : s;
+	  }
+
+	  function _stripToolTokens(text) {
+	    return String(text || '').replace(/\[Tool(?: result)?:\s*[^\]]+\]/g, '').trim();
+	  }
+
+	  function _messageItem(m, i) {
+	    const text = String(m && m.text || '');
+	    const stripped = _stripToolTokens(text);
+	    const isToolOnly = stripped.length === 0 && /\[Tool: /.test(text);
+	    const msgType = MR.classifyMessage(m || {}, stripped, isToolOnly);
+	    return { m: m || { role: 'system', text: '' }, i, msgType, stripped, isToolOnly };
+	  }
+
+	  function _isPromptItem(item) {
+	    if (!item || !item.m || item.m.role !== 'user') return false;
+	    const text = String(item.m.text || '').trim();
+	    if (!text && item.msgType !== 'command') return false;
+	    return item.msgType === 'key' || item.msgType === 'command';
+	  }
+
+	  function _turnResponseItems(turn) {
+	    return (turn && turn.responses ? turn.responses : []).map(item => {
+	      const copy = Object.assign({}, item.m);
+	      copy._reviewIdx = item.i;
+	      return copy;
+	    });
+	  }
+
+	  function _turnCounts(turn) {
+	    const responses = turn.responses || [];
+	    let assistant = 0;
+	    let tools = 0;
+	    let detail = 0;
+	    for (const item of responses) {
+	      if (item.m.role === 'assistant') assistant++;
+	      tools += _toolNamesFromText(item.m.text).length;
+	      if (item.msgType === 'self-thought' || item.msgType === 'skill-body' || item.msgType === 'local-cmd' || item.msgType === 'summary') detail++;
+	    }
+	    return { assistant, tools, detail, total: responses.length };
+	  }
+
+	  function _turnAlert(turn) {
+	    const text = (turn.responses || [])
+	      .map(item => String(item.m && item.m.text || ''))
+	      .join('\n')
+	      .toLowerCase();
+	    if (/(traceback|uncaught|syntaxerror|typeerror|referenceerror|exit code 1|permission denied|merge conflict|blocked|blocker|failed|failure|error:)/.test(text)) {
+	      return { level: 'error', label: 'attention' };
+	    }
+	    if (/(warning:|warned|warns|timed out|timeout|needs user|requires approval|denied)/.test(text)) {
+	      return { level: 'warning', label: 'warning' };
+	    }
+	    return null;
+	  }
+
+	  function _turnMetaHtml(turn) {
+	    const counts = _turnCounts(turn);
+	    const badges = [];
+	    if (counts.assistant) badges.push(counts.assistant + ' repl' + (counts.assistant === 1 ? 'y' : 'ies'));
+	    if (counts.tools) badges.push(counts.tools + ' tool' + (counts.tools === 1 ? '' : 's'));
+	    if (counts.detail) badges.push(counts.detail + ' detail' + (counts.detail === 1 ? '' : 's'));
+	    if (!counts.total && turn.type !== 'setup') badges.push('no response yet');
+	    const alert = _turnAlert(turn);
+	    if (alert) badges.push('<span class="prompt-turn-badge prompt-turn-alert ' + alert.level + '">' + escHtml(alert.label) + '</span>');
+	    return badges.map(b => {
+	      if (String(b).indexOf('<span') === 0) return b;
+	      return '<span class="prompt-turn-badge">' + escHtml(b) + '</span>';
+	    }).join('');
+	  }
+
+	  function _renderPromptBlock(item, turn) {
+	    const m = item.m || {};
+	    const time = m.timestamp ? new Date(m.timestamp).toLocaleString() : '';
+	    const cmd = item.msgType === 'command' ? MR.parseCommandInvocation(m.text) : null;
+	    const bodyHtml = cmd
+	      ? (cmd.args ? MR.formatMsgText(cmd.args) : '<span class="msg-empty">(no arguments)</span>')
+	      : MR.formatMsgText(m.text || '');
+	    const badge = cmd ? '<span class="msg-cmd-badge" title="Slash command">/' + escHtml(cmd.name) + '</span>' : '';
+	    const parentUuid = m.parentUuid ? ' data-parent-uuid="' + escHtml(m.parentUuid) + '"' : '';
+	    return '<div class="review-msg user key-msg prompt-turn-prompt"' + parentUuid + '>'
+	      + '<div class="msg-header">'
+	      + '<span class="msg-role">You</span>'
+	      + badge
+	      + '<span class="msg-time">' + escHtml(time) + '</span>'
+	      + '</div>'
+	      + '<div class="msg-text" data-msg-idx="' + item.i + '">' + bodyHtml + '</div>'
+	      + '</div>';
+	  }
+
+	  function _turnId(turn, idx) {
+	    if (turn.type === 'setup') return 'setup';
+	    const promptIdx = turn.prompt ? turn.prompt.i : idx;
+	    return 'prompt-' + promptIdx;
+	  }
+
+	  MR.groupMessagesIntoTurns = function (messages) {
+	    const turns = [];
+	    let current = null;
+	    let setup = null;
+	    const ensureSetup = () => {
+	      if (!setup) setup = { type: 'setup', prompt: null, responses: [], startIndex: -1, endIndex: -1 };
+	      return setup;
+	    };
+	    (messages || []).forEach((m, i) => {
+	      const item = _messageItem(m, i);
+	      if (_isPromptItem(item)) {
+	        if (current) turns.push(current);
+	        current = { type: 'prompt', prompt: item, responses: [], startIndex: i, endIndex: i };
+	        return;
+	      }
+	      const target = current || ensureSetup();
+	      if (target.startIndex < 0) target.startIndex = i;
+	      target.responses.push(item);
+	      target.endIndex = i;
+	    });
+	    if (current) turns.push(current);
+	    if (setup && setup.responses.length) turns.unshift(setup);
+	    return turns;
+	  };
+
+	  MR.renderReviewTurn = function (turn, idx, opts) {
+	    opts = opts || {};
+	    const id = _turnId(turn, idx);
+	    const expanded = !!opts.expanded;
+	    const typeClass = turn.type === 'setup' ? ' setup-turn' : '';
+	    const promptIdx = turn.prompt ? turn.prompt.i : '';
+	    const parentUuid = turn.prompt && turn.prompt.m && turn.prompt.m.parentUuid
+	      ? ' data-parent-uuid="' + escHtml(turn.prompt.m.parentUuid) + '"'
+	      : '';
+	    const promptHtml = turn.type === 'setup'
+	      ? '<div class="prompt-turn-setup-title">Session setup and context</div>'
+	      : _renderPromptBlock(turn.prompt, turn);
+	    const responseMessages = _turnResponseItems(turn);
+	    const responseHtml = responseMessages.length
+	      ? MR.groupMessages(responseMessages).map(MR.renderGroup).join('')
+	      : '<div class="prompt-turn-empty">No agent response recorded yet.</div>';
+	    return '<section class="prompt-turn' + typeClass + (expanded ? ' expanded' : '') + '" data-turn-id="' + escHtml(id) + '" data-msg-idx="' + escHtml(String(promptIdx)) + '"' + parentUuid + '>'
+	      + '<div class="prompt-turn-header" role="button" tabindex="0" aria-expanded="' + (expanded ? 'true' : 'false') + '">'
+	      + '<span class="prompt-turn-chevron">▶</span>'
+	      + '<div class="prompt-turn-head-main">' + promptHtml + '</div>'
+	      + '<div class="prompt-turn-meta">' + _turnMetaHtml(turn) + '</div>'
+	      + '</div>'
+	      + '<div class="prompt-turn-response">'
+	      + responseHtml
+	      + '</div>'
+	      + '</section>';
+	  };
+
+	  MR.renderReviewTurns = function (messages, opts) {
+	    return MR.groupMessagesIntoTurns(messages).map((turn, idx) => MR.renderReviewTurn(turn, idx, opts)).join('');
+	  };
 
   // ------------------------------------------------------------------
   // Review-page renderers — return HTML strings. The page batches many
@@ -338,30 +492,31 @@
       + '<div class="msg-text">' + textHtml + '</div></div>';
   };
 
-  MR.groupMessages = function (messages) {
-    const groups = [];
-    let i = 0;
-    while (i < messages.length) {
-      const m = messages[i];
-      const stripped = m.text.replace(/\[Tool: [^\]]+\]/g, '').trim();
-      const isToolOnly = stripped.length === 0 && /\[Tool: /.test(m.text);
-      const msgType = MR.classifyMessage(m, stripped, isToolOnly);
+	  MR.groupMessages = function (messages) {
+	    const groups = [];
+	    let i = 0;
+	    while (i < messages.length) {
+	      const m = messages[i];
+	      const idx = typeof m._reviewIdx === 'number' ? m._reviewIdx : i;
+	      const stripped = m.text.replace(/\[Tool: [^\]]+\]/g, '').trim();
+	      const isToolOnly = stripped.length === 0 && /\[Tool: /.test(m.text);
+	      const msgType = MR.classifyMessage(m, stripped, isToolOnly);
 
       if (msgType === 'self-thought') {
         const groupItems = [];
         while (i < messages.length) {
           const gm = messages[i];
-          const gs = gm.text.replace(/\[Tool: [^\]]+\]/g, '').trim();
-          const gto = gs.length === 0 && /\[Tool: /.test(gm.text);
-          if (MR.classifyMessage(gm, gs, gto) !== 'self-thought') break;
-          groupItems.push({ m: gm, i: i, stripped: gs, isToolOnly: gto });
-          i++;
-        }
-        groups.push({ type: 'thought-group', items: groupItems });
-      } else {
-        groups.push({ type: 'message', m, i, msgType, stripped, isToolOnly });
-        i++;
-      }
+	          const gs = gm.text.replace(/\[Tool: [^\]]+\]/g, '').trim();
+	          const gto = gs.length === 0 && /\[Tool: /.test(gm.text);
+	          if (MR.classifyMessage(gm, gs, gto) !== 'self-thought') break;
+	          groupItems.push({ m: gm, i: typeof gm._reviewIdx === 'number' ? gm._reviewIdx : i, stripped: gs, isToolOnly: gto });
+	          i++;
+	        }
+	        groups.push({ type: 'thought-group', items: groupItems });
+	      } else {
+	        groups.push({ type: 'message', m, i: idx, msgType, stripped, isToolOnly });
+	        i++;
+	      }
     }
     return groups;
   };
@@ -492,9 +647,9 @@
   // `{ type: 'stream-event', data: { type: 'assistant', ... } }`. Look
   // at evt.type first, fall back to evt.data.type.
   const _ROLES = ['user', 'assistant', 'tool_result', 'summary'];
-  MR.renderConversationEvent = function (evt) {
-    const text = (evt.data?.text || '').trim();
-    const toolUses = evt.data?.toolUses || [];
+	  MR.renderConversationEvent = function (evt) {
+	    const text = (evt.data?.text || '').trim();
+	    const toolUses = evt.data?.toolUses || [];
 
     let evType = _ROLES.includes(evt.type) ? evt.type : null;
     if (!evType && _ROLES.includes(evt.data?.type)) evType = evt.data.type;
@@ -849,8 +1004,132 @@
       return div;
     }
 
-    return null;
-  };
+	    return null;
+	  };
+
+	  function _conversationEventType(evt) {
+	    let evType = _ROLES.includes(evt && evt.type) ? evt.type : null;
+	    if (!evType && _ROLES.includes(evt && evt.data && evt.data.type)) evType = evt.data.type;
+	    return evType;
+	  }
+
+	  function _conversationEventText(evt) {
+	    return String(evt && evt.data && evt.data.text || '').trim();
+	  }
+
+	  MR.isConversationPromptEvent = function (evt) {
+	    if (_conversationEventType(evt) !== 'user') return false;
+	    const text = _conversationEventText(evt);
+	    if (!text) return false;
+	    if (MR.parseSkillBody(text) || MR.parseLocalCommand(text)) return false;
+	    return true;
+	  };
+
+	  MR.setPromptTurnExpanded = function (turnEl, expanded) {
+	    if (!turnEl) return;
+	    const has = turnEl.classList && turnEl.classList.contains('expanded');
+	    if (expanded && !has) turnEl.classList.add('expanded');
+	    if (!expanded && has) turnEl.classList.remove('expanded');
+	    const header = turnEl.querySelector('.prompt-turn-header');
+	    if (header) header.setAttribute('aria-expanded', expanded ? 'true' : 'false');
+	  };
+
+	  MR.getPromptTurnBody = function (turnEl) {
+	    return turnEl && turnEl.querySelector ? turnEl.querySelector('.prompt-turn-response') : null;
+	  };
+
+	  MR.refreshPromptTurnMeta = function (turnEl) {
+	    if (!turnEl || !turnEl.querySelector) return;
+	    const body = MR.getPromptTurnBody(turnEl);
+	    const meta = turnEl.querySelector('.prompt-turn-meta');
+	    if (!body || !meta) return;
+	    const children = Array.from(body.children || []).filter(el => !(el.dataset && el.dataset.conversationState));
+	    const responseBlocks = children.filter(el => !(el.classList && el.classList.contains('prompt-turn-empty'))).length;
+	    let toolBlocks = 0;
+	    for (const el of children) {
+	      const cls = String(el.className || '');
+	      if (cls.includes('tool-activity-group') || cls.includes('tool-only') || cls.includes('conv-tool-group')) toolBlocks++;
+	    }
+	    meta.textContent = '';
+	    const appendBadge = (text, cls) => {
+	      const badge = document.createElement('span');
+	      badge.className = 'prompt-turn-badge' + (cls ? ' ' + cls : '');
+	      badge.textContent = text;
+	      meta.appendChild(badge);
+	    };
+	    if (responseBlocks) appendBadge(responseBlocks + ' detail' + (responseBlocks === 1 ? '' : 's'));
+	    else appendBadge('no response yet');
+	    if (toolBlocks) appendBadge(toolBlocks + ' tool block' + (toolBlocks === 1 ? '' : 's'));
+	  };
+
+	  function _wirePromptTurnHeader(turnEl, header) {
+	    if (!turnEl || !header) return;
+	    const toggle = (ev) => {
+	      if (ev && ev.target && ev.target.closest && ev.target.closest('a,button,input,textarea,select')) return;
+	      MR.setPromptTurnExpanded(turnEl, !turnEl.classList.contains('expanded'));
+	    };
+	    header.addEventListener('click', toggle);
+	    header.addEventListener('keydown', (ev) => {
+	      if (ev.key === 'Enter' || ev.key === ' ') {
+	        ev.preventDefault();
+	        toggle(ev);
+	      }
+	    });
+	  }
+
+	  MR.createConversationTurn = function (promptEvt, opts) {
+	    opts = opts || {};
+	    const isSetup = !promptEvt || opts.setup;
+	    const turn = document.createElement('section');
+	    turn.className = 'prompt-turn conversation-turn' + (isSetup ? ' setup-turn' : '');
+	    turn.dataset.turnId = isSetup ? 'setup' : ('prompt-' + (promptEvt.data?.parentUuid || Date.now()));
+	    if (!isSetup && promptEvt.data?.parentUuid) turn.dataset.parentUuid = promptEvt.data.parentUuid;
+
+	    const header = document.createElement('div');
+	    header.className = 'prompt-turn-header';
+	    header.setAttribute('role', 'button');
+	    header.setAttribute('tabindex', '0');
+	    header.setAttribute('aria-expanded', opts.expanded ? 'true' : 'false');
+
+	    const chev = document.createElement('span');
+	    chev.className = 'prompt-turn-chevron';
+	    chev.textContent = '▶';
+	    const main = document.createElement('div');
+	    main.className = 'prompt-turn-head-main';
+	    if (isSetup) {
+	      const setupTitle = document.createElement('div');
+	      setupTitle.className = 'prompt-turn-setup-title';
+	      setupTitle.textContent = opts.setupLabel || 'Session setup and context';
+	      main.appendChild(setupTitle);
+	    } else {
+	      const promptEl = MR.renderConversationEvent(promptEvt);
+	      if (promptEl) {
+	        promptEl.classList.add('prompt-turn-prompt');
+	        main.appendChild(promptEl);
+	      }
+	    }
+	    const meta = document.createElement('div');
+	    meta.className = 'prompt-turn-meta';
+	    header.appendChild(chev);
+	    header.appendChild(main);
+	    header.appendChild(meta);
+
+	    const body = document.createElement('div');
+	    body.className = 'prompt-turn-response';
+	    turn.appendChild(header);
+	    turn.appendChild(body);
+	    _wirePromptTurnHeader(turn, header);
+	    MR.setPromptTurnExpanded(turn, !!opts.expanded);
+	    MR.refreshPromptTurnMeta(turn);
+	    return turn;
+	  };
+
+	  MR.createEmptyConversationTurnBody = function () {
+	    const empty = document.createElement('div');
+	    empty.className = 'prompt-turn-empty';
+	    empty.textContent = 'No agent response recorded yet.';
+	    return empty;
+	  };
 
   // ── DOM builders ─────────────────────────────────────────────────────
 

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

@@ -6,7 +6,11 @@
   if (root) root.SessionSearchUtils = api;
 })(typeof globalThis !== 'undefined' ? globalThis : this, function () {
   function normalizeSearchValue(value) {
-    return String(value || '').trim().toLowerCase();
+    return String(value || '')
+      .trim()
+      .toLowerCase()
+      .replace(/(^|[\s([{])[$/]+(?=[a-z0-9_-])/g, '$1')
+      .replace(/\s+/g, ' ');
   }
 
   function getSearchableSessionIds(session) {
@@ -26,6 +30,112 @@
     return ids;
   }
 
+  function rememberRecentSessionIdentities(index, session) {
+    for (const id of getSearchableSessionIds(session)) index.set(id, session);
+  }
+
+  function findSessionIdentityMatch(index, session) {
+    if (!index || !session) return null;
+    for (const id of getSearchableSessionIds(session)) {
+      const existing = index.get(id);
+      if (existing) return existing;
+    }
+    return null;
+  }
+
+  function createSessionIdentityIndex(sessions) {
+    const index = new Map();
+    for (const session of sessions || []) rememberRecentSessionIdentities(index, session);
+    return index;
+  }
+
+  function isNewerTime(candidate, current) {
+    const candidateMs = Date.parse(String(candidate || ''));
+    if (!Number.isFinite(candidateMs)) return false;
+    const currentMs = Date.parse(String(current || ''));
+    return !Number.isFinite(currentMs) || candidateMs > currentMs;
+  }
+
+  function mergeRecentSessionMetadata(target, source) {
+    if (!target || !source) return target;
+
+    const sourceAgent = getRecentSessionAgentType(source);
+    const targetAgent = getRecentSessionAgentType(target);
+    if (sourceAgent && sourceAgent !== 'shell' && (!target.agent || targetAgent === 'shell')) {
+      target.agent = sourceAgent;
+    }
+
+    for (const field of [
+      'agentType',
+      'provider',
+      'agentSessionId',
+      'provisionalId',
+      'cmd',
+      'launchCommand',
+      'cwd',
+      'project',
+      'projectEntry',
+      'firstMessage',
+      'title',
+      'aiTitle',
+      'displayTitle',
+      'gitBranch',
+      'model',
+      'modelProvider',
+      'timestamp',
+      'version',
+      'jsonlPath',
+    ]) {
+      if (!target[field] && source[field]) target[field] = source[field];
+    }
+
+    if (isNewerTime(source.modifiedAt, target.modifiedAt)) target.modifiedAt = source.modifiedAt;
+    if (isNewerTime(source.fileModifiedAt, target.fileModifiedAt)) target.fileModifiedAt = source.fileModifiedAt;
+    if (source.isEmpty === false && target.isEmpty !== false) target.isEmpty = false;
+    if ((source.userMsgCount || 0) > (target.userMsgCount || 0)) target.userMsgCount = source.userMsgCount;
+    if ((source.fileSize || 0) > (target.fileSize || 0)) target.fileSize = source.fileSize;
+    if (source.starred) target.starred = true;
+    if (source.userRenamed) {
+      const renamedTitle = source.aiTitle || source.displayTitle || source.title || '';
+      if (renamedTitle) {
+        target.aiTitle = renamedTitle;
+        target.title = renamedTitle;
+        target.displayTitle = renamedTitle;
+      }
+      target.userRenamed = true;
+    }
+    return target;
+  }
+
+  function mergeRecentSessionCandidates(recentSessions, additionalSessions) {
+    const merged = (recentSessions || []).map((session) => ({ ...session }));
+    const index = createSessionIdentityIndex(merged);
+    for (const raw of additionalSessions || []) {
+      const candidate = { ...raw };
+      const existing = findSessionIdentityMatch(index, candidate);
+      if (existing) mergeRecentSessionMetadata(existing, candidate);
+      else merged.push(candidate);
+      rememberRecentSessionIdentities(index, existing || candidate);
+    }
+    return merged;
+  }
+
+  function dedupeSessionCandidates(sessions) {
+    const merged = [];
+    const index = new Map();
+    for (const raw of sessions || []) {
+      const candidate = { ...raw };
+      const existing = findSessionIdentityMatch(index, candidate);
+      if (existing) {
+        mergeRecentSessionMetadata(existing, candidate);
+        continue;
+      }
+      merged.push(candidate);
+      rememberRecentSessionIdentities(index, candidate);
+    }
+    return merged;
+  }
+
   function scoreSessionIdMatch(session, query) {
     const normalizedQuery = normalizeSearchValue(query);
     if (!normalizedQuery) return 0;
@@ -78,7 +188,69 @@
   }
 
   function stripWorktreePath(value) {
-    return value ? String(value).replace(/\/\.claude\/worktrees\/[^/]+$/, '') : value;
+    return value ? String(value).replace(/\/\.(?:claude|walle)\/worktrees\/[^/]+$/, '') : value;
+  }
+
+  const AGENT_FILTER_LABELS = {
+    codex: 'Codex',
+    claude: 'Claude Code',
+    walle: 'Wall-E',
+    gemini: 'Gemini CLI',
+    opencode: 'OpenCode',
+    'claude-desktop': 'Claude Desktop',
+    shell: 'Shell / Other',
+  };
+
+  const AGENT_FILTER_ORDER = ['codex', 'claude', 'walle', 'gemini', 'opencode', 'claude-desktop', 'shell'];
+
+  function normalizeRecentAgentType(value) {
+    if (!value) return '';
+    const v = String(value).trim().toLowerCase().replace(/[_\s]+/g, '-');
+    if (!v) return '';
+    if (AGENT_FILTER_LABELS[v]) return v;
+    if (v === 'claude-code' || v === 'claude-cli') return 'claude';
+    if (v === 'anthropic') return 'claude';
+    if (v === 'claude-desktop-session' || v === 'desktop') return 'claude-desktop';
+    if (v === 'wall-e' || v === 'walle-session') return 'walle';
+    if (v === 'gemini-cli') return 'gemini';
+    if (v === 'open-code' || v === 'opencode-cli') return 'opencode';
+    if (v === 'terminal' || v === 'unknown' || v === 'other') return 'shell';
+    return '';
+  }
+
+  function detectRecentAgentTypeFromText(value) {
+    if (!value) return '';
+    const v = String(value).toLowerCase();
+    if (v.includes('opencode') || v.includes('open-code')) return 'opencode';
+    if (v.includes('wall-e') || v.includes('walle')) return 'walle';
+    if (v.includes('codex')) return 'codex';
+    if (v.includes('gemini')) return 'gemini';
+    if (v.includes('claude')) return 'claude';
+    return '';
+  }
+
+  function getRecentSessionAgentType(session) {
+    const s = session || {};
+    for (const candidate of [s.agent, s.agentType, s.provider]) {
+      const explicit = normalizeRecentAgentType(candidate);
+      if (explicit) return explicit;
+    }
+    if (s.meta && (s.meta.type === 'walle' || s.meta.agentType === 'walle')) return 'walle';
+    if (s.type === 'walle') return 'walle';
+
+    const detected = detectRecentAgentTypeFromText(s.cmd || (s.meta && s.meta.cmd) || s.launchCommand || '');
+    return detected || 'shell';
+  }
+
+  function recentAgentFilterLabel(agentType) {
+    const normalized = normalizeRecentAgentType(agentType) || 'shell';
+    return AGENT_FILTER_LABELS[normalized] || AGENT_FILTER_LABELS.shell;
+  }
+
+  function recentAgentFilterPriority(agentType) {
+    const normalized = normalizeRecentAgentType(agentType) || 'shell';
+    const idx = AGENT_FILTER_ORDER.indexOf(normalized);
+    return idx >= 0 ? idx : AGENT_FILTER_ORDER.length;
   }
 
   function sessionPassesRecentSidebarFilters(session, filters) {
@@ -93,7 +265,8 @@
     const project = stripWorktreePath(f.project || '');
     if (project && stripWorktreePath(s.project || s.cwd || '') !== project) return false;
 
-    if (f.model && s.model !== f.model) return false;
+    const agent = normalizeRecentAgentType(f.agent || '');
+    if (agent && getRecentSessionAgentType(s) !== agent) return false;
     return true;
   }
 
@@ -103,9 +276,18 @@
 
   return {
     buildIdMatchResults,
+    createSessionIdentityIndex,
+    dedupeSessionCandidates,
     filterRecentSessionsForSidebar,
+    findSessionIdentityMatch,
+    mergeRecentSessionMetadata,
+    mergeRecentSessionCandidates,
+    getRecentSessionAgentType,
     getSearchableSessionIds,
     normalizeSearchValue,
+    normalizeRecentAgentType,
+    recentAgentFilterLabel,
+    recentAgentFilterPriority,
     scoreSessionIdMatch,
     sessionPassesRecentSidebarFilters,
     sessionMatchesRecentSearchQuery,