mixdog 0.9.36 → 0.9.38

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 {}
   }

package/src/runtime/shared/process-listener-headroom.mjs

@@ -0,0 +1,12 @@
+// Many independent singletons self-register process-level drains (exit,
+// beforeExit, SIGTERM, …). Standalone scripts that import runtime modules
+// directly bypass src/app.mjs, so raise the cap from a shared helper too.
+export function ensureProcessListenerHeadroom(min = 64) {
+  try {
+    if (typeof process.getMaxListeners !== 'function' || typeof process.setMaxListeners !== 'function') return;
+    const current = process.getMaxListeners();
+    if (current === 0 || current >= min) return;
+    process.setMaxListeners(min);
+  } catch { /* ignore */ }
+}
+

package/src/session-runtime/cwd-plugins.mjs

@@ -234,9 +234,12 @@ export function createCwdPlugins({
   }
 
   async function loadCoreMemoryContext() {
-    // Boot should not pay for memory/PG startup unless explicitly requested.
-    // Recall and memory tools still initialize the memory service on first use.
-    if (process.env.MIXDOG_BOOT_CORE_MEMORY !== '1') {
+    // User-curated core memory injects into new sessions by default.
+    // Explicit opt-out (MIXDOG_BOOT_CORE_MEMORY=0/false/no/off) skips the
+    // memory/PG startup cost; recall and memory tools still initialize the
+    // memory service on first use.
+    const bootFlag = String(process.env.MIXDOG_BOOT_CORE_MEMORY ?? '').trim().toLowerCase();
+    if (bootFlag === '0' || bootFlag === 'false' || bootFlag === 'no' || bootFlag === 'off') {
       bootProfile('core-memory:skipped');
       return '';
     }

package/src/session-runtime/model-route-api.mjs

@@ -17,6 +17,21 @@ import {
   SEARCH_DEFAULT_MODEL,
 } from './workflow.mjs';
 import { writeStatuslineRoute } from './statusline-route.mjs';
+import { SUMMARY_PREFIX } from '../runtime/agent/orchestrator/session/compact.mjs';
+import {
+  hasUserConversationMessage,
+} from '../runtime/agent/orchestrator/session/manager/prompt-utils.mjs';
+
+function isSummaryAnchorMessage(message) {
+  return message?.role === 'user'
+    && typeof message.content === 'string'
+    && message.content.startsWith(SUMMARY_PREFIX);
+}
+
+function hasRouteHistoryMessage(messages) {
+  const list = Array.isArray(messages) ? messages : [];
+  return hasUserConversationMessage(list) || list.some(isSummaryAnchorMessage);
+}
 
 // Model/route/search-route selection + mutation surface. Extracted verbatim from
 // the runtime API object; stateless helpers are imported directly and the
@@ -33,6 +48,8 @@ export function createModelRouteApi(deps) {
     persistLeadRoute, refreshRouteEffort,
     refreshStatuslineUsageSnapshot, scheduleStatuslineUsageRefresh,
     invalidateContextStatusCache, invalidateProviderCaches,
+    createCurrentSession, invalidatePreSessionToolSurface,
+    pushTranscriptRebind,
     collectSearchProviderModels,
   } = deps;
   return {
@@ -125,10 +142,41 @@ export function createModelRouteApi(deps) {
       await refreshRouteEffort(modelMeta);
       refreshStatuslineUsageSnapshot(getRoute());
       scheduleStatuslineUsageRefresh();
-      if (!applyToCurrentSession) {
+      const session = getSession();
+      // Model/provider changes are next-session-only for a session the user
+      // has already talked in or compacted (provider-keyed prompt cache). But
+      // an EMPTY current session — no committed route history and no in-flight
+      // first-turn prompt — has no cache to protect, so /model before the first
+      // chat takes effect live: route + statusline update immediately.
+      const currentSessionEmpty = !!session
+        && !hasRouteHistoryMessage(session.messages)
+        && !hasRouteHistoryMessage(session.liveTurnMessages);
+      const applyLive = applyToCurrentSession || currentSessionEmpty;
+      if (!applyLive) {
+        return getRoute();
+      }
+      if (currentSessionEmpty && session?.id && typeof createCurrentSession === 'function') {
+        // If the boot create is still finishing SessionStart/deferred-surface
+        // work, drain that promise first. Otherwise createCurrentSession()
+        // would return the old in-flight promise after we tombstone/null the
+        // session, racing the intended rebuild for the new provider.
+        await createCurrentSession('model-switch-empty-drain');
+        const emptySession = getSession();
+        if (!emptySession?.id
+          || hasRouteHistoryMessage(emptySession.messages)
+          || hasRouteHistoryMessage(emptySession.liveTurnMessages)) {
+          invalidateContextStatusCache();
+          return getRoute();
+        }
+        statusRoutes?.clearGatewaySessionRoute?.(emptySession.id);
+        mgr.closeSession?.(emptySession.id, 'cli-model-switch-empty', { tombstone: true });
+        setSession(null);
+        invalidatePreSessionToolSurface?.();
+        await createCurrentSession('model-switch-empty');
+        pushTranscriptRebind?.();
+        invalidateContextStatusCache();
         return getRoute();
       }
-      const session = getSession();
       if (session) {
         const route = getRoute();
         const updated = mgr.updateSessionRoute?.(session.id, {

package/src/session-runtime/provider-auth-api.mjs

@@ -31,7 +31,14 @@ export function createProviderAuthApi({
 }) {
   function refreshProviderCatalogsSoon() {
     if (typeof refreshProviderCatalogs !== 'function') return;
-    try { void Promise.resolve(refreshProviderCatalogs()).catch(() => {}); } catch { /* best-effort */ }
+    try {
+      void Promise.resolve(refreshProviderCatalogs())
+        .then(() => {
+          invalidateProviderCaches();
+          warmProviderModelCache();
+        })
+        .catch(() => {});
+    } catch { /* best-effort */ }
   }
 
   return {

package/src/session-runtime/provider-models.mjs

@@ -277,13 +277,13 @@ export function createProviderModels({
     return providerModelsFromCacheRows(await caches.providerModelsPromise);
   }
 
-  function warmProviderModelCache() {
+  function warmProviderModelCache({ loadSecrets = false } = {}) {
     if (Array.isArray(caches.providerModelsCache.models) || caches.providerModelsPromise) return caches.providerModelsPromise;
     profile('warm:start');
     const seq = ++caches.providerModelsLoadSeq;
-    caches.providerModelsPromise = loadProviderModelsFresh({ loadSecrets: false })
+    caches.providerModelsPromise = loadProviderModelsFresh({ loadSecrets })
       .then((models) => {
-        if (seq === caches.providerModelsLoadSeq && shouldAdoptProviderModelCache(models, { loadSecrets: false })) {
+        if (seq === caches.providerModelsLoadSeq && shouldAdoptProviderModelCache(models, { loadSecrets })) {
           caches.providerModelsCache = { models, at: Date.now() };
         }
         bootProfile('provider-models:warm-ready', { count: models.length });

package/src/session-runtime/resource-api.mjs

@@ -80,6 +80,24 @@ export function createResourceApi(deps) {
     }
     return chain.running;
   }
+  function configuredProfileIdentityLine() {
+    try {
+      const config = getConfig();
+      const stored = config?.profile ?? config?.agent?.profile;
+      const profile = cfgMod.normalizeProfileConfig(stored);
+      const title = clean(profile?.title);
+      if (!title) return '';
+      return `[profile] Current configured user name/identity: ${title}. This profile value is authoritative; ignore stale memory rows that say the user's identity is unknown.`;
+    } catch {
+      return '';
+    }
+  }
+  function isIdentityRecallQuery(query) {
+    const q = clean(query).toLowerCase().replace(/\s+/g, '');
+    if (!q) return false;
+    return /(?:\uB0B4\uAC00|\uB098\uB294|\uB098|\uC0AC\uC6A9\uC790|\uC720\uC800|user|my|me).*(?:\uB204\uAD6C|\uB204\uAD70|\uC815\uCCB4|\uC774\uB984|name|identity)|(?:whoami|whoami\?|whoami？)|who(?:am)?i|whoami/.test(q)
+      || /^(?:\uB098\uB204\uAD6C\uB0D0|\uB098\uB294\uB204\uAD6C\uB0D0|\uB0B4\uAC00\uB204\uAD6C\uB0D0|\uB0B4\uC774\uB984\uBB50|\uB0B4\uC774\uB984\uBB50\uC57C|whoami)$/i.test(q);
+  }
   return {
     mcpStatus() {
       return mcpStatus();
@@ -300,6 +318,10 @@ export function createResourceApi(deps) {
       const session = getSession();
       const currentCwd = getCurrentCwd();
       const baseQuery = query || args?.query || '';
+      if (isIdentityRecallQuery(baseQuery)) {
+        const profileLine = configuredProfileIdentityLine();
+        if (profileLine) return profileLine;
+      }
       if (args?.currentSession !== false && session?.id) {
         const currentText = currentSessionRecallRows(session, baseQuery, { limit: args?.limit });
         if (!isEmptyRecallText(currentText)) return currentText;