mixdog 0.9.46 → 0.9.49

package/src/runtime/agent/orchestrator/tools/shell-command.mjs

@@ -406,6 +406,9 @@ export class ExecResult {
     this.signal = opts.signal || null;
     this.timedOut = opts.timedOut === true;
     this.killed = opts.killed === true;
+    // Why mixdog initiated a tree kill. Keep this separate from `signal`,
+    // which is the process-reported termination signal (SIGTERM/SIGKILL).
+    this.killCause = opts.killCause || null;
     this.stdoutPath = opts.stdoutPath || null;
     this.stdoutFileSize = opts.stdoutFileSize || 0;
     this.stderrPath = opts.stderrPath || null;
@@ -463,7 +466,40 @@ async function _spawnShellWithRetry({ shell, argv, spawnOptions, shellArg, cwd }
     let attempt = 0;
     for (;;) {
       try {
-        return spawn(shell, argv, spawnOptions);
+        const child = spawn(shell, argv, spawnOptions);
+        // spawn() reports ENOENT/EACCES on nextTick. Keep a guard listener
+        // attached from the same synchronous frame as spawn(), and do not
+        // resolve this helper until the child emits `spawn`. The caller adopts
+        // the guard atomically (new listener first, guard removal second), so
+        // there is never an unhandled-error window across either await.
+        let bufferedError = null;
+        const guardError = (err) => { bufferedError = bufferedError || err; };
+        child.on('error', guardError);
+        try {
+          await new Promise((resolveSpawn, rejectSpawn) => {
+            const onSpawn = () => {
+              child.removeListener('error', onError);
+              resolveSpawn();
+            };
+            const onError = (err) => {
+              child.removeListener('spawn', onSpawn);
+              rejectSpawn(err);
+            };
+            child.once('spawn', onSpawn);
+            child.once('error', onError);
+          });
+        } catch (err) {
+          child.removeListener('error', guardError);
+          throw err;
+        }
+        return {
+          child,
+          adoptErrorHandler(handler) {
+            child.on('error', handler);
+            child.removeListener('error', guardError);
+            if (bufferedError) handler(bufferedError);
+          },
+        };
       } catch (err) {
         try {
           console.error('[shell-spawn-retry] ' + JSON.stringify({
@@ -507,6 +543,12 @@ export function execShellCommand({
     const taskOutput = new TaskOutput(taskId);
     let timedOut = false;
     let killed = false;
+    let killCause = null;
+    let failurePhase = null;
+    let failureReason = null;
+    let spawnError = null;
+    let pendingChildError = null;
+    let settle = null;
     let settled = false;
     let timer = null;
     let abortHandler = null;
@@ -535,7 +577,9 @@ export function execShellCommand({
     // outside the timeout branch. Function declaration so callers placed
     // above settle()'s const definition still resolve via hoisting; the
     // 5 s deadline always fires after settle is constructed.
-    function _treeKillForceSettle() {
+    function _treeKillForceSettle(cause) {
+      killed = true;
+      killCause = killCause || cause || 'runtime-guard';
       treeKill(child);
       const _killDeadline = setTimeout(() => {
         if (settled) return;
@@ -574,7 +618,7 @@ export function execShellCommand({
       const argv = Array.isArray(shellArgs) && shellArgs.length > 0
         ? [...shellArgs, _spawnCommand]
         : [shellArg, _spawnCommand];
-      child = await _spawnShellWithRetry({
+      const spawned = await _spawnShellWithRetry({
         shell,
         argv,
         shellArg,
@@ -598,6 +642,14 @@ export function execShellCommand({
         detached: process.platform !== 'win32',
         },
       });
+      child = spawned.child;
+      spawned.adoptErrorHandler((err) => {
+        spawnError = spawnError || err;
+        failurePhase = 'tool';
+        failureReason = 'spawn failed';
+        if (settle) settle(1, null);
+        else pendingChildError = pendingChildError || err;
+      });
       startChildGuardian({
         childPid: child.pid,
         childGroupPid: child.pid,
@@ -624,8 +676,7 @@ export function execShellCommand({
     // before spawn returned (synchronous reentry from a parent abort), so
     // the child doesn't run for the full timeoutMs window.
     if (abortSignal && abortSignal.aborted) {
-      killed = true;
-      _treeKillForceSettle();
+      _treeKillForceSettle('cancellation');
     }
 
     child.stdout.setEncoding('utf-8');
@@ -640,13 +691,12 @@ export function execShellCommand({
     // by a successful exit code on a truncated capture.
     const _abortOnCaptureError = () => {
       if (taskOutput.writeError && !killed && !settled && !autoBackgrounded) {
-        killed = true;
-        _treeKillForceSettle();
+        _treeKillForceSettle('output-capture-error');
       }
     };
 
     let sizeWatchdog = null;
-    const settle = async (exitCode, signal) => {
+    settle = async (exitCode, signal) => {
       if (settled || autoBackgrounded) return;
       settled = true;
       if (timer) {
@@ -678,6 +728,7 @@ export function execShellCommand({
       catch (err) { taskOutput.writeError = taskOutput.writeError || err; }
       try { stderr = await taskOutput.getStderr(); }
       catch (err) { taskOutput.writeError = taskOutput.writeError || err; }
+      if (spawnError && !stderr) stderr = String(spawnError.message || spawnError);
       // Inline-only path: nothing spilled. Nothing to clean up.
       // Spilled but tiny: drop the files — outputFilePath would duplicate
       // the inline body. Spilled and large: keep the files, caller renders
@@ -698,6 +749,7 @@ export function execShellCommand({
           signal,
           timedOut,
           killed,
+          killCause,
           stdoutPath: taskOutput.spilled ? taskOutput.stdoutPath : null,
           stdoutFileSize: taskOutput.stdoutFileSize,
           stderrPath: taskOutput.spilled ? taskOutput.stderrPath : null,
@@ -705,6 +757,8 @@ export function execShellCommand({
           taskId,
           partialOutput,
           outputCaptureError: taskOutput.writeError,
+          failurePhase,
+          failureReason,
         }),
       );
     };
@@ -715,7 +769,7 @@ export function execShellCommand({
     // after stdio is fully drained, so getStdout()/getStderr() see the
     // complete capture.
     child.once('close', (code, signal) => settle(code, signal));
-    child.once('error', () => settle(1, null));
+    if (pendingChildError) settle(1, null);
     // 'close' only fires after stdio drains; a forked grandchild that
     // inherited stdout/stderr fds can hold them open past direct-child
     // exit and stall settle() until timeoutMs. 'exit' fires on direct
@@ -801,8 +855,12 @@ export function execShellCommand({
       // is honored by the kill path too.)
       if (!job) {
         autoBackgrounded = false;
-        if (reason === 'timeout') timedOut = true; else killed = true;
-        _treeKillForceSettle();
+        if (reason === 'timeout') {
+          timedOut = true;
+          _treeKillForceSettle('timeout');
+        } else {
+          _treeKillForceSettle('background-adoption-failed');
+        }
         return;
       }
       // Wire the lifecycle: on close, write the exit-code file FIRST then
@@ -815,14 +873,6 @@ export function execShellCommand({
           try { writeFileSync(job.donePath, ''); } catch {}
         });
       }
-      // Adoption committed. If a cancel already fired (before or during the
-      // adoption window), bring the now-adopted child down via its jobId so the
-      // promotion can't outlive a user abort. Idempotent with the still-attached
-      // abort handler's treeKill.
-      if (abortSignal && abortSignal.aborted) {
-        try { killShellJob(job.jobId); } catch {}
-        try { treeKill(child); } catch {}
-      }
       // Snapshot the partial output captured so far for the immediate result.
       let stdout = '';
       let stderr = '';
@@ -831,6 +881,33 @@ export function execShellCommand({
       try { stderr = await taskOutput.getStderr(); }
       catch (err) { taskOutput.writeError = taskOutput.writeError || err; }
       const jobId = job ? job.jobId : null;
+      // Re-check after the awaited capture reads: cancellation can race after
+      // adoption commits. Never report that cancelled process as a successful
+      // still-running background task.
+      if (abortSignal && abortSignal.aborted) {
+        killed = true;
+        killCause = 'cancellation';
+        try { killShellJob(jobId); } catch {}
+        try { treeKill(child); } catch {}
+        resolve(new ExecResult({
+          stdout,
+          stderr,
+          exitCode: null,
+          signal: child.signalCode || null,
+          timedOut: false,
+          killed: true,
+          killCause,
+          stdoutPath,
+          stdoutFileSize: taskOutput.stdoutFileSize,
+          stderrPath: taskOutput.spilled ? taskOutput.stderrPath : null,
+          stderrFileSize: taskOutput.stderrFileSize,
+          taskId,
+          partialOutput: true,
+          outputCaptureError: taskOutput.writeError,
+          backgrounded: false,
+        }));
+        return;
+      }
       const secs = Math.max(0, Math.round((Date.now() - _startMs) / 1000));
       const _verb = reason === 'timeout'
         ? `moved to background at timeout after ${secs}s`
@@ -880,7 +957,7 @@ export function execShellCommand({
           return;
         }
         timedOut = true;
-        _treeKillForceSettle();
+        _treeKillForceSettle('timeout');
       }, timeoutMs);
       if (timer.unref) timer.unref();
     }
@@ -921,16 +998,14 @@ export function execShellCommand({
       if (settled || autoBackgrounded) return;
       _abortOnCaptureError();
       if (taskOutput.totalDiskBytes() > SHELL_OUTPUT_DISK_CAP) {
-        killed = true;
-        _treeKillForceSettle();
+        _treeKillForceSettle('output-limit');
       }
     }, SIZE_WATCHDOG_INTERVAL_MS);
     if (sizeWatchdog.unref) sizeWatchdog.unref();
 
     if (abortSignal) {
       abortHandler = () => {
-        killed = true;
-        _treeKillForceSettle();
+        _treeKillForceSettle('cancellation');
       };
       try {
         abortSignal.addEventListener('abort', abortHandler, { once: true });

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

@@ -622,7 +622,7 @@ export function createMemoryActionHandlers({
                 // project=<pool> lets the UI thread project_id into the follow-up
                 // promote/dismiss call — matters under project_id:'*' listing where
                 // rows span pools. Uses the same COMMON/slug convention as op:'list'.
-                `id=${c.id} project=${c.project_id == null ? 'COMMON' : c.project_id} [${c.category}] score=${c.score == null ? '-' : c.score.toFixed(2)} ${c.element} — ${String(c.summary || '').slice(0, 200)} (${c.reason})`,
+                `id=${c.id} project=${c.project_id == null ? 'COMMON' : c.project_id} score=${c.score == null ? '-' : c.score.toFixed(2)} ${c.element} — ${String(c.summary || '').slice(0, 200)} (${c.reason})`,
               ).join('\n'),
             }
           }
@@ -634,11 +634,11 @@ export function createMemoryActionHandlers({
           if (op === 'promote') {
             const entry = await promoteCoreCandidate(coreDataDir, args.id, { ...args, scope })
             const mergeNote = entry.merged_with ? ` (merged into core id=${entry.merged_with}, sim=${entry.sim})` : ''
-            return { text: `core promoted candidate id=${args.id} → core id=${entry.id}${mergeNote}: [${entry.category}] ${entry.element}` }
+            return { text: `core promoted candidate id=${args.id} → core id=${entry.id}${mergeNote}: ${entry.element}` }
           }
           // dismiss
           const removed = await dismissCoreCandidate(coreDataDir, args.id, { scope })
-          return { text: `core candidate dismissed (id=${removed.id}): [${removed.category}] ${removed.element}` }
+          return { text: `core candidate dismissed (id=${removed.id}): ${removed.element}` }
         } catch (e) {
           return { text: `core ${op} failed: ${e.message}`, isError: true }
         }
@@ -656,10 +656,15 @@ export function createMemoryActionHandlers({
       })()
       try {
         if (op === 'add' || op === 'edit') {
-          const normalized = normalizeCoreInput(args, {
+          // Category is intentionally absent from the public memory schema.
+          // New direct entries use normalizeCoreInput's internal compatibility
+          // default; edits omit the field so editCore preserves the stored value.
+          const categoryFreeArgs = { ...args }
+          delete categoryFreeArgs.category
+          const normalized = normalizeCoreInput(categoryFreeArgs, {
             requireElement: true,
             requireSummary: true,
-            requireCategory: true,
+            requireCategory: false,
           })
           const errors = [...normalized.errors]
           if (op === 'add') {
@@ -680,7 +685,12 @@ export function createMemoryActionHandlers({
           if (errors.length) {
             return { text: `core ${op}: ${errors.join('; ')}`, isError: true }
           }
-          args = { ...args, element: normalized.element, summary: normalized.summary, category: normalized.category }
+          args = {
+            ...categoryFreeArgs,
+            element: normalized.element,
+            summary: normalized.summary,
+            ...(op === 'add' ? { category: normalized.category } : {}),
+          }
         }
         if (projectId === '*' && op !== 'list') {
           return { text: `core ${op}: project_id "*" only valid for op="list"`, isError: true }
@@ -689,7 +699,7 @@ export function createMemoryActionHandlers({
           if (projectId !== '*') {
             const entries = await listCore(coreDataDir, projectId)
             if (entries.length === 0) return { text: 'core: empty' }
-            return { text: entries.map(e => `id=${e.id} [${e.category}] ${e.element} — ${String(e.summary || '').slice(0, 200)}`).join('\n') }
+            return { text: entries.map(e => `id=${e.id} ${e.element} — ${String(e.summary || '').slice(0, 200)}`).join('\n') }
           }
           // Cross-pool listing — group by project_id, COMMON first
           const entries = await listCore(coreDataDir, '*')
@@ -704,22 +714,22 @@ export function createMemoryActionHandlers({
           for (const [key, rows] of groups) {
             lines.push(`${key === null ? 'COMMON' : key}:`)
             for (const e of rows) {
-              lines.push(`  id=${e.id} [${e.category}] ${e.element} — ${String(e.summary || '').slice(0, 200)}`)
+              lines.push(`  id=${e.id} ${e.element} — ${String(e.summary || '').slice(0, 200)}`)
             }
           }
           return { text: lines.join('\n') }
         }
         if (op === 'add') {
           const entry = await addCore(coreDataDir, args, projectId)
-          return { text: `core added (id=${entry.id}): [${entry.category}] ${entry.element} — ${entry.summary.slice(0, 200)}` }
+          return { text: `core added (id=${entry.id}): ${entry.element} — ${entry.summary.slice(0, 200)}` }
         }
         if (op === 'edit') {
           const entry = await editCoreImpl(coreDataDir, args.id, args)
-          return { text: `core edited (id=${entry.id}): [${entry.category}] ${entry.element} — ${entry.summary.slice(0, 200)}` }
+          return { text: `core edited (id=${entry.id}): ${entry.element} — ${entry.summary.slice(0, 200)}` }
         }
         if (op === 'delete') {
           const removed = await deleteCore(coreDataDir, args.id)
-          return { text: `core deleted (id=${removed.id}): [${removed.category}] ${removed.element}` }
+          return { text: `core deleted (id=${removed.id}): ${removed.element}` }
         }
       } catch (e) {
         return { text: `core ${op} failed: ${e.message}`, isError: true }

package/src/runtime/memory/lib/memory-cycle2-gate.mjs

@@ -11,11 +11,10 @@ import { __mixdogMemoryLog, throwIfAborted, resourceDir } from './memory-cycle2-
 
 export const CYCLE2_ACTIVE_TARGET_CAP = 100
 
-// Minimum number of active (promoted) rows cycle2 must preserve. When the
-// active pool is at or below this floor, active recheck/demotion is skipped
-// and no archiving path may push active below it — prevents draining the
-// pool to zero. Configurable via config.active_floor.
-export const CYCLE2_ACTIVE_MIN_FLOOR = 20
+// Default active-row floor for cycle2. It is zero so rolling active rechecks
+// always run; protection from archive verdicts is opt-in via
+// config.active_floor.
+export const CYCLE2_ACTIVE_MIN_FLOOR = 0
 
 // Status-based verb whitelist. 3-tier policy: pending → active/archived,
 // active → active/archived/update/merge.
@@ -224,6 +223,15 @@ export function loadCurrentRulesDigest() {
       }
     } catch {}
   }
+  const workflows = join(resourceDir(), 'workflows')
+  try {
+    if (existsSync(workflows)) {
+      for (const dir of readdirSync(workflows).sort()) {
+        const workflow = join(workflows, dir, 'WORKFLOW.md')
+        if (existsSync(workflow)) sources.push(workflow)
+      }
+    }
+  } catch {}
   const parts = []
   for (const p of sources) {
     try {

package/src/runtime/memory/lib/memory-cycle2.mjs

@@ -259,16 +259,19 @@ async function _runCycle2Impl(db, config = {}, options = {}, dataDir = null) {
   // over-cap path was historically the ONLY one that re-examined active.
   // Reserve a bounded slice of batch slots for the stalest active rows so
   // rule-duplicate / drifted promotions are archived continuously instead of
-  // sitting forever un-rechecked. Bounded count + reviewed_at rotation
-  // prevents eroding the set to zero (the original over-cap-only concern):
+  // sitting forever un-rechecked. Bounded count + reviewed_at rotation keep
+  // each cycle's exposure small (with the default floor of 0 the pool CAN
+  // erode to zero over repeated cycles if the gate keeps archiving; set
+  // config.active_floor to retain a hard minimum):
   // only the oldest few are re-judged per cycle, and the gate — shown
   // {{CURRENT_RULES}} — keeps genuine A/B entries and archives only
   // restatements. Embedding dedup is skipped on purpose: rule restatements
   // are often cross-language paraphrases whose cosine never clears the merge
   // threshold, but the LLM gate catches the semantic overlap.
-  // Floor guard: when the active pool is at/below the minimum floor, skip the
-  // rolling active recheck entirely so demotions cannot drain it further.
-  const activeRecheckQuota = (reviewActiveRows || activeCount <= activeFloor)
+  // Rolling active recheck always runs outside the over-cap broad review,
+  // including when the active pool is small. Floor protection is opt-in via
+  // config.active_floor and is enforced by the shared floor guard below.
+  const activeRecheckQuota = reviewActiveRows
     ? 0
     : Math.max(0, Math.min(Number(config.active_recheck_quota ?? 8), batchSize - 1))
   const pendingLimit = batchSize - activeRecheckQuota

package/src/runtime/memory/lib/memory-cycle3.mjs

@@ -112,7 +112,30 @@ function coreText(core) {
   return `${core?.element || ''}\n${core?.summary || ''}`
 }
 
-function isSafeConservativeUpdate(current, action) {
+function hasSubstantialNonLatinScript(value) {
+  const text = String(value ?? '')
+  const letters = text.match(/\p{L}/gu) || []
+  const latinLetters = letters.filter((letter) => /\p{Script=Latin}/u.test(letter))
+  const nonLatinLetters = letters.length - latinLetters.length
+  return nonLatinLetters >= 3 && nonLatinLetters >= letters.length * 0.3
+}
+
+function cosineSimilarity(a, b) {
+  if (!Array.isArray(a) || !Array.isArray(b) || a.length === 0 || a.length !== b.length) return null
+  let dot = 0
+  let aNorm = 0
+  let bNorm = 0
+  for (let i = 0; i < a.length; i++) {
+    if (!Number.isFinite(a[i]) || !Number.isFinite(b[i])) return null
+    dot += a[i] * b[i]
+    aNorm += a[i] ** 2
+    bNorm += b[i] ** 2
+  }
+  if (aNorm === 0 || bNorm === 0) return null
+  return dot / Math.sqrt(aNorm * bNorm)
+}
+
+async function isSafeConservativeUpdate(current, action) {
   if (!current || !action?.element || !action?.summary) return { ok: false, reason: 'missing text' }
   const newElement = normalizeComparable(action.element)
   const newSummary = normalizeComparable(action.summary)
@@ -123,11 +146,23 @@ function isSafeConservativeUpdate(current, action) {
   const newText = `${action.element}\n${action.summary}`
   const oldLen = normalizeComparable(oldText).length
   const newLen = normalizeComparable(newText).length
-  if (oldLen > 0 && newLen > oldLen + 20) return { ok: false, reason: 'rewrite expands entry' }
-
   const sim = charDice(oldText, newText)
-  if (sim < 0.28) return { ok: false, reason: `rewrite drift sim=${sim.toFixed(2)}` }
-  return { ok: true, reason: 'safe compression' }
+  const crossLanguageRewrite = sim < 0.28 && hasSubstantialNonLatinScript(oldText)
+  if (!crossLanguageRewrite) {
+    if (oldLen > 0 && newLen > oldLen + 20) return { ok: false, reason: 'rewrite expands entry' }
+    if (sim < 0.28) return { ok: false, reason: `rewrite drift sim=${sim.toFixed(2)}` }
+    return { ok: true, reason: 'safe compression' }
+  }
+
+  try {
+    const [oldEmbedding, newEmbedding] = await Promise.all([embedText(oldText), embedText(newText)])
+    const cosine = cosineSimilarity(oldEmbedding, newEmbedding)
+    if (cosine == null) return { ok: false, reason: 'cross-language embedding invalid' }
+    if (cosine < 0.6) return { ok: false, reason: `cross-language semantic drift cosine=${cosine.toFixed(2)}` }
+    return { ok: true, reason: `safe cross-language rewrite cosine=${cosine.toFixed(2)}` }
+  } catch (err) {
+    return { ok: false, reason: `cross-language embedding failed: ${err?.message || 'unknown error'}` }
+  }
 }
 
 function findElementConflict(coreById, currentId, element, projectId) {
@@ -659,7 +694,7 @@ async function _runCycle3Impl(db, config, dataDir, options = {}) {
     }
     if (a.verb === 'update') {
       proposed.updated++
-      const safety = conservative ? isSafeConservativeUpdate(coreById.get(a.id), a) : { ok: true, reason: 'confirmed' }
+      const safety = conservative ? await isSafeConservativeUpdate(coreById.get(a.id), a) : { ok: true, reason: 'confirmed' }
       const conflictId = conservative
         ? findElementConflict(coreById, a.id, a.element, coreById.get(a.id)?.project_id ?? null)
         : null

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

@@ -49,7 +49,7 @@ export function createQueryHandlers({
   // Raw-row priority lookup for narrow-window queries. Raw rows (is_root=0,
   // chunk_root IS NULL) are inserted immediately by ingestTranscriptFile before
   // cycle1 runs, so they always carry the freshest turns in the DB.
-  async function readRawRowsInWindow(db, tsFromMs, tsToMs, hardLimit = 10, { projectScope, sessionId, terms } = {}) {
+  async function readRawRowsInWindow(db, tsFromMs, tsToMs, hardLimit = 10, { projectScope, sessionId, terms, minHits: minHitsOverride } = {}) {
     try {
       // Composable WHERE assembly (mirrors retrieveEntries' filter semantics so
       // raw and chunked legs stay in filter parity: projectScope AND sessionId
@@ -78,7 +78,9 @@ export function createQueryHandlers({
         // 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.
-        const minHits = terms.length >= 3 ? 2 : 1
+        const minHits = Number.isFinite(Number(minHitsOverride))
+          ? Math.max(1, Math.floor(Number(minHitsOverride)))
+          : (terms.length >= 3 ? 2 : 1)
         where.push(`(${clauses.join(' + ')}) >= ${minHits}`)
       }
       params.push(hardLimit)
@@ -722,7 +724,7 @@ export function createQueryHandlers({
       // Deterministic tie-breaker: equal MAX(ts) across sessions would let the
       // LIMIT/OFFSET window skip or duplicate a session between offset pages
       // without a stable secondary sort.
-      const sessSql = `SELECT session_id, MAX(ts) AS last_ts
+      const sessSql = `SELECT session_id, MIN(ts) AS first_ts, MAX(ts) AS last_ts
                        FROM entries
                        WHERE ${selWhere.join(' AND ')}
                        GROUP BY session_id
@@ -732,6 +734,7 @@ export function createQueryHandlers({
       // 2) per selected session, fetch its newest rows (roots+members, sort by
       //    date) plus the fresh raw window, capped at PER_SESSION_ROW_CAP.
       const allRows = []
+      const sessionMeta = new Map()
       for (const s of sessRows) {
         const sid = String(s?.session_id || '').trim()
         if (!sid) continue
@@ -743,7 +746,24 @@ export function createQueryHandlers({
         const sRows = await retrieveEntries(db, sf)
         let merged = sRows
         if (includeRaw) {
-          const rawRows = await readRawRowsInWindow(db, null, Date.now(), perSessionFetchCap, { projectScope, sessionId: sid, terms: queryTerms })
+          let rawRows
+          if (queryTerms.length > 0) {
+            // Keep a full unfiltered recency window for the newest-row floor,
+            // while separately retaining the deeper term-matched raw window.
+            const [recentRawRows, matchedRawRows] = await Promise.all([
+              readRawRowsInWindow(db, null, Date.now(), perSessionFetchCap, { projectScope, sessionId: sid, terms: [] }),
+              readRawRowsInWindow(db, null, Date.now(), perSessionFetchCap, { projectScope, sessionId: sid, terms: queryTerms, minHits: 1 }),
+            ])
+            const rawIds = new Set()
+            rawRows = [...recentRawRows, ...matchedRawRows].filter((r) => {
+              const id = Number(r.id)
+              if (rawIds.has(id)) return false
+              rawIds.add(id)
+              return true
+            })
+          } else {
+            rawRows = await readRawRowsInWindow(db, null, Date.now(), perSessionFetchCap, { projectScope, sessionId: sid, terms: [] })
+          }
           const seenIds = new Set(sRows.map((r) => Number(r.id)))
           for (const r of sRows) if (Array.isArray(r.members)) for (const m of r.members) seenIds.add(Number(m.id))
           // readRawRowsInWindow carries no category filter, so a category-
@@ -768,14 +788,37 @@ export function createQueryHandlers({
             merged.sort((a, b) => (Number(b.ts) || 0) - (Number(a.ts) || 0) || (Number(b.id) || 0) - (Number(a.id) || 0))
           }
         }
+        const fetchedCount = merged.length
+        let queryFiltered = false
         if (queryTerms.length > 0) {
-          merged = merged.filter(matchesQueryTerms)
+          const newestRows = merged.slice(0, 3)
+          const newestIds = new Set(newestRows.map((r) => r.id))
+          const matchedRows = merged.filter(matchesQueryTerms)
+          // A topic query must not obscure a session's latest activity: keep
+          // its three newest rows, then use term matches for the remaining
+          // display slots without duplicating rows already kept for recency.
+          merged = [...newestRows, ...matchedRows.filter((r) => !newestIds.has(r.id))]
+          // Only mark query filtering when its floor+match union actually
+          // excludes fetched rows. The later display cap is independent.
+          queryFiltered = merged.length < fetchedCount
         }
         merged = merged.slice(0, PER_SESSION_ROW_CAP)
+        sessionMeta.set(sid, {
+          minTs: Number(s.first_ts),
+          maxTs: Number(s.last_ts),
+          fetchedCount,
+          shownCount: merged.length,
+          queryFiltered,
+        })
         for (const r of merged) allRows.push(r)
       }
       const _currentSessionHint = String(args?.currentSessionId || '').trim()
-      return { text: recallCapPrefix + renderSessionGroupedLines(allRows, { currentSessionId: _currentSessionHint, recencyOrder: true, spanHeaders: true }) }
+      return { text: recallCapPrefix + renderSessionGroupedLines(allRows, {
+        currentSessionId: _currentSessionHint,
+        recencyOrder: true,
+        spanHeaders: true,
+        sessionMeta,
+      }) }
     }
 
     const filters = { limit: limit + offset }

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

@@ -336,10 +336,16 @@ function spanHeaderSuffix(minTs, maxTs, n) {
 // group's lines are globally ts-desc: without it a chunk root's members (stored
 // ts-ASC) interleave with raw rows and invert the visible timeline within a
 // session (e.g. 04:33 rendered above 04:41).
-export function renderSessionGroupedLines(rows, { currentSessionId, recencyOrder = false, spanHeaders = false } = {}) {
-  if (!rows || rows.length === 0) return '(no results)'
+export function renderSessionGroupedLines(rows, { currentSessionId, recencyOrder = false, spanHeaders = false, sessionMeta } = {}) {
+  const hasSessionMeta = spanHeaders && Number(sessionMeta?.size) > 0
+  if ((!rows || rows.length === 0) && !hasSessionMeta) return '(no results)'
   const groups = new Map()
-  for (const r of rows) {
+  // Seed selected sessions so an entirely query-filtered session still
+  // reports its real activity span and filtering status.
+  if (hasSessionMeta) {
+    for (const sid of sessionMeta.keys()) groups.set(sid, [])
+  }
+  for (const r of rows || []) {
     const sid = String(r?.session_id || '').trim()
     const key = sid || '(no session)'
     if (!groups.has(key)) groups.set(key, [])
@@ -356,11 +362,20 @@ export function renderSessionGroupedLines(rows, { currentSessionId, recencyOrder
     for (const [sid, groupRows] of groups) {
       const mark = current && sid === current ? ' (current)' : ''
       const label = sid === '(no session)' ? sid : `session ${shortSessionLabel(sid)}`
+      const meta = sessionMeta?.get?.(sid)
       const tsAll = collectGroupTs(groupRows)
-      const suffix = tsAll.length
-        ? ` ${spanHeaderSuffix(Math.min(...tsAll), Math.max(...tsAll), groupRows.length)}`
+      const minTs = Number(meta?.minTs)
+      const maxTs = Number(meta?.maxTs)
+      const hasActivitySpan = Number.isFinite(minTs) && Number.isFinite(maxTs)
+      const suffix = hasActivitySpan
+        ? ` ${spanHeaderSuffix(minTs, maxTs, groupRows.length)}`
+        : tsAll.length
+          ? ` ${spanHeaderSuffix(Math.min(...tsAll), Math.max(...tsAll), groupRows.length)}`
         : ` (${groupRows.length} entries)`
-      parts.push(`## ${label}${mark}${suffix}`)
+      const filterNote = meta?.queryFiltered
+        ? ` · query-filtered ${meta.shownCount}/${meta.fetchedCount} rows`
+        : ''
+      parts.push(`## ${label}${mark}${suffix}${filterNote}`)
       const bodyStr = renderEntryLines(groupRows, { recencyOrder })
       const bodyLines = bodyStr === '(no results)'
         ? []

package/src/runtime/memory/tool-defs.mjs

@@ -8,7 +8,7 @@ export const TOOL_DEFS = [
     name: 'memory',
     title: 'Memory Cycle',
     annotations: { title: 'Memory Cycle', readOnlyHint: false, destructiveHint: true, idempotentHint: false, openWorldHint: false },
-    description: 'Core-memory mutation and status; use recall for retrieval. Store durable rules/preferences/facts, one short clause each — never transient task state. add requires project_id+category+summary; edit works by id alone.',
+    description: 'Core-memory mutation and status; use recall for retrieval. Store durable rules/preferences/facts, one compact ENGLISH clause each — never transient task state. add requires project_id+summary; edit works by id alone.',
     inputSchema: {
       type: 'object',
       properties: {
@@ -16,8 +16,7 @@ export const TOOL_DEFS = [
         op: { type: 'string', enum: ['add','edit','delete','list','candidates','promote','dismiss'], description: 'Mutation op. candidates/promote/dismiss drive core-memory proposal approval.' },
         id: { type: 'number', description: 'Exact memory id.' },
         element: { type: 'string', maxLength: 40, description: 'Memory key/title. Defaults to the first 40 chars of summary. Max 40 chars.' },
-        summary: { type: 'string', maxLength: 100, description: 'Memory content: one short fact, max 100 chars.' },
-        category: { type: 'string', enum: ['rule','constraint','decision','fact','goal','preference','task','issue'], description: 'Category.' },
+        summary: { type: 'string', maxLength: 100, description: 'Memory content: one short English clause, max 100 chars.' },
         status: { type: 'string', enum: ['pending','active','archived'], description: 'Lifecycle status.' },
         limit: { type: 'number', description: 'Max rows/items.' },
         confirm: { type: 'string', description: 'Exact confirmation phrase for destructive actions.' },