mixdog 0.9.55 → 0.9.59

package/src/runtime/channels/lib/voice-runtime-fetcher.mjs

@@ -40,6 +40,30 @@ import { spawnSync } from 'child_process'
 import { createGunzip } from 'zlib'
 import { renameWithRetrySync, writeFileAtomicSync } from '../../shared/atomic-file.mjs'
 import { windowsProgramRoots, windowsSystemRoot } from '../../agent/orchestrator/tools/builtin/windows-roots.mjs'
+import { detectDeviceLanguage, normalizeWhisperLanguage } from './whisper-language.mjs'
+
+// Model catalog: `models.standard` / `models.korean` in the manifest, with the
+// legacy single `model` section as the standard fallback for older manifests.
+// Selection: explicit voice.model config wins; 'auto' picks the Korean
+// fine-tune only when the device language resolves to Korean.
+export function selectVoiceModelId(voiceConfig = null) {
+  const pref = String(voiceConfig?.model || 'auto').trim().toLowerCase()
+  if (pref === 'standard' || pref === 'korean') return pref
+  // voice.language is the strongest auto signal: Node's ICU default locale
+  // often resolves to en-US even on a Korean Windows install, so an explicit
+  // transcription language wins over device-locale detection.
+  const configured = normalizeWhisperLanguage(voiceConfig?.language)
+  if (configured === 'ko') return 'korean'
+  if (configured) return 'standard'
+  return detectDeviceLanguage() === 'ko' ? 'korean' : 'standard'
+}
+
+function manifestModelEntry(manifest, modelId = 'standard') {
+  const entry = manifest?.models && typeof manifest.models === 'object'
+    ? manifest.models[modelId]
+    : null
+  return entry || manifest?.model || null
+}
 
 const BUNDLED_MANIFEST_PATH = fileURLToPath(new URL('../data/voice-runtime-manifest.json', import.meta.url))
 const MANIFEST_URL = 'https://raw.githubusercontent.com/tribgames/mixdog/main/src/runtime/channels/data/voice-runtime-manifest.json'
@@ -597,11 +621,45 @@ export function resolveManagedWhisperCmd(dataDir) {
 export function resolveManagedWhisperModel(dataDir) {
   if (!existsSync(BUNDLED_MANIFEST_PATH)) return null
   const manifest = JSON.parse(readFileSync(BUNDLED_MANIFEST_PATH, 'utf8'))
-  if (!manifest.model?.filename) return null
-  const p = join(dataDir, 'voice', 'models', manifest.model.filename)
+  return resolveManagedWhisperModelForId(manifest, dataDir, 'standard')
+}
+
+export function resolveManagedWhisperModelById(dataDir, modelId = 'standard') {
+  if (!existsSync(BUNDLED_MANIFEST_PATH)) return null
+  const manifest = JSON.parse(readFileSync(BUNDLED_MANIFEST_PATH, 'utf8'))
+  return resolveManagedWhisperModelForId(manifest, dataDir, modelId)
+}
+
+function resolveManagedWhisperModelForId(manifest, dataDir, modelId) {
+  const entry = manifestModelEntry(manifest, modelId)
+  if (!entry?.filename) return null
+  const modelDir = join(dataDir, 'voice', 'models')
+  const p = join(modelDir, entry.filename)
   return existsSync(p) ? p : null
 }
 
+// Clean-install policy: the models dir holds ONLY filenames declared by the
+// current manifest (standard/korean). Anything else — the pre-Q8 F16 weight,
+// interrupted renames, hand-copied experiments — is deleted so a model swap
+// never leaves a 1.6GB orphan behind and resolution never silently falls back
+// to a stale weight.
+function gcUnknownModelFiles(manifest, modelDir) {
+  const keep = new Set()
+  for (const entry of [manifest?.model, ...Object.values(manifest?.models || {})]) {
+    if (entry?.filename) keep.add(entry.filename)
+  }
+  if (keep.size === 0) return
+  let names = []
+  try { names = readdirSync(modelDir) } catch { return }
+  for (const name of names) {
+    if (!name.endsWith('.bin') || keep.has(name)) continue
+    try {
+      rmSync(join(modelDir, name), { force: true })
+      process.stderr.write(`[voice-runtime] removed stale model file ${name}\n`)
+    } catch {}
+  }
+}
+
 // Single managed ffmpeg binary used by transcribe (ogg→wav). Layout mirrors
 // whisper-runtime: one binary per OS×arch fetched once, sha256-verified, atomic
 // stage→rename, GC of stale ffmpeg-* dirs. Source binaries are gz-compressed
@@ -701,9 +759,9 @@ export function resolveManagedFfmpegPath(dataDir) {
   return null
 }
 
-export function resolveVoiceRuntime(dataDir) {
+export function resolveVoiceRuntime(dataDir, { modelId = 'standard' } = {}) {
   const managedWhisperCmd = resolveManagedWhisperCmd(dataDir)
-  const managedModelPath = resolveManagedWhisperModel(dataDir)
+  const managedModelPath = resolveManagedWhisperModelById(dataDir, modelId)
   const managedFfmpegPath = resolveManagedFfmpegPath(dataDir)
   const ext = process.platform === 'win32' ? '.exe' : ''
   const managedServerCmd = managedWhisperCmd
@@ -720,7 +778,8 @@ export function resolveVoiceRuntime(dataDir) {
     whisperCmd: managedWhisperCmd,
     serverCmd,
     modelPath: managedModelPath,
-    modelName: managedModelPath ? 'ggml-large-v3-turbo.bin' : '',
+    modelId,
+    modelName: managedModelPath ? managedModelPath.split(/[\\/]/).pop() : '',
     ffmpegPath: managedFfmpegPath,
   }
 }
@@ -729,9 +788,9 @@ export function resolveVoiceRuntime(dataDir) {
 // the resolved file exists and matches the manifest sha256, return without
 // re-downloading. Atomic install via stage-then-rename so a partial download
 // on a kill/crash never leaves the model dir holding a corrupted .bin.
-export async function ensureWhisperModel(dataDir, onProgress = null) {
+export async function ensureWhisperModel(dataDir, onProgress = null, modelId = 'standard') {
   const manifest = await loadManifest(dataDir)
-  const model = manifest.model
+  const model = manifestModelEntry(manifest, modelId)
   if (!model) {
     throw new Error('[voice-runtime] manifest is missing the `model` section — cannot resolve whisper model')
   }
@@ -751,7 +810,10 @@ export async function ensureWhisperModel(dataDir, onProgress = null) {
   return _withInstallLock(modelDir, 'install', async () => {
     if (existsSync(modelPath)) {
       const actual = await sha256File(modelPath)
-      if (actual === model.sha256) return { modelPath, modelId: model.id, size: model.size }
+      if (actual === model.sha256) {
+        gcUnknownModelFiles(manifest, modelDir)
+        return { modelPath, modelId: model.id, size: model.size }
+      }
       try { rmSync(modelPath, { force: true }) } catch {}
     }
     gcStagingPartials(modelDir)
@@ -764,6 +826,7 @@ export async function ensureWhisperModel(dataDir, onProgress = null) {
       })
       await verifySha256(stagingPath, model.sha256)
       renameWithRetrySync(stagingPath, modelPath)
+      gcUnknownModelFiles(manifest, modelDir)
       process.stderr.write(`[voice-runtime] model ${model.id} ready at ${modelPath}\n`)
       return { modelPath, modelId: model.id, size: model.size }
     } catch (err) {

package/src/runtime/channels/lib/voice-transcription.mjs

@@ -3,7 +3,7 @@ import * as fs from "fs";
 import * as os from "os";
 import * as path from "path";
 import { createRequire } from "module";
-import { resolveVoiceRuntime } from "./voice-runtime-fetcher.mjs";
+import { resolveVoiceRuntime, selectVoiceModelId } from "./voice-runtime-fetcher.mjs";
 import { ensureReady, transcribe } from "./whisper-server.mjs";
 import { normalizeWhisperLanguage, detectDeviceLanguage } from "./whisper-language.mjs";
 
@@ -119,7 +119,7 @@ function createVoiceTranscription({ getConfig, dataDir }) {
   async function _doTranscribeVoice(audioPath, attachmentId) {
     const config = getConfig();
     try {
-      const runtime = resolveVoiceRuntime(dataDir);
+      const runtime = resolveVoiceRuntime(dataDir, { modelId: selectVoiceModelId(config.voice) });
       if (!runtime?.installed) {
         const missing = [runtime?.binary ? null : 'binary', runtime?.model ? null : 'model', runtime?.ffmpeg ? null : 'ffmpeg'].filter(Boolean).join(' + ');
         throw new Error(`voice runtime not installed (missing: ${missing}) — open the setup wizard and click "Install voice"`);

package/src/runtime/channels/lib/whisper-language.mjs

@@ -6,6 +6,10 @@ let resolvedWhisperLanguage = null;
 function normalizeWhisperLanguage(value) {
   const raw = String(value ?? "").trim().toLowerCase();
   if (!raw || raw === "auto") return null;
+  // POSIX pseudo-locales (LANG=C / C.UTF-8 / POSIX) carry no language signal;
+  // treating them as a language poisoned detection ('c.utf-8' reached whisper
+  // and blocked the ko-KR Intl fallback from ever being consulted).
+  if (raw === "c" || raw === "posix" || raw.startsWith("c.") || raw.startsWith("posix.")) return null;
   if (raw.startsWith("ko")) return "ko";
   if (raw.startsWith("ja")) return "ja";
   if (raw.startsWith("en")) return "en";

package/src/runtime/memory/lib/embedding-provider.mjs

@@ -74,6 +74,13 @@ function ensureWorker() {
   const execArgv = process.execArgv.filter((arg) => !String(arg).startsWith('--input-type'))
   worker = new Worker(WORKER_PATH, { env: { ...process.env }, execArgv })
   worker.on('message', (msg) => {
+    if (msg.type === 'log') {
+      // Worker-thread stdio forwarded via IPC (see embedding-worker.mjs
+      // header): route through the parent's guardable stderr so TUI runs
+      // file it instead of tearing the terminal frame.
+      try { process.stderr.write(String(msg.chunk ?? '')) } catch { /* best-effort */ }
+      return
+    }
     if (msg.type === 'profile') {
       writeProfilePoint(msg.record)
       return

package/src/runtime/memory/lib/embedding-worker.mjs

@@ -21,6 +21,26 @@ import {
 } from './embedding-model-config.mjs'
 
 const MODEL_ID = getConfiguredEmbeddingModelId()
+
+// Reroute ALL worker-thread stdio through parentPort. Without stdout:true/
+// stderr:true the worker's stream writes are copied straight into the
+// process's REAL fds, bypassing the TUI stderr guard and painting over the
+// alternate-screen frame (third-party noise: transformers.js progress,
+// ORT JS warnings, stray console.*). Piped stdio (stdout:true) is NOT an
+// option here — reading a worker's piped stdio refs the MessagePort for the
+// worker's lifetime and blocks process exit (see save-session-worker.mjs,
+// same pattern). __mixdogMemoryLog above intentionally keeps the raw bound
+// writer: it is already gated by MIXDOG_QUIET_MEMORY_LOG in TUI runs.
+const __forwardWorkerWrite = (chunk, encoding, callback) => {
+  const done = typeof encoding === 'function' ? encoding : callback
+  try {
+    parentPort?.postMessage({ type: 'log', chunk: typeof chunk === 'string' ? chunk : String(chunk ?? '') })
+  } catch { /* drop — logging must never break embedding */ }
+  if (typeof done === 'function') { try { done() } catch { /* ignore */ } }
+  return true
+}
+process.stdout.write = __forwardWorkerWrite
+process.stderr.write = __forwardWorkerWrite
 const DEFAULT_DEVICE = getDefaultEmbeddingDevice(MODEL_ID)
 const DEFAULT_DTYPE = getDefaultEmbeddingDtype(MODEL_ID)
 const MODEL_LOAD_OPTIONS = getEmbeddingModelLoadOptions(MODEL_ID)

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

@@ -19,6 +19,7 @@ import {
   renderEntryLines,
   renderSessionGroupedLines,
   collapseNearDuplicateRows,
+  compactDigestRows,
 } from './recall-format.mjs'
 import { searchRelevantHybrid } from './memory-recall-store.mjs'
 import { fetchEntriesByIdsScoped } from './memory-recall-id-patch.mjs'
@@ -101,6 +102,10 @@ export function createQueryHandlers({
     const sessionId = String(args.sessionId || args.session_id || '').trim()
     if (!sessionId) return { text: '(no current session)' }
     const limit = Math.max(1, Math.min(100, Number(args.limit) || 20))
+    const compactDigest = args.compactDigest === true
+    // Over-fetch before compact-only dedupe so duplicated legacy rows cannot
+    // consume the requested page and hide distinct older context.
+    const fetchLimit = compactDigest ? Math.min(100, Math.max(limit, limit * 4)) : limit
     const terms = sessionRecallTerms(args.query)
     const params = [sessionId]
     // Roots + not-yet-chunked leaves only. Once cycle1 turns raw leaves into
@@ -147,7 +152,7 @@ export function createQueryHandlers({
       })
       where.push(`(${clauses.join(' OR ')})`)
     }
-    params.push(limit)
+    params.push(fetchLimit)
     let rows = (await db.query(`
       SELECT id, ts, role, content, session_id, source_turn, chunk_root, is_root,
              element, category, summary, status, score, last_seen_at, project_id
@@ -156,9 +161,9 @@ export function createQueryHandlers({
       ORDER BY ts DESC, id DESC
       LIMIT $${params.length}
     `, params)).rows
-    if (rows.length < limit) {
+    if (rows.length < fetchLimit) {
       const seen = new Set(rows.map((row) => Number(row.id)).filter((id) => Number.isFinite(id)))
-      const fillLimit = Math.max(0, limit - rows.length)
+      const fillLimit = Math.max(0, fetchLimit - rows.length)
       const fillWhere = ['session_id = $1', 'id <> ALL($2::bigint[])', '(is_root = 1 OR chunk_root IS NULL OR chunk_root = id)']
       const fillParams = [sessionId, [...seen]]
       if (Number.isFinite(excludeSourceTurnId)) {
@@ -201,7 +206,8 @@ export function createQueryHandlers({
         }
       }
     }
-    return { text: renderEntryLines(rows) }
+    if (compactDigest) rows = compactDigestRows(rows, limit)
+    return { text: renderEntryLines(rows, { pendingMarks: !compactDigest }) }
   }
 
   async function recallCoreRows(query, { projectScope, category, limit } = {}) {

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

@@ -149,7 +149,7 @@ export function interleaveRawRows(hybridRows, rawRows) {
   return out
 }
 
-export function renderEntryLines(rows, { recencyOrder = false } = {}) {
+export function renderEntryLines(rows, { recencyOrder = false, pendingMarks = true } = {}) {
   if (!rows || rows.length === 0) return '(no results)'
   // Each emitted line is tracked as a { ts, text } unit so the recencyOrder
   // path can sort the WHOLE stream (roots + their members, plus leaf/raw rows)
@@ -202,7 +202,7 @@ export function renderEntryLines(rows, { recencyOrder = false } = {}) {
         : cleanMemoryText(String(r.content ?? '')).slice(0, 8000)
       // Unchunked raw leaf (cycle1 hasn't classified it yet): mark it so
       // callers can tell fresh-but-unprocessed rows from chunked memory.
-      const pendingMark = (r.is_root === 0 && r.chunk_root == null) ? ' [pending]' : ''
+      const pendingMark = pendingMarks && (r.is_root === 0 && r.chunk_root == null) ? ' [pending]' : ''
       units.push({ ts: Number(r.ts) || 0, text: `[${ts}] ${rolePrefix}${body.slice(0, 8000)}${pendingMark} #${r.id}` })
     }
   }
@@ -240,6 +240,37 @@ function normalizedRowText(r) {
   return String(body).toLowerCase()
 }
 
+function exactDuplicateKey(r) {
+  if (Array.isArray(r?.members) && r.members.length > 0) {
+    return JSON.stringify(['members', r.members.map((m) => [
+      m?.role ?? '',
+      cleanMemoryText(String(m?.content ?? '')),
+    ])])
+  }
+  const element = r?.element ?? ''
+  const summary = r?.summary ?? ''
+  const body = (element || summary)
+    ? `${element}${summary ? ' — ' + summary : ''}`
+    : cleanMemoryText(String(r?.content ?? ''))
+  return JSON.stringify([r?.role ?? '', body])
+}
+
+// Legacy object-identity-only ingest could mint duplicate rows on JSON reload.
+// Keep the newest/highest-ranked exact body once, including short acknowledgments
+// that shingle dedupe intentionally ignores.
+export function collapseExactDuplicateRows(rows) {
+  if (!Array.isArray(rows) || rows.length < 2) return rows
+  const seen = new Set()
+  const out = []
+  for (const row of rows) {
+    const key = exactDuplicateKey(row)
+    if (seen.has(key)) continue
+    seen.add(key)
+    out.push(row)
+  }
+  return out
+}
+
 export function collapseNearDuplicateRows(rows, {
   stubOverlap = 0.65,
   dropOverlap = 0.9,
@@ -290,6 +321,16 @@ export function collapseNearDuplicateRows(rows, {
   return out
 }
 
+// Compact handoffs are authoritative state, not browsable search output.
+// Remove exact and near-duplicate bodies completely (no id stubs) so polluted
+// legacy rows cannot crowd distinct recent work out of the digest.
+export function compactDigestRows(rows, limit = 30) {
+  const cap = Math.max(1, Math.floor(Number(limit) || 30))
+  return collapseNearDuplicateRows(collapseExactDuplicateRows(rows))
+    .filter((row) => !row?._dupStub)
+    .slice(0, cap)
+}
+
 // Compact session label for group headers: keep short ids verbatim, shorten
 // long ones to a recognizable tail (ids are typically unique in the suffix —
 // timestamp/counter — not the prefix).

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

@@ -85,7 +85,7 @@ export function createSessionIngestRuntime({
       _sessionIngestOrdinalState.set(sessionId, existing)
       return existing
     }
-    const st = { occNext: new Map(), seeded: false }
+    const st = { occNext: new Map(), seeded: false, snapshot: [] }
     _sessionIngestOrdinalState.set(sessionId, st)
     while (_sessionIngestOrdinalState.size > _ORDINAL_STATE_MAX_SESSIONS) {
       const oldest = _sessionIngestOrdinalState.keys().next().value
@@ -95,14 +95,10 @@ export function createSessionIngestRuntime({
     return st
   }
   // Ordinal assigned to a given session-message OBJECT at first sight, reused on
-  // every later hydrate so its source_ref stays stable and ON CONFLICT dedupes
-  // it. This is the survivor-vs-new-append signal — VERIFIED valid in
-  // production: ingest_session runs IN-PROCESS (runtime-core executor →
-  // memoryMod.handleToolCall(args), session-runtime/runtime-core.mjs), NOT over
-  // an HTTP/JSON boundary, so the SAME message objects arrive across calls for a
-  // live session. WeakMap: entries vanish when a message is GC'd (compaction
-  // drops it from the array). Across a process restart (or LRU eviction) the
-  // signal is gone; the walk then falls back to positional ordinals.
+  // later hydrates while the live array survives. Resume/reopen JSON-parses a new
+  // object graph even when this memory runtime remains warm, so object identity
+  // is only the fast/strong signal; the ordered snapshot fallback below handles
+  // cloned transcript replays.
   const _ingestedMessageOrdinal = new WeakMap()
   // Assign/reuse the occurrence ordinal for message `m` under identity `occKey`.
   // A re-presented object reuses its recorded ordinal AND advances the session
@@ -123,17 +119,22 @@ export function createSessionIngestRuntime({
     _ingestedMessageOrdinal.set(m, ord)
     return ord
   }
+  // Reuse an occurrence recovered from the previous ingest's content/order
+  // snapshot. Session resume/reopen JSON-parses the transcript, so every row is
+  // a fresh object even while the long-lived memory runtime (and its WeakMaps)
+  // stays warm. Object identity alone therefore misclassified a cloned replay
+  // as newly appended history and minted a new source_ref for every old turn.
+  function _reuseOccurrence(occNext, occKey, m, occurrence) {
+    const ord = Math.max(0, Math.floor(Number(occurrence) || 0))
+    if (ord + 1 > (occNext.get(occKey) ?? 0)) occNext.set(occKey, ord + 1)
+    _ingestedMessageOrdinal.set(m, ord)
+    return ord
+  }
   // Cache of (role, cleaned content) per session message OBJECT, keyed by
   // identity (WeakMap — entries vanish once the message is GC'd, e.g. after
-  // compaction drops the array). The subset-reingest ordinal fix below must
-  // replay cleanMemoryText/shouldExcludeIngestMessage over messages[0, start)
-  // on every call; without caching that turned an O(limit)-bounded ingest into
-  // an O(full transcript) regex pass on every hydrate. Message objects are
-  // immutable transcript entries reused by reference across calls (recall-
-  // fasttrack re-ingests the same in-memory array as the session grows), so
-  // once a message's identity fields are computed they never change — caching
-  // makes every call after the first pay only for genuinely NEW messages,
-  // restoring the limit-bounded cost in steady state.
+  // compaction or JSON reload replaces the array). Live-array steady-state calls
+  // reuse the cache; cloned replays recompute once and then reconcile against the
+  // ordered snapshot.
   const _ingestIdentityFieldsCache = new WeakMap()
   // Return { role, content } for a session message's dedup identity, or null if
   // the message would be skipped by ingest (no role / excluded / empty content
@@ -257,61 +258,72 @@ export function createSessionIngestRuntime({
       } catch { /* absent/corrupt state file → in-memory only (invariant 2 safe) */ }
       ordinalState.durableLoaded = true
     }
-    if (!ordinalState.seeded) {
-      // Replay identity/exclude logic over messages[0, start) so occNext reflects
-      // full-array position (and any surviving recorded ordinals) even when this
-      // call ingests only a later window. Runs once per fresh/evicted state; a
-      // warm state already carries the counts, so re-seeding would double-count.
-      for (let i = 0; i < start; i += 1) {
-        const m = messages[i]
-        if (!m || typeof m !== 'object') continue
-        // Cached (WeakMap-keyed) so a repeated hydrate over the SAME prefix
-        // objects only pays the clean/normalize cost once per message.
-        const fields = _ingestIdentityFields(m)
-        if (!fields) continue
-        _assignOccurrence(occNext, `${fields.role}\u0000${fields.content}`, m)
+    // Content/order fallback for JSON-cloned transcript replays. The previous
+    // eligible sequence is indexed by a stable base source key; a greedy
+    // forward subsequence match recognizes unchanged prefixes, compacted
+    // survivors, and appended suffixes in O(n). Same-object rows keep the
+    // stronger WeakMap occurrence and advance the cursor to that exact prior
+    // occurrence. Unmatched rows alone consume the historical high-water, so a
+    // genuine append remains distinct while a reopen/reload stays idempotent.
+    const priorSnapshot = Array.isArray(ordinalState.snapshot) ? ordinalState.snapshot : []
+    const priorByKey = new Map()
+    for (let i = 0; i < priorSnapshot.length; i += 1) {
+      const item = priorSnapshot[i]
+      if (!item?.key) continue
+      if (!priorByKey.has(item.key)) priorByKey.set(item.key, [])
+      priorByKey.get(item.key).push({ index: i, occurrence: item.occurrence })
+    }
+    const priorPointers = new Map()
+    let priorCursor = 0
+    const takePrior = (key, wantedOccurrence = null) => {
+      const list = priorByKey.get(key)
+      if (!list?.length) return null
+      let p = priorPointers.get(key) ?? 0
+      while (p < list.length && list[p].index < priorCursor) p += 1
+      if (wantedOccurrence != null) {
+        while (p < list.length
+          && list[p].index >= priorCursor
+          && Number(list[p].occurrence) !== Number(wantedOccurrence)) p += 1
+      }
+      if (p >= list.length) {
+        priorPointers.set(key, p)
+        return null
       }
-      ordinalState.seeded = true
+      const match = list[p]
+      priorPointers.set(key, p + 1)
+      priorCursor = match.index + 1
+      return match
     }
-    for (let i = start; i < messages.length; i += 1) {
+    const currentSnapshot = []
+    const prepared = []
+    for (let i = 0; i < messages.length; i += 1) {
       const m = messages[i]
       if (!m || typeof m !== 'object') continue
-      const role = normalizeIngestRole(m.role)
-      // ingest_session persists user/assistant only; system/developer/tool rows
-      // are dropped so recall-fasttrack summaries stay conversation-focused and
-      // do not re-inject content already in the protected system prefix.
-      if (!role) continue
-      // Exclude synthetic / non-conversation rows entirely (reference-files
-      // injections, compaction summaries, protected-context `.` acks, internal
-      // runtime nudges). These are mechanical noise, not conversation.
-      if (shouldExcludeIngestMessage(m)) continue
-      // Pure-conversation shaping: only the human/model prose text. The ingest
-      // shaper NEVER inlines tool_call / tool_result traces and strips the
-      // deterministic manager.mjs user-turn prefix envelopes (# Session /
-      // # Additional context / # Prefetch / # Task) so only the real human
-      // prompt remains. cleanMemoryText then removes the <system-reminder> block
-      // and residual transcript noise.
-      const content = cleanMemoryText(sessionMessageContentForIngest(m))
-      if (!content || !content.trim()) continue
-      considered += 1
-      const tsMs = parseTsToMs(m.ts ?? m.timestamp ?? (Date.now() - (messages.length - i)))
-      // Assign the next monotonic turn BEFORE building the source_ref so identical
-      // untimestamped repeats get distinct identities (peekNext is stable until a
-      // row is actually inserted → next()).
-      const assignedTurn = turnAllocator.peekNext()
-      // Stable occurrence index for this identity (pre-hash; role+content is a
-      // sufficient discriminator for the duplicate case the ordinal disambiguates).
-      // See the distinction-rule comment above and _assignOccurrence. For an
-      // UNTIMESTAMPED turn a WARM first-seen assignment is floored by the durable
-      // per-identity high-water so a genuine post-restart/eviction append lands
-      // above every persisted copy; the durable high-water is then advanced.
+      const fields = _ingestIdentityFields(m)
+      if (!fields) continue
+      const { role, content } = fields
       const occKey = `${role}\u0000${content}`
       const rawTs = m.ts ?? m.timestamp
       const untimestamped = !((typeof rawTs === 'number' && Number.isFinite(rawTs))
         || (typeof rawTs === 'string' && rawTs.trim()))
       const idHash = untimestamped ? _identityHash(occKey) : null
-      const floor = (warmCall && untimestamped) ? (ordinalState.durable.get(idHash) ?? 0) : 0
-      const occurrence = _assignOccurrence(occNext, occKey, m, floor)
+      // occurrence=0 makes a stable match key: timestamp/tool ids remain part
+      // of the key, while repeated untimestamped text shares a key and is
+      // disambiguated by ordered snapshot occurrences.
+      const snapshotKey = stableSessionSourceRef(sessionId, m, role, content, 0)
+      let occurrence
+      if (_ingestedMessageOrdinal.has(m)) {
+        occurrence = _assignOccurrence(occNext, occKey, m)
+        takePrior(snapshotKey, occurrence)
+      } else {
+        const prior = takePrior(snapshotKey)
+        if (prior) {
+          occurrence = _reuseOccurrence(occNext, occKey, m, prior.occurrence)
+        } else {
+          const floor = (warmCall && untimestamped) ? (ordinalState.durable.get(idHash) ?? 0) : 0
+          occurrence = _assignOccurrence(occNext, occKey, m, floor)
+        }
+      }
       if (untimestamped && occurrence >= 1) {
         // Duplicate untimestamped identity (occurrence>0): record/raise its durable
         // next-ordinal (write-behind persisted below). Monotonic — never regresses
@@ -319,6 +331,20 @@ export function createSessionIngestRuntime({
         const cur = ordinalState.durable.get(idHash) ?? 0
         if (occurrence + 1 > cur) { ordinalState.durable.set(idHash, occurrence + 1); ordinalState.dirty = true }
       }
+      currentSnapshot.push({ key: snapshotKey, occurrence })
+      if (i >= start) {
+        considered += 1
+        prepared.push({ m, role, content, occurrence, index: i })
+      }
+    }
+    ordinalState.snapshot = currentSnapshot
+    ordinalState.seeded = true
+    for (const { m, role, content, occurrence, index } of prepared) {
+      const tsMs = parseTsToMs(m.ts ?? m.timestamp ?? (Date.now() - (messages.length - index)))
+      // Assign the next monotonic turn BEFORE building the source_ref so identical
+      // untimestamped repeats get distinct identities (peekNext is stable until a
+      // row is actually inserted → next()).
+      const assignedTurn = turnAllocator.peekNext()
       // Stable per-message identity. The previous `session:${id}#${i+1}` key was
       // positional, so after compaction shrinks/reindexes session.messages a
       // later turn could reuse an old index and be silently skipped by

package/src/runtime/shared/err-text.mjs

@@ -152,7 +152,10 @@ export function presentErrorText(error, options = {}) {
   const quotaRetry = /retryAfter=([^\s:]+)/i.exec(text);
   if (/\b429\b|rate[_ -]?limit|quota|too many requests|resource exhausted|insufficient_quota|quota_exceeded/i.test(text)) {
     const provider = /Anthropic OAuth/i.test(text) ? 'Anthropic' : 'Provider';
-    return `${provider} quota/rate limit hit${quotaRetry?.[1] ? `; retry after ${quotaRetry[1]}` : ''}.`;
+    // Cooldown refusals are recoverable right now by switching accounts —
+    // surface that path instead of leaving only the wait option.
+    const hint = /cooldown/i.test(text) ? ' Re-login or switch the provider account to continue now.' : '';
+    return `${provider} quota/rate limit hit${quotaRetry?.[1] ? `; retry after ${quotaRetry[1]}` : ''}.${hint}`;
   }
 
   const firstResponse = /(?:agent\s+)?first response stale\s*\((\d+)ms\)/i.exec(text);

package/src/runtime/shared/resource-admission.mjs

@@ -86,6 +86,8 @@ export class ResourceAdmissionController {
     this.now = now;
     this.active = { agent: 0, shell: 0 };
     this.queue = [];
+    // Live leases for saturation diagnostics only (labels/ages in snapshot()).
+    this.activeLeases = new Set();
     this.context = new AsyncLocalStorage();
   }
 
@@ -183,10 +185,12 @@ export class ResourceAdmissionController {
       restorePending: null,
       parent,
       releasePromise: null,
+      startedAt: this.now(),
       queuedMs: queuedAt == null ? 0 : Math.max(0, this.now() - queuedAt),
       release: () => {
         if (lease.released) return lease.releasePromise || Promise.resolve();
         lease.released = true;
+        this.activeLeases.delete(lease);
         if (lease.restorePending) {
           const item = lease.restorePending.item;
           const index = this.queue.indexOf(item);
@@ -212,6 +216,7 @@ export class ResourceAdmissionController {
         return restored;
       },
     };
+    this.activeLeases.add(lease);
     return lease;
   }
 
@@ -353,10 +358,16 @@ export class ResourceAdmissionController {
   }
 
   snapshot() {
+    const now = this.now();
     return {
       active: { ...this.active },
       queued: this.queue.length,
       limits: { ...this.limits },
+      activeLeases: [...this.activeLeases].map((lease) => ({
+        kind: lease.kind,
+        label: lease.label,
+        ageMs: Math.max(0, now - (lease.startedAt || now)),
+      })),
     };
   }
 }

package/src/runtime/shared/schedule-model-ref.mjs

@@ -0,0 +1,28 @@
+// schedule.model wire format shared by the channels-worker scheduler and the
+// engine-side run-now dispatch: either a config.presets id/name (legacy) or a
+// direct "provider/model[@effort][+fast]" route string written by the desktop
+// schedule editor. Slash-form values become {provider,model,effort?,fast?}
+// route objects, which agent-dispatch consumes without a presets lookup.
+export function parseScheduleModelRef(ref) {
+  const raw = String(ref || '');
+  const slash = raw.indexOf('/');
+  if (slash <= 0) return raw;
+  let rest = raw.slice(slash + 1);
+  let fast = false;
+  if (rest.endsWith('+fast')) {
+    fast = true;
+    rest = rest.slice(0, -5);
+  }
+  let effort = '';
+  const at = rest.lastIndexOf('@');
+  if (at > 0) {
+    effort = rest.slice(at + 1);
+    rest = rest.slice(0, at);
+  }
+  return {
+    provider: raw.slice(0, slash),
+    model: rest,
+    ...(effort ? { effort } : {}),
+    ...(fast ? { fast: true } : {}),
+  };
+}