@agent-native/core 0.184.0 → 0.184.1-nightly-20260922211241

package/corpus/README.md

@@ -31,4 +31,4 @@ rg -n "defineAction|useActionQuery" node_modules/@agent-native/core/corpus
 
 ## Generated Counts
 
-- template files: 9718
+- template files: 9728

package/corpus/templates/analytics/changelog/2026-09-22-apps-start-with-an-app-shaped-skeleton-while-session-data-lo.md

@@ -0,0 +1,6 @@
+---
+type: improved
+date: 2026-09-22
+---
+
+Apps start with an app-shaped skeleton while session data loads immediately.

package/corpus/templates/calendar/changelog/2026-09-22-apps-start-with-an-app-shaped-skeleton-while-session-data-lo.md

@@ -0,0 +1,6 @@
+---
+type: improved
+date: 2026-09-22
+---
+
+Apps start with an app-shaped skeleton while session data loads immediately.

package/corpus/templates/clips/changelog/2026-09-22-apps-start-with-an-app-shaped-skeleton-while-session-data-lo.md

@@ -0,0 +1,6 @@
+---
+type: improved
+date: 2026-09-22
+---
+
+Apps start with an app-shaped skeleton while session data loads immediately.

package/corpus/templates/clips/changelog/2026-09-22-rewind-uses-less-storage-by-default.md

@@ -0,0 +1,6 @@
+---
+type: fixed
+date: 2026-09-22
+---
+
+Rewind keeps its rolling screen history within a smaller default storage limit.

package/corpus/templates/clips/desktop/src/app.tsx

@@ -396,7 +396,7 @@ const DEFAULT_SCREEN_MEMORY_CONFIG = {
   enabled: false,
   paused: false,
   retentionHours: 8,
-  maxBytes: 20 * 1024 * 1024 * 1024,
+  maxBytes: 5 * 1024 * 1024 * 1024,
   segmentSeconds: 5 * 60,
   sampleIntervalSeconds: 10,
   captureMode: "visuals" as const,

package/corpus/templates/clips/desktop/src-tauri/src/config.rs

@@ -3,7 +3,7 @@ use std::path::PathBuf;
 use tauri::{AppHandle, Emitter, Manager};
 use tauri_plugin_autostart::ManagerExt as AutostartManagerExt;
 
-const FEATURE_CONFIG_VERSION: u32 = 1;
+const FEATURE_CONFIG_VERSION: u32 = 2;
 
 #[derive(Debug, Clone, Serialize, Deserialize)]
 #[serde(rename_all = "camelCase")]
@@ -211,7 +211,7 @@ fn default_screen_memory_exclude_private_windows() -> bool {
 }
 
 fn default_screen_memory_max_bytes() -> u64 {
-    20 * 1024 * 1024 * 1024
+    5 * 1024 * 1024 * 1024
 }
 
 fn default_screen_memory_segment_seconds() -> u64 {
@@ -253,8 +253,13 @@ impl Default for FeatureConfig {
 }
 
 fn migrate_feature_config(mut config: FeatureConfig) -> FeatureConfig {
-    if config.config_version < FEATURE_CONFIG_VERSION {
+    if config.config_version < 1 {
         config.auto_hide_popover_enabled = true;
+    }
+    if config.config_version < 2 && config.screen_memory.max_bytes == 20 * 1024 * 1024 * 1024 {
+        config.screen_memory.max_bytes = default_screen_memory_max_bytes();
+    }
+    if config.config_version < FEATURE_CONFIG_VERSION {
         config.config_version = FEATURE_CONFIG_VERSION;
     }
     config
@@ -482,6 +487,28 @@ mod tests {
         assert!(!opt_out.auto_hide_popover_enabled);
     }
 
+    #[test]
+    fn migrates_the_previous_screen_memory_storage_default() {
+        let mut config = FeatureConfig::default();
+        config.config_version = 1;
+        config.auto_hide_popover_enabled = false;
+        config.screen_memory.max_bytes = 20 * 1024 * 1024 * 1024;
+
+        let migrated = migrate_feature_config(config);
+
+        assert_eq!(migrated.config_version, FEATURE_CONFIG_VERSION);
+        assert_eq!(migrated.screen_memory.max_bytes, 5 * 1024 * 1024 * 1024);
+        assert!(!migrated.auto_hide_popover_enabled);
+
+        let mut custom = FeatureConfig::default();
+        custom.config_version = 1;
+        custom.screen_memory.max_bytes = 50 * 1024 * 1024 * 1024;
+        assert_eq!(
+            migrate_feature_config(custom).screen_memory.max_bytes,
+            50 * 1024 * 1024 * 1024
+        );
+    }
+
     #[test]
     fn feature_config_migration_updates_legacy_default_but_preserves_current_opt_out() {
         let legacy: FeatureConfig = serde_json::from_value(serde_json::json!({

package/corpus/templates/clips/desktop/src-tauri/src/screen_memory.rs

@@ -3247,7 +3247,7 @@ fn prune_segments(app: &AppHandle, config: &ScreenMemoryConfig) -> Result<(), St
         let expired = ended_at.map(|value| value < cutoff).unwrap_or(false);
         kept_bytes = kept_bytes.saturating_add(segment.bytes);
         if (expired || kept_bytes > config.max_bytes) && !segment_is_pinned(app, &segment.id) {
-            let _ = delete_segment(app, &segment.id);
+            delete_segment(app, &segment.id)?;
         }
     }
     prune_events(app, cutoff)?;

package/corpus/templates/content/AGENTS.md

@@ -63,7 +63,7 @@ Read the relevant skill before deeper work:
 | `navigate` | Move the UI to a document, comments, media, or settings |
 | `refresh-list` | Repaint the sidebar after an out-of-band mutation |
 | `list-documents` | Document metadata tree, without bodies |
-| `search-documents` | Title and content search with snippets |
+| `search-documents` | Title-first search with snippets |
 | `get-document` | One document with full content |
 | `pull-document` | Flush live collab state, then read (external edits) |
 | `get-blocks-field-word-count` | Count one exact Blocks field; omit `propertyId` for the primary Content body |

package/corpus/templates/content/actions/_document-search-ranking.ts

@@ -0,0 +1,191 @@
+import { and, or, sql, type SQL, type SQLWrapper } from "drizzle-orm";
+
+import type {
+  ParsedSearchQuery,
+  SearchQueryGroup,
+  SearchQueryTerm,
+} from "../shared/search-query.js";
+
+function escapeLike(value: string) {
+  return value.replace(/([\\%_])/g, "\\$1");
+}
+
+function substringMatch(column: SQLWrapper, term: SearchQueryTerm): SQL {
+  return sql`${column} ILIKE ${`%${escapeLike(term.text)}%`} ESCAPE '\\'`;
+}
+
+function escapeRegex(value: string) {
+  return value.replace(/[\\^$.*+?()[\]{}|]/g, "\\$&");
+}
+
+function regexTerm(value: string) {
+  return escapeRegex(value.trim()).replace(/\s+/g, "[[:space:]]+");
+}
+
+export function searchQueryProximityPattern(parsed: ParsedSearchQuery) {
+  if (
+    parsed.groups.length < 2 ||
+    parsed.groups.some(
+      (group) => group.terms.length !== 1 || group.terms[0]!.titleOnly,
+    )
+  ) {
+    return null;
+  }
+  return parsed.groups
+    .map((group) => regexTerm(group.terms[0]!.text))
+    .join("(.|\\n){0,240}");
+}
+
+function wordPrefixMatch(column: SQLWrapper, term: SearchQueryTerm): SQL {
+  const pattern = regexTerm(term.text);
+  return sql`${column} ~* ${`(^|[^[:alnum:]_])${pattern}`}`;
+}
+
+function groupSubstringMatch(column: SQLWrapper, group: SearchQueryGroup): SQL {
+  return or(...group.terms.map((term) => substringMatch(column, term)))!;
+}
+
+function nonTitleGroupSubstringMatch(
+  column: SQLWrapper,
+  group: SearchQueryGroup,
+): SQL {
+  const terms = group.terms.filter((term) => !term.titleOnly);
+  return terms.length
+    ? or(...terms.map((term) => substringMatch(column, term)))!
+    : sql`false`;
+}
+
+function groupWordPrefixMatch(
+  column: SQLWrapper,
+  group: SearchQueryGroup,
+): SQL {
+  return or(...group.terms.map((term) => wordPrefixMatch(column, term)))!;
+}
+
+function countMatchingGroups(
+  column: SQLWrapper,
+  groups: SearchQueryGroup[],
+  nonTitleOnly = false,
+): SQL<number> {
+  if (!groups.length) return sql<number>`0`;
+  return sql<number>`(${sql.join(
+    groups.map(
+      (group) =>
+        sql`case when ${nonTitleOnly ? nonTitleGroupSubstringMatch(column, group) : groupSubstringMatch(column, group)} then 1 else 0 end`,
+    ),
+    sql` + `,
+  )})`;
+}
+
+export interface DocumentSearchRankingColumns {
+  title: SQLWrapper;
+  description: SQLWrapper;
+  content: SQLWrapper;
+}
+
+export interface DocumentSearchRankingOptions {
+  includeNonTitleFields?: boolean;
+}
+
+function bodyProximityScore(
+  parsed: ParsedSearchQuery,
+  content: SQLWrapper,
+): SQL<number> {
+  if (
+    parsed.groups.length < 2 ||
+    parsed.groups.some(
+      (group) => group.terms.length !== 1 || group.terms[0]!.titleOnly,
+    )
+  ) {
+    return sql<number>`case when true then 0 else 0 end`;
+  }
+  const phrase = parsed.groups
+    .map((group) => group.terms[0]!.text.trim())
+    .join(" ");
+  return sql<number>`case when ${content} ILIKE ${`%${escapeLike(phrase)}%`} ESCAPE '\\' then 1 else 0 end`;
+}
+
+/**
+ * Returns lexicographic ranking keys. The first key is a protected match tier:
+ * no recency or repetition signal can move a body match above a title match.
+ */
+export function documentSearchRanking(
+  parsed: ParsedSearchQuery,
+  columns: DocumentSearchRankingColumns,
+  options: DocumentSearchRankingOptions = {},
+) {
+  const groups = parsed.groups;
+  const includeNonTitleFields = options.includeNonTitleFields ?? true;
+  const normalizedTitle = sql<string>`regexp_replace(lower(trim(coalesce(${columns.title}, ''))), '\\s+', ' ', 'g')`;
+  const simpleQueries =
+    groups.length > 0 && groups.every((group) => group.terms.length === 1)
+      ? [groups.map((group) => group.terms[0]!.text.trim()).join(" ")]
+      : groups.length === 1
+        ? groups[0]!.terms.map((term) => term.text.trim())
+        : [];
+  const normalizedSimpleQueries = simpleQueries.map((query) =>
+    query.toLocaleLowerCase().replace(/\s+/g, " "),
+  );
+  const guardNormalizedTitle = groups.every((group) =>
+    group.terms.every((term) => !/\s/.test(term.text)),
+  );
+  const allTitleSubstrings = groups.length
+    ? and(...groups.map((group) => groupSubstringMatch(columns.title, group)))!
+    : sql`false`;
+  const allTitleWordPrefixes = groups.length
+    ? and(...groups.map((group) => groupWordPrefixMatch(columns.title, group)))!
+    : sql`false`;
+  const allTitleOrDescription = groups.length
+    ? and(
+        ...groups.map((group) =>
+          includeNonTitleFields
+            ? or(
+                groupSubstringMatch(columns.title, group),
+                nonTitleGroupSubstringMatch(columns.description, group),
+              )!
+            : groupSubstringMatch(columns.title, group),
+        ),
+      )!
+    : sql`false`;
+  const matchTier = sql<number>`case
+    when ${
+      normalizedSimpleQueries.length
+        ? and(
+            guardNormalizedTitle ? allTitleSubstrings : sql`true`,
+            or(
+              ...normalizedSimpleQueries.map(
+                (query) => sql`${normalizedTitle} = ${query}`,
+              ),
+            )!,
+          )!
+        : sql`false`
+    } then 5
+    when ${
+      normalizedSimpleQueries.length
+        ? and(
+            guardNormalizedTitle ? allTitleSubstrings : sql`true`,
+            or(
+              ...normalizedSimpleQueries.map(
+                (query) =>
+                  sql`${normalizedTitle} like ${`${escapeLike(query)}%`} escape '\\'`,
+              ),
+            )!,
+          )!
+        : sql`false`
+    } then 4
+    when ${allTitleSubstrings} and ${allTitleWordPrefixes} then 3
+    when ${allTitleSubstrings} then 2
+    when ${allTitleOrDescription} then 1
+    else 0
+  end`;
+  return {
+    matchTier,
+    titleCoverage: countMatchingGroups(columns.title, groups),
+    descriptionCoverage: includeNonTitleFields
+      ? countMatchingGroups(columns.description, groups, true)
+      : sql<number>`0::integer`,
+    bodyProximity: includeNonTitleFields
+      ? bodyProximityScore(parsed, columns.content)
+      : sql<number>`0::integer`,
+  };
+}

package/corpus/templates/content/actions/search-documents.ts

@@ -32,6 +32,10 @@ import {
   documentDiscoveryPagination,
   documentDiscoveryWhere,
 } from "./_document-discovery-query.js";
+import {
+  documentSearchRanking,
+  searchQueryProximityPattern,
+} from "./_document-search-ranking.js";
 
 function escapeLike(s: string): string {
   return s.replace(/([\\%_])/g, "\\$1");
@@ -45,15 +49,21 @@ function escapeLike(s: string): string {
 // no-match case. The row is still returned either way.
 function makeSnippet(content: string, query: string, radius = 120) {
   const compact = content.replace(/\s+/g, " ").trim();
+  const compactQuery = query.replace(/\s+/g, " ").trim();
   if (!compact) return "";
-  const index = compact.toLowerCase().indexOf(query.toLowerCase());
+  if (!compactQuery) {
+    return compact.length <= radius * 2
+      ? compact
+      : `${compact.slice(0, radius * 2).trimEnd()}...`;
+  }
+  const index = compact.toLowerCase().indexOf(compactQuery.toLowerCase());
   if (index < 0) {
     return compact.length <= radius * 2
       ? compact
       : `${compact.slice(0, radius * 2).trimEnd()}...`;
   }
   const start = Math.max(0, index - radius);
-  const end = Math.min(compact.length, index + query.length + radius);
+  const end = Math.min(compact.length, index + compactQuery.length + radius);
   return `${start > 0 ? "..." : ""}${compact.slice(start, end).trim()}${
     end < compact.length ? "..." : ""
   }`;
@@ -61,7 +71,7 @@ function makeSnippet(content: string, query: string, radius = 120) {
 
 export default defineAction({
   description:
-    'Search one bounded page of access-scoped documents by title and content, or find an exact title within a parent, space, and document type. The query supports Google-style operators: "exact phrase", -excludedTerm, OR between terms (uppercase), intitle:term; bare words combine with AND and %, _ match literally. Returns explicit pagination; follow nextOffset until hasMore is false. Returns metadata and snippets; use get-document for full content.',
+    'Search one relevance-ranked, bounded page of access-scoped documents by title and content, or find an exact title within a parent, space, and document type. Exact and partial title matches rank above description and body matches. The query supports Google-style operators: "exact phrase", -excludedTerm, OR between terms (uppercase), intitle:term; bare words combine with AND and %, _ match literally. Returns explicit pagination; follow nextOffset until hasMore is false. Returns metadata and snippets; use get-document for full content.',
   deferLoading: false,
   mcpTool: true,
   schema: z
@@ -131,6 +141,7 @@ export default defineAction({
       ]),
     ];
     let bodyNeedles: string[] = [];
+    let parsedQuery: ReturnType<typeof parseSearchQuery> | null = null;
     const queryTermPredicate = (term: SearchQueryTerm): SQL => {
       const pattern = `%${escapeLike(term.text)}%`;
       const columns =
@@ -148,6 +159,7 @@ export default defineAction({
     const matchPredicates: SQL[] = [];
     if (args.query) {
       const parsed = parseSearchQuery(args.query);
+      parsedQuery = parsed;
       if (parsed.empty) {
         // Punctuation-only input (lone `-`, empty quotes) matches nothing by
         // design; report that as a loud empty page rather than every document.
@@ -169,7 +181,7 @@ export default defineAction({
                 .map((term) => term.text),
             ),
           ),
-        ];
+        ].slice(0, 256);
       }
     }
     const where = documentDiscoveryWhere({
@@ -204,39 +216,110 @@ export default defineAction({
           : undefined,
       ),
     });
-    const [countRow] = await db
-      .select({ count: sql<number>`count(*)` })
-      .from(schema.documents)
-      .where(where);
-    const totalItems = Number(countRow?.count ?? 0);
-
     // Project a bounded preview of `content` instead of the full column:
     // document bodies can be multi-MB, and this action only returns a short
     // snippet (use get-document for full content). In free-text mode the
-    // preview window is anchored at the earliest in-body occurrence of an
-    // eligible positive term. The selected term is projected with the window
-    // so `makeSnippet` centers on the same match. Query order breaks ties;
+    // preview window is anchored at an in-body occurrence that keeps the most
+    // eligible positive terms in view. The selected term is projected with the
+    // window so `makeSnippet` preserves the complete match. Position and query
+    // order break ties;
     // title-only matches and exactTitle mode keep the head projection. The
     // true length still comes from SQL `length()` rather than reading `.length`
     // off a truncated string. Mirrors the
     // `substr`/`length` projection style in list-documents.ts; `position`,
     // `substr`, and `length` all work in PostgreSQL and PGlite.
     const normalizedContent = sql<string>`coalesce(${schema.documents.content}, '')`;
-    const selectedBodyNeedle = bodyNeedles.length
-      ? sql<string>`(
-          select candidate.needle
-          from unnest(array[${sql.join(
-            bodyNeedles.map((needle) => sql`${needle}`),
-            sql`, `,
-          )}]::text[]) with ordinality as candidate(needle, query_order)
-          where position(lower(candidate.needle) in lower(${normalizedContent})) > 0
-          order by position(lower(candidate.needle) in lower(${normalizedContent})), candidate.query_order
+    const bodyNeedleArray = bodyNeedles.length
+      ? sql`array[${sql.join(
+          bodyNeedles.map((needle) => sql`${needle}`),
+          sql`, `,
+        )}]::text[]`
+      : undefined;
+    const maxOccurrencesPerNeedle = Math.max(
+      1,
+      Math.floor(256 / Math.max(1, bodyNeedles.length)),
+    );
+    const proximityPattern =
+      bodyNeedleArray && parsedQuery
+        ? searchQueryProximityPattern(parsedQuery)
+        : null;
+    const proximityPosition = proximityPattern
+      ? sql<number>`regexp_instr(${normalizedContent}, ${proximityPattern}, 1, 1, 0, 'i')`
+      : undefined;
+    // Inspect repeated occurrences so the snippet can prefer a later,
+    // denser passage. Cap each needle to keep pathological repeated-token
+    // documents from turning one result preview into an unbounded scan.
+    const fallbackBodyPosition =
+      bodyNeedles.length === 1
+        ? sql<number>`nullif(position(lower(${bodyNeedles[0]!}) in lower(${normalizedContent})), 0)`
+        : bodyNeedleArray
+          ? sql<number>`(
+          with recursive body_occurrence(needle, query_order, match_position, occurrence_number) as (
+            select candidate.needle, candidate.query_order,
+              position(lower(candidate.needle) in lower(${normalizedContent})), 1
+            from unnest(${bodyNeedleArray}) with ordinality as candidate(needle, query_order)
+            where position(lower(candidate.needle) in lower(${normalizedContent})) > 0
+            union all
+            select occurrence.needle, occurrence.query_order,
+              occurrence.match_position + position(
+                lower(occurrence.needle)
+                in substring(lower(${normalizedContent}) from occurrence.match_position + 1)
+              ), occurrence.occurrence_number + 1
+            from body_occurrence as occurrence
+            where occurrence.occurrence_number < ${maxOccurrencesPerNeedle} and position(
+              lower(occurrence.needle)
+              in substring(lower(${normalizedContent}) from occurrence.match_position + 1)
+            ) > 0
+          )
+          select candidate.match_position
+          from body_occurrence as candidate
+          order by (
+            select count(*)
+            from unnest(${bodyNeedleArray}) as nearby(needle)
+            where position(
+              lower(nearby.needle)
+              in lower(substr(
+                ${normalizedContent},
+                greatest(1, candidate.match_position - 120),
+                240 + length(candidate.needle)
+              ))
+            ) > 0
+          ) desc,
+          candidate.match_position,
+          candidate.query_order
           limit 1
         )`
-      : undefined;
-    const matchWindow = selectedBodyNeedle
-      ? sql<string>`case when ${selectedBodyNeedle} is not null then substr(${normalizedContent}, greatest(1, position(lower(${selectedBodyNeedle}) in lower(${normalizedContent})) - 120), 240 + length(${selectedBodyNeedle})) else substr(${normalizedContent}, 1, 5000) end`
+          : undefined;
+    const selectedBodyPosition =
+      proximityPosition && fallbackBodyPosition
+        ? sql<number>`coalesce(nullif(${proximityPosition}, 0), ${fallbackBodyPosition})`
+        : fallbackBodyPosition;
+    const selectedBodyNeedle =
+      bodyNeedleArray && selectedBodyPosition
+        ? sql<string>`(
+            select candidate.needle
+            from unnest(${bodyNeedleArray}) with ordinality as candidate(needle, query_order)
+            where lower(substr(${normalizedContent}, ${selectedBodyPosition}, length(candidate.needle))) = lower(candidate.needle)
+            order by candidate.query_order
+            limit 1
+          )`
+        : undefined;
+    const matchWindow = selectedBodyPosition
+      ? sql<string>`case when ${selectedBodyPosition} is not null then substr(${normalizedContent}, greatest(1, ${selectedBodyPosition} - 120), least(5000, 240 + coalesce(length(${selectedBodyNeedle}), 0))) else substr(${normalizedContent}, 1, 5000) end`
       : sql<string>`substr(${normalizedContent}, 1, 5000)`;
+    const ranking = parsedQuery?.groups.length
+      ? documentSearchRanking(
+          parsedQuery,
+          {
+            title: schema.documents.title,
+            description: schema.documents.description,
+            content: normalizedContent,
+          },
+          {
+            includeNonTitleFields: args.searchFields !== "title",
+          },
+        )
+      : null;
     const docs = await db
       .select({
         id: schema.documents.id,
@@ -244,11 +327,6 @@ export default defineAction({
         title: schema.documents.title,
         description: schema.documents.description,
         icon: schema.documents.icon,
-        contentPreview: matchWindow,
-        snippetNeedle: selectedBodyNeedle
-          ? sql<string>`coalesce(${selectedBodyNeedle}, '')`
-          : sql<string>`''`,
-        contentLength: sql<number>`length(${normalizedContent})`,
         hideFromSearch: schema.documents.hideFromSearch,
         updatedAt: schema.documents.updatedAt,
         sourceKind: schema.documents.sourceKind,
@@ -264,12 +342,63 @@ export default defineAction({
               ),
             ),
         )} then 'database' else 'page' end`,
+        totalItems: sql<number>`count(*) over()`,
       })
       .from(schema.documents)
       .where(where)
-      .orderBy(desc(schema.documents.updatedAt), asc(schema.documents.id))
+      .orderBy(
+        ...(ranking
+          ? [
+              desc(ranking.matchTier),
+              desc(ranking.titleCoverage),
+              desc(ranking.descriptionCoverage),
+              // Phrase coherence is a minor body-only tie-breaker. Bound its
+              // full-body scan so broad searches keep predictable latency;
+              // protected field tiers still rank the complete result set.
+              desc(
+                sql<number>`case when count(*) over() <= 1000 then ${ranking.bodyProximity} else 0 end`,
+              ),
+            ]
+          : []),
+        desc(schema.documents.updatedAt),
+        asc(schema.documents.id),
+      )
       .limit(args.limit)
       .offset(args.offset);
+    const previews = docs.length
+      ? await db
+          .select({
+            id: schema.documents.id,
+            contentPreview: matchWindow,
+            snippetNeedle: selectedBodyNeedle
+              ? sql<string>`coalesce(${selectedBodyNeedle}, '')`
+              : sql<string>`''`,
+            contentLength: sql<number>`length(${normalizedContent})`,
+          })
+          .from(schema.documents)
+          .where(
+            and(
+              where,
+              inArray(
+                schema.documents.id,
+                docs.map((doc) => doc.id),
+              ),
+            ),
+          )
+      : [];
+    const previewById = new Map(
+      previews.map((preview) => [preview.id, preview]),
+    );
+    const totalItems = docs.length
+      ? Number(docs[0]!.totalItems)
+      : Number(
+          (
+            await db
+              .select({ count: sql<number>`count(*)` })
+              .from(schema.documents)
+              .where(where)
+          )[0]?.count ?? 0,
+        );
 
     const parentIds = [
       ...new Set(docs.flatMap((doc) => (doc.parentId ? [doc.parentId] : []))),
@@ -290,24 +419,30 @@ export default defineAction({
     const parentById = new Map(parents.map((parent) => [parent.id, parent]));
 
     return {
-      documents: docs.map((doc) => ({
-        id: doc.id,
-        parentId:
-          doc.parentId && parentById.has(doc.parentId) ? doc.parentId : null,
-        parentTitle: doc.parentId
-          ? (parentById.get(doc.parentId)?.title ?? null)
-          : null,
-        documentType: doc.documentType,
-        sourceKind: doc.sourceKind,
-        sourceUpdatedAt: doc.sourceUpdatedAt,
-        title: doc.title,
-        description: doc.description,
-        icon: doc.icon,
-        snippet: makeSnippet(doc.contentPreview, doc.snippetNeedle),
-        contentLength: Number(doc.contentLength) || 0,
-        hideFromSearch: parseDocumentHideFromSearch(doc.hideFromSearch),
-        updatedAt: doc.updatedAt,
-      })),
+      documents: docs.map((doc) => {
+        const preview = previewById.get(doc.id);
+        return {
+          id: doc.id,
+          parentId:
+            doc.parentId && parentById.has(doc.parentId) ? doc.parentId : null,
+          parentTitle: doc.parentId
+            ? (parentById.get(doc.parentId)?.title ?? null)
+            : null,
+          documentType: doc.documentType,
+          sourceKind: doc.sourceKind,
+          sourceUpdatedAt: doc.sourceUpdatedAt,
+          title: doc.title,
+          description: doc.description,
+          icon: doc.icon,
+          snippet: makeSnippet(
+            preview?.contentPreview ?? "",
+            preview?.snippetNeedle ?? "",
+          ),
+          contentLength: Number(preview?.contentLength) || 0,
+          hideFromSearch: parseDocumentHideFromSearch(doc.hideFromSearch),
+          updatedAt: doc.updatedAt,
+        };
+      }),
       pagination: documentDiscoveryPagination({
         offset: args.offset,
         limit: args.limit,

package/corpus/templates/content/changelog/2026-09-21-search-ranks-title-matches-first.md

@@ -0,0 +1,6 @@
+---
+type: improved
+date: 2026-09-21
+---
+
+Search now ranks exact and partial title matches above incidental matches in document bodies.