mixdog 0.9.1 → 0.9.3

package/src/session-runtime/effort.mjs

@@ -0,0 +1,128 @@
+// Reasoning-effort catalogs and coercion. Pure helpers.
+import { clean } from './session-text.mjs';
+
+export const TOOL_MODES = new Set(['full', 'readonly', 'lead']);
+export const ALL_EFFORT_LEVELS = new Set(['none', 'low', 'medium', 'high', 'xhigh', 'max']);
+export const EFFORT_LABELS = {
+  none: 'None',
+  low: 'Low',
+  medium: 'Medium',
+  high: 'High',
+  xhigh: 'Extra High',
+  max: 'Max',
+};
+
+export const EFFORT_OPTIONS_BY_PROVIDER = {
+  openai: ['none', 'low', 'medium', 'high', 'xhigh'],
+  'openai-oauth': ['none', 'low', 'medium', 'high', 'xhigh'],
+  anthropic: ['low', 'medium', 'high', 'xhigh', 'max'],
+  'anthropic-oauth': ['low', 'medium', 'high', 'xhigh', 'max'],
+  xai: ['none', 'low', 'medium', 'high'],
+  'grok-oauth': ['none', 'low', 'medium', 'high'],
+  'opencode-go': ['high', 'max'],
+};
+export const EFFORT_BY_FAMILY = {
+  opus: ['low', 'medium', 'high', 'xhigh', 'max'],
+  sonnet: ['low', 'medium', 'high'],
+  haiku: [],
+  'gpt-5.5': ['none', 'low', 'medium', 'high', 'xhigh'],
+  'gpt-5.4': ['none', 'low', 'medium', 'high', 'xhigh'],
+  'gpt-5.2': ['none', 'low', 'medium', 'high', 'xhigh'],
+  'gpt-5': ['none', 'low', 'medium', 'high', 'xhigh'],
+  'gpt-mini': ['none', 'low', 'medium', 'high', 'xhigh'],
+  'gpt-nano': ['none', 'low', 'medium', 'high'],
+  'gpt-codex': ['none', 'low', 'medium', 'high'],
+  grok: ['none', 'low', 'medium', 'high'],
+};
+export const EFFORT_FALLBACKS = {
+  max: ['max', 'xhigh', 'high', 'medium', 'low'],
+  xhigh: ['xhigh', 'high', 'medium', 'low'],
+  high: ['high', 'medium', 'low'],
+  medium: ['medium', 'low'],
+  low: ['low'],
+  none: ['none'],
+};
+
+export function normalizeToolMode(mode) {
+  const value = String(mode || '').trim().toLowerCase();
+  return TOOL_MODES.has(value) ? value : 'full';
+}
+
+export function normalizeEffortInput(value) {
+  const v = clean(value).toLowerCase();
+  if (!v || v === 'auto') return null;
+  if (!ALL_EFFORT_LEVELS.has(v)) {
+    throw new Error(`effort must be one of auto, ${[...ALL_EFFORT_LEVELS].join(', ')}`);
+  }
+  return v;
+}
+
+export function effortOptionsFor(provider, model) {
+  const providerAllowed = EFFORT_OPTIONS_BY_PROVIDER[provider] || null;
+  const filterProvider = (values) => {
+    const unique = [...new Set((values || []).map(clean).filter(Boolean))];
+    return providerAllowed ? unique.filter((v) => providerAllowed.includes(v)) : unique;
+  };
+  const declared = Array.isArray(model?.reasoningLevels)
+    ? model.reasoningLevels.map(clean).filter(Boolean)
+    : [];
+  const family = clean(model?.family).toLowerCase();
+  if (Array.isArray(model?.reasoningLevels)) {
+    if (declared.length) return filterProvider(declared);
+    if (Object.prototype.hasOwnProperty.call(EFFORT_BY_FAMILY, family)) {
+      return filterProvider(EFFORT_BY_FAMILY[family]);
+    }
+    return [];
+  }
+  const reasoningOptionEffort = Array.isArray(model?.reasoningOptions)
+    ? model.reasoningOptions.find((option) => clean(option?.type).toLowerCase() === 'effort')
+    : null;
+  const reasoningOptionValues = Array.isArray(reasoningOptionEffort?.values)
+    ? reasoningOptionEffort.values.map(clean).filter(Boolean)
+    : [];
+  if (reasoningOptionValues.length) return filterProvider(reasoningOptionValues);
+  if (Object.prototype.hasOwnProperty.call(EFFORT_BY_FAMILY, family)) {
+    return filterProvider(EFFORT_BY_FAMILY[family]);
+  }
+  return providerAllowed || [];
+}
+
+export function coerceEffortFor(provider, model, effort) {
+  if (!effort) return null;
+  const allowed = effortOptionsFor(provider, model);
+  if (!allowed || allowed.length === 0) return null;
+  if (allowed.includes(effort)) return effort;
+  for (const candidate of EFFORT_FALLBACKS[effort] || []) {
+    if (allowed.includes(candidate)) return candidate;
+  }
+  return null;
+}
+
+export function normalizeSavedEffort(value) {
+  try {
+    return normalizeEffortInput(value);
+  } catch {
+    return null;
+  }
+}
+
+export function effortItemsFor(provider, model, activeEffort) {
+  const allowed = effortOptionsFor(provider, model);
+  const items = [];
+  for (const value of allowed || []) {
+    items.push({
+      value,
+      label: EFFORT_LABELS[value] || value,
+      description: value === activeEffort ? 'current' : '',
+    });
+  }
+  return items;
+}
+
+export function toolSpecForMode(mode) {
+  return mode === 'readonly' ? ['tools:readonly'] : 'full';
+}
+
+export function deferredSurfaceModeForLead(mode) {
+  return mode === 'readonly' ? 'readonly' : 'lead';
+}

package/src/session-runtime/fs-utils.mjs

@@ -0,0 +1,10 @@
+// Small filesystem read helpers used by session-runtime submodules.
+import { readFileSync } from 'node:fs';
+
+export function readJsonSafe(path) {
+  try { return JSON.parse(readFileSync(path, 'utf8')); } catch { return null; }
+}
+
+export function readTextSafe(path) {
+  try { return readFileSync(path, 'utf8').trim(); } catch { return ''; }
+}

package/src/session-runtime/model-capabilities.mjs

@@ -0,0 +1,130 @@
+// Provider/model capability probes: fast-tier + hosted web-search support, and
+// model-settings persistence. Pure except saveModelSettings (takes cfgMod).
+import { clean, hasOwn } from './session-text.mjs';
+
+const FAST_CAPABLE_PROVIDERS = new Set(['anthropic', 'anthropic-oauth', 'openai', 'openai-oauth']);
+export const LAZY_SECRET_PROVIDERS = new Set(['openai-oauth', 'anthropic-oauth', 'grok-oauth', 'ollama', 'lmstudio']);
+
+export function routeFastKey(provider, model) {
+  const p = clean(provider);
+  const m = clean(model);
+  return p && m ? `${p}/${m}` : '';
+}
+
+function openAiModelMetaSupportsFast(model) {
+  const tiers = Array.isArray(model?.serviceTiers) ? model.serviceTiers : [];
+  const speedTiers = Array.isArray(model?.additionalSpeedTiers) ? model.additionalSpeedTiers : [];
+  if (tiers.length || speedTiers.length || model?.defaultServiceTier) {
+    return tiers.some((tier) => tier?.id === 'priority')
+      || speedTiers.includes('priority')
+      || model?.defaultServiceTier === 'priority';
+  }
+  const id = clean(model?.id || model).toLowerCase();
+  if (id.includes('mini') || id.includes('nano') || id.includes('codex')) return false;
+  return /^gpt-5(\.|-|$)/.test(id);
+}
+
+function openAiDirectModelSupportsFast(model) {
+  const id = clean(model?.id || model);
+  return /^gpt-5\.5(?:-\d{4}|$)/.test(id)
+    || /^gpt-5\.4(?:-\d{4}|$)/.test(id)
+    || /^gpt-5\.4-mini(?:-\d{4}|$)/.test(id);
+}
+
+function openAiModelSupportsHostedWebSearch(model) {
+  const id = clean(model?.id || model).toLowerCase();
+  if (!id) return false;
+  if (model?.supportsWebSearch === true) return true;
+  const tools = [
+    ...(Array.isArray(model?.supportedTools) ? model.supportedTools : []),
+    ...(Array.isArray(model?.tools) ? model.tools : []),
+    ...(Array.isArray(model?.capabilities?.tools) ? model.capabilities.tools : []),
+  ].map((tool) => clean(tool?.type || tool?.name || tool).toLowerCase());
+  if (tools.some((tool) => tool === 'web_search' || tool === 'web_search_preview')) return true;
+  if (/codex|image|audio|tts|stt|embedding|rerank|moderation|search-preview/.test(id)) return false;
+  return /^gpt-(5(?:\.|$|-)|4\.1(?:-|$)|4o(?:-|$)|4\.5(?:-|$))/.test(id)
+    || /^o[34](?:-|$)/.test(id);
+}
+
+function grokModelSupportsHostedWebSearch(model) {
+  const id = clean(model?.id || model).toLowerCase();
+  if (!id || /imagine|image|video|composer/.test(id)) return false;
+  if (id === 'grok-build') return false;
+  return /^grok-/.test(id);
+}
+
+function geminiModelSupportsHostedWebSearch(model) {
+  const id = clean(model?.id || model).toLowerCase();
+  if (!id || /embedding|aqa|imagen|veo|tts|image|computer-use|customtools/.test(id)) return false;
+  return /^gemini-(3(?:\.|-|$)|2\.5-|2\.0-flash)/.test(id);
+}
+
+function anthropicModelSupportsHostedWebSearch(model) {
+  const id = clean(model?.id || model).toLowerCase();
+  if (!id) return false;
+  const match = id.match(/^claude-(opus|sonnet|haiku)-(\d+)(?:[-.](\d+))?/);
+  if (!match) return false;
+  const major = Number(match[2]) || 0;
+  const minor = Number(match[3]) || 0;
+  return major > 4 || (major === 4 && minor >= 0);
+}
+
+function anthropicModelMetaSupportsFast(model) {
+  const id = clean(model?.id || model).toLowerCase();
+  return /^claude-(opus|sonnet)/.test(id);
+}
+
+export function fastCapableFor(provider, model) {
+  const p = clean(provider);
+  if (!FAST_CAPABLE_PROVIDERS.has(p)) return false;
+  if (p === 'openai') return openAiDirectModelSupportsFast(model);
+  if (p === 'openai-oauth') return openAiModelMetaSupportsFast(model);
+  if (p === 'anthropic' || p === 'anthropic-oauth') return anthropicModelMetaSupportsFast(model);
+  return false;
+}
+
+// searchCapableFor needs the search-route normalizers, which live in
+// search-routes.mjs and themselves are pure. Wire them in via a factory to keep
+// this module free of a circular import at load time.
+export function makeSearchCapableFor(normalizeSearchProviderId, isSearchCapableProvider) {
+  return function searchCapableFor(provider, model) {
+    const p = normalizeSearchProviderId(provider);
+    if (!isSearchCapableProvider(p)) return false;
+    if (p === 'openai' || p === 'openai-oauth') return openAiModelSupportsHostedWebSearch(model);
+    if (p === 'grok-oauth' || p === 'xai') return grokModelSupportsHostedWebSearch(model);
+    if (p === 'gemini') return geminiModelSupportsHostedWebSearch(model);
+    if (p === 'anthropic' || p === 'anthropic-oauth') return anthropicModelSupportsHostedWebSearch(model);
+    return model?.supportsWebSearch === true;
+  };
+}
+
+export function fastPreferenceFor(config, provider, model) {
+  const key = routeFastKey(provider, model);
+  if (!key) return false;
+  const saved = config?.modelSettings?.[key];
+  if (saved && typeof saved === 'object' && hasOwn(saved, 'fast')) return saved.fast === true;
+  return config?.fastModels?.[key] === true;
+}
+
+export function saveModelSettings(cfgMod, route, { fastCapable = true, baseConfig = null } = {}) {
+  const key = routeFastKey(route?.provider, route?.model);
+  if (!key) return baseConfig || cfgMod.loadConfig();
+  const nextConfig = baseConfig || cfgMod.loadConfig();
+  const modelSettings = { ...(nextConfig.modelSettings || {}) };
+  const nextSetting = { ...(modelSettings[key] || {}) };
+  if (hasOwn(route, 'effort') && route.effort) nextSetting.effort = route.effort;
+  else delete nextSetting.effort;
+  if (fastCapable) nextSetting.fast = route.fast === true;
+  else nextSetting.fast = false;
+  modelSettings[key] = nextSetting;
+
+  // Legacy compatibility: keep fastModels true entries for old readers, but
+  // let modelSettings.fast=false override them in new readers.
+  const fastModels = { ...(nextConfig.fastModels || {}) };
+  if (nextSetting.fast === true) fastModels[key] = true;
+  else delete fastModels[key];
+
+  const savedConfig = { ...nextConfig, modelSettings, fastModels };
+  cfgMod.saveConfig(savedConfig);
+  return savedConfig;
+}

package/src/session-runtime/output-styles.mjs

@@ -0,0 +1,124 @@
+// Output-style catalog + metadata parsing. Roots are injected so this module
+// stays free of the runtime's path constants.
+import { basename, join } from 'node:path';
+import { readFileSync, readdirSync } from 'node:fs';
+import { clean } from './session-text.mjs';
+import { readJsonSafe } from './fs-utils.mjs';
+
+const OUTPUT_STYLE_ORDER = ['default', 'simple', 'minimal', 'oneline'];
+const OUTPUT_STYLE_ALIASES = new Map([
+  ['compact', 'default'],
+  ['normal', 'default'],
+  ['extreme', 'minimal'],
+  ['extremesimple', 'minimal'],
+  ['extreme-simple', 'minimal'],
+  ['extreme_simple', 'minimal'],
+  ['mono', 'oneline'],
+  ['oneline', 'oneline'],
+  ['one-line', 'oneline'],
+  ['one_line', 'oneline'],
+]);
+
+export function normalizeOutputStyleId(value) {
+  const raw = clean(value).toLowerCase();
+  if (!raw) return '';
+  const slug = raw.replace(/[_\s]+/g, '-').replace(/^-+|-+$/g, '');
+  const compact = slug.replace(/[_.-]+/g, '');
+  if (OUTPUT_STYLE_ALIASES.has(slug)) return OUTPUT_STYLE_ALIASES.get(slug);
+  if (OUTPUT_STYLE_ALIASES.has(compact)) return OUTPUT_STYLE_ALIASES.get(compact);
+  return /^[a-z0-9.-]+$/.test(slug) ? slug : '';
+}
+
+function outputStyleCompactKey(value) {
+  return normalizeOutputStyleId(value).replace(/[_.-]+/g, '');
+}
+
+function titleCaseOutputStyle(id) {
+  return clean(id)
+    .split(/[_.-]+/)
+    .filter(Boolean)
+    .map((part) => `${part.charAt(0).toUpperCase()}${part.slice(1)}`)
+    .join(' ') || 'Default';
+}
+
+function parseOutputStyleFrontmatter(markdown) {
+  const match = String(markdown || '').match(/^---\r?\n([\s\S]*?)\r?\n---/);
+  const meta = {};
+  if (!match) return meta;
+  for (const line of match[1].split(/\r?\n/)) {
+    const kv = line.match(/^([A-Za-z0-9_-]+):\s*(.*?)\s*$/);
+    if (!kv) continue;
+    meta[kv[1]] = kv[2].replace(/^['"]|['"]$/g, '').trim();
+  }
+  return meta;
+}
+
+function readOutputStyleMetadata(filePath, source) {
+  let raw = '';
+  try { raw = readFileSync(filePath, 'utf8'); } catch { return null; }
+  const meta = parseOutputStyleFrontmatter(raw);
+  const fileId = normalizeOutputStyleId(basename(filePath).replace(/\.md$/i, ''));
+  const id = normalizeOutputStyleId(meta.name) || fileId;
+  if (!id) return null;
+  const aliases = clean(meta.aliases)
+    .split(',')
+    .map((value) => normalizeOutputStyleId(value))
+    .filter(Boolean);
+  const label = clean(meta.title || meta.label) || titleCaseOutputStyle(id);
+  return {
+    id,
+    label,
+    description: clean(meta.description),
+    aliases,
+    source,
+  };
+}
+
+export function listOutputStyleCatalog(rootDir, dataDir) {
+  const byId = new Map();
+  const dirs = [
+    { dir: join(rootDir, 'output-styles'), source: 'builtin' },
+    { dir: join(dataDir, 'output-styles'), source: 'user' },
+  ];
+  for (const { dir, source } of dirs) {
+    let entries = [];
+    try { entries = readdirSync(dir, { withFileTypes: true }); } catch { continue; }
+    for (const entry of entries) {
+      if (!entry.isFile() || !entry.name.toLowerCase().endsWith('.md')) continue;
+      const style = readOutputStyleMetadata(join(dir, entry.name), source);
+      if (style) byId.set(style.id, style);
+    }
+  }
+  return [...byId.values()].sort((a, b) => {
+    const ai = OUTPUT_STYLE_ORDER.indexOf(a.id);
+    const bi = OUTPUT_STYLE_ORDER.indexOf(b.id);
+    if (ai !== bi) return (ai < 0 ? 999 : ai) - (bi < 0 ? 999 : bi);
+    return a.label.localeCompare(b.label, 'en', { sensitivity: 'base' });
+  });
+}
+
+export function findOutputStyle(value, styles) {
+  const id = normalizeOutputStyleId(value);
+  const compact = outputStyleCompactKey(value);
+  if (!id && !compact) return null;
+  return (styles || []).find((style) => {
+    if (style.id === id || outputStyleCompactKey(style.id) === compact) return true;
+    if (outputStyleCompactKey(style.label) === compact) return true;
+    return (style.aliases || []).some((alias) => alias === id || outputStyleCompactKey(alias) === compact);
+  }) || null;
+}
+
+function configuredOutputStyleValue(dataDir) {
+  const unified = readJsonSafe(join(dataDir, 'mixdog-config.json')) || {};
+  return clean(unified.outputStyle || (unified.agent && unified.agent.outputStyle) || 'default') || 'default';
+}
+
+export function outputStyleStatus(rootDir, dataDir) {
+  const styles = listOutputStyleCatalog(rootDir, dataDir);
+  const configured = configuredOutputStyleValue(dataDir);
+  const current = findOutputStyle(configured, styles)
+    || findOutputStyle('default', styles)
+    || styles[0]
+    || { id: 'default', label: 'Default', description: '', aliases: [], source: 'builtin' };
+  return { configured, current, styles };
+}

package/src/session-runtime/plugin-mcp.mjs

@@ -0,0 +1,114 @@
+// Plugin/project MCP server discovery + normalization, and skill-file counting.
+import { existsSync, readFileSync, readdirSync } from 'node:fs';
+import { isAbsolute, join, resolve } from 'node:path';
+import { clean } from './session-text.mjs';
+import { readJsonSafe } from './fs-utils.mjs';
+
+// Project-local MCP ingress: read `.mcp.json` from the project root and return
+// a cleaned { name: cfg } map. Best-effort — never throws. Accepts either the
+// standard `{ mcpServers: {...} }` shape or a bare name->cfg map. Self-ref
+// servers (`mixdog` / `trib-plugin`) are stripped for parity with loadConfig.
+// Inputs are not mutated.
+export function readProjectMcpServers(cwd) {
+  const path = join(cwd || '.', '.mcp.json');
+  if (!existsSync(path)) return {};
+  let raw;
+  try {
+    raw = JSON.parse(readFileSync(path, 'utf8'));
+  } catch (error) {
+    process.stderr.write(`[mcp-client] Ignoring unparseable .mcp.json at ${path}: ${error?.message || String(error)}\n`);
+    return {};
+  }
+  if (!raw || typeof raw !== 'object' || Array.isArray(raw)) return {};
+  const map = raw.mcpServers && typeof raw.mcpServers === 'object' && !Array.isArray(raw.mcpServers)
+    ? raw.mcpServers
+    : raw;
+  if (!map || typeof map !== 'object' || Array.isArray(map)) return {};
+  const out = {};
+  for (const [name, cfg] of Object.entries(map)) {
+    const key = clean(name);
+    if (!key) continue;
+    const lower = key.toLowerCase();
+    if (lower === 'mixdog' || lower === 'trib-plugin') continue;
+    if (!cfg || typeof cfg !== 'object' || Array.isArray(cfg)) continue;
+    // stdio entries (command + no url) spawn relative to the process launch
+    // dir, but mixdog tracks the project dir in memory (no process.chdir).
+    // Anchor their cwd to the .mcp.json directory: default when absent, resolve
+    // relative values against it, keep absolute values as-is.
+    const isStdio = typeof cfg.command === 'string' && cfg.command !== '' && !cfg.url;
+    if (isStdio) {
+      out[key] = { ...cfg, cwd: typeof cfg.cwd === 'string' && cfg.cwd ? resolve(cwd, cfg.cwd) : resolve(cwd) };
+    } else {
+      out[key] = cfg;
+    }
+  }
+  return out;
+}
+
+export function countSkillFiles(root) {
+  const skillsDir = join(root, 'skills');
+  if (!existsSync(skillsDir)) return 0;
+  let count = 0;
+  const walk = (dir) => {
+    for (const entry of readdirSync(dir, { withFileTypes: true })) {
+      const full = join(dir, entry.name);
+      if (entry.isDirectory()) walk(full);
+      else if (/^(SKILL|skill)\.md$/i.test(entry.name) || entry.name.toLowerCase().endsWith('.md')) count += 1;
+    }
+  };
+  try { walk(skillsDir); } catch { return count; }
+  return count;
+}
+
+export function mcpScriptForPlugin(root) {
+  const candidates = [
+    '.mcp.json',
+    'scripts/run-mcp.mjs',
+    'mcp/server.mjs',
+    'server.mjs',
+  ];
+  return candidates.find((rel) => existsSync(join(root, rel))) || null;
+}
+
+function substitutePluginRootTokens(value, root) {
+  if (typeof value !== 'string') return value;
+  return value
+    .replace(/\$\{CLAUDE_PLUGIN_ROOT\}/g, root)
+    .replace(/\$\{CODEX_PLUGIN_ROOT\}/g, root);
+}
+
+function substitutePluginRootTokensDeep(value, root) {
+  if (typeof value === 'string') return substitutePluginRootTokens(value, root);
+  if (Array.isArray(value)) return value.map((v) => substitutePluginRootTokensDeep(v, root));
+  if (value && typeof value === 'object') {
+    const out = {};
+    for (const [k, v] of Object.entries(value)) out[k] = substitutePluginRootTokensDeep(v, root);
+    return out;
+  }
+  return value;
+}
+
+export function normalizePluginMcpServerConfig(cfg, root) {
+  const substituted = substitutePluginRootTokensDeep(cfg, root) || {};
+  const out = { ...substituted };
+  if (typeof out.cwd === 'string' && out.cwd) {
+    out.cwd = isAbsolute(out.cwd) ? out.cwd : join(root, out.cwd);
+  } else {
+    out.cwd = root;
+  }
+  return out;
+}
+
+export function pluginManifest(root) {
+  return readJsonSafe(join(root, '.codex-plugin', 'plugin.json'))
+    || readJsonSafe(join(root, 'plugin.json'))
+    || {};
+}
+
+export function pluginMcpServerName(plugin = {}) {
+  const base = clean(plugin.name || plugin.title || 'plugin')
+    .toLowerCase()
+    .replace(/[^a-z0-9_.-]+/g, '-')
+    .replace(/^-+|-+$/g, '');
+  return base ? `plugin-${base}` : 'plugin-mcp';
+}

package/src/session-runtime/session-text.mjs

@@ -0,0 +1,100 @@
+// Session message/preview text helpers. Pure, no runtime-closure deps.
+
+export function sessionMessageText(content) {
+  if (content == null) return '';
+  if (typeof content === 'string') return content;
+  const parts = Array.isArray(content)
+    ? content
+    : (content && typeof content === 'object' && Array.isArray(content.content) ? content.content : null);
+  if (parts) {
+    return parts.map((part) => {
+      if (typeof part === 'string') return part;
+      return part?.text ?? '';
+    }).filter(Boolean).join('\n');
+  }
+  if (typeof content === 'object' && typeof content.text === 'string') return content.text;
+  try { return JSON.stringify(content); } catch { return String(content); }
+}
+
+export function messageContextText(message) {
+  if (!message || typeof message !== 'object') return '';
+  let text = sessionMessageText(message.content);
+  if (message.role === 'assistant' && Array.isArray(message.toolCalls) && message.toolCalls.length) {
+    try { text += `\n${JSON.stringify(message.toolCalls)}`; }
+    catch { text += `\n[${message.toolCalls.length} tool calls]`; }
+  }
+  if (message.role === 'tool' && message.toolCallId) text += `\n${message.toolCallId}`;
+  return text;
+}
+
+export function isSessionPreviewNoise(text) {
+  const value = String(text || '').trim();
+  return !value
+    || value.startsWith('<system-reminder>')
+    || value.startsWith('</system-reminder>')
+    || /^#\s*permission\b/i.test(value)
+    || /^permission:\s*/i.test(value)
+    || /^cwd:\s*/i.test(value);
+}
+
+export function cleanSessionPreview(text) {
+  return String(text || '')
+    .replace(/<system-reminder>[\s\S]*?<\/system-reminder>/gi, ' ')
+    .replace(/\s+/g, ' ')
+    .trim()
+    .slice(0, 160);
+}
+
+export function clean(value) {
+  return String(value ?? '').trim();
+}
+
+export function hasOwn(obj, key) {
+  return Object.prototype.hasOwnProperty.call(obj || {}, key);
+}
+
+export function toolResponseText(result) {
+  if (result && typeof result === 'object' && Array.isArray(result.content)) {
+    return result.content
+      .map((part) => (part?.type === 'text' ? part.text || '' : JSON.stringify(part)))
+      .join('\n');
+  }
+  if (typeof result === 'string') return result;
+  return JSON.stringify(result, null, 2);
+}
+
+export function isEmptyRecallText(value) {
+  const text = String(value || '').trim();
+  return !text || /^\(?no results\)?$/i.test(text) || /^\(?empty memory result\)?$/i.test(text);
+}
+
+export function currentSessionRecallRows(session, query, { limit = 10 } = {}) {
+  const messages = Array.isArray(session?.messages) ? session.messages : [];
+  if (!messages.length) return '(no results)';
+  const terms = [...new Set(String(query || '').toLowerCase().match(/[\p{L}\p{N}_./:-]{2,}/gu) || [])]
+    .filter(Boolean)
+    .slice(0, 16);
+  const max = Math.max(1, Math.min(100, Number(limit) || 10));
+  const rows = [];
+  for (let i = messages.length - 1; i >= 0 && rows.length < max; i -= 1) {
+    const m = messages[i];
+    if (!m || (m.role !== 'user' && m.role !== 'assistant' && m.role !== 'tool')) continue;
+    const text = messageContextText(m).replace(/\s+/g, ' ').trim();
+    if (!text) continue;
+    if (terms.length && !terms.some((term) => text.toLowerCase().includes(term))) continue;
+    rows.push(`[session:${i + 1}] ${m.role}: ${text.slice(0, 1000)}`);
+  }
+  return rows.length ? rows.join('\n') : '(no results)';
+}
+
+export function sessionHasConversationMessages(activeSession) {
+  const messages = Array.isArray(activeSession?.messages) ? activeSession.messages : [];
+  return messages.some((message) => {
+    const role = message?.role;
+    if (role !== 'user' && role !== 'assistant' && role !== 'tool') return false;
+    const text = sessionMessageText(message.content).trim();
+    if (!text && role !== 'assistant') return false;
+    if (role === 'user' && isSessionPreviewNoise(text)) return false;
+    return true;
+  });
+}

package/src/session-runtime/statusline-route.mjs

@@ -0,0 +1,35 @@
+// Statusline route serialization. Pure helpers.
+import { clean, hasOwn } from './session-text.mjs';
+
+export function routeForStatusline(route) {
+  const out = {
+    mode: 'fixed',
+    defaultProvider: route.provider,
+    defaultModel: route.model,
+  };
+  const preset = route.preset || {};
+  if (preset.id) out.presetId = preset.id;
+  if (preset.name) out.presetName = preset.name;
+  // Prefer the preset's curated label, then the route's resolved model display
+  // (set by refreshRouteEffort from the live/offline catalog). Without the
+  // route fallback, a preset-less direct model (e.g. claude-fable-5) reaches
+  // the statusline with no display and renders as the raw id.
+  const modelDisplay = clean(preset.modelDisplay) || clean(route.modelDisplay);
+  if (modelDisplay) out.modelDisplay = modelDisplay;
+  if (route.fast === true || route.fast === false) out.fast = route.fast;
+  else if (preset.fast === true || preset.fast === false) out.fast = preset.fast;
+  if (route.effectiveEffort) {
+    out.effort = route.effectiveEffort;
+    out.displayEffort = route.effectiveEffort;
+  } else if (hasOwn(route, 'effort')) {
+    delete out.effort;
+    delete out.displayEffort;
+  }
+  return out;
+}
+
+export function writeStatuslineRoute(statusRoutes, session, route) {
+  if (!session?.id || !route) return;
+  const clientHostPid = session?.clientHostPid || process.pid;
+  statusRoutes?.writeGatewaySessionRoute?.(session.id, routeForStatusline(route), { clientHostPid });
+}