mixdog 0.9.17 → 0.9.19

package/src/runtime/memory/lib/memory-recall-store.mjs

@@ -36,7 +36,13 @@ const SEMANTIC_TOP_RANK_MAX = 3
 // 0.749 against real rows), so anything below ~0.70 is noise regardless of
 // rank; cross-language relevant pairs measured 0.67-0.74. 0.70 keeps most of
 // the cross-language rescue while rejecting pure-noise top ranks.
+// The softer 0.70 floor SITS INSIDE the noise band (noise peaked at 0.749), so
+// it only rescues rows that ALSO carry a lexical leg as corroboration. A
+// semantic-only row (no sparse/trgm/exact) must clear SEMANTIC_TOP_RANK_STRICT_SIM
+// instead — set above the measured 0.749 noise ceiling so unrelated top ranks
+// (e.g. old narration surfacing for "embedding worker crash") stop leaking in.
 const SEMANTIC_TOP_RANK_MIN_SIM = 0.70
+const SEMANTIC_TOP_RANK_STRICT_SIM = 0.78
 const SHORT_QUERY_TOKEN_MAX = 2
 // Dense-similarity weighting for retrievalScore. Lexical RRF sums 1/(K+rank)
 // per matching leg (K=60), so a row hitting 2 lexical legs at rank 1 scores
@@ -53,6 +59,64 @@ const SHORT_QUERY_TOKEN_MAX = 2
 // matches the noise floor used elsewhere for MiniLM-class embeddings.
 const SIM_FLOOR = 0.60
 const W_DENSE = 0.04
+// Recency nudge applied ONLY when a [ts_from, ts_to] window is active. Inside a
+// fixed window absolute-age freshness is often disabled (applyFreshness=false)
+// or too flat to separate early-window from late-window rows, so a 07-04 row
+// could outrank a 07-05 row of comparable relevance under a 24h period. This
+// term is a normalized position-in-window score (newest→1) scaled small enough
+// to break comparable-relevance ties toward newer rows without overriding a
+// clearly stronger lexical/semantic match.
+// Kept below a single rank-1 RRF leg (~0.016) so it only breaks ties between
+// comparable-relevance rows and never overrides a clearly stronger match.
+const W_WINDOW_RECENCY = 0.008
+// Rare-token display boost. A query token that appears in the RENDERED display
+// of only a small fraction of the candidate set (an IDF-style rarity signal) is
+// strong evidence a row is genuinely about that term — even for a
+// cross-language row whose only lexical tie is one distinctive English token
+// (e.g. "embedding" inside otherwise-Korean content). We add a boost when such
+// a rare token is present in the fields that actually render (element/summary
+// for roots, content for member-hit turns), so a low-lexical row surfaces above
+// common-token neighbours. Scoped to display fields so we never promote a row
+// whose match hides in un-rendered body text. RARE_DF_MAX gates "rare": tokens
+// present in >34% of candidates are common and earn nothing.
+// Scaled to at most one rank-1 RRF leg (1/(K+1) ≈ 0.0164 at K=60): a rare
+// display token is a genuine relevance signal, but the IDF boost should only
+// carry the weight of a single extra retrieval-leg agreement — enough to break
+// ties toward the distinctive-token row without overriding a clearly stronger
+// multi-leg lexical/semantic match. W_RARE * (1 - df/N) peaks below this cap.
+const W_RARE = 0.016
+const RARE_DF_MAX = 0.34
+
+// Lowercased, de-duplicated query tokens (>= 2 chars) for DF/boost/gate use.
+// Capped at 12 (mirrors buildExactTerms) so a paragraph-length query can't
+// turn the per-row DF scan into O(tokens × candidateWindow) on display text.
+function queryTokensLower(query) {
+  const clean = String(query ?? '').replace(/\s+/g, ' ').trim()
+  const toks = (clean.match(/[\p{L}\p{N}_./:-]+/gu) || [])
+    .map(t => t.toLowerCase())
+    .filter(t => Array.from(t).length >= 2)
+  return [...new Set(toks)].slice(0, 12)
+}
+
+// The text that actually renders as a result LINE for a row: element+summary
+// for a root (its members render on their own lines), plus content for a
+// member-hit turn (its own content is the rendered line). Deliberately excludes
+// a ROOT's body content, which never renders when the row is shown as a summary
+// line — matching there is incidental, not topical.
+function rowDisplayText(row) {
+  const base = `${row?.element ?? ''} ${row?.summary ?? ''}`
+  const withBody = Number(row?.is_root) === 0 ? `${base} ${row?.content ?? ''}` : base
+  return withBody.toLowerCase()
+}
+
+function windowRecencyFactor(ts, tsFrom, tsTo, nowMs) {
+  const t = Number(ts)
+  if (!Number.isFinite(t)) return 0
+  const hi = tsTo != null ? tsTo : nowMs
+  const lo = tsFrom != null ? tsFrom : hi - 86_400_000 // default 24h span when open-started
+  if (!(hi > lo)) return 0
+  return Math.max(0, Math.min(1, (t - lo) / (hi - lo)))
+}
 
 function buildExactTerms(query) {
   const clean = String(query ?? '').replace(/\s+/g, ' ').trim()
@@ -100,7 +164,8 @@ function hasQueryTokenCoverage(row, queryTokenCount) {
   if (queryTokenCount <= SHORT_QUERY_TOKEN_MAX) return true
   const hits = Number(row?.exact_hits)
   // Majority coverage, not full coverage. Requiring EVERY query token to hit
-  // made mixed-language queries ("usage spike 원인") return nothing when one
+  // made mixed-language queries (English "usage spike" plus a Korean noun for
+  // "cause") return nothing when one
   // token has no lexical counterpart in the row — ~60% of tokens matching is
   // strong enough lexical evidence alongside the semantic leg.
   const required = Math.max(2, Math.ceil(queryTokenCount * 0.6))
@@ -221,8 +286,14 @@ export async function searchRelevantHybrid(db, query, options = {}) {
   // Returns { clause: string, params: any[] }; clause begins with AND or is ''.
   function buildFilterClause(offset, opts = {}) {
     return buildRecallScopeFilter(offset, {
-      ts_from: opts.skipTsWindow ? null : tsFrom,
-      ts_to: opts.skipTsWindow ? null : tsTo,
+      // skipTsWindow must fully DROP the ts predicate for member-hit roots
+      // (their own ts can sit outside the window; the member ts was already
+      // gated). Pass `undefined`, not `null`: buildRecallScopeFilter coerces
+      // its ts inputs via Number(x), and Number(null) === 0 (finite) would
+      // inject `ts BETWEEN 0 AND 0`, silently dropping every member-hit root.
+      // Number(undefined) === NaN, which the finite-check correctly skips.
+      ts_from: opts.skipTsWindow ? undefined : tsFrom,
+      ts_to: opts.skipTsWindow ? undefined : tsTo,
       excludeStatuses,
       category: categories,
       projectScope,
@@ -514,6 +585,36 @@ LEFT JOIN exact  x ON x.id = c.id`
   const K = 60
   const nowMs = Date.now()
 
+  // ── Rare-token display DF (IDF-style rarity) ─────────────────────────────
+  // Count, per query token, how many candidate rows carry it in their RENDERED
+  // display text. A token in only a small fraction of candidates is rare and
+  // earns a boost for the rows that show it (see rareTokenDisplayBoost).
+  const qTokens = queryTokensLower(clean)
+  const candCount = rawRows.length || 1
+  const displayDf = new Map()
+  if (qTokens.length > 0) {
+    const displayTexts = rawRows.map(rowDisplayText)
+    for (const t of qTokens) {
+      let c = 0
+      for (const dt of displayTexts) if (dt.includes(t)) c++
+      displayDf.set(t, c)
+    }
+  }
+  function rareTokenDisplayBoost(row) {
+    if (qTokens.length === 0) return 0
+    const disp = rowDisplayText(row)
+    let best = 0
+    for (const t of qTokens) {
+      const df = displayDf.get(t) ?? 0
+      if (df === 0) continue
+      if (df / candCount > RARE_DF_MAX) continue // common token: no rarity credit
+      if (!disp.includes(t)) continue
+      const b = W_RARE * (1 - df / candCount)
+      if (b > best) best = b
+    }
+    return best
+  }
+
   const scoredAll = rawRows.map(row => {
     const id = Number(row.id)
     const denseRank = row.dense_rank != null ? Number(row.dense_rank) : null
@@ -526,21 +627,37 @@ LEFT JOIN exact  x ON x.id = c.id`
               + (exactRank ? 1 / (K + exactRank) : 0)
     const freshness = applyFreshness ? freshnessFactor(row.ts, nowMs) : 1.0
     const boost = exactTextBoost(clean, row, row.exact_hits)
+    const rareBoost = rareTokenDisplayBoost(row)
     const sim = Number(row.dense_sim)
     const denseTerm = Number.isFinite(sim)
       ? W_DENSE * Math.max(0, sim - SIM_FLOOR) / (1 - SIM_FLOOR) * freshness
       : 0
-    return { id, row, rrf, freshness, retrievalScore: (rrf * freshness) + boost + denseTerm }
+    const windowRecency = hasTsFilter ? W_WINDOW_RECENCY * windowRecencyFactor(row.ts, tsFrom, tsTo, nowMs) : 0
+    return { id, row, rrf, freshness, retrievalScore: (rrf * freshness) + boost + rareBoost + denseTerm + windowRecency }
   })
   let semanticOnlyDropped = 0
   let weakTextDropped = 0
+  // Cross-language signature: a query whose candidate set produced NO lexical
+  // leg at all is almost always a cross-language recall where dense is the only
+  // usable signal. In that case relax the top-rank rescue back to the measured
+  // 0.70-0.74 band; when lexical evidence exists elsewhere, keep demanding
+  // lexical corroboration (or the stricter above-noise floor) per row.
+  const setHasLexicalLeg = scoredAll.some(({ row }) => row.sparse_rank != null || row.exact_rank != null)
   const scored = scoredAll.filter(({ row }) => {
     const hasTextSupport = row.sparse_rank != null || row.trgm_rank != null || row.exact_rank != null
     const sim = Number(row.dense_sim)
     const denseRankNum = row.dense_rank != null ? Number(row.dense_rank) : null
-    const hasSemanticSupport = (Number.isFinite(sim) && sim >= SEMANTIC_ONLY_MIN_SIM)
-      || (Number.isFinite(sim) && sim >= SEMANTIC_TOP_RANK_MIN_SIM
-          && denseRankNum != null && denseRankNum <= SEMANTIC_TOP_RANK_MAX)
+    const hasStrongSemantic = Number.isFinite(sim) && sim >= SEMANTIC_ONLY_MIN_SIM
+    const hasLexicalLeg = row.sparse_rank != null || row.exact_rank != null
+    // Top-rank rescue now demands corroboration: the softer 0.70 floor only
+    // rescues rows that also carry a lexical leg, while a purely semantic row
+    // must clear the stricter above-noise floor. This stops sub-noise top
+    // ranks (unrelated narration) from surfacing on semantic-only queries.
+    const inTopRank = denseRankNum != null && denseRankNum <= SEMANTIC_TOP_RANK_MAX
+    const hasTopRankRescue = Number.isFinite(sim) && inTopRank
+      && ((sim >= SEMANTIC_TOP_RANK_MIN_SIM && (hasLexicalLeg || !setHasLexicalLeg))
+          || sim >= SEMANTIC_TOP_RANK_STRICT_SIM)
+    const hasSemanticSupport = hasStrongSemantic || hasTopRankRescue
     if (!hasTextSupport) {
       if (hasSemanticSupport) return true
       semanticOnlyDropped += 1
@@ -554,7 +671,37 @@ LEFT JOIN exact  x ON x.id = c.id`
     if (categories.length > 0) return true
     const hasFullPhrase = hasFullQueryTextMatch(clean, row)
     if (hasFullPhrase) return true
-    if (queryTokenCount <= SHORT_QUERY_TOKEN_MAX) return true
+    // Short keyword/identifier lookups: pass real lexical legs (FTS/exact)
+    // freely, but a trigram-only fuzzy hit riding a sub-floor dense leg is
+    // filler — require the strong semantic floor so an unrelated 2-token query
+    // (e.g. an identifier like "ProjectAA" plus a Korean word for "balance"
+    // against another project) returns empty rather
+    // than accidental trigram neighbours.
+    if (queryTokenCount <= SHORT_QUERY_TOKEN_MAX) {
+      // A real FTS (sparse) hit is a topical match — keep it. But an exact/trgm
+      // hit alone can be INCIDENTAL: the term appears only in un-rendered body
+      // text (e.g. a "C:\Project\ProjectAA" path buried in a codeGraph note),
+      // so the row renders a line that never mentions the query at all. For a
+      // short keyword query where every rendered line is expected to be about
+      // the term, require the token to actually land in the display fields
+      // (element/summary, or a member turn's own content) before accepting an
+      // exact/trgm-only row. This drops pure filler without touching genuine
+      // FTS or in-display keyword hits.
+      if (row.sparse_rank != null) return true
+      if (hasStrongSemantic) return true
+      const tokenInDisplay = qTokens.length > 0 && (() => {
+        const d = rowDisplayText(row)
+        return qTokens.some(t => d.includes(t))
+      })()
+      if (hasLexicalLeg && tokenInDisplay) return true
+      // Strong trigram match survives even with a cold/absent dense leg (full
+      // ILIKE=1.0, no-vector path pins 0.5 — both above the 0.3 real-fuzzy
+      // cutoff), but only when the term is on the rendered line, not incidental.
+      const trgSim = Number(row.trg_sim)
+      if (row.trgm_rank != null && Number.isFinite(trgSim) && trgSim >= 0.3 && tokenInDisplay) return true
+      weakTextDropped += 1
+      return false
+    }
     if (row.sparse_rank != null) return true
     // Semantic support as a second signal only applies when the dense leg
     // actually ran. With a cold embedding model (no queryVector) semantic
@@ -582,12 +729,21 @@ LEFT JOIN exact  x ON x.id = c.id`
   // all matching roots at once, then resolve each member from rootById.
   const memberRootIds = []
   const memberRootSeen = new Set()
+  // Matched member ids grouped by their chunk root. A member-hit root is a
+  // grouping artifact surfaced because a SPECIFIC turn matched; rendering its
+  // full sibling set floods precision-sensitive queries (bench:
+  // negative-projectaa) with turns that never mention the term. Attach only the
+  // matched turns for such roots (see membersByRoot filtering below); roots
+  // matched on their own row keep full chunk expansion for context.
+  const matchedMembersByRoot = new Map()
   for (const { id } of filtered) {
     const r0 = byId.get(id)
     if (!r0 || r0.is_root === 1) continue
     if (r0.chunk_root != null && r0.chunk_root !== r0.id) {
       const rid = Number(r0.chunk_root)
       if (!memberRootSeen.has(rid)) { memberRootSeen.add(rid); memberRootIds.push(rid) }
+      if (!matchedMembersByRoot.has(rid)) matchedMembersByRoot.set(rid, new Set())
+      matchedMembersByRoot.get(rid).add(Number(r0.id))
     }
   }
   const rootById = new Map()
@@ -732,7 +888,24 @@ LEFT JOIN exact  x ON x.id = c.id`
     if (!finalRoot) continue
     const out = { ...finalRoot, rrf, retrievalScore, retrievalRank }
     if (includeMembers && finalRoot.is_root === 1) {
-      out.members = membersByRoot.get(Number(finalRoot.id)) ?? []
+      const allMembers = membersByRoot.get(Number(finalRoot.id)) ?? []
+      // Member-hit root: attach only the turns that actually matched (keeps the
+      // rendered lines on-topic; a broad conversation root that matched on one
+      // buried turn no longer floods with unrelated siblings). Root-matched
+      // chunks keep full expansion for context. Fall back to full expansion if
+      // the matched set somehow resolves empty.
+      const matched = matchedMembersByRoot.get(Number(finalRoot.id))
+      if (matched && matched.size > 0) {
+        const kept = allMembers.filter(m => matched.has(Number(m.id)))
+        const use = kept.length > 0 ? kept : allMembers
+        // Attach only the matched turns (general: avoids flooding with
+        // unrelated siblings of a broad conversation root), rendering each
+        // matched turn's FULL content — no per-line token trimming, which could
+        // drop the answer line when only the question line carries the term.
+        out.members = use
+      } else {
+        out.members = allMembers
+      }
     }
     results.push(out)
   }

package/src/runtime/memory/lib/query-handlers.mjs

@@ -18,6 +18,7 @@ import {
   interleaveRawRows,
   renderEntryLines,
   renderSessionGroupedLines,
+  collapseNearDuplicateRows,
 } from './recall-format.mjs'
 import { searchRelevantHybrid } from './memory-recall-store.mjs'
 import { fetchEntriesByIdsScoped } from './memory-recall-id-patch.mjs'
@@ -72,7 +73,7 @@ export function createQueryHandlers({
           return `(CASE WHEN ${textExpr} LIKE $${params.length} THEN 1 ELSE 0 END)`
         })
         // Multi-token queries: from 3+ terms require at least 2 matching terms
-        // so one common token ("대화", "recall") can't drag unrelated raw rows
+        // so one common token ("chat", "recall") can't drag unrelated raw rows
         // into the page. 1-2 term queries keep single-hit contains semantics —
         // short Korean queries are often exactly two meaningful tokens and a
         // 2-of-2 requirement silently emptied the raw leg for them.
@@ -432,7 +433,7 @@ export function createQueryHandlers({
     const hasQueryForSort = Array.isArray(args.query)
       ? args.query.some((v) => String(v || '').trim())
       : String(args.query ?? '').trim() !== ''
-    const sort = args.sort != null ? String(args.sort) : (hasQueryForSort ? 'importance' : 'date')
+    let sort = args.sort != null ? String(args.sort) : (hasQueryForSort ? 'importance' : 'date')
     // Chunk content is the primary recall output. Members default to true so
     // callers receive the raw chunk leaves (the cycle1-produced semantic
     // chunks) rather than just the root's cycle2-compressed summary line.
@@ -448,6 +449,13 @@ export function createQueryHandlers({
     const includeArchived = args.includeArchived !== false
     const category = args.category
     const temporal = parsePeriod(period, Boolean(query))
+    // Bounded-period query recall reads as a timeline ("today's work"), not a
+    // relevance ranking: when the caller EXPLICITLY supplied a period that
+    // resolves to a real time window and did NOT pin sort, force newest-first
+    // so the page is strictly chronological (bench: recency-today). Gated on
+    // the explicit `period` string — the implicit 30d default a bare query
+    // gets must keep importance ranking (else topical query recall regresses).
+    if (args.sort == null && query && period && temporal && temporal.startMs != null) sort = 'date'
 
     // Derive projectScope from caller cwd (falls back to process.cwd()).
     // Explicit args.projectScope (string) takes priority so callers can
@@ -584,7 +592,19 @@ export function createQueryHandlers({
           { projectScope, terms: sessionRecallTerms(query) },
         )
         const seenIds = new Set(filtered.map(r => r.id))
-        const newRaw = rawRows.filter(r => !seenIds.has(r.id))
+        let newRaw = rawRows.filter(r => !seenIds.has(r.id))
+        // Relevance gate: readRawRowsInWindow's SQL term filter is loose
+        // (minHits 1 for <3-term queries), so unscored raw rows that share a
+        // single common token still get stride-interleaved into a ranked
+        // result set and push real hits down the page. In the query branch,
+        // keep only raw rows whose body actually contains >=1 query term.
+        const rawTerms = sessionRecallTerms(query)
+        if (rawTerms.length > 0) {
+          newRaw = newRaw.filter((r) => {
+            const hay = `${r.content ?? ''} ${r.element ?? ''} ${r.summary ?? ''}`.toLowerCase()
+            return rawTerms.some((t) => hay.includes(t))
+          })
+        }
         if (sort === 'date') {
           for (const r of newRaw) filtered.push(r)
           filtered.sort((a, b) => (Number(b.ts) || 0) - (Number(a.ts) || 0))
@@ -599,6 +619,12 @@ export function createQueryHandlers({
       if (coreRows.length > 0) {
         filtered = [...coreRows, ...filtered]
       }
+      // Core rows are prepended by relevance and carry updated_at as ts, so on
+      // the chronological (date) path they'd break strict newest-first. Re-sort
+      // the merged list by ts desc before slicing so the timeline stays intact.
+      if (sort === 'date') {
+        filtered.sort((a, b) => (Number(b.ts) || 0) - (Number(a.ts) || 0) || (Number(b.id) || 0) - (Number(a.id) || 0))
+      }
       const sliced = filtered.slice(offset, offset + limit)
       const _t2 = Date.now()
       if (process.env.MIXDOG_DEBUG_MEMORY) {
@@ -622,7 +648,13 @@ export function createQueryHandlers({
           }]).catch(e => log(`[trace] insertTraceEvents error: ${e?.message}\n`))
         }
       }
-      const out = { text: recallCapPrefix + renderEntryLines(sliced) }
+      // Collapse near-duplicate long bodies within this single result set so
+      // paraphrased restatements don't each spend the full line budget. Search
+      // path only — id-lookup output above never calls this.
+      const deduped = collapseNearDuplicateRows(sliced)
+      // recencyOrder render on the date path flattens roots+members into one
+      // ts-desc stream so per-chunk (ts-ASC) members can't invert the timeline.
+      const out = { text: recallCapPrefix + renderEntryLines(deduped, { recencyOrder: sort === 'date' }) }
       if (process.env.MIXDOG_DEBUG_MEMORY) {
         log(`[search-time] render+trace=${Date.now() - _t2}ms total=${Date.now() - _t0}ms textLen=${out.text.length}\n`)
       }

package/src/runtime/memory/lib/recall-format.mjs

@@ -149,30 +149,47 @@ export function interleaveRawRows(hybridRows, rawRows) {
   return out
 }
 
-export function renderEntryLines(rows) {
+export function renderEntryLines(rows, { recencyOrder = false } = {}) {
   if (!rows || rows.length === 0) return '(no results)'
-  const lines = []
+  // Each emitted line is tracked as a { ts, text } unit so the recencyOrder
+  // path can sort the WHOLE stream (roots + their members, plus leaf/raw rows)
+  // strictly newest-first. Members are fetched ts-ASC per chunk, so without
+  // this global re-sort a multi-member chunk would emit oldest-first lines and
+  // break a strict newest-first contract (bench: recency-today).
+  const units = []
   // Bound total emitted lines (roots x members) so a many-member recall can't
   // inject unbounded output. Per-line content is already capped at 1000 chars;
   // this caps the line COUNT. Narrow the query (limit/period/projectScope) for more.
   const RECALL_LINE_CAP = 200
+  // recencyOrder collects every unit first (so the ts sort sees the full set)
+  // and caps AFTER sorting; the default path keeps the original cap-as-we-go.
+  const COLLECT_CAP = recencyOrder ? Infinity : RECALL_LINE_CAP
   let _capped = false
   outer:
   for (const r of rows) {
+    // Collapsed near-duplicate (search path only — set by
+    // collapseNearDuplicateRows). Emit a one-line stub carrying its #id so an
+    // id-lookup follow-up can still fetch the full body; never rendered for
+    // id-lookup output (those rows never carry _dupStub).
+    if (r && r._dupStub) {
+      if (units.length >= COLLECT_CAP) { _capped = true; break }
+      units.push({ ts: Number(r.ts) || 0, text: `[${formatTs(r.ts)}] (near-duplicate of #${r._dupOf} — collapsed) #${r.id}` })
+      continue
+    }
     const hasMembers = Array.isArray(r.members) && r.members.length > 0
     if (hasMembers) {
       // Chunks present: emit each member as its own line. Root row is a
       // grouping artifact for retrieval — the caller wants the chunk
       // content (cycle1 raw), not the cycle2-compressed summary.
       for (const m of r.members) {
-        if (lines.length >= RECALL_LINE_CAP) { _capped = true; break outer }
+        if (units.length >= COLLECT_CAP) { _capped = true; break outer }
         const mTs = formatTs(m.ts)
         const role = m.role === 'user' ? 'u' : m.role === 'assistant' ? 'a' : (m.role || '?')
         const content = cleanMemoryText(String(m.content ?? '')).slice(0, 1000)
-        lines.push(`[${mTs}] ${role}: ${content} #${m.id}`)
+        units.push({ ts: Number(m.ts) || 0, text: `[${mTs}] ${role}: ${content} #${m.id}` })
       }
     } else {
-      if (lines.length >= RECALL_LINE_CAP) { _capped = true; break }
+      if (units.length >= COLLECT_CAP) { _capped = true; break }
       // No chunks (root not yet chunked by cycle1, or orphan leaf): emit
       // the row itself in the same shape. element/summary fall back to
       // raw content when both are absent.
@@ -192,13 +209,96 @@ export function renderEntryLines(rows) {
       // Unchunked raw leaf (cycle1 hasn't classified it yet): mark it so
       // callers can tell fresh-but-unprocessed rows from chunked memory.
       const pendingMark = (r.is_root === 0 && r.chunk_root == null) ? ' [pending]' : ''
-      lines.push(`[${ts}] ${rolePrefix}${body.slice(0, 1000)}${pendingMark} #${r.id}`)
+      units.push({ ts: Number(r.ts) || 0, text: `[${ts}] ${rolePrefix}${body.slice(0, 1000)}${pendingMark} #${r.id}` })
     }
   }
+  if (recencyOrder) {
+    // Array.sort is stable in V8, so units sharing the same ts keep their
+    // insertion (root/member) order; only cross-unit ts breaks are corrected.
+    units.sort((a, b) => b.ts - a.ts)
+    if (units.length > RECALL_LINE_CAP) { units.length = RECALL_LINE_CAP; _capped = true }
+  }
+  const lines = units.map((u) => u.text)
   if (_capped) lines.push(`[recall truncated — showing first ${RECALL_LINE_CAP} lines; narrow the query (limit/period/projectScope) for the rest]`)
   return lines.join('\n')
 }
 
+// Search-result de-duplication. Within a SINGLE formatted result set, hybrid
+// recall frequently returns several long rows that restate the same design in
+// slightly different words (e.g. a root summary plus a chunk that paraphrases
+// it). They each spend the ~1000-char line budget on near-identical text.
+// Cheap heuristic (no embeddings): normalize each row's body to word tokens,
+// build 3-gram shingle sets, and measure containment overlap = |A∩B| /
+// min(|A|,|B|) against already-kept rows. Rows arrive rank/date-ordered, so the
+// FIRST occurrence is the newest/highest-ranked and is kept full; a later
+// high-overlap row is dropped (near-total) or rendered as an id-stub.
+//   - drop  when overlap >= DROP_OVERLAP (0.9): body adds nothing.
+//   - stub  when overlap >= STUB_OVERLAP (0.65): keep the #id reachable.
+// Short bodies (< MIN_TOKENS words) are never collapsed — they can't carry
+// enough signal for the overlap metric to be meaningful and are cheap anyway.
+// Applies to search results only; id-lookup output must never call this.
+function normalizedRowText(r) {
+  if (Array.isArray(r?.members) && r.members.length > 0) {
+    return r.members.map((m) => cleanMemoryText(String(m.content ?? ''))).join(' ').toLowerCase()
+  }
+  const element = r?.element ?? ''
+  const summary = r?.summary ?? ''
+  const body = (element || summary)
+    ? `${element} ${summary}`
+    : cleanMemoryText(String(r?.content ?? ''))
+  return String(body).toLowerCase()
+}
+
+export function collapseNearDuplicateRows(rows, {
+  stubOverlap = 0.65,
+  dropOverlap = 0.9,
+  minTokens = 12,
+} = {}) {
+  if (!Array.isArray(rows) || rows.length < 2) return rows
+  const shingle = (r) => {
+    const toks = normalizedRowText(r).match(/[\p{L}\p{N}_]+/gu) || []
+    if (toks.length < minTokens) return null
+    const set = new Set()
+    if (toks.length < 3) { for (const t of toks) set.add(t); return set }
+    for (let i = 0; i + 3 <= toks.length; i += 1) set.add(`${toks[i]} ${toks[i + 1]} ${toks[i + 2]}`)
+    return set
+  }
+  const kept = [] // { row, shingles }
+  const out = []
+  for (const r of rows) {
+    const sh = shingle(r)
+    if (!sh) { out.push(r); continue }
+    // Two metrics per kept row:
+    //   containment = |A∩B| / min(|A|,|B|)  — catches paraphrase/superset
+    //   jaccard     = |A∩B| / |A∪B|         — size-aware, immune to the
+    //                                         short-vs-long 1.0 false positive
+    // Dropping on containment alone let a short distinct UPDATE fully contained
+    // in a long earlier row score 1.0 and vanish. Drop only on high jaccard OR
+    // high containment between comparably-sized rows (size ratio >= 0.5). Stub
+    // stays containment-based so paraphrase restatements still collapse to a
+    // reachable id-stub.
+    let bestStub = 0
+    let bestStubId = null
+    let drop = false
+    for (const k of kept) {
+      const [small, large] = sh.size <= k.shingles.size ? [sh, k.shingles] : [k.shingles, sh]
+      let inter = 0
+      for (const g of small) if (large.has(g)) inter += 1
+      const containment = small.size ? inter / small.size : 0
+      const union = sh.size + k.shingles.size - inter
+      const jaccard = union ? inter / union : 0
+      const sizeRatio = large.size ? small.size / large.size : 0
+      if (jaccard >= 0.85 || (containment >= dropOverlap && sizeRatio >= 0.5)) drop = true
+      if (containment > bestStub) { bestStub = containment; bestStubId = k.row.id }
+    }
+    if (drop) continue
+    if (bestStub >= stubOverlap) { out.push({ ...r, _dupStub: true, _dupOf: bestStubId }); continue }
+    kept.push({ row: r, shingles: sh })
+    out.push(r)
+  }
+  return out
+}
+
 // Compact session label for group headers: keep short ids verbatim, shorten
 // long ones to a recognizable tail (ids are typically unique in the suffix —
 // timestamp/counter — not the prefix).

package/src/runtime/memory/lib/session-ingest.mjs

@@ -234,7 +234,7 @@ function stripUserTurnPrefixEnvelopes(text) {
   //    `# Session\n` are EXACTLY the fixed fields buildSessionStartBlock emits
   //    (`Cwd: `, `Model: `, `Workflow: `, each on its own line) before the
   //    blank-line terminator. A human doc that merely STARTS with a `# Session`
-  //    heading followed by free prose (e.g. `프로젝트 회의록입니다`) does NOT match
+  //    heading followed by free prose in any language (e.g. `meeting notes`) does NOT match
   //    — its next line is not a `Cwd:/Model:/Workflow:` field — so it is
   //    preserved verbatim (zero-loss). Anchored ^.
   out = out.replace(/^# Session\n(?:(?:Cwd|Model|Workflow): [^\n]*\n)+(?:\n|$)/, '')

package/src/runtime/shared/atomic-file.mjs

@@ -75,7 +75,13 @@ export function withFileLockSync(lockPath, fn, opts = {}) {
       }
       try {
         const st = statSync(lockPath);
-        if (Date.now() - st.mtimeMs > staleMs) {
+        // Dead-owner fast path: if the lock's recorded owner pid is gone,
+        // force-release immediately instead of waiting out staleMs. A crashed
+        // owner would otherwise hold the path until the 30s stale window,
+        // starving waiters past the 8s acquire timeout (the restart stall).
+        const ownerPidEarly = _readLockOwnerPid(lockPath);
+        const ownerDead = ownerPidEarly !== null && _pidIsDead(ownerPidEarly);
+        if (ownerDead || Date.now() - st.mtimeMs > staleMs) {
           // Only steal a stale lock when we can prove the owner is
           // gone. Reading the pid from the lock file and probing it
           // with kill(pid, 0) protects a slow-but-live holder from
@@ -96,14 +102,14 @@ export function withFileLockSync(lockPath, fn, opts = {}) {
           // path unlink is not a portable unlink-if-token-still-matches
           // primitive, so live-lock safety rests on the lockPath token
           // reverify immediately before the lockPath unlink below.
-          const deadPid = _readLockOwnerPid(lockPath);
-          if (deadPid !== null && _pidIsDead(deadPid)) {
+          const deadPid = ownerPidEarly;
+          if (ownerDead) {
             const reclaim = _tryAcquireReclaimGuard(lockPath, staleMs);
             if (reclaim !== null) {
               let reclaimed = false;
               try {
                 const currentSt = statSync(lockPath);
-                if (Date.now() - currentSt.mtimeMs > staleMs) {
+                if (ownerDead || Date.now() - currentSt.mtimeMs > staleMs) {
                   const currentPid = _readLockOwnerPid(lockPath);
                   if (currentPid === deadPid && _pidIsDead(currentPid)) {
                     try { unlinkSync(lockPath); reclaimed = true; } catch {}

package/src/runtime/shared/background-tasks.mjs

@@ -48,8 +48,10 @@ export function resolveExecutionMode(args = {}, defaultMode = 'sync') {
 }
 
 export function executionModeSchemaDescription(defaultMode = 'sync') {
-  const defaultText = defaultMode === 'async' ? 'Default async.' : 'Default sync.';
-  return `sync = inline result; async = task_id + completion notification. ${defaultText}`;
+  if (defaultMode === 'async') {
+    return 'sync = inline result; async = task_id + completion notification. Default async.';
+  }
+  return 'Runs sync; long-running auto-promotes to a background task_id + completion notification. async forces background.';
 }
 
 export function taskIdFromArgs(args = {}) {

package/src/runtime/shared/tool-execution-contract.mjs

@@ -2,7 +2,7 @@ export const TOOL_SYNC_EXECUTION_CONTRACT =
   'Runs synchronously in this tool call.';
 
 export const TOOL_ASYNC_EXECUTION_CONTRACT =
-  'Async returns task_id; completion notification follows. status/read/wait are recovery/blocking only.';
+  'Runs sync; long-running auto-promotes to a task_id + completion notification. async forces background. status/read/wait are recovery/blocking only.';
 
 export const TOOL_MANUAL_CONTROL_CONTRACT =
   'wait/read/status/cancel are for explicit blocking or recovery only.';

package/src/runtime/shared/tool-result-summary.mjs

@@ -74,7 +74,7 @@ export function formatLineDelta(totals) {
 }
 
 export function parseUpdateSummary(text) {
-  const match = /^(Updated|Created|Deleted)\s+(.+?)(?:\s+·\s+|$)/i.exec(String(text || '').trim());
+  const match = /^(Updated|Created|Deleted|Checked)\s+(.+?)(?:\s+·\s+|$)/i.exec(String(text || '').trim());
   if (!match) return null;
   const action = titleWord(match[1]);
   const target = match[2].trim();

package/src/runtime/shared/tool-surface.mjs

@@ -703,7 +703,36 @@ export function formatAggregateDetail(summaries) {
     }
 
     const update = parseUpdateSummary(text);
-    if (update) {
+    // Dry-run patch checks ("Checked foo.js · +7 -5") are validations, not
+    // edits: their line delta must NEVER be summed into the real edit total.
+    // They get their own metric so repeated checks still merge; the preview
+    // delta is shown only when the card has no real edit delta it could be
+    // confused with. Delta-less "Checked ..." texts (task/memory summaries)
+    // fall through to extras unchanged.
+    if (update && update.action === 'Checked') {
+      if (update.seen) {
+        const metric = addMetric('checked_files', {
+          files: new Set(),
+          fileCount: 0,
+          added: 0,
+          removed: 0,
+          seen: false,
+          render: (m) => {
+            const count = m.fileCount + m.files.size;
+            const target = count === 1 && m.fileCount === 0 ? [...m.files][0] : `${count} ${pluralize(count, 'file')}`;
+            const editDelta = formatLineDelta(metrics.get('updated_files'));
+            const delta = editDelta ? '' : formatLineDelta(m);
+            return delta ? `Checked ${target} · ${delta}` : `Checked ${target}`;
+          },
+        });
+        if (update.file) metric.files.add(update.file);
+        metric.fileCount += update.fileCount;
+        metric.added += update.added;
+        metric.removed += update.removed;
+        metric.seen = metric.seen || update.seen;
+        continue;
+      }
+    } else if (update) {
       const metric = addMetric('updated_files', {
         files: new Set(),
         fileCount: 0,

package/src/session-runtime/config-lifecycle.mjs

@@ -58,7 +58,7 @@ export function createConfigLifecycle({
     ) {
       return outputStyleStatusCache;
     }
-    outputStyleStatusCache = outputStyleStatus(dataDir);
+    outputStyleStatusCache = outputStyleStatus(dataDir, { fresh });
     outputStyleStatusCacheAt = now;
     outputStyleStatusCacheDir = cacheDir;
     return outputStyleStatusCache;