create-walle 0.9.21 → 0.9.23

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

@@ -6,7 +6,7 @@
   if (root) root.SessionActivityUtils = api;
 })(typeof globalThis !== 'undefined' ? globalThis : this, function () {
   const ACTIVE_ACTIVITY_BUCKET_MS = 10 * 60 * 1000;
-  const ACTIVE_STATUS_RANK = { running: 0, waiting: 1, idle: 2, exited: 3 };
+  const ACTIVE_STATUS_RANK = { running: 0, resuming: 1, waiting: 2, idle: 3, exited: 4 };
   const OBSERVED_TIME_FUTURE_SKEW_MS = 60 * 1000;
 
   function parseTimeMs(value) {
@@ -74,6 +74,9 @@
   function recentSessionUpdatedValue(session, now = Date.now()) {
     const meta = sessionMeta(session);
     const durableValues = [
+      meta.lastMessageAt,
+      meta.lastActivityAt,
+      meta.activityAt,
       meta.fileModifiedAt,
       meta.modifiedAt,
     ];
@@ -85,6 +88,13 @@
 
   function recentSessionUpdatedAtMs(session, now = Date.now()) {
     const meta = sessionMeta(session);
+    const transcriptTimes = [
+      meta.lastMessageAt,
+      meta.lastActivityAt,
+      meta.activityAt,
+    ].map(parseTimeMs).filter((ms) => ms > 0);
+    if (transcriptTimes.length) return transcriptTimes[0];
+
     const durableTimes = [
       meta.fileModifiedAt,
       meta.modifiedAt,

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

@@ -5,7 +5,14 @@
   if (typeof module !== 'undefined' && module.exports) module.exports = api;
   if (root) root.SessionSearchUtils = api;
 })(typeof globalThis !== 'undefined' ? globalThis : this, function () {
-  function normalizeSearchValue(value) {
+  const SESSION_ID_RE = /[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}/ig;
+  const SEARCH_WRAP_RE = /^[\s"'`“”‘’]+|[\s"'`“”‘’,.;:!?)}\]]+$/g;
+
+  function stripSearchWrapping(value) {
+    return String(value || '').trim().replace(SEARCH_WRAP_RE, '').trim();
+  }
+
+  function normalizeSearchText(value) {
     return String(value || '')
       .trim()
       .toLowerCase()
@@ -13,6 +20,73 @@
       .replace(/\s+/g, ' ');
   }
 
+  function normalizeSearchValue(value) {
+    return normalizeSearchText(stripSearchWrapping(value));
+  }
+
+  function uniqueValues(values) {
+    const seen = new Set();
+    const out = [];
+    for (const raw of values || []) {
+      const value = String(raw || '').trim().toLowerCase();
+      if (!value || seen.has(value)) continue;
+      seen.add(value);
+      out.push(value);
+    }
+    return out;
+  }
+
+  function safeDecodeSearchValue(value) {
+    const raw = String(value || '');
+    try {
+      return decodeURIComponent(raw);
+    } catch {
+      return raw;
+    }
+  }
+
+  function extractSessionIdsFromSearchValue(value) {
+    const raw = String(value || '').trim();
+    const unwrapped = stripSearchWrapping(raw);
+    const variants = uniqueValues([raw, unwrapped, safeDecodeSearchValue(raw), safeDecodeSearchValue(unwrapped)]);
+    const ids = [];
+    for (const text of variants) {
+      for (const match of text.matchAll(SESSION_ID_RE)) ids.push(match[0]);
+      for (const match of text.matchAll(/(?:^|[?#&\s])(?:session|review)=([0-9a-f-]{36})(?=$|[&#\s"'`),.;:!?}])/ig)) {
+        ids.push(match[1]);
+      }
+    }
+    return uniqueValues(ids);
+  }
+
+  function parseSessionIdentityQuery(value) {
+    const raw = String(value || '').trim();
+    const unwrapped = stripSearchWrapping(raw);
+    const decoded = safeDecodeSearchValue(unwrapped);
+    const normalized = normalizeSearchText(unwrapped);
+    const decodedNormalized = normalizeSearchText(decoded);
+    const sessionIds = extractSessionIdsFromSearchValue(raw);
+    const referenceNeedles = [];
+    for (const id of sessionIds) {
+      referenceNeedles.push(id, `session=${id}`, `#session=${id}`, `review=${id}`, `#review=${id}`);
+    }
+    if (decodedNormalized && decodedNormalized.includes('://')) referenceNeedles.push(decodedNormalized);
+    return {
+      raw,
+      unwrapped,
+      normalized,
+      decoded,
+      sessionIds,
+      referenceNeedles: uniqueValues(referenceNeedles),
+      looksLikeSessionIdentity: sessionIds.length > 0,
+    };
+  }
+
+  function sessionIdentitySearchNeedles(query) {
+    const parsed = parseSessionIdentityQuery(query);
+    return uniqueValues([...parsed.sessionIds, parsed.normalized]);
+  }
+
   function getSearchableSessionIds(session) {
     const rawIds = [
       session && session.sessionId,
@@ -146,19 +220,22 @@
   }
 
   function scoreSessionIdMatch(session, query) {
-    const normalizedQuery = normalizeSearchValue(query);
-    if (!normalizedQuery) return 0;
+    const needles = sessionIdentitySearchNeedles(query);
+    if (needles.length === 0) return 0;
 
     let bestScore = 0;
     for (const candidate of getSearchableSessionIds(session)) {
       const normalizedCandidate = normalizeSearchValue(candidate);
       if (!normalizedCandidate) continue;
-      if (normalizedCandidate === normalizedQuery) {
-        bestScore = Math.max(bestScore, 120);
-      } else if (normalizedCandidate.startsWith(normalizedQuery)) {
-        bestScore = Math.max(bestScore, 90);
-      } else if (normalizedCandidate.includes(normalizedQuery)) {
-        bestScore = Math.max(bestScore, 60);
+      for (const normalizedQuery of needles) {
+        if (!normalizedQuery) continue;
+        if (normalizedCandidate === normalizedQuery) {
+          bestScore = Math.max(bestScore, 120);
+        } else if (normalizedCandidate.startsWith(normalizedQuery)) {
+          bestScore = Math.max(bestScore, 90);
+        } else if (normalizedCandidate.includes(normalizedQuery)) {
+          bestScore = Math.max(bestScore, 60);
+        }
       }
     }
     return bestScore;
@@ -206,11 +283,12 @@
     walle: 'Wall-E',
     gemini: 'Gemini CLI',
     opencode: 'OpenCode',
+    cursor: 'Cursor',
     'claude-desktop': 'Claude Desktop',
     shell: 'Shell / Other',
   };
 
-  const AGENT_FILTER_ORDER = ['codex', 'claude', 'walle', 'gemini', 'opencode', 'claude-desktop', 'shell'];
+  const AGENT_FILTER_ORDER = ['codex', 'claude', 'walle', 'cursor', 'gemini', 'opencode', 'claude-desktop', 'shell'];
 
   function normalizeRecentAgentType(value) {
     if (!value) return '';
@@ -223,6 +301,7 @@
     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 === 'cursor-agent' || v === 'cursor-cli') return 'cursor';
     if (v === 'terminal' || v === 'unknown' || v === 'other') return 'shell';
     return '';
   }
@@ -231,6 +310,7 @@
     if (!value) return '';
     const v = String(value).toLowerCase();
     if (v.includes('opencode') || v.includes('open-code')) return 'opencode';
+    if (v.includes('cursor')) return 'cursor';
     if (v.includes('wall-e') || v.includes('walle')) return 'walle';
     if (v.includes('codex')) return 'codex';
     if (v.includes('gemini')) return 'gemini';
@@ -328,6 +408,7 @@
     buildIdMatchResults,
     createSessionIdentityIndex,
     dedupeSessionCandidates,
+    extractSessionIdsFromSearchValue,
     filterRecentSessionsForSidebar,
     findSessionIdentityMatch,
     mergeRecentSessionMetadata,
@@ -336,11 +417,14 @@
     getSearchableSessionIds,
     normalizeSearchValue,
     normalizeRecentAgentType,
+    parseSessionIdentityQuery,
     recentAgentFilterLabel,
     recentAgentFilterPriority,
     scoreSessionIdMatch,
+    sessionIdentitySearchNeedles,
     sessionPassesRecentSidebarFilters,
     sessionMatchesRecentSearchQuery,
+    stripSearchWrapping,
     stripWorktreePath,
   };
 });

package/template/claude-task-manager/public/js/session-status-precedence.js

@@ -13,21 +13,24 @@
   const SERVER_WORKING_TTL_MS = 10000;
   const RECENT_OUTPUT_TTL_MS = 5000;
   const RECENT_INPUT_TTL_MS = 3000;
+  const ACTIVE_TURN_MAX_QUIET_MS = 45 * 60 * 1000;
   const OBSERVED_TIME_FUTURE_SKEW_MS = 60 * 1000;
   const WAITING_INPUT_STALE_MS = 30 * 60 * 1000;
 
   const STATUS_TEXT = {
     running: 'Running',
-    waiting: 'Waiting',
+    resuming: 'Resuming',
+    waiting: 'Needs You',
     idle: 'Idle',
     exited: 'Exited',
   };
 
   function normalizeLiveSessionStatus(status) {
-    const text = String(status || '').toLowerCase();
+    const text = String(status || '').toLowerCase().replace(/[-\s]+/g, '_');
     if (!text) return '';
     if (text === 'busy' || text === 'active' || text === 'thinking') return 'running';
-    if (text === 'waiting_input' || text === 'waiting-for-input') return 'waiting';
+    if (text === 'restoring' || text === 'resuming' || text === 'restore_starting' || text === 'restarting') return 'resuming';
+    if (text === 'waiting_input' || text === 'waiting_for_input') return 'waiting';
     if (Object.prototype.hasOwnProperty.call(STATUS_TEXT, text)) return text;
     return '';
   }
@@ -66,7 +69,7 @@
 
   function isBlockingWaitingReason(reason) {
     const text = String(reason || '').toLowerCase();
-    return text === 'approval' || text === 'choice';
+    return text === 'approval' || text === 'choice' || /\bapproval\b/.test(text) || /\bpermission\b/.test(text);
   }
 
   function resolveSessionStatus(input = {}, options = {}) {
@@ -92,6 +95,16 @@
     const providerRunningHold = Boolean(input.providerRunningHold);
     const pendingNonRunningStatus = result(input.codexPendingNonRunningStatus, 'codex-pending-demotion');
     const pendingNonRunningEventAt = observedTime(input.codexPendingNonRunningEventAt);
+    const activeTurnStartedAt = observedTime(input.activeTurnStartedAt);
+    const activeTurnLastEvidenceAt = observedTime(input.activeTurnLastEvidenceAt);
+    const activeTurnMaxQuietMs = Math.max(0, Number(input.activeTurnMaxQuietMs) || ACTIVE_TURN_MAX_QUIET_MS);
+    const activeTurnEvidenceAt = Math.max(activeTurnStartedAt, activeTurnLastEvidenceAt);
+    const activeTurnOpen = Boolean(input.activeTurnOpen) &&
+      activeTurnEvidenceAt &&
+      activeTurnMaxQuietMs &&
+      (now - activeTurnEvidenceAt) <= activeTurnMaxQuietMs;
+    const restoreStatus = normalizeLiveSessionStatus(input.restoreStatus);
+    const restoreResuming = Boolean(input.restoreStarting || input.restoreResuming || restoreStatus === 'resuming');
     const activationStatus = normalizeLiveSessionStatus(input.activationPreservedStatus);
     const activationStatusCapturedAt = observedTime(input.activationPreservedStatusCapturedAt);
     const activationStatusUntil = parseTimeMs(input.activationPreservedStatusUntil, 0, parser);
@@ -117,6 +130,7 @@
 
     const serverLive = result(input.serverLiveStatus, 'server-live');
     if (serverLive && isFresh(serverLiveStatusAt, now, SERVER_LIVE_STATUS_TTL_MS)) {
+      if (serverLive.cls === 'resuming') return serverLive;
       const serverLiveRunningIsStale = serverLive.cls === 'running' &&
         serverLiveStatusMaxEventAgeMs > 0 &&
         serverLiveStatusEventAt &&
@@ -186,6 +200,7 @@
         if (newerTerminalBusy) return result('running', 'codex-terminal-busy');
         const newerRunningEvidence =
           serverWorking ||
+          (activeTurnOpen && (!authAt || activeTurnEvidenceAt >= authAt)) ||
           (streamRunning && (!authAt || streamStatusAt >= authAt)) ||
           (recentOutput && (!authAt || lastOutputAt >= authAt));
         if (newerRunningEvidence) return result('running', 'newer-running-evidence');
@@ -195,6 +210,7 @@
 
     if (serverWorking) return result('running', 'server-working');
     if (waitingForInput) return result('waiting', 'waiting-for-input');
+    if (activeTurnOpen) return result('running', 'active-turn');
     if (streamSettlesLocalBusy) return result(streamStatus, 'stream-status');
     if (terminalBusyStatus) return result('running', 'codex-terminal-busy');
     if (codexRunningHold) return result('running', 'codex-running-hold');
@@ -206,9 +222,10 @@
       if (pendingIsNotObsolete) return pendingNonRunningStatus;
     }
     if (streamFresh && !streamIsStaleNonRunning) return result(streamStatus, 'stream-status');
+    if (recentOutput) return result('running', 'recent-output');
+    if (restoreResuming) return result('resuming', 'restore');
     if (activationPreservedRunning) return result('running', 'activation-preserved-running');
     if (waitingForInput && !recentOutput) return result('waiting', 'waiting-fallback');
-    if (recentOutput) return result('running', 'recent-output');
     const lastInputAt = observedTime(input.lastInputAt);
     if (lastInputAt && (now - lastInputAt) < RECENT_INPUT_TTL_MS) return result('running', 'recent-input');
     return result('idle', 'default-idle');
@@ -217,6 +234,7 @@
   return {
     AUTHORITATIVE_STATUS_TTL_MS,
     SERVER_LIVE_STATUS_TTL_MS,
+    ACTIVE_TURN_MAX_QUIET_MS,
     OBSERVED_TIME_FUTURE_SKEW_MS,
     WAITING_INPUT_STALE_MS,
     normalizeLiveSessionStatus,