pilotswarm 0.5.65 → 0.5.67

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "pilotswarm",
-    "version": "0.5.65",
+    "version": "0.5.67",
     "description": "PilotSwarm application package: terminal UI, browser portal + Web API server, and MCP server — one install, three bins.",
     "type": "module",
     "license": "MIT",
@@ -81,7 +81,7 @@
         "ink": "^6.8.0",
         "jose": "^6.2.2",
         "mermaid": "^11.16.0",
-        "pilotswarm-sdk": "0.5.65",
+        "pilotswarm-sdk": "0.5.67",
         "react": "^19.2.4",
         "react-dom": "^19.2.4",
         "ws": "^8.18.2"

package/ui/core/src/controller.js

@@ -2530,13 +2530,16 @@ export class PilotSwarmUiController {
         }
         await this.refreshSessions();
         this.catalogTimer = setInterval(() => {
+            // Do not queue more catalog traffic behind a slow periodic read.
+            if (this.catalogPollInFlight) return;
+            this.catalogPollInFlight = true;
             this.refreshSessions().catch((error) => {
                 this.dispatch({
                     type: "connection/error",
                     error: error?.message || String(error),
                     statusText: SESSION_REFRESH_FAILED_STATUS,
                 });
-            });
+            }).finally(() => { this.catalogPollInFlight = false; });
         }, 4000);
     }
 
@@ -2628,6 +2631,16 @@ export class PilotSwarmUiController {
         const recoveringConnection = !preRefreshState.connection.connected || Boolean(preRefreshState.connection.error);
         const shouldClearRefreshFailureBanner = preRefreshState.ui.statusText === SESSION_REFRESH_FAILED_STATUS;
         const previousActive = this.getState().sessions.activeSessionId;
+        const previousNavigationGeneration = this.navigationGeneration;
+        // The folder catalog is independent of the session pages: overlap its RTT.
+        const groupRowsPromise = typeof this.transport.listSessionGroups === "function"
+            ? Promise.resolve().then(() => this.transport.listSessionGroups())
+                .then(groups => (Array.isArray(groups) ? groups : []).map(sessionGroupToRow).filter(Boolean))
+                .catch(error => {
+                    console.warn(`[PilotSwarmUi] session-group fetch failed, keeping the known folders: ${error?.message || error}`);
+                    return null;
+                })
+            : Promise.resolve(null);
         let sessions = (await loadSessionCatalogPageWindow(this.transport)).map(normalizeSessionListRow);
         // Folders are NOT merged into the session payload any more: they live
         // in their own state slice, so a session refresh cannot drop them. A
@@ -2641,15 +2654,7 @@ export class PilotSwarmUiController {
         // state alone is judge which folders are still claimed, since the store
         // still holds the PREVIOUS membership at this point; the incoming rows
         // ride along on the action for exactly that.
-        let pendingGroupRows = null;
-        if (typeof this.transport.listSessionGroups === "function") {
-            try {
-                const groups = await this.transport.listSessionGroups();
-                pendingGroupRows = (Array.isArray(groups) ? groups : []).map(sessionGroupToRow).filter(Boolean);
-            } catch (error) {
-                console.warn(`[PilotSwarmUi] session-group fetch failed, keeping the known folders: ${error?.message || error}`);
-            }
-        }
+        const pendingGroupRows = await groupRowsPromise;
         // A pending deep-link target may be readable but absent from the
         // paged catalog window — fetch it explicitly. A definitive failure
         // (unknown or unshared: identical 404 shapes) fails the intent; the
@@ -2753,6 +2758,8 @@ export class PilotSwarmUiController {
             if (!existingHistory?.events?.length) {
                 await this.ensureSessionHistory(selected, { force: true }).catch(() => {});
             }
+            if (this.getState().sessions.activeSessionId !== selected
+                || this.navigationGeneration !== previousNavigationGeneration) return;
             // Boot-restore can hydrate the selection through THIS branch
             // instead of loadSession (whether the profile poll beats the first
             // sessions refresh is a race), so the canvas snapshot must be
@@ -2954,7 +2961,27 @@ export class PilotSwarmUiController {
         return history;
     }
 
-    async ensureSessionHistory(sessionId, { force = false } = {}) {
+    async ensureSessionHistory(sessionId, options = {}) {
+        if (!sessionId) return null;
+        if (this.sessionHistoryLoads.has(sessionId)) return this.sessionHistoryLoads.get(sessionId);
+        const existing = this.getState().history.bySessionId.get(sessionId);
+        if (!options.force && existing?.events && existing?.loadState !== "failed") return existing;
+        this.dispatch({ type: "history/loadState", sessionId, loadState: "loading" });
+        const pending = this.loadSessionHistory(sessionId, { ...options, force: true });
+        this.sessionHistoryLoads.set(sessionId, pending);
+        try {
+            const result = await pending;
+            this.dispatch({ type: "history/loadState", sessionId, loadState: "loaded" });
+            return result;
+        } catch (error) {
+            this.dispatch({ type: "history/loadState", sessionId, loadState: "failed" });
+            throw error;
+        } finally {
+            if (this.sessionHistoryLoads.get(sessionId) === pending) this.sessionHistoryLoads.delete(sessionId);
+        }
+    }
+
+    async loadSessionHistory(sessionId, { force = false } = {}) {
         if (!sessionId) return null;
         const existingHistory = this.getState().history.bySessionId.get(sessionId);
         const requestedLimit = Math.min(
@@ -2967,9 +2994,6 @@ export class PilotSwarmUiController {
         if (!force && existingHistory?.events) {
             return existingHistory;
         }
-        if (!force && this.sessionHistoryLoads.has(sessionId)) {
-            return this.sessionHistoryLoads.get(sessionId);
-        }
 
         // Re-entry catch-up: when the expanded window is already in memory,
         // fetch only the delta after lastSeq and append — the user's pulled-in
@@ -3052,12 +3076,7 @@ export class PilotSwarmUiController {
                 });
             }
             return history;
-        })()
-            .finally(() => {
-                this.sessionHistoryLoads.delete(sessionId);
-            });
-
-        this.sessionHistoryLoads.set(sessionId, loadPromise);
+        })();
         return loadPromise;
     }
 
@@ -5727,6 +5746,7 @@ export class PilotSwarmUiController {
 
     async loadSession(sessionId) {
         if (!sessionId) return;
+        const navigationGeneration = this.navigationGeneration = (this.navigationGeneration || 0) + 1;
         const active = this.getState().sessions.activeSessionId;
         if (active !== sessionId) {
             if (this.getState().ui.promptEdit) {
@@ -5742,10 +5762,13 @@ export class PilotSwarmUiController {
             this.detachActiveSession();
             return;
         }
-        await this.ensureSessionHistory(sessionId, { force: true });
-        if (this.getState().sessions.activeSessionId !== sessionId) return;
-        await this.syncSessionDetail(sessionId).catch(() => {});
-        if (this.getState().sessions.activeSessionId !== sessionId) return;
+        // Independent reads share one network-latency window. Cached chat stays visible.
+        await Promise.all([
+            this.ensureSessionHistory(sessionId, { force: true }),
+            this.syncSessionDetail(sessionId).catch(() => {}),
+        ]);
+        if (this.navigationGeneration !== navigationGeneration
+            || this.getState().sessions.activeSessionId !== sessionId) return;
         this.attachActiveSession(sessionId);
         this.ensureInspectorData().catch(() => {});
         // Canvas snapshot rides the selection burst. Invalidate-then-fetch on

package/ui/core/src/index.js

@@ -6,6 +6,7 @@ export * from "./layout.js";
 export * from "./repo-links.js";
 export * from "./repo-import.js";
 export * from "./session-tree.js";
+export * from "./session-search.js";
 export * from "./state.js";
 export * from "./reducer.js";
 export * from "./portal-links.js";

package/ui/core/src/reducer.js

@@ -1073,8 +1073,11 @@ function baseReducer(state, action) {
                 state.sessions.navigationIntent
                 && state.sessions.navigationIntent.status !== "failed",
             );
+            // Saved selection is a boot preference. Once this tab navigates,
+            // a slow profile read (or another device) must not navigate it back.
             const hasActive = Object.prototype.hasOwnProperty.call(settings, "activeSessionId")
-                && !navigationIntentLatched;
+                && !navigationIntentLatched
+                && !state.sessions.localSelectionMade;
             const hasLoadedSessions = Object.keys(state.sessions.byId || {}).length > 0;
             const nextLayout = hasLayout
                 ? {
@@ -1385,11 +1388,12 @@ function baseReducer(state, action) {
                     filterExceptionId: null,
                 ownerFilterAutoAdmitted: null,
                 };
-                const selection = applyVisibleSessionSelection(state, nextSessions);
                 return {
                     ...state,
-                    sessions: selection.sessions,
-                    ui: selection.ui,
+                    // Search filters the list, not the attached chat. Keeping
+                    // the active session stable also prevents a keystroke in
+                    // the search box from moving the list and main pane.
+                    sessions: nextSessions,
                 };
             }
 
@@ -1888,7 +1892,7 @@ function baseReducer(state, action) {
         }
 
         case "sessions/selected": {
-            state = { ...state, sessions: { ...state.sessions, listDeselected: false } };
+            state = { ...state, sessions: { ...state.sessions, listDeselected: false, localSelectionMade: true } };
             // Per-session chat scroll memory: stash both the outgoing offset
             // and whether it follows the bottom. A paused reading position
             // stays paused as new messages arrive and across session switches.
@@ -2191,6 +2195,17 @@ function baseReducer(state, action) {
             };
         }
 
+        case "history/loadState": {
+            // A gone-session response may already have evicted this entry.
+            if (!state.sessions.byId[action.sessionId]) return state;
+            const bySessionId = cloneHistoryMap(state.history.bySessionId);
+            bySessionId.set(action.sessionId, {
+                ...bySessionId.get(action.sessionId),
+                loadState: action.loadState,
+            });
+            return { ...state, history: { ...state.history, bySessionId } };
+        }
+
         case "history/set": {
             const previousHistory = state.history.bySessionId.get(action.sessionId) || null;
             const previousChat = previousHistory?.chat || [];

package/ui/core/src/selectors.js

@@ -1,7 +1,12 @@
 import { INSPECTOR_TABS, FOCUS_REGIONS } from "./commands.js";
 import { chatCallLine, firstCallLine } from "./chat-activity.js";
 import { canvasKey as canvasSlotKey, parseCanvasKey } from "./state.js";
-import { isManuallyOrderableSession } from "./session-tree.js";
+import { buildSessionTree, isManuallyOrderableSession } from "./session-tree.js";
+import {
+    buildSessionSearchDocument,
+    parseSessionSearchQuery,
+    scoreSessionSearchDocument,
+} from "./session-search.js";
 import {
     createSplashCard,
     isRehydrationNoticeText,
@@ -1287,6 +1292,132 @@ function matchesSearchQuery(value, query) {
     return String(value || "").toLowerCase().includes(normalizedQuery);
 }
 
+const searchedSessionFlatCache = new WeakMap();
+
+function sessionGroupTitle(session, byId) {
+    if (session?.isGroup) return session.title || "";
+    if (session?.groupId) return byId?.[`group:${session.groupId}`]?.title || "";
+    let current = session;
+    const seen = new Set();
+    while (current?.parentSessionId && !seen.has(current.parentSessionId)) {
+        seen.add(current.parentSessionId);
+        current = byId?.[current.parentSessionId];
+        if (current?.groupId) return byId?.[`group:${current.groupId}`]?.title || "";
+    }
+    return "";
+}
+
+function sessionSearchOwner(session, byId) {
+    const direct = effectiveSessionOwner(session, byId);
+    if (direct) return direct;
+    let current = session;
+    const seen = new Set();
+    while (current?.parentSessionId && !seen.has(current.parentSessionId)) {
+        seen.add(current.parentSessionId);
+        current = byId?.[current.parentSessionId];
+        if (current?.owner) return current.owner;
+    }
+    return null;
+}
+
+function buildSearchedSessionFlat(state, query) {
+    const existingFlat = Array.isArray(state.sessions?.flat) ? state.sessions.flat : [];
+    if (!query) return existingFlat;
+    const cached = searchedSessionFlatCache.get(existingFlat);
+    if (cached?.query === query) return cached.result;
+
+    const byId = state.sessions?.byId || {};
+    const parsed = parseSessionSearchQuery(query);
+    const expanded = buildSessionTree(
+        Object.values(byId),
+        new Set(),
+        state.sessions?.orderById,
+        state.sessions?.pinnedIds,
+        state.sessions?.manualOrder,
+    );
+    const parentById = new Map();
+    const entryById = new Map();
+    const baseIndex = new Map();
+    const stack = [];
+    for (let index = 0; index < expanded.length; index += 1) {
+        const entry = expanded[index];
+        stack[entry.depth] = entry.sessionId;
+        stack.length = entry.depth + 1;
+        parentById.set(entry.sessionId, entry.depth > 0 ? stack[entry.depth - 1] : null);
+        entryById.set(entry.sessionId, entry);
+        baseIndex.set(entry.sessionId, index);
+    }
+
+    const directScores = new Map();
+    for (const entry of expanded) {
+        const session = byId[entry.sessionId] || entry.standIn;
+        if (!session || !matchesOwnerFilter(session, state.sessions?.ownerFilter, state.auth || {}, byId)) continue;
+        const owner = sessionSearchOwner(session, byId);
+        const document = buildSessionSearchDocument(session, {
+            owner,
+            groupTitle: sessionGroupTitle(session, byId),
+        });
+        const score = scoreSessionSearchDocument(document, parsed);
+        if (score > 0) directScores.set(entry.sessionId, score);
+    }
+    const matchedIds = new Set(directScores.keys());
+    // A just-created or deep-linked session may be admitted explicitly while
+    // the user's prior query still excludes it. Preserve that established
+    // visibility contract and rank the exception first until the user edits
+    // the search (which clears filterExceptionId in the reducer).
+    const exceptionId = state.sessions?.filterExceptionId;
+    if (exceptionId && entryById.has(exceptionId)) {
+        directScores.set(exceptionId, Number.MAX_SAFE_INTEGER);
+    }
+
+    const included = new Set();
+    const subtreeScores = new Map();
+    for (const [sessionId, score] of directScores) {
+        let current = sessionId;
+        const seen = new Set();
+        while (current && !seen.has(current)) {
+            seen.add(current);
+            included.add(current);
+            subtreeScores.set(current, Math.max(subtreeScores.get(current) || 0, score));
+            current = parentById.get(current) || null;
+        }
+    }
+
+    const children = new Map();
+    for (const sessionId of included) {
+        const parentId = parentById.get(sessionId) || null;
+        if (!children.has(parentId)) children.set(parentId, []);
+        children.get(parentId).push(sessionId);
+    }
+    for (const siblings of children.values()) {
+        siblings.sort((a, b) => (subtreeScores.get(b) || 0) - (subtreeScores.get(a) || 0)
+            || (baseIndex.get(a) || 0) - (baseIndex.get(b) || 0));
+    }
+
+    const result = [];
+    const visit = (sessionId, depth) => {
+        const entry = entryById.get(sessionId);
+        if (!entry) return;
+        const childIds = children.get(sessionId) || [];
+        result.push({
+            ...entry,
+            depth,
+            collapsed: false,
+            hasChildren: childIds.length > 0,
+            searchIncluded: true,
+            searchMatch: matchedIds.has(sessionId),
+            searchScore: directScores.get(sessionId) || 0,
+        });
+        for (const childId of childIds) visit(childId, depth + 1);
+    };
+    for (const rootId of children.get(null) || []) visit(rootId, 0);
+    // A user can type an unbounded number of distinct queries while the
+    // catalog array keeps the same identity. Keep only the latest result for
+    // that catalog rather than retaining every intermediate keystroke.
+    searchedSessionFlatCache.set(existingFlat, { query, result });
+    return result;
+}
+
 // The transient deep-link filter exception covers the linked session AND its
 // ancestor chain (real parents plus the synthetic group:<id> row) so the
 // linked row renders with its tree context instead of as an orphan.
@@ -1330,22 +1461,25 @@ function sameRowDeps(a, b) {
 }
 
 export function selectSessionRows(state) {
+    // Keep field punctuation and quotes for the parser (`author:"Ada Lovelace"`).
+    // Individual values are normalized inside session-search.
+    const query = String(state.sessions?.filterQuery || "").trim();
+    const sessionFlat = buildSearchedSessionFlat(state, query);
     const totalDescendantCounts = getTotalDescendantCounts(state.sessions.byId);
-    const visibleDescendantCounts = getVisibleDescendantCounts(state.sessions.flat, state.sessions.byId);
-    const query = normalizeSearchQuery(state.sessions?.filterQuery || "");
+    const visibleDescendantCounts = getVisibleDescendantCounts(sessionFlat, state.sessions.byId);
     const ownerFilter = state.sessions?.ownerFilter || { all: true };
     const auth = state.auth || {};
     const pinnedSet = new Set(Array.isArray(state.sessions?.pinnedIds) ? state.sessions.pinnedIds : []);
     const selectedSet = new Set(Array.isArray(state.sessions?.selectedIds) ? state.sessions.selectedIds : []);
     const filterExceptionIds = collectFilterExceptionIds(state.sessions);
 
-    let memo = sessionRowMemo.get(state.sessions.flat);
+    let memo = sessionRowMemo.get(sessionFlat);
     if (!memo) {
         memo = new Map();
-        sessionRowMemo.set(state.sessions.flat, memo);
+        sessionRowMemo.set(sessionFlat, memo);
     }
 
-    return state.sessions.flat.filter((entry) => (
+    return sessionFlat.filter((entry) => (
         // A row whose session is in neither place can render nothing but an
         // owner chip and a dash - the "[?]" ghost. Drop it rather than show it.
         Boolean(state.sessions.byId[entry.sessionId] || entry.standIn)
@@ -1433,10 +1567,13 @@ export function selectSessionRows(state) {
             // `chrome` as well so a host that draws its own row (the phone's
             // list) can act on it without reading the portal's descriptor.
             pause: rowView.chrome?.pause || null,
+            searchMatch: entry.searchMatch === true,
+            searchScore: Number(entry.searchScore) || 0,
         };
         memo.set(entry.sessionId, { deps, row });
         return row;
     }).filter((row) => {
+        if (query) return true; // searchedSessionFlat already contains only matches and their ancestors.
         if (filterExceptionIds?.has(row.sessionId)) return true;
         const session = state.sessions.byId[row.sessionId];
         if (!matchesOwnerFilter(session, ownerFilter, auth, state.sessions.byId)) return false;
@@ -1444,11 +1581,9 @@ export function selectSessionRows(state) {
         const ownerSearchText = effectiveOwner
             ? `${ownerDisplayName(effectiveOwner, "")} ${effectiveOwner.email || ""}`
             : "";
-        const summarySearchText = "";
         return matchesSearchQuery(row.text, query)
             || matchesSearchQuery(row.sessionId, query)
-            || matchesSearchQuery(ownerSearchText, query)
-            || matchesSearchQuery(summarySearchText, query);
+            || matchesSearchQuery(ownerSearchText, query);
     });
 }
 
@@ -1893,6 +2028,16 @@ export function selectActiveChat(state) {
     }
     const history = state.history.bySessionId.get(sessionId);
     const chat = history?.chat || [];
+    if (!chat.length && ["loading", "failed"].includes(history?.loadState)) {
+        return [{
+            id: `history-load:${sessionId}:${history.loadState}`,
+            role: "system",
+            noChrome: true,
+            text: history.loadState === "loading"
+                ? "Loading conversation…"
+                : "Could not load this conversation. Select the session again to retry.",
+        }];
+    }
     const events = history?.events || [];
     const pendingQuestionMessage = session?.pendingQuestion?.question
         && !chatAlreadyContainsPendingQuestion(chat, session.pendingQuestion.question)

package/ui/core/src/session-search.js

@@ -0,0 +1,151 @@
+const FIELD_ALIASES = Object.freeze({
+    author: "author",
+    owner: "author",
+    agent: "agent",
+    status: "status",
+    group: "group",
+    folder: "group",
+    model: "model",
+    id: "id",
+    topic: "topic",
+    summary: "summary",
+});
+
+const FREE_FIELD_WEIGHTS = Object.freeze({
+    title: 12,
+    id: 11,
+    author: 10,
+    agent: 9,
+    summary: 7,
+    group: 6,
+    model: 5,
+    status: 4,
+});
+
+export function normalizeSessionSearchText(value) {
+    return String(value || "")
+        .normalize("NFKD")
+        .replace(/[\u0300-\u036f]/g, "")
+        .toLowerCase()
+        .replace(/[^a-z0-9@._+-]+/g, " ")
+        .trim()
+        .replace(/\s+/g, " ");
+}
+
+export function parseSessionSearchQuery(value) {
+    const source = String(value || "").trim();
+    const terms = [];
+    const filters = [];
+    const pattern = /(?:(\w+):)?(?:"([^"]+)"|(\S+))/g;
+    let match;
+    while ((match = pattern.exec(source)) !== null) {
+        const rawField = String(match[1] || "").toLowerCase();
+        const rawValue = match[2] ?? match[3] ?? "";
+        const normalized = normalizeSessionSearchText(rawValue);
+        if (!normalized) continue;
+        const field = FIELD_ALIASES[rawField];
+        if (field) filters.push({ field, value: normalized });
+        else terms.push(normalizeSessionSearchText(rawField ? `${rawField} ${rawValue}` : rawValue));
+    }
+    return { source, terms: terms.filter(Boolean), filters };
+}
+
+function boundedDistance(a, b, limit) {
+    if (Math.abs(a.length - b.length) > limit) return limit + 1;
+    let previous = Array.from({ length: b.length + 1 }, (_, index) => index);
+    for (let i = 1; i <= a.length; i += 1) {
+        const current = [i];
+        let rowMinimum = current[0];
+        for (let j = 1; j <= b.length; j += 1) {
+            const value = Math.min(
+                current[j - 1] + 1,
+                previous[j] + 1,
+                previous[j - 1] + (a[i - 1] === b[j - 1] ? 0 : 1),
+            );
+            current.push(value);
+            rowMinimum = Math.min(rowMinimum, value);
+        }
+        if (rowMinimum > limit) return limit + 1;
+        previous = current;
+    }
+    return previous[b.length];
+}
+
+function matchStrength(haystack, needle) {
+    if (!haystack || !needle) return 0;
+    if (haystack === needle) return 16;
+    const words = haystack.split(" ");
+    if (words.includes(needle)) return 14;
+    if (haystack.includes(needle)) return needle.includes(" ") ? 13 : 11;
+    if (needle.length >= 2 && words.some((word) => word.startsWith(needle))) return 9;
+    if (needle.length >= 4 && words.some((word) => word.includes(needle))) return 7;
+    if (needle.length < 4) return 0;
+    // One adjacent transposition is two edits under Levenshtein distance
+    // ("session" → "sessoin"). Permit that for ordinary words while keeping
+    // short tokens exact/prefix-only.
+    const limit = needle.length >= 6 ? 2 : 1;
+    return words.some((word) => boundedDistance(word, needle, limit) <= limit) ? 4 : 0;
+}
+
+function summaryStrings(summaryState) {
+    if (!summaryState || typeof summaryState !== "object") return [];
+    return [summaryState.topic, summaryState.intent, summaryState.summary, summaryState.title]
+        .filter((value) => typeof value === "string" && value.trim());
+}
+
+export function buildSessionSearchDocument(session, { owner = null, groupTitle = "" } = {}) {
+    const title = normalizeSessionSearchText(session?.title);
+    const summary = normalizeSessionSearchText([
+        session?.shortSummary,
+        ...summaryStrings(session?.summaryState),
+    ].filter(Boolean).join(" "));
+    const author = normalizeSessionSearchText([
+        owner?.displayName,
+        owner?.email,
+        owner?.subject,
+    ].filter(Boolean).join(" "));
+    return {
+        title,
+        summary,
+        topic: normalizeSessionSearchText(`${title} ${summary}`),
+        author,
+        agent: normalizeSessionSearchText(session?.agentId),
+        status: normalizeSessionSearchText(session?.status),
+        group: normalizeSessionSearchText(groupTitle),
+        model: normalizeSessionSearchText(`${session?.model || ""} ${session?.reasoningEffort || ""}`),
+        id: normalizeSessionSearchText(session?.sessionId),
+    };
+}
+
+/**
+ * Score one already-authorized, browser-resident session. Structured filters
+ * and free-text terms are ANDed; each free term may match any field. Exact,
+ * prefix and substring matches beat bounded typo matches.
+ */
+export function scoreSessionSearchDocument(document, query) {
+    const parsed = typeof query === "string" ? parseSessionSearchQuery(query) : query;
+    if (!parsed || (parsed.terms.length === 0 && parsed.filters.length === 0)) return 1;
+    let score = 0;
+    for (const filter of parsed.filters) {
+        const strength = matchStrength(document?.[filter.field] || "", filter.value);
+        if (!strength) return 0;
+        score += strength * 14;
+    }
+    for (const term of parsed.terms) {
+        let best = 0;
+        for (const [field, weight] of Object.entries(FREE_FIELD_WEIGHTS)) {
+            // Short numbers such as "Session 2" occur in the fixed portions
+            // of every UUID. Treat IDs as an explicit/long-fragment field so
+            // the human title remains the natural interpretation; `id:...`
+            // is always available for deliberate ID lookup.
+            if (field === "id" && (/^\d+$/.test(term) || term.length < 8)) continue;
+            best = Math.max(best, matchStrength(document?.[field] || "", term) * weight);
+        }
+        if (!best) return 0;
+        score += best;
+    }
+    const phrase = parsed.terms.join(" ");
+    if (phrase && document?.title?.includes(phrase)) score += 120;
+    else if (phrase && document?.summary?.includes(phrase)) score += 60;
+    return score;
+}