mixdog 0.9.35 → 0.9.37

package/src/runtime/agent/orchestrator/tools/code-graph/search.mjs

@@ -255,7 +255,11 @@ export function _formatCalleeRow(row) {
 }
 export async function _prewarmReferenceSourceText(graph, symbol, language) {
   const candidateNodes = _lookupCandidateNodes(graph, symbol, language);
-  if (!candidateNodes.length) return;
+  // Return the resolved candidate set so the immediately-following
+  // _cheapReferenceSearch (references/callers dispatch) can reuse it instead
+  // of recomputing _lookupCandidateNodes for the same (symbol, language) —
+  // which on a token-index miss is a full-graph scan run twice per symbol.
+  if (!candidateNodes.length) return candidateNodes;
   const uncached = [];
   for (const node of candidateNodes) {
     const cached = graph._sourceTextCache?.get(node.rel);
@@ -263,7 +267,7 @@ export async function _prewarmReferenceSourceText(graph, symbol, language) {
       uncached.push(node);
     }
   }
-  if (uncached.length === 0) return;
+  if (uncached.length === 0) return candidateNodes;
   const { readFile } = await import('fs/promises');
   const concurrency = 64;
   let next = 0;
@@ -280,9 +284,10 @@ export async function _prewarmReferenceSourceText(graph, symbol, language) {
   }
   const workerCount = Math.min(Math.max(1, concurrency), uncached.length);
   await Promise.all(Array.from({ length: workerCount }, () => worker()));
+  return candidateNodes;
 }
 
-export function _cheapReferenceSearch(graph, symbol, cwd, { language = null, limit = null, fileRel = null, scopeRelPrefix = null } = {}) {
+export function _cheapReferenceSearch(graph, symbol, cwd, { language = null, limit = null, fileRel = null, scopeRelPrefix = null, nodes = null } = {}) {
   const escaped = String(symbol || '').replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
   if (!escaped) return '(no references)';
   const cacheKey = `${language || '*'}|${symbol}|${Number.isFinite(limit) && limit > 0 ? String(Math.floor(limit)) : 'd'}|${fileRel || '*'}|${scopeRelPrefix || '*'}`;
@@ -291,7 +296,11 @@ export function _cheapReferenceSearch(graph, symbol, cwd, { language = null, lim
     return cached;
   }
   const lines = [];
-  let candidateNodes = _lookupCandidateNodes(graph, symbol, language);
+  // Reuse the caller's precomputed candidate set (from
+  // _prewarmReferenceSourceText) when provided — same (symbol, language) so
+  // the node set is identical; the fileRel/scopeRelPrefix filters below still
+  // apply, keeping the result byte-for-byte unchanged.
+  let candidateNodes = Array.isArray(nodes) ? nodes : _lookupCandidateNodes(graph, symbol, language);
   if (fileRel) candidateNodes = candidateNodes.filter((node) => node.rel === fileRel);
   if (scopeRelPrefix) candidateNodes = candidateNodes.filter((node) => node.rel === scopeRelPrefix.slice(0, -1) || node.rel.startsWith(scopeRelPrefix));
   const ENV_CAP = Math.max(1, Number(process.env.REFERENCE_HIT_CAP) || 200);
@@ -629,16 +638,57 @@ function _formatSearchSymbolRow(name, hit) {
   return `${name}\t${loc}\t${next}`;
 }
 
+const KEYWORD_SEARCH_CACHE_MAX_ENTRIES = Math.max(
+  16,
+  Math.floor(Number(process.env.CODE_GRAPH_KEYWORD_SEARCH_CACHE_MAX_ENTRIES) || 128),
+);
+const KEYWORD_SEARCH_CACHE_MAX_BYTES = Math.max(
+  64 * 1024,
+  Math.floor(Number(process.env.CODE_GRAPH_KEYWORD_SEARCH_CACHE_MAX_BYTES) || (1024 * 1024)),
+);
+
+function _keywordSearchLanguageCacheKey(language) {
+  return language == null ? '<none>' : `lang:${String(language)}`;
+}
+
+function _setKeywordSearchCache(graph, cacheKey, value) {
+  const cache = graph?._keywordSearchCache;
+  if (!(cache instanceof Map)) return value;
+  const valueBytes = Buffer.byteLength(String(value || ''), 'utf8');
+  if (valueBytes > KEYWORD_SEARCH_CACHE_MAX_BYTES) return value;
+  if (cache.has(cacheKey)) cache.delete(cacheKey);
+  cache.set(cacheKey, value);
+  let totalBytes = 0;
+  for (const memo of cache.values()) totalBytes += Buffer.byteLength(String(memo || ''), 'utf8');
+  while (cache.size > KEYWORD_SEARCH_CACHE_MAX_ENTRIES || totalBytes > KEYWORD_SEARCH_CACHE_MAX_BYTES) {
+    const oldest = cache.keys().next().value;
+    if (oldest === undefined) break;
+    const oldValue = cache.get(oldest);
+    totalBytes -= Buffer.byteLength(String(oldValue || ''), 'utf8');
+    cache.delete(oldest);
+  }
+  return value;
+}
+
 export function _searchSymbolsByKeyword(graph, keyword, cwd, { language = null, limit = 30 } = {}) {
   const clean = String(keyword || '').trim();
   if (!clean) return '(no keyword)';
   const cap = Math.max(1, Math.min(100, Math.floor(Number(limit) || 30)));
+  // Memoize the full formatted output per (language, keyword, cap). Repeated
+  // symbol_search scans (e.g. batched keywords) otherwise re-walk every graph
+  // node — native + cheap symbol collection — for each keyword. The cached
+  // string already embeds the truncated WARN line, so truncated/incomplete
+  // semantics are preserved byte-for-byte on a cache hit.
+  const cacheKey = JSON.stringify([_keywordSearchLanguageCacheKey(language), clean, cap]);
+  const cached = graph?._keywordSearchCache?.get(cacheKey);
+  if (typeof cached === 'string') return cached;
+  const _memo = (s) => _setKeywordSearchCache(graph, cacheKey, s);
   const nativeEntries = _collectNativeKeywordSymbolEntries(graph, clean, { language });
   const cheapEntries = _collectCheapKeywordSymbolEntries(graph, clean, { language });
   const entries = [...nativeEntries, ...cheapEntries];
   if (!entries.length) {
     const nodeCount = graph?.nodes?.size ?? 0;
-    return `(no symbol keyword matches in cwd=${cwd})\ngraph: nodes=${nodeCount}${language ? `, language=${language}` : ''}`;
+    return _memo(`(no symbol keyword matches in cwd=${cwd})\ngraph: nodes=${nodeCount}${language ? `, language=${language}` : ''}`);
   }
   entries.sort((a, b) => {
     const rank = Number(b.resolved) - Number(a.resolved);
@@ -669,7 +719,7 @@ export function _searchSymbolsByKeyword(graph, keyword, cwd, { language = null,
   if (graph?.truncated) {
     lines.push(`WARN: graph truncated at CODE_GRAPH_MAX_FILES=${CODE_GRAPH_MAX_FILES} — matches may be incomplete. Re-run with a narrower cwd.`);
   }
-  return lines.join('\n');
+  return _memo(lines.join('\n'));
 }
 
 function _parseReferenceEntries(referenceText) {

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

@@ -413,6 +413,11 @@ export class ExecResult {
     this.taskId = opts.taskId;
     this.partialOutput = opts.partialOutput === true;
     this.outputCaptureError = opts.outputCaptureError || null;
+    // Distinguish a shell tool/control-plane failure (spawn/preflight/capture)
+    // from a command process failure (non-zero exit/signal/timeout). The
+    // renderer in builtin/bash-tool.mjs turns this into a model-visible marker.
+    this.failurePhase = opts.failurePhase || null;
+    this.failureReason = opts.failureReason || null;
     // Auto-background transition (CC startBackgrounding analogue). When a
     // foreground command outlives autoBackgroundMs the call settles with
     // backgrounded:true + the jobId for manual task control. The
@@ -558,6 +563,8 @@ export function execShellCommand({
             timedOut: false,
             killed: false,
             taskId,
+            failurePhase: 'tool',
+            failureReason: 'preflight failed',
           }),
         );
         return;
@@ -605,6 +612,8 @@ export function execShellCommand({
           timedOut: false,
           killed: false,
           taskId,
+          failurePhase: 'tool',
+          failureReason: 'spawn failed',
         }),
       );
       return;

package/src/runtime/channels/lib/worker-main.mjs

@@ -52,6 +52,7 @@ import {
   RUNTIME_ROOT
 } from "./runtime-paths.mjs";
 import { getDiscordToken } from "./config.mjs";
+import { invalidateConfigReadCache } from "../../shared/config.mjs";
 import { bootProfile, localTimestamp } from "./boot-profile.mjs";
 import {
   isChannelsDegraded,
@@ -720,6 +721,10 @@ async function start() {
   if (!_configWatcher) {
     try {
       _configWatcher = fs.watch(path.join(DATA_DIR, "mixdog-config.json"), () => {
+        // Cross-process edit landed on disk; drop this process's short-TTL raw
+        // config cache synchronously so the debounced reload (and any readAll
+        // in between) sees the fresh file immediately, not up to TTL stale.
+        invalidateConfigReadCache();
         if (_reloadDebounce) clearTimeout(_reloadDebounce);
         _reloadDebounce = setTimeout(() => { reloadRuntimeConfig().catch(() => {}); }, 500);
       });

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

@@ -442,6 +442,110 @@ export async function archiveCore(dataDir, id, expect = null) {
   }
 }
 
+// Non-destructive project reclassification: move a mis-scoped core entry to the
+// correct pool (a project slug, or COMMON when newProjectId is null). Only the
+// project_id + updated_at change — no delete, and no re-embed (the embedding is
+// derived from element/summary text, which is pool-independent). Takes BOTH the
+// source and target pool advisory locks in a deterministic (sorted) order so a
+// move can't deadlock with a concurrent add/edit/archive on either pool, then
+// FOR UPDATEs the row and re-validates under the lock. `expect` carries the
+// element/summary cycle3 reviewed; if the live row drifted, the move is skipped
+// ({ skipped, reason }). A live (project_id, element) collision in the target
+// pool means the fact already exists there → skipped, so the caller holds it for
+// manual resolution instead of clobbering the existing row.
+export async function reclassifyCore(dataDir, id, newProjectId, expect = null) {
+  const numId = Number(id)
+  if (!Number.isInteger(numId) || numId <= 0) throw new Error('integer id > 0 required')
+  const targetPid = newProjectId == null ? null : (String(newProjectId).trim() || null)
+  const db = _getDb(dataDir)
+  const now = Date.now()
+  const client = await checkedConnect(db._pool, 'memory')
+  try {
+    await client.query('BEGIN')
+    await client.query(`SET LOCAL lock_timeout = '5s'`)
+    // Read the current pool WITHOUT a row lock first (no FOR UPDATE → acquires
+    // no row lock, can't invert ordering) so the advisory locks are taken first.
+    const pre = (await client.query(`SELECT project_id FROM core_entries WHERE id = $1`, [numId])).rows[0]
+    if (!pre) throw new Error(`no entry with id=${numId}`)
+    const curPid = pre.project_id ?? null
+    if ((curPid ?? null) === (targetPid ?? null)) {
+      await client.query('ROLLBACK')
+      return { id: numId, skipped: true, reason: 'already in target pool' }
+    }
+    // Lock BOTH pools, sorted, so a move in the opposite direction can't deadlock.
+    const keys = [...new Set([
+      `core:${curPid == null ? 'COMMON' : curPid}`,
+      `core:${targetPid == null ? 'COMMON' : targetPid}`,
+    ])].sort()
+    for (const k of keys) await client.query(`SELECT pg_advisory_xact_lock(hashtext($1))`, [k])
+    const locked = (await client.query(
+      `SELECT id, element, summary, project_id, status FROM core_entries WHERE id = $1 FOR UPDATE`,
+      [numId],
+    )).rows[0]
+    if (!locked || !(locked.status == null || locked.status === 'active')) {
+      await client.query('ROLLBACK')
+      return { id: numId, skipped: true, reason: 'concurrently archived/removed' }
+    }
+    if ((locked.project_id ?? null) !== curPid) {
+      await client.query('ROLLBACK')
+      return { id: numId, skipped: true, reason: 'pool changed under lock' }
+    }
+    // Reviewed-source guard: cycle3 decided this move against the pool the row
+    // was in AT REVIEW time. If the row was reclassified into a THIRD pool
+    // between review and now, the in-tx pre-read above sees that new pool (so
+    // the pool-changed-under-lock check passes) but the move is stale → skip.
+    // `expect.sourceProjectId` (null = COMMON) carries the reviewed pool.
+    if (expect && 'sourceProjectId' in expect) {
+      const reviewedPid = expect.sourceProjectId == null ? null : (String(expect.sourceProjectId).trim() || null)
+      if ((locked.project_id ?? null) !== reviewedPid) {
+        await client.query('ROLLBACK')
+        return { id: numId, skipped: true, reason: 'source pool drift' }
+      }
+    }
+    if (expect && (String(expect.element ?? '') !== String(locked.element ?? '') ||
+                   String(expect.summary ?? '') !== String(locked.summary ?? ''))) {
+      await client.query('ROLLBACK')
+      return { id: numId, skipped: true, reason: 'content drift' }
+    }
+    // Unique (project_id, element) guard: a live row with this element already in
+    // the target pool means the fact is present there → don't clobber it.
+    const dup = (await client.query(
+      `SELECT id FROM core_entries
+       WHERE project_id IS NOT DISTINCT FROM $1 AND element = $2
+         AND (status IS NULL OR status = 'active') AND id != $3
+       LIMIT 1`,
+      [targetPid, locked.element, numId],
+    )).rows[0]
+    if (dup) {
+      await client.query('ROLLBACK')
+      return { id: numId, skipped: true, reason: `target pool already has element (id=${dup.id})` }
+    }
+    let r
+    try {
+      await client.query('SAVEPOINT mv')
+      r = await client.query(
+        `UPDATE core_entries SET project_id = $1, updated_at = $2 WHERE id = $3
+         RETURNING id, element, summary, category, project_id, created_at, updated_at`,
+        [targetPid, now, numId],
+      )
+      await client.query('RELEASE SAVEPOINT mv')
+    } catch (err) {
+      if (err.code === '23505') {
+        await client.query('ROLLBACK')
+        return { id: numId, skipped: true, reason: 'unique collision in target pool' }
+      }
+      throw err
+    }
+    await client.query('COMMIT')
+    return { ...r.rows[0], from_project_id: curPid, to_project_id: targetPid }
+  } catch (err) {
+    try { await client.query('ROLLBACK') } catch {}
+    throw err
+  } finally {
+    client.release()
+  }
+}
+
 // ─── Core-candidate promotion pipeline (proposal mode) ───────────────────────
 //
 // nominateCoreCandidates flags strong active entries as core-memory

package/src/runtime/memory/lib/ko-morph.mjs

@@ -175,7 +175,7 @@ export function analyze(text) {
 }
 
 // Content-morpheme stem forms for a Korean phrase. null when not ready.
-// "개선을" → ['개선']; "개선하고" → ['개선','하'] filtered to content tags.
+// Example: an inflected Korean noun/verb phrase is reduced to content stems.
 export function stems(text) {
   const tokens = analyze(text)
   if (!tokens) return null

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

@@ -22,6 +22,7 @@ function __mixdogMemoryLog(...args) {
 //   <id>|update|<element>|<summary>
 //   <id>|merge|<target_id>|<source_ids_csv>
 //   <id>|delete|<reason>
+//   <id>|reclassify|<project_slug|common>
 
 import { existsSync, readFileSync } from 'fs'
 import { join } from 'path'
@@ -29,6 +30,7 @@ import { fileURLToPath } from 'url'
 import { resolveMaintenancePreset } from '../../shared/llm/index.mjs'
 import { callAgentDispatch } from './agent-ipc.mjs'
 import { listCore, editCore, deleteCore, archiveCore, CORE_SUMMARY_MAX } from './core-memory-store.mjs'
+import { reclassifyCore } from './core-memory-store.mjs'
 import { loadCurrentRulesDigest } from './memory-cycle2.mjs'
 import { embedText } from './embedding-provider.mjs'
 import { searchRelevantHybrid } from './memory-recall-store.mjs'
@@ -264,6 +266,17 @@ function parseVerdicts(raw, idSet) {
     } else if (verb === 'delete') {
       const reason = (parts[2] ?? '').trim()
       actions.push({ id, verb: 'delete', reason: reason || null })
+    } else if (verb === 'reclassify' || verb === 'reproject' || verb === 'rescope') {
+      // Project classification correction: move a mis-scoped entry to the right
+      // pool. `<id>|reclassify|<project_slug|common>`. A missing target scope
+      // has no destination → drop. 'common' (case-insensitive) → COMMON pool.
+      const rawTarget = (parts[2] ?? '').trim()
+      if (!rawTarget) {
+        __mixdogMemoryLog(`[cycle3] reclassify rejected: id=${id} missing target scope\n`)
+        continue
+      }
+      const projectId = /^common$/i.test(rawTarget) ? null : rawTarget
+      actions.push({ id, verb: 'reclassify', projectId })
     } else if (verb === 'superseded' || verb === 'supersede') {
       // Require newer-id proof: `id|superseded|<newer_id>`. Without a valid
       // newer active core id the supersession has no evidence → drop to keep.
@@ -288,6 +301,7 @@ function mergeCycle3Counts(a = {}, b = {}) {
     updated: Number(a.updated || 0) + Number(b.updated || 0),
     merged: Number(a.merged || 0) + Number(b.merged || 0),
     deleted: Number(a.deleted || 0) + Number(b.deleted || 0),
+    reclassified: Number(a.reclassified || 0) + Number(b.reclassified || 0),
   }
 }
 
@@ -302,11 +316,13 @@ function mergeCycle3Results(a, b) {
     updated: Number(a.updated || 0) + Number(b.updated || 0),
     merged: Number(a.merged || 0) + Number(b.merged || 0),
     deleted: Number(a.deleted || 0) + Number(b.deleted || 0),
+    reclassified: Number(a.reclassified || 0) + Number(b.reclassified || 0),
     proposed: mergeCycle3Counts(a.proposed, b.proposed),
     held: {
       updated: Number(a?.held?.updated || 0) + Number(b?.held?.updated || 0),
       merged: Number(a?.held?.merged || 0) + Number(b?.held?.merged || 0),
       deleted: Number(a?.held?.deleted || 0) + Number(b?.held?.deleted || 0),
+      reclassified: Number(a?.held?.reclassified || 0) + Number(b?.held?.reclassified || 0),
     },
     details: [...(a.details || []), ...(b.details || [])],
     skippedInFlight: false,
@@ -517,6 +533,10 @@ async function _runCycle3Impl(db, config, dataDir, options = {}) {
 
   const idSet = new Set(cores.map(c => Number(c.id)))
   const coreById = new Map(cores.map(c => [Number(c.id), c]))
+  // Real project pools present in this review — reclassify may only move an
+  // entry INTO a pool we already know is real (COMMON is always valid), never
+  // invent a typo pool from an LLM-supplied slug.
+  const knownPools = new Set(cores.map(c => c.project_id).filter(p => p != null).map(String))
   const parsed = parseVerdicts(raw, idSet)
   if (!parsed) {
     __mixdogMemoryLog(
@@ -605,9 +625,9 @@ async function _runCycle3Impl(db, config, dataDir, options = {}) {
     }
   }
 
-  let kept = 0, updated = 0, merged = 0, deleted = 0, superseded = 0
-  const proposed = { kept: 0, updated: 0, merged: 0, deleted: 0, superseded: 0 }
-  const held = { updated: 0, merged: 0, deleted: 0, superseded: 0 }
+  let kept = 0, updated = 0, merged = 0, deleted = 0, superseded = 0, reclassified = 0
+  const proposed = { kept: 0, updated: 0, merged: 0, deleted: 0, superseded: 0, reclassified: 0 }
+  const held = { updated: 0, merged: 0, deleted: 0, superseded: 0, reclassified: 0 }
   const details = []
   const touched = new Set() // ids already acted on this cycle — avoid double action
   // Safety margin: even when every junk verdict is legitimate, a single
@@ -687,6 +707,44 @@ async function _runCycle3Impl(db, config, dataDir, options = {}) {
       }
       continue
     }
+    if (a.verb === 'reclassify') {
+      proposed.reclassified++
+      // Project classification correction: move a mis-scoped entry to the right
+      // pool. Non-destructive (project_id only, no delete, no re-embed) and
+      // reversible, so it applies in DEFAULT (conservative) mode. Guards: the
+      // move must actually change pools and the target must be a real pool from
+      // this review (or COMMON) — otherwise hold. Unique-collision / content
+      // drift are resolved inside reclassifyCore (returns skipped).
+      const core = coreById.get(a.id)
+      const curPid = core?.project_id ?? null
+      const targetPid = a.projectId ?? null
+      let holdReason = null
+      if ((curPid ?? null) === (targetPid ?? null)) holdReason = 'already in target pool'
+      else if (targetPid != null && !knownPools.has(String(targetPid))) holdReason = `unknown target pool "${targetPid}"`
+      if (!mutate) holdReason = holdReason || 'proposal mode'
+      if (holdReason) {
+        held.reclassified++
+        details.push({ id: a.id, verb: 'reclassify', from: curPid, to: targetPid, applied: false, held: true, reason: holdReason })
+        touched.add(a.id)
+        continue
+      }
+      try {
+        const res = await reclassifyCore(dataDir, a.id, targetPid, core ? { element: core.element, summary: core.summary, sourceProjectId: curPid } : null)
+        if (res?.skipped) {
+          held.reclassified++
+          details.push({ id: a.id, verb: 'reclassify', from: curPid, to: targetPid, applied: false, held: true, reason: res.reason })
+        } else {
+          reclassified++
+          details.push({ id: a.id, verb: 'reclassify', from: curPid, to: targetPid, applied: true })
+        }
+        touched.add(a.id)
+      } catch (err) {
+        if (signal?.aborted) throw signal.reason ?? err
+        __mixdogMemoryLog(`[cycle3] reclassify failed id=${a.id}: ${err.message}\n`)
+        details.push({ id: a.id, verb: 'reclassify', error: err.message })
+      }
+      continue
+    }
     if (a.verb === 'superseded') {
       proposed.superseded++
       // Supersession archives (status flip), never physical DELETE, and applies
@@ -808,9 +866,11 @@ async function _runCycle3Impl(db, config, dataDir, options = {}) {
     ` proposed_update=${proposed.updated} proposed_merge=${proposed.merged} proposed_delete=${proposed.deleted}` +
     ` applied_update=${updated} applied_merge=${merged} applied_delete=${deleted}` +
     ` applied_superseded=${superseded}` +
+    ` applied_reclassify=${reclassified}` +
     ` held_update=${held.updated} held_merge=${held.merged} held_delete=${held.deleted} held_superseded=${held.superseded}` +
+    ` held_reclassify=${held.reclassified}` +
     ` mode=${applyMode}\n`,
   )
 
-  return { reviewed: cores.length, kept, updated, merged, deleted, superseded, proposed, held, applied: mutate, applyMode, details }
+  return { reviewed: cores.length, kept, updated, merged, deleted, superseded, reclassified, proposed, held, applied: mutate, applyMode, details }
 }

package/src/runtime/memory/lib/memory-text-utils.mjs

@@ -10,7 +10,7 @@ const MEMORY_TOKEN_STOPWORDS = new Set([
   'your', 'unless', 'with',
   'user', 'assistant', 'requested', 'request', 'asked', 'ask', 'stated', 'state', 'reported', 'report',
   'mentioned', 'mention', 'clarified', 'clarify', 'explicitly', 'currently',
-  '사용자', '유저', '요청', '질문', '답변', '언급', '말씀', '설명', '보고', '무슨', '뭐야', '했지', 'user', 'asks', 'asked', 'request', 'requested', 'question', 'answer', 'reply', 'said', 'mentioned', 'explained', 'reported', 'what', 'huh',
+  '\uC0AC\uC6A9\uC790', '\uC720\uC800', '\uC694\uCCAD', '\uC9C8\uBB38', '\uB2F5\uBCC0', '\uC5B8\uAE09', '\uB9D0\uC500', '\uC124\uBA85', '\uBCF4\uACE0', '\uBB34\uC2A8', '\uBB50\uC57C', '\uD588\uC9C0', 'user', 'asks', 'asked', 'request', 'requested', 'question', 'answer', 'reply', 'said', 'mentioned', 'explained', 'reported', 'what', 'huh',
 ])
 
 export function normalizeMemoryToken(token) {
@@ -20,9 +20,9 @@ export function normalizeMemoryToken(token) {
   // Korean suffix stripping: basic particles + compound endings
   if (/[\uAC00-\uD7AF]/.test(normalized) && normalized.length > 2) {
     const stripped = normalized
-      .replace(/(했었지|했더라|됐었나|됐던가|했는지|였는지|인건가|하려면|에서는|이라서|였더라|에서도|이었지|으로도|거였지|한건지|이었나)$/u, '')
-      .replace(/(했던|했지|됐던|됐지|하게|되던|이라|에서|으로|하는|없는|있는|었던|하자|않게|할때|인지|인데|인건|이고|보다|처럼|까지|부터|마다|밖에|없이)$/u, '')
-      .replace(/(은|는|이|가|을|를|랑|과|와|도|에|의|로|만|며|나|고|서|자|요)$/u, '')
+      .replace(/(\uD588\uC5C8\uC9C0|\uD588\uB354\uB77C|\uB410\uC5C8\uB098|\uB410\uB358\uAC00|\uD588\uB294\uC9C0|\uC600\uB294\uC9C0|\uC778\uAC74\uAC00|\uD558\uB824\uBA74|\uC5D0\uC11C\uB294|\uC774\uB77C\uC11C|\uC600\uB354\uB77C|\uC5D0\uC11C\uB3C4|\uC774\uC5C8\uC9C0|\uC73C\uB85C\uB3C4|\uAC70\uC600\uC9C0|\uD55C\uAC74\uC9C0|\uC774\uC5C8\uB098)$/u, '')
+      .replace(/(\uD588\uB358|\uD588\uC9C0|\uB410\uB358|\uB410\uC9C0|\uD558\uAC8C|\uB418\uB358|\uC774\uB77C|\uC5D0\uC11C|\uC73C\uB85C|\uD558\uB294|\uC5C6\uB294|\uC788\uB294|\uC5C8\uB358|\uD558\uC790|\uC54A\uAC8C|\uD560\uB54C|\uC778\uC9C0|\uC778\uB370|\uC778\uAC74|\uC774\uACE0|\uBCF4\uB2E4|\uCC98\uB7FC|\uAE4C\uC9C0|\uBD80\uD130|\uB9C8\uB2E4|\uBC16\uC5D0|\uC5C6\uC774)$/u, '')
+      .replace(/(\uC740|\uB294|\uC774|\uAC00|\uC744|\uB97C|\uB791|\uACFC|\uC640|\uB3C4|\uC5D0|\uC758|\uB85C|\uB9CC|\uBA70|\uB098|\uACE0|\uC11C|\uC790|\uC694)$/u, '')
     if (stripped.length >= 2) normalized = stripped
   }
 

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

@@ -314,14 +314,14 @@ function collectGroupTs(groupRows) {
   return all
 }
 
-// Activity-span header suffix: `(MM-DD HH:mm ~ HH:mm, n건)`; the end keeps the
+// Activity-span header suffix: `(MM-DD HH:mm ~ HH:mm, n entries)`; the end keeps the
 // MM-DD prefix only when it falls on a different calendar day than the start.
 function spanHeaderSuffix(minTs, maxTs, n) {
   const min = formatTs(minTs) // "YYYY-MM-DD HH:mm"
   const max = formatTs(maxTs)
   const startPart = min.slice(5) // "MM-DD HH:mm"
   const endPart = min.slice(0, 10) === max.slice(0, 10) ? max.slice(11) : max.slice(5)
-  return `(${startPart} ~ ${endPart}, ${n}건)`
+  return `(${startPart} ~ ${endPart}, ${n} entries)`
 }
 
 // Session-grouped rendering for the GLOBAL query-less browse ("what did we
@@ -359,7 +359,7 @@ export function renderSessionGroupedLines(rows, { currentSessionId, recencyOrder
       const tsAll = collectGroupTs(groupRows)
       const suffix = tsAll.length
         ? ` ${spanHeaderSuffix(Math.min(...tsAll), Math.max(...tsAll), groupRows.length)}`
-        : ` (${groupRows.length}건)`
+        : ` (${groupRows.length} entries)`
       parts.push(`## ${label}${mark}${suffix}`)
       const bodyStr = renderEntryLines(groupRows, { recencyOrder })
       const bodyLines = bodyStr === '(no results)'

package/src/runtime/shared/child-spawn-gate.mjs

@@ -120,6 +120,21 @@ function _abortError() {
   return e;
 }
 
+/**
+ * Best-effort capacity probe for NON-COMPETING prewarm/warmup work. Returns
+ * true only when a slot could be taken right now without queuing — i.e. below
+ * the cap AND with no waiter already queued. Speculative warmers (explore's
+ * code_graph / find prewarm) consult this to skip/defer when the daemon is
+ * busy, so a fire-and-forget warm never pushes a real tool query into the
+ * queue (the "non-competing under fanout" guarantee). This is a probe, NOT a
+ * reservation: the answer can go stale under a race, which is acceptable for
+ * best-effort work. Real queries must use acquire()/withGate() and never gate
+ * themselves on this.
+ */
+export function hasSpareCapacity() {
+  return _inflight < MAX_INFLIGHT && _queue.length === 0;
+}
+
 /**
  * Run `fn` while holding one child-spawn slot. Release is guaranteed in a
  * finally so a throw/return from `fn` cannot leak a slot or deadlock the gate.

package/src/runtime/shared/config.mjs

@@ -2,7 +2,7 @@
  * Unified config reader/writer.
  * Single file: mixdog-config.json with sections such as channels, agent, and memory.
  */
-import { readFileSync, mkdirSync, existsSync } from 'fs'
+import { readFileSync, statSync, mkdirSync, existsSync } from 'fs'
 import { join, dirname } from 'path'
 import { createRequire } from 'module'
 import { resolvePluginData } from './plugin-paths.mjs'
@@ -24,6 +24,78 @@ const CONFIG_PATH = join(DATA_DIR, 'mixdog-config.json')
 
 const GENERATED_KEY = '_generated'
 
+// Process-wide short-TTL cache of the RAW utf8 string of CONFIG_PATH (never
+// the parsed object). Parallel agent spawns each hit the non-RMW read path
+// (readAll → readSection/readConfig/readCapabilities); without this every
+// spawn pays a synchronous readFileSync(CONFIG_PATH) on the event loop,
+// serializing the whole fanout behind redundant disk I/O. Caching the raw
+// string — not the parsed object — lets each caller re-JSON.parse for an
+// isolated, freely-mutable object (no shared-reference poisoning). Only the
+// non-RMW readAll() consults this; the RMW path (readAllForRmW) always reads
+// disk under the lock. Read errors and malformed JSON are never cached.
+let _configReadCache = null // { raw, mtimeMs, size, atMs } | null
+// Optional coarse fast-path window (ms). Default 0 => the cached raw string is
+// validated against the file's mtime+size on EVERY read via a cheap statSync
+// (no content read, no whole-file JSON.parse), so a cross-process edit is
+// observed immediately with ZERO time-based staleness while the expensive
+// full read + parse are still skipped on an unchanged file. Set >0 to also
+// skip the statSync within the window, trading a bounded staleness for fewer
+// syscalls under extreme spawn fanout.
+const CONFIG_READ_TTL_MS = (() => {
+  const n = Number(process.env.MIXDOG_CONFIG_READ_TTL_MS)
+  return Number.isFinite(n) && n >= 0 ? n : 0
+})()
+
+export function invalidateConfigReadCache() {
+  _configReadCache = null
+}
+
+function readConfigRawCached() {
+  const now = Date.now()
+  if (_configReadCache) {
+    // Fast path (only when a TTL window is configured): serve without any
+    // syscall until the window lapses.
+    if (CONFIG_READ_TTL_MS > 0 && now - _configReadCache.atMs < CONFIG_READ_TTL_MS) {
+      return _configReadCache.raw
+    }
+    // Freshness gate: metadata-only stat. Unchanged mtime+size => the cached
+    // raw is still current, cross-process writes included — atomic writers land
+    // a new inode with a fresh mtime, so this reliably detects them.
+    try {
+      const st = statSync(CONFIG_PATH)
+      if (st.mtimeMs === _configReadCache.mtimeMs && st.size === _configReadCache.size) {
+        _configReadCache.atMs = now
+        return _configReadCache.raw
+      }
+    } catch {
+      // stat failed (e.g. transient ENOENT mid-rename); fall through to a fresh
+      // read which re-applies the ENOENT/backup-restore semantics below.
+    }
+  }
+  // Stat BEFORE read: if a write lands between the two we cache newer content
+  // against the older mtime, so the very next call re-reads instead of getting
+  // stuck on stale bytes — the cache always converges toward fresh.
+  let st = null
+  try {
+    st = statSync(CONFIG_PATH)
+  } catch (err) {
+    if (err.code === 'ENOENT') { _configReadCache = null; return null }
+    process.stderr.write(`[config] readConfigRawCached: unexpected stat error for ${CONFIG_PATH}: ${err.message}\n`)
+    throw err
+  }
+  let raw
+  try {
+    raw = readFileSync(CONFIG_PATH, 'utf8')
+  } catch (err) {
+    if (err.code === 'ENOENT') { _configReadCache = null; return null }
+    // Fail closed on unknown read errors (EACCES, EIO, …); do NOT cache.
+    process.stderr.write(`[config] readJsonFile: unexpected read error for ${CONFIG_PATH}: ${err.message}\n`)
+    throw err
+  }
+  _configReadCache = { raw, mtimeMs: st.mtimeMs, size: st.size, atMs: now }
+  return raw
+}
+
 function isPlainObject(value) {
   return !!value && typeof value === 'object' && !Array.isArray(value)
 }
@@ -36,24 +108,32 @@ export function stripGeneratedMarker(data) {
 
 function readJsonFile(path) {
   let raw
-  try {
-    raw = readFileSync(path, 'utf8')
-  } catch (err) {
-    if (err.code === 'ENOENT') return null
-    // Fail closed on unknown read errors (EACCES, EIO, …). Returning {}
-    // here would let a subsequent writeSection() serialize an empty
-    // object back over an existing-but-temporarily-unreadable config and
-    // erase every other section. Better to surface the read error and
-    // abort the RMW than silently destroy data.
-    process.stderr.write(`[config] readJsonFile: unexpected read error for ${path}: ${err.message}\n`)
-    throw err
+  if (path === CONFIG_PATH) {
+    // Non-RMW read path: served from the short-TTL raw-string cache. Returning
+    // {} on a read error here would let a subsequent writeSection() serialize
+    // an empty object over an existing-but-temporarily-unreadable config and
+    // erase every other section, so read errors surface (throw) uncached.
+    raw = readConfigRawCached()
+  } else {
+    try {
+      raw = readFileSync(path, 'utf8')
+    } catch (err) {
+      if (err.code === 'ENOENT') return null
+      process.stderr.write(`[config] readJsonFile: unexpected read error for ${path}: ${err.message}\n`)
+      throw err
+    }
   }
+  if (raw == null) return null
   try {
     return JSON.parse(raw)
   } catch (err) {
     // Quarantine a malformed mixdog-config.json so the next boot starts fresh
     // instead of looping on a broken file.
     if (path === CONFIG_PATH) {
+      // A cached raw string that fails to parse must not be re-served; drop it
+      // so the post-quarantine/restore read hits disk fresh (malformed = never
+      // cached).
+      invalidateConfigReadCache()
       const corrupt = `${path}.corrupt-${Date.now()}`
       try { renameWithRetrySync(path, corrupt) } catch {}
       process.stderr.write(`[config] mixdog-config.json is malformed (${err.message}). Renamed to ${corrupt}. Restore it or delete to start fresh.\n`)
@@ -81,6 +161,9 @@ function writeJsonFile(path, data) {
   }
   writeJsonAtomicSync(path, data, { lock: false, fsyncDir: true, mode: 0o600, secret: true })
   if (path === CONFIG_PATH) {
+    // Our own write just changed CONFIG_PATH on disk; drop the stale raw cache
+    // synchronously so the next in-process readAll() reflects it immediately.
+    invalidateConfigReadCache()
     try { markUserDataInitialized(DATA_DIR) } catch {}
     try { backupUserData(DATA_DIR, 'post-config-write') } catch {}
   }
@@ -226,6 +309,9 @@ async function writeJsonFileAsync(path, data) {
   }
   await writeJsonAtomicAsync(path, data, { lock: false, fsyncDir: true, mode: 0o600, secret: true })
   if (path === CONFIG_PATH) {
+    // Parity with writeJsonFile: invalidate synchronously after the async
+    // write resolves so this process never serves a stale cached config.
+    invalidateConfigReadCache()
     try { markUserDataInitialized(DATA_DIR) } catch {}
     try { await backupUserDataAsync(DATA_DIR, 'post-config-write') } catch {}
   }