@zerwiz/ymir 0.1.33 → 0.1.35

package/apps/sessrumnir/src/shared/pi-command.ts

@@ -0,0 +1,139 @@
+// Aliased: groupLabel/groupCommands take their translator as a parameter
+// named `t` (shadowing this import inside the function body) so
+// `i18next-cli`'s static extractor — which looks for calls on an identifier
+// named `t` — still finds and keeps these keys.
+import { t as sharedT, type Translate } from './i18n'
+
+/** A command exposed by Pi via the RPC `get_commands` request. */
+export interface PiCommand {
+  name: string
+  description: string
+  source: 'skill' | 'prompt' | 'extension' | string
+}
+
+/**
+ * Source used for Pi built-in commands that map to a GUI action rather than
+ * being inserted as text. Pi's RPC only expands `/skill:` and `/template` from
+ * typed input, so these built-ins run the equivalent GUI action directly.
+ */
+export const BUILTIN_SOURCE = 'builtin'
+
+/** Pi lists skills under their invocation token: "skill:<name>". */
+export const SKILL_COMMAND_PREFIX = 'skill:'
+
+/** Bare skill name, with the "skill:" invocation prefix removed if present. */
+export function skillDisplayName(name: string): string {
+  return name.startsWith(SKILL_COMMAND_PREFIX) ? name.slice(SKILL_COMMAND_PREFIX.length) : name
+}
+
+/**
+ * Name shown in command lists. Skills drop the redundant "skill:" prefix (the
+ * source badge already says it); GUI built-ins show their slash form.
+ */
+export function commandDisplayName(cmd: PiCommand): string {
+  if (cmd.source === 'skill') return skillDisplayName(cmd.name)
+  if (cmd.source === BUILTIN_SOURCE) return `/${cmd.name}`
+  return cmd.name
+}
+
+/** Command sources that get their own group, in display order. */
+const GROUP_SOURCES = ['skill', 'prompt', BUILTIN_SOURCE, 'extension'] as const
+
+/** Group id of the catch-all for commands from any other source. */
+const OTHER_GROUP_ID = 'other'
+
+export type CommandGroupId = (typeof GROUP_SOURCES)[number] | typeof OTHER_GROUP_ID
+
+/** The display label for one command group, in the interface language. */
+function groupLabel(id: CommandGroupId, t: Translate): string {
+  switch (id) {
+    case 'skill':
+      return t('common.skills')
+    case 'prompt':
+      return t('commandGroups.prompts')
+    case BUILTIN_SOURCE:
+      return t('commandGroups.commands')
+    case 'extension':
+      return t('commandGroups.extensions')
+    case OTHER_GROUP_ID:
+      return t('commandGroups.other')
+  }
+}
+
+/**
+ * The badge text for a command's source, in the interface language. A source
+ * this app does not know is shown exactly as Pi sent it.
+ */
+export function commandSourceLabel(source: string, t: Translate): string {
+  switch (source) {
+    case 'skill':
+      return t('commandSources.skill')
+    case 'prompt':
+      return t('commandSources.prompt')
+    case BUILTIN_SOURCE:
+      return t('commandSources.builtin')
+    case 'extension':
+      return t('commandSources.extension')
+    default:
+      return source
+  }
+}
+
+export interface CommandGroup {
+  /** Stable group id (the command source, or the catch-all id), for React keys. */
+  id: CommandGroupId
+  label: string
+  items: PiCommand[]
+}
+
+/**
+ * Filter commands for the slash palette. A single leading "/" in the query is
+ * ignored so typing "/rev" matches the same as "rev". Matching is
+ * case-insensitive across name and description.
+ */
+export function filterCommands(commands: PiCommand[], query: string): PiCommand[] {
+  const q = query.replace(/^\//, '').trim().toLowerCase()
+  if (!q) return commands
+  return commands.filter(
+    (c) =>
+      c.name.toLowerCase().includes(q) || c.description.toLowerCase().includes(q)
+  )
+}
+
+/**
+ * True while the composer holds a bare slash-command token (`/` followed by a
+ * command name, no whitespace yet). Once whitespace appears the user is typing
+ * arguments after a chosen command, so command suggestions must not trigger.
+ */
+export function isSlashCommandToken(value: string): boolean {
+  return value.startsWith('/') && !/\s/.test(value)
+}
+
+/** Token inserted into the composer when a skill/prompt/extension is chosen. */
+export function invocationToken(name: string, source: string): string {
+  if (source === 'skill') return `/${SKILL_COMMAND_PREFIX}${skillDisplayName(name)} `
+  return `/${name} `
+}
+
+/**
+ * Group commands by source in display order (empty groups dropped), with an
+ * "Other" catch-all for any unexpected source so nothing is silently hidden.
+ * `flat` matches the visual order — keyboard navigation indexes it.
+ */
+export function groupCommands(
+  results: PiCommand[],
+  t: Translate = sharedT
+): {
+  grouped: CommandGroup[]
+  flat: PiCommand[]
+} {
+  const known = new Set<string>(GROUP_SOURCES)
+  const groups: Array<{ id: CommandGroupId; items: PiCommand[] }> = [
+    ...GROUP_SOURCES.map((source) => ({ id: source, items: results.filter((r) => r.source === source) })),
+    { id: OTHER_GROUP_ID, items: results.filter((r) => !known.has(r.source)) },
+  ]
+  const grouped = groups
+    .filter((g) => g.items.length > 0)
+    .map((g) => ({ id: g.id, label: groupLabel(g.id, t), items: g.items }))
+  return { grouped, flat: grouped.flatMap((g) => g.items) }
+}

package/apps/sessrumnir/src/shared/product-name.ts

@@ -0,0 +1,7 @@
+/** The desktop seat's display name — Sessrúmnir, the hall of many seats.
+ *  A product name, never a translation key (ruling R9). */
+export const SESSRUMNIR_PRODUCT_NAME = 'Sessrúmnir'
+
+/** The name Pi gave this shell before Ymir adopted it. Kept only so an import
+ *  that has not been walked yet cannot break the build; never render it. */
+export const PI_DESKTOP_PRODUCT_NAME = SESSRUMNIR_PRODUCT_NAME

package/apps/sessrumnir/src/shared/session-lineage.test.ts

@@ -0,0 +1,103 @@
+import assert from 'node:assert/strict'
+import { test } from 'node:test'
+import { buildLineageTree, type SessionLineageRecord } from './session-lineage'
+
+const recs: SessionLineageRecord[] = [
+  { sessionId: 'root', path: '/s/root.jsonl', name: 'Root', preview: null, parentPath: null },
+  { sessionId: 'childA', path: '/s/a.jsonl', name: 'A', preview: null, parentPath: '/s/root.jsonl' },
+  { sessionId: 'childB', path: '/s/b.jsonl', name: 'B', preview: null, parentPath: '/s/root.jsonl' },
+  { sessionId: 'grand', path: '/s/g.jsonl', name: 'G', preview: null, parentPath: '/s/a.jsonl' },
+]
+
+test('builds a tree rooted at parentless sessions', () => {
+  const roots = buildLineageTree(recs)
+  assert.equal(roots.length, 1)
+  assert.equal(roots[0].sessionId, 'root')
+  assert.equal(roots[0].children.length, 2)
+})
+
+test('nests grandchildren under the correct parent', () => {
+  const roots = buildLineageTree(recs)
+  const a = roots[0].children.find((c) => c.sessionId === 'childA')!
+  assert.equal(a.children.length, 1)
+  assert.equal(a.children[0].sessionId, 'grand')
+})
+
+test('treats a parentPath with no matching session as a root', () => {
+  const orphan: SessionLineageRecord[] = [
+    { sessionId: 'x', path: '/s/x.jsonl', name: 'X', preview: null, parentPath: '/s/missing.jsonl' },
+  ]
+  const roots = buildLineageTree(orphan)
+  assert.equal(roots.length, 1)
+  assert.equal(roots[0].sessionId, 'x')
+})
+
+test('does not infinite-loop on a self-referential cycle', () => {
+  const cyclic: SessionLineageRecord[] = [
+    { sessionId: 'c', path: '/s/c.jsonl', name: 'C', preview: null, parentPath: '/s/c.jsonl' },
+  ]
+  const roots = buildLineageTree(cyclic)
+  assert.equal(roots.length, 1)
+  assert.equal(roots[0].sessionId, 'c')
+})
+
+test('carries the message preview through the tree build', () => {
+  const withPreview: SessionLineageRecord[] = [
+    { sessionId: 'p', path: '/s/p.jsonl', name: null, preview: 'Refactor auth', parentPath: null },
+    {
+      sessionId: 'c',
+      path: '/s/c.jsonl',
+      name: null,
+      preview: 'Fix token refresh',
+      parentPath: '/s/p.jsonl',
+    },
+  ]
+  const roots = buildLineageTree(withPreview)
+  assert.equal(roots[0].preview, 'Refactor auth')
+  assert.equal(roots[0].children[0].preview, 'Fix token refresh')
+})
+
+test('links a child whose parentPath differs only in case on win32', () => {
+  // getSessionsRoot() reads HOME/USERPROFILE while Pi resolves parentSession via
+  // os.homedir(); neither canonicalizes drive-letter case, so a raw map lookup
+  // misses and the child silently becomes a second root.
+  const winRecs: SessionLineageRecord[] = [
+    {
+      sessionId: 'parent',
+      path: 'C:\\Users\\night\\.pi\\agent\\sessions\\proj\\parent.jsonl',
+      name: null,
+      preview: 'parent topic',
+      parentPath: null,
+    },
+    {
+      sessionId: 'child',
+      path: 'C:\\Users\\night\\.pi\\agent\\sessions\\proj\\child.jsonl',
+      name: null,
+      preview: 'child topic',
+      parentPath: 'c:\\users\\night\\.pi\\agent\\sessions\\proj\\parent.jsonl',
+    },
+  ]
+  const roots = buildLineageTree(winRecs, true)
+  assert.equal(roots.length, 1)
+  assert.equal(roots[0].sessionId, 'parent')
+  assert.equal(roots[0].children.length, 1)
+  assert.equal(roots[0].children[0].sessionId, 'child')
+})
+
+test('keeps case-distinct POSIX paths separate', () => {
+  // The same fold must not apply on POSIX, where the two really are different.
+  const posixRecs: SessionLineageRecord[] = [
+    { sessionId: 'lower', path: '/s/a.jsonl', name: null, preview: 'lower', parentPath: null },
+    { sessionId: 'upper', path: '/s/A.jsonl', name: null, preview: 'upper', parentPath: '/s/a.jsonl' },
+  ]
+  const roots = buildLineageTree(posixRecs, false)
+  assert.equal(roots.length, 1)
+  assert.equal(roots[0].children.length, 1)
+
+  // …and a parent reference that only matches under folding stays an orphan.
+  const unmatched: SessionLineageRecord[] = [
+    { sessionId: 'lower', path: '/s/a.jsonl', name: null, preview: 'lower', parentPath: null },
+    { sessionId: 'other', path: '/s/b.jsonl', name: null, preview: 'other', parentPath: '/s/A.jsonl' },
+  ]
+  assert.equal(buildLineageTree(unmatched, false).length, 2)
+})

package/apps/sessrumnir/src/shared/session-lineage.ts

@@ -0,0 +1,50 @@
+import { pathGroupKey } from './path-compare'
+
+/** Cross-session lineage record extracted from a session JSONL header. */
+export interface SessionLineageRecord {
+  sessionId: string
+  path: string
+  /** Explicit session name (`session_info`), or null if never named. */
+  name: string | null
+  /** Preview of the session's first user message, or null if it has none. */
+  preview: string | null
+  /** Absolute path to the originating session (`parentSession`), or null. */
+  parentPath: string | null
+}
+
+/** A lineage record with its resolved children. */
+export interface LineageNode extends SessionLineageRecord {
+  children: LineageNode[]
+}
+
+/**
+ * Build a forest of LineageNodes from flat records. A record is a root when its
+ * parentPath is null or points to a path not present in the input. Cycles are
+ * broken: a node is only ever attached to one parent and never to itself.
+ *
+ * Paths are keyed with `pathGroupKey`, so a `parentSession` that differs from the
+ * child's own path only in case still links on Windows: the GUI derives session
+ * paths from `HOME`/`USERPROFILE` while Pi derives `parentSession` from
+ * `os.homedir()`, and neither canonicalizes drive-letter case. `caseInsensitive`
+ * overrides platform detection for tests and callers that know the target
+ * filesystem's semantics.
+ */
+export function buildLineageTree(
+  records: SessionLineageRecord[],
+  caseInsensitive?: boolean
+): LineageNode[] {
+  const byPath = new Map<string, LineageNode>()
+  for (const r of records) {
+    byPath.set(pathGroupKey(r.path, caseInsensitive), { ...r, children: [] })
+  }
+
+  const roots: LineageNode[] = []
+  for (const node of byPath.values()) {
+    const nodeKey = pathGroupKey(node.path, caseInsensitive)
+    const parentKey = node.parentPath ? pathGroupKey(node.parentPath, caseInsensitive) : null
+    const parent = parentKey !== null && parentKey !== nodeKey ? byPath.get(parentKey) : undefined
+    if (parent) parent.children.push(node)
+    else roots.push(node)
+  }
+  return roots
+}

package/apps/sessrumnir/src/shared/session-preview.test.ts

@@ -0,0 +1,93 @@
+import assert from 'node:assert/strict'
+import { test } from 'node:test'
+import {
+  MAX_PREVIEW_CHARS,
+  PLANNING_PREAMBLE_OPENING,
+  PLANNING_PREAMBLE_SENTINEL,
+  sessionPreview,
+  stripInjectedPreamble,
+} from './session-preview'
+
+/**
+ * Stands in for the renderer's `buildPlanningPrompt`, which shared code may not
+ * import. `planning-prompt.test.ts` guards that the real builder still matches.
+ */
+const injectedPrompt = (request: string): string =>
+  [
+    PLANNING_PREAMBLE_OPENING,
+    '',
+    'Return a step-by-step plan before any implementation.',
+    '',
+    PLANNING_PREAMBLE_SENTINEL,
+    request,
+  ].join('\n')
+
+test('sessionPreview collapses newlines and runs of whitespace', () => {
+  assert.equal(
+    sessionPreview('Refactor auth\n\n  module   login\tlogic'),
+    'Refactor auth module login logic'
+  )
+})
+
+test('sessionPreview trims surrounding whitespace', () => {
+  assert.equal(sessionPreview('\n  Fix token refresh  \n'), 'Fix token refresh')
+})
+
+test('sessionPreview returns null for text with no visible characters', () => {
+  assert.equal(sessionPreview('   \n\t  '), null)
+  assert.equal(sessionPreview(''), null)
+})
+
+test('sessionPreview leaves text at the cap unchanged', () => {
+  const exact = 'a'.repeat(MAX_PREVIEW_CHARS)
+  assert.equal(sessionPreview(exact), exact)
+})
+
+test('sessionPreview truncates over-long text and marks the cut', () => {
+  const long = 'a'.repeat(MAX_PREVIEW_CHARS + 50)
+  const preview = sessionPreview(long)!
+  // The ellipsis signals truncation without inflating the payload past the cap.
+  assert.ok(preview.endsWith('…'), `expected an ellipsis, got ${JSON.stringify(preview.slice(-8))}`)
+  assert.equal(Array.from(preview).length, MAX_PREVIEW_CHARS + 1)
+  assert.ok(long.startsWith(preview.slice(0, -1)))
+})
+
+test('sessionPreview does not split a surrogate pair when truncating', () => {
+  // Each rocket is one code point but two UTF-16 units; a naive slice(0, N)
+  // cuts the pair and yields a lone replacement char.
+  const rockets = '🚀'.repeat(MAX_PREVIEW_CHARS + 10)
+  const preview = sessionPreview(rockets)!
+  assert.ok(!preview.includes('�'), 'preview contains a replacement character')
+  assert.equal(preview, '🚀'.repeat(MAX_PREVIEW_CHARS) + '…')
+})
+
+test('stripInjectedPreamble recovers the request from a planning-mode prompt', () => {
+  assert.equal(
+    stripInjectedPreamble(injectedPrompt('Add a remember-me checkbox')),
+    'Add a remember-me checkbox'
+  )
+})
+
+test('stripInjectedPreamble leaves an ordinary message untouched', () => {
+  const plain = 'Explain this project structure'
+  assert.equal(stripInjectedPreamble(plain), plain)
+})
+
+test('stripInjectedPreamble keeps a message that merely mentions the sentinel', () => {
+  // Only a message that *opens* with the injected preamble may be stripped;
+  // otherwise a user writing "User request:" would lose everything before it.
+  const plain = 'Here is the User request: format we should adopt'
+  assert.equal(stripInjectedPreamble(plain), plain)
+})
+
+test('stripInjectedPreamble keeps the preamble when no request follows it', () => {
+  // Degenerate but real: stripping would leave an empty preview, which is worse
+  // than showing the boilerplate.
+  const preambleOnly = injectedPrompt('')
+  assert.equal(stripInjectedPreamble(preambleOnly), preambleOnly)
+})
+
+test('a planning prompt previews as the user request alone', () => {
+  const prompt = injectedPrompt('  Wire up the token refresh retry  ')
+  assert.equal(sessionPreview(stripInjectedPreamble(prompt)), 'Wire up the token refresh retry')
+})

package/apps/sessrumnir/src/shared/session-preview.ts

@@ -0,0 +1,56 @@
+/**
+ * Turns a session's first user message into a one-line row label.
+ *
+ * Pure string helpers, shared because main reads the message off disk while the
+ * renderer owns the planning-mode preamble those messages can carry — the
+ * sentinels below must have exactly one definition or the two would drift.
+ */
+
+/**
+ * Longest preview kept on the IPC wire and in a row title. Every render site
+ * CSS-truncates to its own width, so this only has to bound the payload and
+ * leave enough text to tell two sessions apart.
+ */
+export const MAX_PREVIEW_CHARS = 120
+
+/** Marks a preview that was cut short. */
+const ELLIPSIS = '…'
+
+/**
+ * Planning mode prepends a fixed preamble to the user's prompt, so the stored
+ * first message of every planning session opens with the same boilerplate and
+ * would preview identically. `buildPlanningPrompt` composes both sentinels, so
+ * the real request can be recovered by locating the second one.
+ */
+export const PLANNING_PREAMBLE_OPENING = 'You are in read-only planning mode.'
+export const PLANNING_PREAMBLE_SENTINEL = 'User request:'
+
+/**
+ * Recover the user's own words from a message that opens with GUI-injected
+ * boilerplate. The text must *start* with the preamble, so a message that merely
+ * quotes the sentinel keeps everything before it.
+ */
+export function stripInjectedPreamble(text: string): string {
+  if (!text.startsWith(PLANNING_PREAMBLE_OPENING)) return text
+
+  const sentinelAt = text.indexOf(PLANNING_PREAMBLE_SENTINEL)
+  if (sentinelAt === -1) return text
+
+  const request = text.slice(sentinelAt + PLANNING_PREAMBLE_SENTINEL.length).trim()
+  // A preamble with nothing after it is still better than an empty preview.
+  return request || text
+}
+
+/**
+ * Collapse a message to a single capped line, or null when it carries no visible
+ * characters. Truncation counts code points, so a cut never lands inside a
+ * surrogate pair and leaves a replacement character behind.
+ */
+export function sessionPreview(text: string): string | null {
+  const collapsed = text.replace(/\s+/g, ' ').trim()
+  if (!collapsed) return null
+
+  const points = Array.from(collapsed)
+  if (points.length <= MAX_PREVIEW_CHARS) return collapsed
+  return points.slice(0, MAX_PREVIEW_CHARS).join('') + ELLIPSIS
+}

package/apps/sessrumnir/src/shared/sidebar-width.test.ts

@@ -0,0 +1,58 @@
+import assert from 'node:assert/strict'
+import { test } from 'node:test'
+import {
+  DEFAULT_SIDEBAR_WIDTH,
+  MAX_SIDEBAR_WIDTH,
+  MIN_SIDEBAR_WIDTH,
+  clampSidebarWidth,
+  resolveSidebarWidth,
+} from './sidebar-width'
+
+test('the default width sits inside the allowed range', () => {
+  assert.ok(MIN_SIDEBAR_WIDTH < MAX_SIDEBAR_WIDTH)
+  assert.ok(DEFAULT_SIDEBAR_WIDTH >= MIN_SIDEBAR_WIDTH)
+  assert.ok(DEFAULT_SIDEBAR_WIDTH <= MAX_SIDEBAR_WIDTH)
+})
+
+test('clampSidebarWidth keeps a width already in range', () => {
+  assert.equal(clampSidebarWidth(320), 320)
+  assert.equal(clampSidebarWidth(MIN_SIDEBAR_WIDTH), MIN_SIDEBAR_WIDTH)
+  assert.equal(clampSidebarWidth(MAX_SIDEBAR_WIDTH), MAX_SIDEBAR_WIDTH)
+})
+
+test('clampSidebarWidth pulls out-of-range widths to the bounds', () => {
+  // A drag past either edge, or a hand-edited settings.json, must not be able to
+  // collapse the sidebar to nothing or push the chat off screen.
+  assert.equal(clampSidebarWidth(0), MIN_SIDEBAR_WIDTH)
+  assert.equal(clampSidebarWidth(-500), MIN_SIDEBAR_WIDTH)
+  assert.equal(clampSidebarWidth(10_000), MAX_SIDEBAR_WIDTH)
+})
+
+test('clampSidebarWidth rounds to whole pixels', () => {
+  assert.equal(clampSidebarWidth(320.6), 321)
+})
+
+test('clampSidebarWidth falls back to the default for a non-numeric width', () => {
+  // settings.json is user-editable, so NaN/Infinity have to be survivable.
+  assert.equal(clampSidebarWidth(Number.NaN), DEFAULT_SIDEBAR_WIDTH)
+  assert.equal(clampSidebarWidth(Number.POSITIVE_INFINITY), DEFAULT_SIDEBAR_WIDTH)
+})
+
+test('resolveSidebarWidth prefers an in-progress drag over the saved width', () => {
+  assert.equal(resolveSidebarWidth(400, 300), 400)
+})
+
+test('resolveSidebarWidth uses the saved width when no drag is active', () => {
+  assert.equal(resolveSidebarWidth(null, 300), 300)
+})
+
+test('resolveSidebarWidth falls back to the default before settings load', () => {
+  // The sidebar renders before the settings IPC round-trip resolves.
+  assert.equal(resolveSidebarWidth(null, undefined), DEFAULT_SIDEBAR_WIDTH)
+  assert.equal(resolveSidebarWidth(null, null), DEFAULT_SIDEBAR_WIDTH)
+})
+
+test('resolveSidebarWidth clamps both sources', () => {
+  assert.equal(resolveSidebarWidth(9999, null), MAX_SIDEBAR_WIDTH)
+  assert.equal(resolveSidebarWidth(null, 1), MIN_SIDEBAR_WIDTH)
+})

package/apps/sessrumnir/src/shared/sidebar-width.ts

@@ -0,0 +1,37 @@
+/**
+ * Bounds and resolution for the sidebar's user-adjustable width.
+ *
+ * Shared because the default is part of `AppSettings` (so main can seed
+ * settings.json) while the clamping belongs to the renderer that drags the
+ * handle — one definition keeps a hand-edited settings.json from producing a
+ * sidebar that cannot be read or cannot be shrunk.
+ */
+
+/** Narrow enough to reclaim space, wide enough for the nav labels. */
+export const MIN_SIDEBAR_WIDTH = 240
+/** Wide enough for a long session title without crowding out the chat. */
+export const MAX_SIDEBAR_WIDTH = 560
+/**
+ * Fits roughly 36 characters of a session title — the previous 272px cut most
+ * first-message previews mid-word.
+ */
+export const DEFAULT_SIDEBAR_WIDTH = 320
+
+/** Coerce any stored or dragged value into a usable whole-pixel width. */
+export function clampSidebarWidth(raw: number): number {
+  if (!Number.isFinite(raw)) return DEFAULT_SIDEBAR_WIDTH
+  return Math.round(Math.min(Math.max(raw, MIN_SIDEBAR_WIDTH), MAX_SIDEBAR_WIDTH))
+}
+
+/**
+ * The width to render: an in-progress drag wins, then the saved setting, then the
+ * default (the sidebar renders before the settings IPC round-trip resolves).
+ */
+export function resolveSidebarWidth(
+  draft: number | null,
+  persisted: number | null | undefined
+): number {
+  if (draft !== null) return clampSidebarWidth(draft)
+  if (persisted !== null && persisted !== undefined) return clampSidebarWidth(persisted)
+  return DEFAULT_SIDEBAR_WIDTH
+}

package/apps/sessrumnir/src/shared/theme/builtin-ids.ts

@@ -0,0 +1,16 @@
+// The built-in theme ids, frozen since the token system's first task.
+// These are also persisted in users' settings.json, so this list must never
+// change without a migration. Both the renderer's theme registry
+// (src/renderer/src/themes/index.ts) and the main process's user-theme store
+// (src/main/theme-store.ts) must agree on this exact set — the renderer is
+// the source of the actual theme files, but the main process cannot import
+// those (separate process/bundle), so this module is the single shared
+// source of truth for just the id strings.
+//
+// `fensalir` was appended when the carved cloth of the halls arrived: the last
+// entry is new, every id before it is unchanged, and a new id is additive —
+// old settings keep resolving, new ones may select it. Never reorder, rename
+// or drop an id here; only ever append.
+export const BUILTIN_THEME_IDS = [
+  'sessrumnir', 'fensalir', 'dark', 'light', 'nord', 'gruvbox', 'breeze-dark', 'breeze-light', 'breeze-claudius',
+] as const

package/apps/sessrumnir/src/shared/theme/resolve.test.ts

@@ -0,0 +1,66 @@
+import { test } from 'node:test'
+import assert from 'node:assert/strict'
+import { resolveThemeVars } from './resolve'
+import { TOKEN_NAMES, cssVarForToken } from './tokens'
+import { SYNTAX_KEYS, THEME_SCHEMA_V1, type ThemeFile } from './theme-file'
+
+const base: ThemeFile = {
+  $schema: THEME_SCHEMA_V1,
+  name: 'Test',
+  kind: 'dark',
+  seeds: {
+    app: '#0a0a0a', surface: '#171717', text: '#f5f5f5', accent: '#2563eb',
+    success: '#34d399', warning: '#facc15', error: '#f87171',
+  },
+}
+
+test('resolves every token and syntax variable', () => {
+  const vars = resolveThemeVars(base)
+  for (const token of TOKEN_NAMES) {
+    assert.ok(vars[cssVarForToken(token)], `missing ${token}`)
+  }
+  for (const key of SYNTAX_KEYS) {
+    assert.ok(vars[`--cm-${key}`], `missing --cm-${key}`)
+  }
+})
+
+test('seeds pass through, derived tokens are color-mix templates', () => {
+  const vars = resolveThemeVars(base)
+  assert.equal(vars['--color-app'], '#0a0a0a')
+  assert.equal(vars['--color-primary'], '#f5f5f5')
+  assert.match(vars['--color-surface-hover'], /^color-mix\(in oklab,/)
+})
+
+test('overrides beat seeds and derivations', () => {
+  const vars = resolveThemeVars({
+    ...base,
+    overrides: { surface: '#123456', 'surface-hover': '#654321' },
+  })
+  assert.equal(vars['--color-surface'], '#123456')
+  assert.equal(vars['--color-surface-hover'], '#654321')
+})
+
+test('overriding a non-identity-mapped token beats its backing seed', () => {
+  // 'surface' above is identity-named with its seed (seed 'surface' backs
+  // token 'surface'), which would still pass if override precedence only
+  // ever checked the seed name rather than the token name. 'primary' is
+  // backed by the differently-named seed 'text' (see SEED_TO_TOKEN), so this
+  // catches a regression that special-cases identity-named seeds.
+  const vars = resolveThemeVars({
+    ...base,
+    overrides: { primary: '#abcdef' },
+  })
+  assert.equal(vars['--color-primary'], '#abcdef')
+})
+
+test('syntax merges over kind defaults', () => {
+  const vars = resolveThemeVars({ ...base, syntax: { keyword: '#ff0000' } })
+  assert.equal(vars['--cm-keyword'], '#ff0000')
+  assert.ok(vars['--cm-string'].startsWith('#'))
+})
+
+test('light kind selects the light syntax defaults', () => {
+  const dark = resolveThemeVars(base)
+  const light = resolveThemeVars({ ...base, kind: 'light' })
+  assert.notEqual(dark['--cm-keyword'], light['--cm-keyword'])
+})

package/apps/sessrumnir/src/shared/theme/resolve.ts

@@ -0,0 +1,29 @@
+import {
+  DERIVED_TOKENS, SEED_TO_TOKEN, TOKEN_NAMES, cssVarForToken,
+  type SeedName,
+} from './tokens'
+import { SYNTAX_KEYS, type ThemeFile } from './theme-file'
+import { DEFAULT_SYNTAX } from './syntax-defaults'
+
+const TOKEN_FOR_SEED = Object.fromEntries(
+  Object.entries(SEED_TO_TOKEN).map(([seed, token]) => [token, seed]),
+) as Record<string, SeedName>
+
+export function resolveThemeVars(file: ThemeFile): Record<string, string> {
+  const vars: Record<string, string> = {}
+  for (const token of TOKEN_NAMES) {
+    const override = file.overrides?.[token]
+    if (override !== undefined) {
+      vars[cssVarForToken(token)] = override
+    } else if (token in TOKEN_FOR_SEED) {
+      vars[cssVarForToken(token)] = file.seeds[TOKEN_FOR_SEED[token]]
+    } else {
+      vars[cssVarForToken(token)] = DERIVED_TOKENS[token]
+    }
+  }
+  const syntaxDefaults = DEFAULT_SYNTAX[file.kind]
+  for (const key of SYNTAX_KEYS) {
+    vars[`--cm-${key}`] = file.syntax?.[key] ?? syntaxDefaults[key]
+  }
+  return vars
+}