mixdog 0.9.4 → 0.9.5

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

@@ -4,7 +4,7 @@ function __mixdogMemoryLog(...args) {
   return __mixdogMemoryStderrWrite(...args);
 }
 
-import { buildFtsQuery } from './memory-text-utils.mjs'
+import { buildFtsQuery, buildFtsPrefixQuery } from './memory-text-utils.mjs'
 import { VALID_CATEGORY, embeddingToSql } from './memory.mjs'
 import { freshnessFactor } from './memory-score.mjs'
 import { buildRecallScopeFilter } from './memory-recall-scope-filter.mjs'
@@ -28,6 +28,21 @@ const SEMANTIC_TOP_RANK_MAX = 3
 // the cross-language rescue while rejecting pure-noise top ranks.
 const SEMANTIC_TOP_RANK_MIN_SIM = 0.70
 const SHORT_QUERY_TOKEN_MAX = 2
+// Dense-similarity weighting for retrievalScore. Lexical RRF sums 1/(K+rank)
+// per matching leg (K=60), so a row hitting 2 lexical legs at rank 1 scores
+// rrf ≈ 2/(60+1) = 0.0328 — enough to bury a single semantically-close dense
+// hit that never shares lexical terms. We add a normalized dense-similarity
+// term so a strong dense-only match can outrank stale multi-leg lexical hits:
+//   denseTerm = W_DENSE * max(0, sim - SIM_FLOOR) / (1 - SIM_FLOOR) * freshness
+// At sim=0.85: (0.85-0.60)/(1-0.60) = 0.625, so denseTerm = 0.04 * 0.625 = 0.025
+// with freshness=1. That alone doesn't beat 0.0328, but combined with the
+// row's own rrf contribution (a dense-only row still has 1/(60+rank) from its
+// dense rank, e.g. rank 1 → 0.0164) the total ≈ 0.0164 + 0.025 = 0.0414,
+// which clears the 0.0328 two-leg lexical baseline. W_DENSE=0.04 was chosen
+// as the smallest round value satisfying this at sim=0.85; SIM_FLOOR=0.60
+// matches the noise floor used elsewhere for MiniLM-class embeddings.
+const SIM_FLOOR = 0.60
+const W_DENSE = 0.04
 
 function buildExactTerms(query) {
   const clean = String(query ?? '').replace(/\s+/g, ' ').trim()
@@ -230,7 +245,13 @@ export async function searchRelevantHybrid(db, query, options = {}) {
     ? embeddingToSql(options.queryVector)
     : null
 
-  const ftsQuery = clean.length >= 3 ? (buildFtsQuery(clean) ?? null) : null
+  // Prefer the Kiwi morph prefix-form query (to_tsquery, ':*' prefix match on
+  // content-morpheme stems) when kiwi is ready; else fall back to the plain
+  // websearch_to_tsquery path. ftsPrefixMode drives which tsquery ctor the
+  // sparse CTE uses (to_tsquery vs websearch_to_tsquery).
+  const ftsPrefix = clean.length >= 3 ? buildFtsPrefixQuery(clean) : null
+  const ftsQuery = ftsPrefix ? ftsPrefix.query : (clean.length >= 3 ? (buildFtsQuery(clean) ?? null) : null)
+  const ftsPrefixMode = Boolean(ftsPrefix)
   const exactTerms = buildExactTerms(clean)
   const queryTokenCount = countQueryTokens(clean)
   const minExactHits = exactTerms.length >= 8 ? 3 : exactTerms.length >= 4 ? 2 : 1
@@ -329,23 +350,29 @@ dense AS (SELECT NULL::bigint AS id, NULL::float8 AS sim, NULL::bigint AS dense_
 
   // sparse CTE: active only when ftsQuery is non-null.
   // useHotActive → queries mv_hot_active GIN index (mv_hot_active_tsv).
+  // tsqExpr: to_tsquery for the Kiwi morph prefix-form query ('stem:* & ...'),
+  // else websearch_to_tsquery for the plain fallback token string. Both parse
+  // $2 under the 'simple' config to match search_tsv's simple-config lexemes.
+  const tsqExpr = ftsPrefixMode
+    ? `to_tsquery('simple', $2)`
+    : `websearch_to_tsquery('simple', $2)`
   const sparseCte = ftsQuery ? (useHotActive ? `
 sparse AS (
   SELECT id,
-         ts_rank_cd(search_tsv, websearch_to_tsquery('simple', $2)) AS lex,
-         ROW_NUMBER() OVER (ORDER BY ts_rank_cd(search_tsv, websearch_to_tsquery('simple', $2)) DESC) AS sparse_rank
+         ts_rank_cd(search_tsv, ${tsqExpr}) AS lex,
+         ROW_NUMBER() OVER (ORDER BY ts_rank_cd(search_tsv, ${tsqExpr}) DESC) AS sparse_rank
   FROM mv_hot_active
-  WHERE search_tsv @@ websearch_to_tsquery('simple', $2)
+  WHERE search_tsv @@ ${tsqExpr}
     ${mvFilterClause}
   ORDER BY lex DESC
   LIMIT $4
 ),` : `
 sparse AS (
   SELECT id,
-         ts_rank_cd(search_tsv, websearch_to_tsquery('simple', $2)) AS lex,
-         ROW_NUMBER() OVER (ORDER BY ts_rank_cd(search_tsv, websearch_to_tsquery('simple', $2)) DESC) AS sparse_rank
+         ts_rank_cd(search_tsv, ${tsqExpr}) AS lex,
+         ROW_NUMBER() OVER (ORDER BY ts_rank_cd(search_tsv, ${tsqExpr}) DESC) AS sparse_rank
   FROM entries
-  WHERE search_tsv @@ websearch_to_tsquery('simple', $2)
+  WHERE search_tsv @@ ${tsqExpr}
     ${filterClause}
   ORDER BY lex DESC
   LIMIT $4
@@ -489,7 +516,11 @@ LEFT JOIN exact  x ON x.id = c.id`
               + (exactRank ? 1 / (K + exactRank) : 0)
     const freshness = applyFreshness ? freshnessFactor(row.ts, nowMs) : 1.0
     const boost = exactTextBoost(clean, row, row.exact_hits)
-    return { id, row, rrf, freshness, retrievalScore: (rrf * freshness) + boost }
+    const sim = Number(row.dense_sim)
+    const denseTerm = Number.isFinite(sim)
+      ? W_DENSE * Math.max(0, sim - SIM_FLOOR) / (1 - SIM_FLOOR) * freshness
+      : 0
+    return { id, row, rrf, freshness, retrievalScore: (rrf * freshness) + boost + denseTerm }
   })
   let semanticOnlyDropped = 0
   let weakTextDropped = 0
@@ -515,7 +546,13 @@ LEFT JOIN exact  x ON x.id = c.id`
     if (hasFullPhrase) return true
     if (queryTokenCount <= SHORT_QUERY_TOKEN_MAX) return true
     if (row.sparse_rank != null) return true
-    if (hasSemanticSupport && hasQueryTokenCoverage(row, queryTokenCount)) return true
+    // Semantic support as a second signal only applies when the dense leg
+    // actually ran. With a cold embedding model (no queryVector) semantic
+    // support is unattainable, and requiring it silently zeroed every
+    // multi-token lexical recall until warmup finished. Token coverage alone
+    // carries the filter in that degraded mode.
+    const semanticLegActive = vecSql != null
+    if ((!semanticLegActive || hasSemanticSupport) && hasQueryTokenCoverage(row, queryTokenCount)) return true
     weakTextDropped += 1
     return false
   })

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

@@ -1,6 +1,7 @@
 import {
   cleanMemoryText,
 } from './memory-extraction.mjs'
+import { isReady as koMorphReady, stems as koMorphStems } from './ko-morph.mjs'
 
 const MEMORY_TOKEN_STOPWORDS = new Set([
   'a', 'an', 'and', 'are', 'as', 'at', 'be', 'but', 'by', 'did', 'do', 'does', 'for', 'from',
@@ -55,4 +56,49 @@ export function buildFtsQuery(text) {
   return ftsTokens.map(t => t.replace(/["']/g, '')).filter(t => t.length > 0).join(' ')
 }
 
+const HANGUL_RE = /[\uAC00-\uD7AF]/
+
+// Sanitize a single lexeme for embedding inside a to_tsquery string. Strips the
+// tsquery operator characters so a raw token can never inject syntax.
+function sanitizeLexeme(t) {
+  return String(t ?? '').replace(/[&|!():*'"\\\s]+/g, '')
+}
+
+// Prefix-form (to_tsquery) builder. Returns null when kiwi morph is not ready,
+// signalling the caller to keep the websearch_to_tsquery fallback path. When
+// ready: Korean tokens → Kiwi content-morpheme stems (NNG/NNP/VV/VA/XR/SL),
+// non-Korean tokens kept as-is; every lexeme gets a ':*' prefix match and the
+// set is '&'-joined to preserve the current AND semantics.
+//
+// Returns { query, prefix:true } on success, or null.
+export function buildFtsPrefixQuery(text) {
+  if (!koMorphReady()) return null
+  const tokens = tokenizeMemoryText(text)
+  if (tokens.length === 0) return null
+  const ftsTokens = [...new Set(tokens)].filter(t => t.length >= 3 || (t.length === 2 && HANGUL_RE.test(t)))
+  if (ftsTokens.length === 0) return null
+
+  const lexemes = []
+  const seen = new Set()
+  for (const tok of ftsTokens) {
+    if (HANGUL_RE.test(tok)) {
+      // Analyze against the ORIGINAL token (pre suffix-strip) so Kiwi sees the
+      // real inflection; normalizeMemoryToken already ran, so also feed the
+      // stripped form — union of both keeps recall high.
+      const st = koMorphStems(tok)
+      const forms = (st && st.length > 0) ? st : [tok]
+      for (const f of forms) {
+        const lex = sanitizeLexeme(f)
+        if (lex.length >= 1 && !seen.has(lex)) { seen.add(lex); lexemes.push(lex) }
+      }
+    } else {
+      const lex = sanitizeLexeme(tok)
+      if (lex.length >= 1 && !seen.has(lex)) { seen.add(lex); lexemes.push(lex) }
+    }
+  }
+  if (lexemes.length === 0) return null
+  const query = lexemes.map(l => `${l}:*`).join(' & ')
+  return { query, prefix: true }
+}
+
 

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

@@ -479,17 +479,39 @@ export function createQueryHandlers({
       let queryVector = null
       if (isEmbeddingModelReady()) {
         queryVector = await embedText(query)
+      } else if (embeddingWarmupCanStart()) {
+        // Cold model: WAIT for warmup (bounded) instead of silently degrading
+        // to lexical-only. Raw rows are already embedded at ingest time, so
+        // the query vector is the only missing piece of the dense leg — a few
+        // seconds of warmup buys full hybrid quality on the first recall.
+        // On timeout the warmup keeps running in the background and this
+        // recall falls back to lexical (same as before).
+        const COLD_RECALL_WARMUP_WAIT_MS = Math.max(0, Number(process.env.MIXDOG_RECALL_WARMUP_WAIT_MS) || 8_000)
+        let timer
+        try {
+          queryVector = await Promise.race([
+            warmupEmbeddingProvider().then(() => embedText(query)),
+            new Promise((resolve) => { timer = setTimeout(() => resolve(null), COLD_RECALL_WARMUP_WAIT_MS) }),
+          ])
+        } catch (err) {
+          log(`[memory-service] embedding warmup during cold recall failed: ${err?.message || err}\n`)
+          queryVector = null
+        } finally {
+          clearTimeout(timer)
+        }
+        if (!Array.isArray(queryVector)) {
+          const now = Date.now()
+          if (now - _embeddingColdRecallLogAt > 10_000) {
+            _embeddingColdRecallLogAt = now
+            log(`[recall] embedding still cold after ${COLD_RECALL_WARMUP_WAIT_MS}ms wait; returning lexical results while background warmup continues\n`)
+          }
+        }
       } else {
         const now = Date.now()
         if (now - _embeddingColdRecallLogAt > 10_000) {
           _embeddingColdRecallLogAt = now
           log('[recall] embedding model cold; returning lexical results while background warmup continues\n')
         }
-        if (embeddingWarmupCanStart()) {
-          void warmupEmbeddingProvider().catch((err) => {
-            log(`[memory-service] embedding warmup after cold recall failed: ${err?.message || err}\n`)
-          })
-        }
       }
       if (signal?.aborted) throw signal.reason ?? new Error('aborted')
       const _t1 = Date.now()

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

@@ -8,7 +8,7 @@ export const TOOL_DEFS = [
     name: 'memory',
     title: 'Memory Cycle',
     annotations: { title: 'Memory Cycle', readOnlyHint: false, destructiveHint: true, idempotentHint: false, openWorldHint: false },
-    description: 'Core-memory mutation and status. Use recall for retrieval. When the user explicitly asks to remember something (e.g. "remember this", a stated preference, or a decision), persist it immediately with action:"core" op:"add" — do not wait for a cycle.',
+    description: 'Core-memory mutation and status. Use recall for retrieval. Persist with action:"core" op:"add" when: user corrects/confirms your approach, states a durable preference, or says "remember". Only what code/git/docs cannot derive; include the why. Never transient task state. No prior recall dedup needed — the cycle dedups.',
     inputSchema: {
       type: 'object',
       properties: {
@@ -30,7 +30,7 @@ export const TOOL_DEFS = [
     name: 'recall',
     title: 'Recall',
     annotations: { title: 'Recall', readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: false },
-    description: 'Retrieve stored memory/session history; when in doubt, recall first. Query is topic/semantic search (hybrid embedding+keyword), not regex. Common patterns — previous conversation: period:"last" (all history newest-first, grouped per session); current session: sessionId with no query; recent window: period:"3h"/"30m"/"24h"; specific timeframe: period:"2026-07-03" / "2026-07-01~2026-07-03" / "12:00~14:00" (today) / "2026-07-03 12:00~14:00"; topic: query alone or query+period; exact follow-up: id from a prior result.',
+    description: 'Retrieve stored memory/session history. Use only to check prior conversation or past events: resumes, prior work, earlier decisions or messages. Do not call as a reflexive pre-step, to verify a just-made decision, or before storing memory. Query is topic/semantic search, not regex. Patterns: period:"last" for previous conversation; sessionId without query for current session; period:"3h"/"30m"/"24h" for recent; YYYY-MM-DD, date ranges, or HH:MM~HH:MM for time windows; id for exact follow-up.',
     inputSchema: {
       type: 'object',
       properties: {

package/src/runtime/shared/config.mjs

@@ -263,10 +263,20 @@ export function diagnoseDiscordTokenValue(value, config = {}) {
   const discord = config?.discord && typeof config.discord === 'object' ? config.discord : {}
   const appId = String(discord.applicationId || '').trim()
   if (appId && token === appId) return 'Bot token field contains the Application ID, not the bot token.'
-  const channels = config?.channelsConfig && typeof config.channelsConfig === 'object' ? config.channelsConfig : {}
-  for (const ch of Object.values(channels)) {
-    const channelId = String(ch?.channelId || '').trim()
-    if (channelId && token === channelId) return 'Bot token field contains a Channel ID, not the bot token.'
+  // Single main channel: check the `channel` object. Legacy `channelsConfig`
+  // is still read here (read-only) so the diagnostic keeps working on configs
+  // that predate the single-channel collapse.
+  const candidateEntries = []
+  if (config?.channel && typeof config.channel === 'object') candidateEntries.push(config.channel)
+  if (config?.channelsConfig && typeof config.channelsConfig === 'object') {
+    candidateEntries.push(...Object.values(config.channelsConfig))
+  }
+  for (const ch of candidateEntries) {
+    if (!ch || typeof ch !== 'object') continue
+    for (const id of [ch.channelId, ch.discordChannelId, ch.telegramChatId]) {
+      const channelId = String(id || '').trim()
+      if (channelId && token === channelId) return 'Bot token field contains a Channel ID, not the bot token.'
+    }
   }
   if (isDiscordSnowflake(token)) return 'Bot token field contains a numeric Discord ID, not the bot token.'
   return null

package/src/runtime/shared/markdown-frontmatter.mjs

@@ -44,6 +44,25 @@ export function readMarkdownDocument(markdown) {
   };
 }
 
+// Serialize a single-file frontmatter markdown document:
+//   ---
+//   key: value
+//   ---
+//
+//   <body>
+// Values are stringified as-is (enabled:false -> "false"); the reader casts
+// types back. Mirrors the WORKFLOW.md / SKILL.md single-file convention,
+// where `name` and `description` lead the frontmatter.
+export function serializeFrontmatterDoc(meta = {}, body = '') {
+  const lines = ['---'];
+  for (const [key, value] of Object.entries(meta)) {
+    if (value === undefined || value === null) continue;
+    lines.push(`${key}: ${value}`);
+  }
+  lines.push('---', '');
+  return `${lines.join('\n')}\n${String(body || '').trim()}\n`;
+}
+
 export function normalizeAgentPermission(value) {
   const key = clean(value).toLowerCase();
   return AGENT_PERMISSION_ALIASES.get(key) || null;

package/src/runtime/shared/schedules-store.mjs

@@ -3,8 +3,9 @@
  *
  * `<Mixdog data dir>/schedules/<name>/` is the single source of truth.
  * Each schedule directory contains a single `SCHEDULE.md` — YAML-ish
- * frontmatter (metadata: time/timezone/days/channel/model/enabled) plus a
- * markdown body (the prompt). Both the setup UI (POST /schedules) and the
+ * frontmatter (name/description lead per the SKILL.md convention, then
+ * metadata: time/timezone/days/channel/model/enabled) plus a markdown
+ * body (the prompt). Both the setup UI (POST /schedules) and the
  * `schedule-add` skill write the same one file; every reader —
  * setup-server (GET /schedules), channels/lib/config.mjs (loadConfig),
  * status/aggregator.mjs — must go through listSchedules() so a single
@@ -35,9 +36,12 @@ function readTextFile(path) {
  *
  * Return shape per entry: `{ name, ...frontmatter, prompt }`.
  * - `name` is the directory name (slug).
+ * - `description` from frontmatter (display-only; defaults to '').
  * - Spread of `SCHEDULE.md` frontmatter keys (time/timezone/days/channel/
  *   model/enabled). All frontmatter values arrive as strings; `enabled` is
  *   cast to a boolean here so downstream `s.enabled !== false` filters work.
+ *   Frontmatter `name` is display-only and never overrides the dir slug used
+ *   for identity/routing.
  * - `prompt` carries the `SCHEDULE.md` body (empty string when the file is
  *   missing — caller decides whether that is a hard error).
  *
@@ -66,7 +70,13 @@ export function listSchedules() {
     if (Object.prototype.hasOwnProperty.call(cfg, 'enabled')) {
       cfg.enabled = cfg.enabled !== 'false' && cfg.enabled !== false;
     }
-    out.push({ name, ...cfg, prompt: body });
+    // Dir name is canonical identity; frontmatter `name` is display-only and
+    // must not override the slug. `description` defaults to '' (backward compat
+    // for old files with no such key).
+    const description = String(cfg.description || '');
+    delete cfg.name;
+    delete cfg.description;
+    out.push({ name, description, ...cfg, prompt: body });
   }
   return out;
 }

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

@@ -2,10 +2,10 @@ export const TOOL_SYNC_EXECUTION_CONTRACT =
   'Runs synchronously in this tool call.';
 
 export const TOOL_ASYNC_EXECUTION_CONTRACT =
-  'Async returns task_id; completion notification follows. status/read/wait are manual recovery or blocking only.';
+  'Async returns task_id; completion notification follows. status/read/wait are recovery/blocking only.';
 
 export const TOOL_MANUAL_CONTROL_CONTRACT =
-  'Manual wait/read/status/cancel only for explicit blocking or recovery.';
+  'wait/read/status/cancel are for explicit blocking or recovery only.';
 
 function clean(value) {
   return String(value ?? '').trim();

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

@@ -114,15 +114,18 @@ const AUTO_CLEAR_DEFAULT_IDLE_MS = 60 * 60 * 1000;
 
 // Provider-aware auto-clear idle-sweep defaults. Rationale mirrors the
 // provider cache TTLs documented in agent-runtime/cache-strategy.mjs
-// (explicit breakpoint / managed-cache windows): Anthropic, Gemini, xAI and
-// Mistral caches run ~1h, Groq's implicit cache persists ~2h, OpenAI/
-// DeepSeek key-prefix/implicit caches persist far longer (~24h), and OpenAI
-// OAuth's in-memory server cache is short-lived (~5-10min), so we round up
-// slightly to 10m to avoid sweeping a still-warm cache. Unknown/
-// unrecognized providers fall back to the 'default' 1h entry.
+// (explicit breakpoint / managed-cache windows): Anthropic follows the BP4
+// messages-tail TTL (5m default cache_control window; BP1~3 stay on the 1h
+// extended TTL and are prefix-shared, so reaping at 5m only forfeits an
+// already-cold tail — see resolveLeadMessagesTtl). Gemini, xAI and Mistral
+// caches run ~1h, Groq's implicit cache persists ~2h, OpenAI/DeepSeek
+// key-prefix/implicit caches persist far longer (~24h), and OpenAI OAuth's
+// in-memory server cache is short-lived (~5-10min), so we round up slightly
+// to 10m to avoid sweeping a still-warm cache. Unknown/unrecognized
+// providers fall back to the 'default' 1h entry.
 export const AUTO_CLEAR_PROVIDER_IDLE_MS = Object.freeze({
-  'anthropic': 60 * 60 * 1000,
-  'anthropic-oauth': 60 * 60 * 1000,
+  'anthropic': 5 * 60 * 1000,
+  'anthropic-oauth': 5 * 60 * 1000,
   'gemini': 60 * 60 * 1000,
   'groq': 2 * 60 * 60 * 1000,
   'openai': 24 * 60 * 60 * 1000,
@@ -132,15 +135,46 @@ export const AUTO_CLEAR_PROVIDER_IDLE_MS = Object.freeze({
   'mistral': 60 * 60 * 1000,
   'default': AUTO_CLEAR_DEFAULT_IDLE_MS,
 });
+export const AUTO_CLEAR_PROVIDER_IDS = Object.freeze(Object.keys(AUTO_CLEAR_PROVIDER_IDLE_MS));
 export const AUTO_CLEAR_UNKNOWN_PROVIDER_IDLE_MS = AUTO_CLEAR_PROVIDER_IDLE_MS.default;
 
+export function normalizeAutoClearProviderIdleMs(value = {}) {
+  const raw = value && typeof value === 'object' ? value : {};
+  const out = {};
+  for (const [key, ms] of Object.entries(raw)) {
+    const provider = clean(key).toLowerCase();
+    const idleMs = Number(ms);
+    if (!provider || !Number.isFinite(idleMs) || idleMs <= 0) continue;
+    out[provider] = Math.max(60_000, Math.round(idleMs));
+  }
+  return out;
+}
+
 // Resolve the auto-clear idle-sweep threshold for a given provider id.
 // Unknown/missing providers fall back to the 'default' 1h entry (above).
-export function autoClearIdleMsForProvider(provider) {
+export function autoClearIdleMsForProvider(provider, providerIdleMs = null) {
+  const overrides = normalizeAutoClearProviderIdleMs(providerIdleMs);
   const key = clean(provider).toLowerCase();
+  if (overrides[key]) return overrides[key];
+  if (key && AUTO_CLEAR_PROVIDER_IDLE_MS[key]) return AUTO_CLEAR_PROVIDER_IDLE_MS[key];
+  if (overrides.default) return overrides.default;
   return AUTO_CLEAR_PROVIDER_IDLE_MS[key] ?? AUTO_CLEAR_PROVIDER_IDLE_MS.default;
 }
 
+export function autoClearProviderDefaults(providerIdleMs = null) {
+  const overrides = normalizeAutoClearProviderIdleMs(providerIdleMs);
+  return AUTO_CLEAR_PROVIDER_IDS.map((provider) => {
+    const builtInMs = AUTO_CLEAR_PROVIDER_IDLE_MS[provider] ?? AUTO_CLEAR_PROVIDER_IDLE_MS.default;
+    const idleMs = overrides[provider] ?? builtInMs;
+    return {
+      provider,
+      idleMs,
+      builtInMs,
+      custom: overrides[provider] != null,
+    };
+  });
+}
+
 // Resolve the effective auto-clear idle window for a config + provider:
 // an explicit user-set idleMs (config.autoClear.idleMs) always wins; else
 // fall back to the provider's default; else the global 1h default.
@@ -148,7 +182,7 @@ export function resolveAutoClearIdleMs(config, provider) {
   const raw = config?.autoClear && typeof config.autoClear === 'object' ? config.autoClear : {};
   const idleMs = Number(raw.idleMs ?? raw.thresholdMs ?? raw.idleMillis);
   if (Number.isFinite(idleMs) && idleMs > 0) return Math.max(60_000, Math.round(idleMs));
-  return autoClearIdleMsForProvider(provider);
+  return autoClearIdleMsForProvider(provider, raw.providerIdleMs ?? raw.providerDefaults ?? raw.providers);
 }
 
 export function normalizeSystemShellConfig(value = {}) {
@@ -186,6 +220,7 @@ export function normalizeAutoClearConfig(value = {}) {
     enabled: raw.enabled !== false,
     idleMs: hasExplicitIdle ? Math.max(60_000, Math.round(idleMs)) : null,
     custom: hasExplicitIdle,
+    providerIdleMs: normalizeAutoClearProviderIdleMs(raw.providerIdleMs ?? raw.providerDefaults ?? raw.providers),
   };
 }
 

package/src/session-runtime/quick-model-rows.mjs

@@ -4,6 +4,32 @@
 import { clean } from './session-text.mjs';
 import { QUICK_SEARCH_MODELS } from './quick-search-models.mjs';
 import { SEARCH_DEFAULT_PROVIDER, SEARCH_DEFAULT_MODEL } from './workflow.mjs';
+import { getModelMetadataSync } from '../runtime/agent/orchestrator/providers/model-catalog.mjs';
+
+function metadataFor(provider, modelId) {
+  try {
+    return getModelMetadataSync(modelId, provider) || {};
+  } catch {
+    return {};
+  }
+}
+
+function hydratedModel(provider, model = {}) {
+  const modelId = clean(model?.id || model);
+  const meta = metadataFor(provider, modelId);
+  const base = model && typeof model === 'object' ? model : { id: modelId };
+  return {
+    ...base,
+    contextWindow: meta.contextWindow || base?.contextWindow || null,
+    outputTokens: meta.outputTokens || base?.outputTokens || null,
+    supportsWebSearch: base?.supportsWebSearch === true || meta.supportsWebSearch === true,
+    supportsFunctionCalling: base?.supportsFunctionCalling === true || meta.supportsFunctionCalling === true,
+    supportsPromptCaching: base?.supportsPromptCaching === true || meta.supportsPromptCaching === true,
+    supportsReasoning: base?.supportsReasoning === true || meta.supportsReasoning === true,
+    reasoningOptions: Array.isArray(base?.reasoningOptions) && base.reasoningOptions.length ? base.reasoningOptions : (meta.reasoningOptions || []),
+    reasoningContentField: base?.reasoningContentField || meta.reasoningContentField || null,
+  };
+}
 
 export function createQuickModelRows({
   getRoute,
@@ -32,12 +58,19 @@ export function createQuickModelRows({
       const key = `${provider}:${model}`;
       if (seen.has(key)) return;
       seen.add(key);
+      const meta = metadataFor(provider, model);
       const row = providerModelCacheRow(provider, {
         id: model,
         name: routeLike.modelDisplay || routeLike.display || model,
         display: routeLike.modelDisplay || routeLike.display || model,
+        contextWindow: meta.contextWindow || null,
+        outputTokens: meta.outputTokens || null,
         latest: routeLike.latest === true,
-        supportsReasoning: !!routeLike.effort,
+        supportsReasoning: !!routeLike.effort || meta.supportsReasoning === true,
+        supportsFunctionCalling: meta.supportsFunctionCalling === true,
+        supportsPromptCaching: meta.supportsPromptCaching === true,
+        reasoningOptions: meta.reasoningOptions || [],
+        reasoningContentField: meta.reasoningContentField || null,
         mode: 'chat',
       });
       rows.push(row);
@@ -57,19 +90,21 @@ export function createQuickModelRows({
     if (!providerName || !modelId || !isSearchCapableProvider(providerName)) return;
     const key = `${providerName}:${modelId}`;
     if (seen.has(key)) return;
+    const resolved = hydratedModel(providerName, model);
     const row = providerModelCacheRow(providerName, {
       id: modelId,
-      name: model?.name || model?.display || modelId,
-      display: model?.display || model?.name || modelId,
-      contextWindow: model?.contextWindow || null,
-      outputTokens: model?.outputTokens || null,
-      latest: model?.latest === true,
+      name: resolved?.name || resolved?.display || modelId,
+      display: resolved?.display || resolved?.name || modelId,
+      contextWindow: resolved?.contextWindow || null,
+      outputTokens: resolved?.outputTokens || null,
+      latest: resolved?.latest === true,
       supportsWebSearch: true,
-      supportsFunctionCalling: model?.supportsFunctionCalling === true,
-      supportsPromptCaching: model?.supportsPromptCaching === true,
-      supportsReasoning: model?.supportsReasoning === true,
-      reasoningLevels: Array.isArray(model?.reasoningLevels) ? model.reasoningLevels : undefined,
-      reasoningOptions: Array.isArray(model?.reasoningOptions) ? model.reasoningOptions : [],
+      supportsFunctionCalling: resolved?.supportsFunctionCalling === true,
+      supportsPromptCaching: resolved?.supportsPromptCaching === true,
+      supportsReasoning: resolved?.supportsReasoning === true,
+      reasoningLevels: Array.isArray(resolved?.reasoningLevels) ? resolved.reasoningLevels : undefined,
+      reasoningOptions: Array.isArray(resolved?.reasoningOptions) ? resolved.reasoningOptions : [],
+      reasoningContentField: resolved?.reasoningContentField || null,
       mode: 'chat',
     });
     if (row.supportsWebSearch !== true) return;

package/src/session-runtime/quick-search-models.mjs

@@ -1,46 +1,47 @@
-// Static quick-pick model catalog surfaced during onboarding / search setup.
-// Pure data extracted from mixdog-session-runtime.mjs.
+// Static quick-pick model ids surfaced during onboarding / search setup.
+// Limits are intentionally not hardcoded here: rows are hydrated from live
+// provider caches and provider-scoped metadata during catalog construction.
 
 export const ONBOARDING_VERSION = 1;
 
 export const QUICK_SEARCH_MODELS = Object.freeze({
   'openai-oauth': [
-    { id: 'gpt-5.5', display: 'GPT-5.5', latest: true, contextWindow: 1000000 },
-    { id: 'gpt-5.4', display: 'GPT-5.4', latest: true, contextWindow: 1000000 },
-    { id: 'gpt-5', display: 'GPT-5', contextWindow: 400000 },
-    { id: 'gpt-4.1', display: 'GPT-4.1', contextWindow: 1000000 },
+    { id: 'gpt-5.5', display: 'GPT-5.5', latest: true },
+    { id: 'gpt-5.4', display: 'GPT-5.4', latest: true },
+    { id: 'gpt-5', display: 'GPT-5' },
+    { id: 'gpt-4.1', display: 'GPT-4.1' },
   ],
   openai: [
-    { id: 'gpt-5.5', display: 'GPT-5.5', latest: true, contextWindow: 1000000 },
-    { id: 'gpt-5.4', display: 'GPT-5.4', latest: true, contextWindow: 1000000 },
-    { id: 'gpt-5', display: 'GPT-5', contextWindow: 400000 },
-    { id: 'gpt-4.1', display: 'GPT-4.1', contextWindow: 1000000 },
-    { id: 'gpt-4o', display: 'GPT-4o', contextWindow: 128000 },
+    { id: 'gpt-5.5', display: 'GPT-5.5', latest: true },
+    { id: 'gpt-5.4', display: 'GPT-5.4', latest: true },
+    { id: 'gpt-5', display: 'GPT-5' },
+    { id: 'gpt-4.1', display: 'GPT-4.1' },
+    { id: 'gpt-4o', display: 'GPT-4o' },
   ],
   'grok-oauth': [
-    { id: 'grok-4.3', display: 'Grok 4.3', latest: true, contextWindow: 1000000 },
-    { id: 'grok-4.20', display: 'Grok 4.20', contextWindow: 1000000 },
-    { id: 'grok-4', display: 'Grok 4', contextWindow: 256000 },
+    { id: 'grok-4.3', display: 'Grok 4.3', latest: true },
+    { id: 'grok-4.20', display: 'Grok 4.20' },
+    { id: 'grok-4', display: 'Grok 4' },
   ],
   xai: [
-    { id: 'grok-4.3', display: 'Grok 4.3', latest: true, contextWindow: 1000000 },
-    { id: 'grok-4.20', display: 'Grok 4.20', contextWindow: 1000000 },
-    { id: 'grok-4', display: 'Grok 4', contextWindow: 256000 },
+    { id: 'grok-4.3', display: 'Grok 4.3', latest: true },
+    { id: 'grok-4.20', display: 'Grok 4.20' },
+    { id: 'grok-4', display: 'Grok 4' },
   ],
   gemini: [
-    { id: 'gemini-3-pro', display: 'Gemini 3 Pro', latest: true, contextWindow: 1000000 },
-    { id: 'gemini-2.5-pro', display: 'Gemini 2.5 Pro', contextWindow: 1000000 },
-    { id: 'gemini-2.5-flash', display: 'Gemini 2.5 Flash', contextWindow: 1000000 },
-    { id: 'gemini-2.0-flash', display: 'Gemini 2.0 Flash', contextWindow: 1000000 },
+    { id: 'gemini-3-pro', display: 'Gemini 3 Pro', latest: true },
+    { id: 'gemini-2.5-pro', display: 'Gemini 2.5 Pro' },
+    { id: 'gemini-2.5-flash', display: 'Gemini 2.5 Flash' },
+    { id: 'gemini-2.0-flash', display: 'Gemini 2.0 Flash' },
   ],
   'anthropic-oauth': [
-    { id: 'claude-opus-4-8', display: 'Claude Opus 4.8', latest: true, contextWindow: 1000000 },
-    { id: 'claude-sonnet-4-6', display: 'Claude Sonnet 4.6', latest: true, contextWindow: 1000000 },
-    { id: 'claude-haiku-4-5-20251001', display: 'Claude Haiku 4.5', contextWindow: 200000 },
+    { id: 'claude-opus-4-8', display: 'Claude Opus 4.8', latest: true },
+    { id: 'claude-sonnet-4-6', display: 'Claude Sonnet 4.6', latest: true },
+    { id: 'claude-haiku-4-5-20251001', display: 'Claude Haiku 4.5' },
   ],
   anthropic: [
-    { id: 'claude-opus-4-8', display: 'Claude Opus 4.8', latest: true, contextWindow: 1000000 },
-    { id: 'claude-sonnet-4-6', display: 'Claude Sonnet 4.6', latest: true, contextWindow: 1000000 },
-    { id: 'claude-haiku-4-5-20251001', display: 'Claude Haiku 4.5', contextWindow: 200000 },
+    { id: 'claude-opus-4-8', display: 'Claude Opus 4.8', latest: true },
+    { id: 'claude-sonnet-4-6', display: 'Claude Sonnet 4.6', latest: true },
+    { id: 'claude-haiku-4-5-20251001', display: 'Claude Haiku 4.5' },
   ],
 });