mixdog 0.9.2 → 0.9.3

package/src/runtime/shared/transcript-writer.mjs

@@ -14,8 +14,14 @@
  * `mixdog: transcript-writer: `) and suppress duplicates so a broken path
  * cannot spam the terminal.
  */
-import { appendFileSync, mkdirSync, writeFileSync } from 'node:fs';
+import { existsSync, mkdirSync, renameSync, statSync, writeFileSync } from 'node:fs';
 import { dirname, join, resolve } from 'node:path';
+import { appendBuffered, drainPathSync, hasInFlightWrite } from './buffered-appender.mjs';
+
+// Rotate the JSONL transcript once it exceeds this size, keeping one prior
+// generation (`<path>.1`). Checked on each append; the check itself is a
+// cheap statSync so no extra timer/interval is needed.
+const TRANSCRIPT_ROTATE_BYTES = 10 * 1024 * 1024;
 
 // Byte-identical to cwdToProjectSlug() in
 // src/runtime/channels/lib/session-discovery.mjs. Inlined to avoid a
@@ -56,10 +62,31 @@ export function createTranscriptWriter({ mixdogHome, sessionId, cwd, pid } = {})
     }
   }
 
+  function rotateIfNeeded() {
+    try {
+      if (!existsSync(transcriptPath)) return;
+      const { size } = statSync(transcriptPath);
+      if (size < TRANSCRIPT_ROTATE_BYTES) return;
+      // An async appendFile may be in flight for this path; renaming out
+      // from under it races the write on Windows. Skip this round and
+      // retry rotation on the next append instead.
+      if (hasInFlightWrite(transcriptPath)) return;
+      // Force any still-buffered bytes onto disk before renaming, so the
+      // rotated-out file ends with everything queued for it and the fresh
+      // file post-rename doesn't inherit stale in-memory chunks.
+      drainPathSync(transcriptPath);
+      const rotatedPath = `${transcriptPath}.1`;
+      try { renameSync(transcriptPath, rotatedPath); } catch (err) { logOnce(err); }
+    } catch (err) {
+      logOnce(err);
+    }
+  }
+
   function appendLine(entry) {
     ensureProjectDir();
+    rotateIfNeeded();
     try {
-      appendFileSync(transcriptPath, `${JSON.stringify(entry)}\n`);
+      appendBuffered(transcriptPath, `${JSON.stringify(entry)}\n`);
     } catch (err) {
       logOnce(err);
     }

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

@@ -0,0 +1,209 @@
+// Config normalization helpers: default provider, presets/routes, module
+// enable flags, shell/auto-clear/compaction config, and duration formatting.
+import { clean, hasOwn } from './session-text.mjs';
+import { normalizeEffortInput, normalizeSavedEffort } from './effort.mjs';
+import { routeFastKey, fastPreferenceFor } from './model-capabilities.mjs';
+
+export const DEFAULT_PROVIDER = 'anthropic-oauth';
+export const DEFAULT_MODEL = '';
+
+// Resolve the provider to use when a route carries no explicit provider.
+// Priority: config.defaultProvider (when it names a known provider) > DEFAULT_PROVIDER.
+export function makeResolveDefaultProvider(isKnownProvider) {
+  return function resolveDefaultProvider(config) {
+    const configured = clean(config?.defaultProvider);
+    if (configured && isKnownProvider(configured)) return configured;
+    return DEFAULT_PROVIDER;
+  };
+}
+
+export function modelSettingsFor(config, provider, model) {
+  const key = routeFastKey(provider, model);
+  const value = key ? config?.modelSettings?.[key] : null;
+  return value && typeof value === 'object' ? value : {};
+}
+
+export function findPreset(config, key) {
+  const wanted = clean(key).toLowerCase();
+  if (!wanted) return null;
+  const presets = Array.isArray(config?.presets) ? config.presets : [];
+  return presets.find((p) => {
+    const id = clean(p?.id).toLowerCase();
+    const name = clean(p?.name).toLowerCase();
+    return id === wanted || name === wanted;
+  }) || null;
+}
+
+export function makeResolveRoute(resolveDefaultProvider) {
+  return function resolveRoute(config, { provider, model, effort, fast } = {}) {
+    const explicitProvider = clean(provider);
+    const explicitModel = clean(model);
+    const hasExplicitEffort = effort !== undefined;
+    const explicitEffort = hasExplicitEffort ? normalizeEffortInput(effort) : undefined;
+    const hasExplicitFast = fast !== undefined;
+    const explicitFast = fast === true;
+
+    if (explicitModel && !explicitProvider) {
+      const preset = findPreset(config, explicitModel);
+      if (preset) {
+        const p = clean(preset.provider) || DEFAULT_PROVIDER;
+        const m = clean(preset.model) || DEFAULT_MODEL;
+        const saved = modelSettingsFor(config, p, m);
+        return {
+          provider: p,
+          model: m,
+          preset,
+          effort: hasExplicitEffort ? explicitEffort : normalizeSavedEffort(saved.effort ?? preset.effort),
+          fast: hasExplicitFast ? explicitFast : (hasOwn(saved, 'fast') ? saved.fast === true : (preset.fast === true || fastPreferenceFor(config, p, m))),
+        };
+      }
+    }
+
+    if (!explicitProvider && !explicitModel) {
+      const defaultKey = config?.default;
+      const preset = findPreset(config, defaultKey);
+      if (preset) {
+        const p = clean(preset.provider) || DEFAULT_PROVIDER;
+        const m = clean(preset.model) || DEFAULT_MODEL;
+        const saved = modelSettingsFor(config, p, m);
+        return {
+          provider: p,
+          model: m,
+          preset,
+          effort: hasExplicitEffort ? explicitEffort : normalizeSavedEffort(saved.effort ?? preset.effort),
+          fast: hasExplicitFast ? explicitFast : (hasOwn(saved, 'fast') ? saved.fast === true : (preset.fast === true || fastPreferenceFor(config, p, m))),
+        };
+      }
+    }
+
+    const p = explicitProvider || resolveDefaultProvider(config);
+    const m = explicitModel || DEFAULT_MODEL;
+    const saved = modelSettingsFor(config, p, m);
+    return {
+      provider: p,
+      model: m,
+      preset: null,
+      effort: hasExplicitEffort ? explicitEffort : normalizeSavedEffort(saved.effort),
+      fast: hasExplicitFast ? explicitFast : (hasOwn(saved, 'fast') ? saved.fast === true : fastPreferenceFor(config, p, m)),
+    };
+  };
+}
+
+export function isLikelyRawModelId(value) {
+  const model = clean(value);
+  if (!model || model.length > 160) return false;
+  if (/\s/.test(model)) return false;
+  return /^[A-Za-z0-9][A-Za-z0-9._:/@+-]*$/.test(model);
+}
+
+export function validateRequestedModelSelector(config, requested = {}) {
+  const model = clean(requested.model);
+  if (!model) return;
+  if (findPreset(config, model)) return;
+  if (isLikelyRawModelId(model)) return;
+  throw new Error(`Invalid model selector "${model}". Use a preset or a model id; free-form text cannot be used as a model.`);
+}
+
+export function ensureProviderEnabled(config, provider) {
+  const providers = { ...(config?.providers || {}) };
+  providers[provider] = { ...(providers[provider] || {}), enabled: true };
+  return providers;
+}
+
+const AUTO_CLEAR_DEFAULT_IDLE_MS = 60 * 60 * 1000;
+
+export function normalizeSystemShellConfig(value = {}) {
+  const raw = value && typeof value === 'object' ? value : {};
+  const command = clean(raw.command ?? raw.path ?? raw.executable ?? raw.shell);
+  const envCommand = clean(process.env.MIXDOG_SHELL);
+  return {
+    command,
+    effective: command || envCommand || '',
+    source: command ? 'config' : (envCommand ? 'env' : 'auto'),
+  };
+}
+
+export function normalizeSystemShellCommand(value) {
+  const command = clean(value).replace(/^auto$/i, '').replace(/^['"](.+)['"]$/, '$1').trim();
+  if (!command) return '';
+  if (process.platform === 'win32') {
+    const stem = command.split(/[\\/]/).pop().toLowerCase().replace(/\.exe$/, '');
+    if (stem !== 'powershell' && stem !== 'pwsh') {
+      throw new Error('system shell command must be powershell.exe or pwsh on Windows');
+    }
+  }
+  return command;
+}
+
+export function normalizeAutoClearConfig(value = {}) {
+  const raw = value && typeof value === 'object' ? value : {};
+  const idleMs = Number(raw.idleMs ?? raw.thresholdMs ?? raw.idleMillis);
+  return {
+    enabled: raw.enabled !== false,
+    idleMs: Number.isFinite(idleMs) && idleMs > 0 ? Math.max(60_000, Math.round(idleMs)) : AUTO_CLEAR_DEFAULT_IDLE_MS,
+  };
+}
+
+export function normalizeCompactTypeSetting(value, fallback = 'semantic') {
+  const raw = clean(value).toLowerCase().replace(/_/g, '-');
+  if (!raw) return fallback;
+  if (raw === '1' || raw === 'type1' || raw === 'type-1' || raw === 'semantic' || raw === 'summary' || raw === 'default') return 'semantic';
+  if (raw === '2' || raw === 'type2' || raw === 'type-2' || raw === 'recall' || raw === 'recall-fast' || raw === 'recall-fasttrack' || raw === 'recall-fast-track' || raw === 'fasttrack' || raw === 'fast-track') return 'recall-fasttrack';
+  return fallback;
+}
+
+export function normalizeCompactionConfig(value = {}, { memoryEnabled = true } = {}) {
+  const raw = value && typeof value === 'object' ? value : {};
+  let compactType = normalizeCompactTypeSetting(raw.compactType ?? raw.compact_type ?? raw.type, 'semantic');
+  if (compactType === 'recall-fasttrack' && memoryEnabled === false) compactType = 'semantic';
+  return {
+    ...raw,
+    auto: raw.auto !== false && raw.enabled !== false,
+    type: compactType,
+    compactType,
+  };
+}
+
+export function moduleEnabled(configLike, name, fallback = true) {
+  const entry = configLike?.modules?.[name];
+  if (entry && typeof entry === 'object' && entry.enabled === false) return false;
+  return fallback !== false;
+}
+
+export function setModuleEnabledInConfig(configLike, name, enabled) {
+  const next = { ...(configLike || {}) };
+  next.modules = { ...(next.modules || {}) };
+  next.modules[name] = {
+    ...(next.modules[name] || {}),
+    enabled: enabled !== false,
+  };
+  return next;
+}
+
+export function formatDurationMs(ms) {
+  const value = Math.max(0, Number(ms) || 0);
+  if (value % 3_600_000 === 0) return `${value / 3_600_000}h`;
+  if (value % 60_000 === 0) return `${value / 60_000}m`;
+  return `${Math.round(value / 1000)}s`;
+}
+
+export function parseDurationMs(input) {
+  const text = clean(input).toLowerCase();
+  if (!text) return null;
+  const match = /^(\d+(?:\.\d+)?)(ms|s|m|h)?$/.exec(text);
+  if (!match) return null;
+  const n = Number(match[1]);
+  if (!Number.isFinite(n) || n <= 0) return null;
+  const unit = match[2] || 'm';
+  const mult = unit === 'h' ? 3_600_000 : unit === 'm' ? 60_000 : unit === 's' ? 1000 : 1;
+  return Math.max(60_000, Math.round(n * mult));
+}
+
+// A resolved model meta carries catalog-derived fields (contextWindow, pricing,
+// capabilities, …). The lookupModelMeta() fallback for an unknown id is the
+// bare shape `{ id, provider }`, so "more than id/provider" reliably tells a
+// real catalog hit apart from that placeholder.
+export function modelMetaLooksResolved(meta) {
+  if (!meta || typeof meta !== 'object') return false;
+  return Object.keys(meta).some((key) => key !== 'id' && key !== 'provider');
+}

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 };
+}