@zerwiz/ymir 0.1.33 → 0.1.35

package/apps/sessrumnir/src/renderer/src/themes/light.json

@@ -0,0 +1,46 @@
+{
+  "$schema": "pi-theme/v1",
+  "name": "Light",
+  "kind": "light",
+  "seeds": {
+    "app": "#ffffff",
+    "surface": "#f5f5f5",
+    "text": "#171717",
+    "accent": "#2563eb",
+    "success": "#10b981",
+    "warning": "#f59e0b",
+    "error": "#ef4444"
+  },
+  "overrides": {
+    "surface-hover": "#e5e5e5",
+    "card": "#e5e5e5",
+    "elevated": "#d4d4d4",
+    "highlight": "#f5f5f5",
+    "highlight-strong": "#e5e5e5",
+    "secondary": "#404040",
+    "muted": "#525252",
+    "dim": "#737373",
+    "faint": "#a3a3a3",
+    "ghost": "#d4d4d4",
+    "inverse": "#ffffff",
+    "border": "#e5e5e5",
+    "border-strong": "#d4d4d4",
+    "focus": "#3b82f6",
+    "accent-hover": "#1d4ed8",
+    "accent-fg": "#3b82f6",
+    "accent-bg": "rgba(30, 64, 175, 0.15)",
+    "success-bg": "rgba(6, 95, 70, 0.15)",
+    "warning-bg": "rgba(113, 63, 18, 0.15)",
+    "error-bg": "rgba(153, 27, 27, 0.15)",
+    "info": "#3b82f6",
+    "info-bg": "rgba(30, 64, 175, 0.15)",
+    "special": "#a855f7",
+    "special-bg": "rgba(88, 28, 135, 0.15)",
+    "chat-column": "#ffffff",
+    "chat-column-border": "#e5e5e5",
+    "scrollbar": "#d4d4d4",
+    "scrollbar-hover": "#a3a3a3",
+    "md-code": "#a855f7",
+    "md-pre-bg": "#f8f9fa"
+  }
+}

package/apps/sessrumnir/src/renderer/src/themes/nord.json

@@ -0,0 +1,69 @@
+{
+  "$schema": "pi-theme/v1",
+  "name": "Nord",
+  "kind": "dark",
+  "seeds": {
+    "app": "#2E3440",
+    "surface": "#3B4252",
+    "text": "#ECEFF4",
+    "accent": "#5E81AC",
+    "success": "#A3BE8C",
+    "warning": "#EBCB8B",
+    "error": "#BF616A"
+  },
+  "overrides": {
+    "surface-hover": "#434C5E",
+    "card": "#434C5E",
+    "elevated": "#4C566A",
+    "highlight": "#3B4252",
+    "highlight-strong": "#434C5E",
+    "secondary": "#D8DEE9",
+    "muted": "#9599A3",
+    "dim": "#616E88",
+    "faint": "#4C566A",
+    "ghost": "#434C5E",
+    "inverse": "#2E3440",
+    "border": "#434C5E",
+    "border-strong": "#4C566A",
+    "focus": "#88C0D0",
+    "accent-hover": "#81A1C1",
+    "accent-fg": "#81A1C1",
+    "accent-bg": "rgba(46, 52, 64, 0.5)",
+    "success-bg": "rgba(163, 190, 140, 0.15)",
+    "warning-bg": "rgba(235, 203, 139, 0.15)",
+    "error-bg": "rgba(191, 97, 106, 0.15)",
+    "info": "#81A1C1",
+    "info-bg": "rgba(46, 52, 64, 0.5)",
+    "special": "#B48EAD",
+    "special-bg": "rgba(180, 142, 173, 0.15)",
+    "chat-column": "#2E3440",
+    "chat-column-border": "#434C5E",
+    "scrollbar": "#434C5E",
+    "scrollbar-hover": "#4C566A",
+    "md-code": "#B48EAD",
+    "md-pre-bg": "#242932"
+  },
+  "syntax": {
+    "keyword": "#C792EA",
+    "string": "#C3E88D",
+    "comment": "#7B88A1",
+    "function": "#82AAFF",
+    "type": "#FFCB6B",
+    "number": "#F78C6C",
+    "operator": "#89DDFF",
+    "property": "#F78C6C",
+    "tag": "#F07178",
+    "variable": "#EEFFFF",
+    "constant": "#F78C6C",
+    "heading": "#C792EA",
+    "link": "#C3E88D",
+    "list": "#F78C6C",
+    "quote": "#7B88A1",
+    "meta": "#B2CCD6",
+    "mark": "#C792EA",
+    "invalid": "#F07178",
+    "active-line-bg": "rgba(216, 222, 233, 0.05)",
+    "selection-bg": "rgba(94, 129, 172, 0.40)",
+    "selection-match-bg": "rgba(216, 222, 233, 0.08)"
+  }
+}

package/apps/sessrumnir/src/renderer/src/themes/sessrumnir.json

@@ -0,0 +1,82 @@
+{
+  "$schema": "pi-theme/v1",
+  "name": "Sessrúmnir",
+  "kind": "dark",
+  "author": "Ymir",
+  "description": "The seat's own cloth — the carved stone, bone, bronze and blood of the landing page. The default look of the seat; a user theme chosen still wins over it.",
+  "seeds": {
+    "app": "#0e0c09",
+    "surface": "#151209",
+    "text": "#cfc3a9",
+    "accent": "#c9973f",
+    "success": "#96a0a8",
+    "warning": "#c9973f",
+    "error": "#c2584a"
+  },
+  "overrides": {
+    "app": "#0e0c09",
+    "surface": "#151209",
+    "surface-hover": "#1a1610",
+    "card": "#151209",
+    "elevated": "#1a1610",
+    "highlight": "#14100b",
+    "highlight-strong": "#1a1610",
+    "primary": "#cfc3a9",
+    "secondary": "rgba(207, 195, 169, 0.82)",
+    "muted": "#9a8f75",
+    "dim": "#6b6250",
+    "faint": "rgba(207, 195, 169, 0.38)",
+    "ghost": "rgba(207, 195, 169, 0.26)",
+    "inverse": "#0e0c09",
+    "border": "#2b241a",
+    "border-strong": "#7d5f2a",
+    "border-strong-hover": "#c9973f",
+    "focus": "#c9973f",
+    "accent": "#c9973f",
+    "accent-hover": "#7d5f2a",
+    "accent-fg": "#cfc3a9",
+    "accent-bg": "rgba(201, 151, 79, 0.14)",
+    "success": "#96a0a8",
+    "success-bg": "rgba(150, 160, 168, 0.14)",
+    "warning": "#c9973f",
+    "warning-bg": "rgba(201, 151, 79, 0.18)",
+    "error": "#c2584a",
+    "error-hover": "#7c3a30",
+    "error-bg": "rgba(124, 58, 48, 0.24)",
+    "info": "#9a8f75",
+    "info-bg": "rgba(154, 143, 117, 0.14)",
+    "special": "#7d5f2a",
+    "special-bg": "rgba(125, 95, 42, 0.18)",
+    "chat-column": "#0e0c09",
+    "chat-column-border": "#2b241a",
+    "scrollbar": "#2b241a",
+    "scrollbar-hover": "#7d5f2a",
+    "md-code": "#c9973f",
+    "md-pre-bg": "#14100b",
+    "selection-bg": "#57411a",
+    "selection-fg": "#f0e6cd"
+  },
+  "syntax": {
+    "keyword": "#c9973f",
+    "string": "#96a0a8",
+    "comment": "#6b6250",
+    "function": "#cfc3a9",
+    "type": "#9a8f75",
+    "number": "#c2584a",
+    "operator": "#9a8f75",
+    "property": "#96a0a8",
+    "tag": "#c2584a",
+    "variable": "#cfc3a9",
+    "constant": "#c9973f",
+    "heading": "#cfc3a9",
+    "link": "#c9973f",
+    "list": "#c2584a",
+    "quote": "#9a8f75",
+    "meta": "#6b6250",
+    "mark": "#c9973f",
+    "invalid": "#c2584a",
+    "active-line-bg": "rgba(207, 195, 169, 0.04)",
+    "selection-bg": "#57411a",
+    "selection-match-bg": "rgba(207, 195, 169, 0.08)"
+  }
+}

package/apps/sessrumnir/src/renderer/src/utils/debounced-buffer.test.ts

@@ -0,0 +1,81 @@
+import { test } from 'node:test'
+import assert from 'node:assert/strict'
+import { createDebouncedBuffer } from './debounced-buffer'
+
+const DELAY_MS = 150
+
+test('commits the latest pushed text once the delay elapses', (t) => {
+  t.mock.timers.enable({ apis: ['setTimeout'] })
+  const commits: string[] = []
+  const buffer = createDebouncedBuffer(DELAY_MS, (text) => commits.push(text))
+
+  buffer.push('a')
+  buffer.push('ab')
+  t.mock.timers.tick(DELAY_MS - 1)
+  assert.deepEqual(commits, [], 'nothing may commit before the delay elapses')
+  t.mock.timers.tick(1)
+  assert.deepEqual(commits, ['ab'], 'only the latest text commits, once')
+})
+
+test('every push restarts the delay window', (t) => {
+  t.mock.timers.enable({ apis: ['setTimeout'] })
+  const commits: string[] = []
+  const buffer = createDebouncedBuffer(DELAY_MS, (text) => commits.push(text))
+
+  buffer.push('a')
+  t.mock.timers.tick(DELAY_MS - 1)
+  buffer.push('ab')
+  t.mock.timers.tick(DELAY_MS - 1)
+  assert.deepEqual(commits, [], 'the second push must restart the window')
+  t.mock.timers.tick(1)
+  assert.deepEqual(commits, ['ab'])
+})
+
+test('flush commits pending text immediately and returns it', (t) => {
+  t.mock.timers.enable({ apis: ['setTimeout'] })
+  const commits: string[] = []
+  const buffer = createDebouncedBuffer(DELAY_MS, (text) => commits.push(text))
+
+  buffer.push('typed')
+  const flushed = buffer.flush()
+
+  assert.equal(flushed, 'typed')
+  assert.deepEqual(commits, ['typed'])
+  t.mock.timers.tick(DELAY_MS)
+  assert.deepEqual(commits, ['typed'], 'the cancelled timer must not commit again')
+})
+
+test('flush with nothing pending returns null and commits nothing', (t) => {
+  t.mock.timers.enable({ apis: ['setTimeout'] })
+  const commits: string[] = []
+  const buffer = createDebouncedBuffer(DELAY_MS, (text) => commits.push(text))
+
+  assert.equal(buffer.flush(), null)
+  assert.deepEqual(commits, [])
+})
+
+test('cancel discards pending text without committing', (t) => {
+  t.mock.timers.enable({ apis: ['setTimeout'] })
+  const commits: string[] = []
+  const buffer = createDebouncedBuffer(DELAY_MS, (text) => commits.push(text))
+
+  buffer.push('doomed')
+  buffer.cancel()
+  t.mock.timers.tick(DELAY_MS * 2)
+
+  assert.deepEqual(commits, [], 'cancelled text must never commit')
+  assert.equal(buffer.flush(), null, 'cancel must clear the pending text')
+})
+
+test('push after flush starts a fresh window', (t) => {
+  t.mock.timers.enable({ apis: ['setTimeout'] })
+  const commits: string[] = []
+  const buffer = createDebouncedBuffer(DELAY_MS, (text) => commits.push(text))
+
+  buffer.push('first')
+  buffer.flush()
+  buffer.push('second')
+  t.mock.timers.tick(DELAY_MS)
+
+  assert.deepEqual(commits, ['first', 'second'])
+})

package/apps/sessrumnir/src/renderer/src/utils/debounced-buffer.ts

@@ -0,0 +1,57 @@
+/**
+ * Debounced text buffer for editor input: keystrokes are committed to state
+ * only after a quiet period (smoothing per-keystroke re-renders), while the
+ * newest text stays reachable synchronously so consumers that must not act on
+ * stale state — saving, reverting, switching files — can flush or discard the
+ * pending text instead of racing the timer.
+ */
+export interface DebouncedBuffer {
+  /** Record the latest text and (re)start the delay before it commits. */
+  push(text: string): void
+  /** Commit any pending text immediately; returns it, or null if none. */
+  flush(): string | null
+  /** Discard any pending text without committing. */
+  cancel(): void
+}
+
+export function createDebouncedBuffer(
+  delayMs: number,
+  commit: (text: string) => void
+): DebouncedBuffer {
+  let timer: ReturnType<typeof setTimeout> | null = null
+  let pending: string | null = null
+
+  const clear = (): void => {
+    if (timer !== null) {
+      clearTimeout(timer)
+      timer = null
+    }
+  }
+
+  return {
+    push(text) {
+      pending = text
+      clear()
+      timer = setTimeout(() => {
+        timer = null
+        if (pending !== null) {
+          const text = pending
+          pending = null
+          commit(text)
+        }
+      }, delayMs)
+    },
+    flush() {
+      clear()
+      if (pending === null) return null
+      const text = pending
+      pending = null
+      commit(text)
+      return text
+    },
+    cancel() {
+      clear()
+      pending = null
+    },
+  }
+}

package/apps/sessrumnir/src/renderer/src/utils/format-relative-time.test.ts

@@ -0,0 +1,62 @@
+import { test } from 'node:test'
+import assert from 'node:assert/strict'
+import { formatRelativeTime } from './format-relative-time'
+import { i18n } from '../../../shared/i18n'
+import { SOURCE_LANGUAGE } from '../../../shared/i18n/languages'
+
+const SECOND = 1000
+const MINUTE = 60 * SECOND
+const HOUR = 60 * MINUTE
+const DAY = 24 * HOUR
+
+// A fixed "now" so the absolute-date fallback is deterministic.
+const NOW = Date.parse('2026-07-12T12:00:00Z')
+const ago = (ms: number): string => formatRelativeTime(NOW - ms, NOW)
+
+test('sub-45s reads "just now" (incl. clock-skew future timestamps)', () => {
+  assert.equal(ago(0), 'just now')
+  assert.equal(ago(44 * SECOND), 'just now')
+  assert.equal(ago(-5 * SECOND), 'just now') // timestamp slightly in the future
+})
+
+test('minutes bucket (singular at the boundary)', () => {
+  assert.equal(ago(60 * SECOND), '1 minute ago')
+  assert.equal(ago(5 * MINUTE), '5 minutes ago')
+  assert.equal(ago(59 * MINUTE), '59 minutes ago')
+})
+
+test('hours bucket (singular at the boundary)', () => {
+  assert.equal(ago(HOUR), '1 hour ago')
+  assert.equal(ago(20 * HOUR), '20 hours ago')
+})
+
+test('yesterday, then days — never a unit coarser than days', () => {
+  assert.equal(ago(25 * HOUR), 'yesterday')
+  assert.equal(ago(3 * DAY), '3 days ago')
+  assert.equal(ago(29 * DAY), '29 days ago')
+})
+
+test('falls back to an absolute date beyond ~30 days', () => {
+  // "Mon D, YYYY" — not "N days ago". Asserting the shape keeps this
+  // timezone-independent (the date parts render in local time).
+  const dateShape = /^[A-Z][a-z]{2} \d{1,2}, \d{4}$/
+  assert.match(ago(30 * DAY), dateShape)
+  assert.match(ago(200 * DAY), dateShape)
+  assert.doesNotMatch(ago(29 * DAY), dateShape)
+})
+
+const GERMAN = 'de'
+const NAMESPACE = 'translation'
+
+test('uses the interface language', async () => {
+  i18n.addResourceBundle(GERMAN, NAMESPACE, { time: { justNow: 'gerade eben' } })
+  await i18n.changeLanguage(GERMAN)
+  try {
+    assert.equal(ago(0), 'gerade eben')
+    assert.equal(ago(25 * HOUR), 'gestern')
+    assert.equal(ago(3 * DAY), 'vor 3 Tagen')
+  } finally {
+    await i18n.changeLanguage(SOURCE_LANGUAGE)
+    i18n.removeResourceBundle(GERMAN, NAMESPACE)
+  }
+})

package/apps/sessrumnir/src/renderer/src/utils/format-relative-time.ts

@@ -0,0 +1,28 @@
+import { i18n, t } from '../../../shared/i18n'
+
+const SECOND = 1000
+const MINUTE = 60 * SECOND
+const HOUR = 60 * MINUTE
+const DAY = 24 * HOUR
+const JUST_NOW_LIMIT = 45 * SECOND
+const ONE_MINUTE_LIMIT = 90 * SECOND
+const RELATIVE_DAYS_LIMIT = 30 * DAY
+
+/**
+ * A friendly relative-time label capped at days — never a coarser unit than
+ * "days". Beyond ~30 days it falls back to an absolute date ("Jul 3, 2026" in
+ * English). Single unit only (no "1 hour 5 minutes"). `now` is passed in so a
+ * single shared ticker can drive every label (see `NowContext`). Uses the
+ * interface language, not the OS default.
+ */
+export function formatRelativeTime(timestamp: number, now: number): string {
+  const diff = now - timestamp
+  // Clock skew / not-yet timestamps: treat as just now rather than "in -3s".
+  if (diff < JUST_NOW_LIMIT) return t('time.justNow')
+  const relative = new Intl.RelativeTimeFormat(i18n.language, { numeric: 'auto' })
+  if (diff < ONE_MINUTE_LIMIT) return relative.format(-1, 'minute')
+  if (diff < HOUR) return relative.format(-Math.floor(diff / MINUTE), 'minute')
+  if (diff < DAY) return relative.format(-Math.floor(diff / HOUR), 'hour')
+  if (diff < RELATIVE_DAYS_LIMIT) return relative.format(-Math.floor(diff / DAY), 'day')
+  return new Intl.DateTimeFormat(i18n.language, { month: 'short', day: 'numeric', year: 'numeric' }).format(timestamp)
+}

package/apps/sessrumnir/src/renderer/src/utils/heatmap-grid.test.ts

@@ -0,0 +1,57 @@
+import assert from 'node:assert/strict'
+import { test } from 'node:test'
+import { buildWeeks, intensityLevel } from './heatmap-grid'
+import type { ActivityDay } from '../../../shared/ipc-contracts'
+
+function rangeDays(start: string, n: number): ActivityDay[] {
+  const out: ActivityDay[] = []
+  const base = new Date(`${start}T00:00:00`)
+  for (let i = 0; i < n; i++) {
+    const d = new Date(base.getTime() + i * 86_400_000)
+    const key = `${d.getFullYear()}-${String(d.getMonth() + 1).padStart(2, '0')}-${String(d.getDate()).padStart(2, '0')}`
+    out.push({ date: key, count: 0 })
+  }
+  return out
+}
+
+test('buildWeeks groups days into 7-row week columns', () => {
+  // 2026-06-21 is a Sunday: a clean 14-day span makes exactly 2 full weeks.
+  const weeks = buildWeeks(rangeDays('2026-06-21', 14))
+  assert.equal(weeks.length, 2)
+  assert.equal(weeks[0].length, 7)
+  assert.equal(weeks[0][0]?.date, '2026-06-21')
+  assert.equal(weeks[1][0]?.date, '2026-06-28')
+})
+
+test('buildWeeks pads the first column when the range starts mid-week', () => {
+  // 2026-06-24 is a Wednesday (weekday index 3): first 3 cells are null pads.
+  const weeks = buildWeeks(rangeDays('2026-06-24', 4))
+  assert.equal(weeks[0][0], null)
+  assert.equal(weeks[0][1], null)
+  assert.equal(weeks[0][2], null)
+  assert.equal(weeks[0][3]?.date, '2026-06-24')
+})
+
+test('buildWeeks pads the trailing column when the range ends mid-week', () => {
+  // 2026-06-21 is a Sunday: 10 days covers one full week plus 3 days,
+  // so the last column has days at indices 0-2 and null pads at 3-6.
+  const weeks = buildWeeks(rangeDays('2026-06-21', 10))
+  assert.equal(weeks.length, 2)
+  const lastWeek = weeks[1]
+  assert.equal(lastWeek[2]?.date, '2026-06-30')
+  assert.equal(lastWeek[3], null)
+  assert.equal(lastWeek[4], null)
+  assert.equal(lastWeek[5], null)
+  assert.equal(lastWeek[6], null)
+})
+
+test('intensityLevel buckets counts from 0 to 4', () => {
+  assert.equal(intensityLevel(0, 10), 0)
+  assert.equal(intensityLevel(10, 10), 4)
+  assert.equal(intensityLevel(1, 10), 1)
+  assert.equal(intensityLevel(5, 10), 2)
+})
+
+test('intensityLevel returns 0 when maxCount is 0', () => {
+  assert.equal(intensityLevel(0, 0), 0)
+})

package/apps/sessrumnir/src/renderer/src/utils/heatmap-grid.ts

@@ -0,0 +1,41 @@
+import type { ActivityDay } from '../../../shared/ipc-contracts'
+
+const DAYS_PER_WEEK = 7
+const INTENSITY_LEVELS = 4 // levels 1..4 above the empty level 0
+
+export type IntensityLevel = 0 | 1 | 2 | 3 | 4
+
+/**
+ * Group ascending daily activity into column-major weeks. Each inner array
+ * has 7 slots (Sunday..Saturday). The first column is left-padded with `null`
+ * so the first real day lands on its correct weekday row; the last column is
+ * right-padded the same way.
+ */
+export function buildWeeks(days: ActivityDay[]): (ActivityDay | null)[][] {
+  if (days.length === 0) return []
+  const weeks: (ActivityDay | null)[][] = []
+  let current: (ActivityDay | null)[] = []
+
+  const firstWeekday = new Date(`${days[0].date}T00:00:00`).getDay()
+  for (let i = 0; i < firstWeekday; i++) current.push(null)
+
+  for (const day of days) {
+    current.push(day)
+    if (current.length === DAYS_PER_WEEK) {
+      weeks.push(current)
+      current = []
+    }
+  }
+  if (current.length > 0) {
+    while (current.length < DAYS_PER_WEEK) current.push(null)
+    weeks.push(current)
+  }
+  return weeks
+}
+
+/** Map a day's count to a 0..4 intensity bucket relative to the busiest day. */
+export function intensityLevel(count: number, maxCount: number): IntensityLevel {
+  if (count <= 0 || maxCount <= 0) return 0
+  const level = Math.ceil((count / maxCount) * INTENSITY_LEVELS)
+  return Math.min(level, INTENSITY_LEVELS) as IntensityLevel
+}

package/apps/sessrumnir/src/renderer/src/utils/ipc-error.test.ts

@@ -0,0 +1,22 @@
+import assert from 'node:assert/strict'
+import { test } from 'node:test'
+import { formatIpcError } from './ipc-error'
+
+test('strips the Electron remote-method prefix and inner Error label', () => {
+  assert.equal(
+    formatIpcError(new Error("Error invoking remote method 'file:diff': Error: git diff failed: fatal: bad object HEAD")),
+    'git diff failed: fatal: bad object HEAD',
+  )
+})
+
+test('strips the prefix when no inner Error label is present', () => {
+  assert.equal(
+    formatIpcError(new Error("Error invoking remote method 'file:diff': No active workspace")),
+    'No active workspace',
+  )
+})
+
+test('passes through plain errors and non-Error values', () => {
+  assert.equal(formatIpcError(new Error('plain failure')), 'plain failure')
+  assert.equal(formatIpcError('string failure'), 'string failure')
+})

package/apps/sessrumnir/src/renderer/src/utils/ipc-error.ts

@@ -0,0 +1,12 @@
+/**
+ * Electron prefixes errors thrown by ipcMain.handle with
+ * "Error invoking remote method '<channel>': Error: " before they reach the
+ * renderer's rejected promise. Strip that plumbing so users see the message
+ * the main process actually wrote.
+ */
+const IPC_ERROR_PREFIX_RE = /^Error invoking remote method '[^']+': (?:Error: )?/
+
+export function formatIpcError(err: unknown): string {
+  const message = err instanceof Error ? err.message : String(err)
+  return message.replace(IPC_ERROR_PREFIX_RE, '')
+}

package/apps/sessrumnir/src/renderer/src/utils/model-search.test.ts

@@ -0,0 +1,63 @@
+import assert from 'node:assert/strict'
+import { test } from 'node:test'
+import type { ModelInfo } from '../../../shared/ipc-contracts'
+import { filterModels, normalizeModelSearchText } from './model-search'
+
+function model(partial: Pick<ModelInfo, 'id' | 'name' | 'provider'> & Partial<ModelInfo>): ModelInfo {
+  return {
+    api: 'openai-completions',
+    baseUrl: '',
+    reasoning: false,
+    input: ['text'],
+    contextWindow: 8000,
+    maxTokens: 4096,
+    cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
+    ...partial,
+  }
+}
+
+const models: ModelInfo[] = [
+  model({
+    id: 'claude-sonnet-4',
+    name: 'Claude Sonnet 4',
+    provider: 'anthropic',
+    contextWindow: 200000,
+    reasoning: true,
+  }),
+  model({
+    id: 'gpt-4o',
+    name: 'GPT-4o',
+    provider: 'openai',
+    contextWindow: 128000,
+  }),
+  model({
+    id: 'llama3.2',
+    name: 'Llama 3.2',
+    provider: 'ollama',
+    contextWindow: 8000,
+  }),
+]
+
+test('normalizeModelSearchText collapses separators', () => {
+  assert.equal(normalizeModelSearchText('Claude-Sonnet_4'), 'claude sonnet 4')
+})
+
+test('filterModels returns all models for empty query', () => {
+  assert.equal(filterModels(models, '').length, 3)
+  assert.equal(filterModels(models, '   ').length, 3)
+})
+
+test('filterModels matches partial tokens across hyphenated slugs', () => {
+  const hits = filterModels(models, 'sonnet 4')
+  assert.equal(hits.length, 1)
+  assert.equal(hits[0].id, 'claude-sonnet-4')
+})
+
+test('filterModels matches provider or short id fragments', () => {
+  assert.equal(filterModels(models, 'openai').length, 1)
+  assert.equal(filterModels(models, 'gpt 4o')[0]?.id, 'gpt-4o')
+})
+
+test('filterModels requires every token (AND)', () => {
+  assert.equal(filterModels(models, 'claude openai').length, 0)
+})

package/apps/sessrumnir/src/renderer/src/utils/model-search.ts

@@ -0,0 +1,20 @@
+import type { ModelInfo } from '../../../shared/ipc-contracts'
+
+/** Lowercase and treat `_` / `-` / `.` as spaces so "sonnet 4" hits "claude-sonnet-4". */
+export function normalizeModelSearchText(s: string): string {
+  return s
+    .toLowerCase()
+    .replace(/[_\-./:]+/g, ' ')
+    .replace(/\s+/g, ' ')
+    .trim()
+}
+
+/** Every query token must match somewhere in name, id, or provider. */
+export function filterModels(models: ModelInfo[], query: string): ModelInfo[] {
+  const tokens = normalizeModelSearchText(query).split(' ').filter(Boolean)
+  if (tokens.length === 0) return models
+  return models.filter((m) => {
+    const haystack = normalizeModelSearchText(`${m.name} ${m.id} ${m.provider}`)
+    return tokens.every((t) => haystack.includes(t))
+  })
+}