@zerwiz/ymir 0.1.34 → 0.1.35

package/apps/sessrumnir/src/main/models-file.test.ts

@@ -0,0 +1,114 @@
+import assert from 'node:assert/strict'
+import { mkdtemp, rm, writeFile, mkdir } from 'node:fs/promises'
+import { tmpdir } from 'node:os'
+import { join } from 'node:path'
+import { test } from 'node:test'
+import {
+  describeModelsReadFailure,
+  isModelsConfig,
+  parseModelsFile,
+  resolveModelsFile,
+  serializeModelsFile,
+} from './models-file'
+
+test('resolveModelsFile picks Pi models.json', () => {
+  const location = resolveModelsFile('pi', '/home/u')
+  assert.equal(location.file, join('/home/u', '.pi', 'agent', 'models.json'))
+  assert.equal(location.name, 'models.json')
+  assert.equal(location.format, 'json')
+})
+
+test('resolveModelsFile defaults OMP to models.yml', () => {
+  const location = resolveModelsFile('omp', '/nonexistent-home')
+  assert.equal(location.file, join('/nonexistent-home', '.omp', 'agent', 'models.yml'))
+  assert.equal(location.name, 'models.yml')
+  assert.equal(location.format, 'yaml')
+})
+
+test('resolveModelsFile prefers an existing OMP models.yaml', async () => {
+  const home = await mkdtemp(join(tmpdir(), 'models-file-'))
+  try {
+    const agentDir = join(home, '.omp', 'agent')
+    await mkdir(agentDir, { recursive: true })
+    await writeFile(join(agentDir, 'models.yaml'), 'providers: {}\n', 'utf-8')
+    const location = resolveModelsFile('omp', home)
+    assert.equal(location.name, 'models.yaml')
+    assert.equal(location.format, 'yaml')
+  } finally {
+    await rm(home, { recursive: true, force: true })
+  }
+})
+
+test('parseModelsFile reads YAML and JSON payloads', () => {
+  const yamlParsed = parseModelsFile('providers:\n  ollama:\n    baseUrl: http://x\n', 'yaml')
+  assert.deepEqual(yamlParsed, { providers: { ollama: { baseUrl: 'http://x' } } })
+
+  const jsonParsed = parseModelsFile('{"providers":{"a":{}}}', 'json')
+  assert.deepEqual(jsonParsed, { providers: { a: {} } })
+
+  // Legacy JSON payload left inside a .yml file still parses (YAML superset).
+  const legacy = parseModelsFile('{"providers":{"a":{}}}', 'yaml')
+  assert.deepEqual(legacy, { providers: { a: {} } })
+})
+
+test('parseModelsFile throws on malformed input', () => {
+  assert.throws(() => parseModelsFile('{nope', 'json'))
+  assert.throws(() => parseModelsFile('a: [unclosed', 'yaml'))
+})
+
+test('serializeModelsFile round-trips both formats', () => {
+  const config = { providers: { ollama: { baseUrl: 'http://x', models: [{ id: 'm1', name: 'M1' }] } } }
+  assert.deepEqual(JSON.parse(serializeModelsFile(config, 'json')), config)
+  assert.deepEqual(parseModelsFile(serializeModelsFile(config, 'yaml'), 'yaml'), config)
+})
+
+test('isModelsConfig requires a providers object', () => {
+  assert.equal(isModelsConfig({ providers: {} }), true)
+  assert.equal(isModelsConfig({ providers: { a: {} } }), true)
+  assert.equal(isModelsConfig({}), false)
+  assert.equal(isModelsConfig({ providers: [] }), false)
+  assert.equal(isModelsConfig({ providers: null }), false)
+  assert.equal(isModelsConfig(null), false)
+  assert.equal(isModelsConfig('providers'), false)
+})
+
+test('resolveModelsFile keeps a not-yet-migrated OMP models.json', async () => {
+  const home = await mkdtemp(join(tmpdir(), 'models-file-'))
+  try {
+    const agentDir = join(home, '.omp', 'agent')
+    await mkdir(agentDir, { recursive: true })
+    await writeFile(join(agentDir, 'models.json'), '{"providers":{}}\n', 'utf-8')
+    const location = resolveModelsFile('omp', home)
+    assert.equal(location.name, 'models.json')
+    assert.equal(location.format, 'json')
+    // Once OMP has migrated, the YAML file wins.
+    await writeFile(join(agentDir, 'models.yml'), 'providers: {}\n', 'utf-8')
+    assert.equal(resolveModelsFile('omp', home).name, 'models.yml')
+  } finally {
+    await rm(home, { recursive: true, force: true })
+  }
+})
+
+test('parseModelsFile treats an empty YAML document as an empty config', () => {
+  assert.deepEqual(parseModelsFile('', 'yaml'), { providers: {} })
+  assert.deepEqual(parseModelsFile('# just a comment\n', 'yaml'), { providers: {} })
+  assert.deepEqual(parseModelsFile('providers:\n', 'yaml'), { providers: {} })
+  assert.equal(isModelsConfig(parseModelsFile('providers:\n', 'yaml')), true)
+  // JSON keeps strict semantics: an empty file is still malformed.
+  assert.throws(() => parseModelsFile('', 'json'))
+})
+
+test('describeModelsReadFailure keeps the current English messages', () => {
+  assert.equal(
+    describeModelsReadFailure('models.json', { kind: 'invalid-syntax', format: 'json', detail: 'bad token' }),
+    'models.json is not valid JSON: bad token',
+  )
+  assert.equal(
+    describeModelsReadFailure('models.yml', { kind: 'missing-providers' }),
+    'models.yml is not a valid models config (missing "providers")',
+  )
+  assert.equal(
+    describeModelsReadFailure('models.json', { kind: 'unreadable', detail: 'EACCES' }),
+    'Could not read models.json: EACCES',
+  )
+})

package/apps/sessrumnir/src/main/models-file.ts

@@ -0,0 +1,89 @@
+import { join } from 'path'
+import { existsSync } from 'fs'
+import { parse as parseYaml, stringify as stringifyYaml } from 'yaml'
+import { t } from '../shared/i18n'
+import type { AgentEngineKind, ModelsConfig, ModelsReadFailure } from '../shared/ipc-contracts'
+
+/**
+ * Per-engine custom-models file resolution and (de)serialization.
+ *
+ * Pi keeps `~/.pi/agent/models.json` (JSON). OMP 18 moved to
+ * `~/.omp/agent/models.yml` (YAML; `.yaml` also accepted). OMP migrates a
+ * legacy `models.json` on startup, but only while no YAML file exists yet, so
+ * until OMP has run once after an upgrade the GUI keeps reading and writing
+ * that legacy JSON file — creating `models.yml` beside it would block the
+ * migration and strand the providers in the old file.
+ */
+
+export type ModelsFileFormat = 'json' | 'yaml'
+
+export interface ModelsFileLocation {
+  /** Agent config dir that holds the file (created on write when missing). */
+  dir: string
+  /** Absolute path of the models file. */
+  file: string
+  /** Basename, for user-facing messages ("models.yml is not valid…"). */
+  name: string
+  format: ModelsFileFormat
+}
+
+export const OMP_MODELS_BASENAMES = ['models.yml', 'models.yaml'] as const
+export const PI_MODELS_BASENAME = 'models.json'
+
+export function resolveModelsFile(engine: AgentEngineKind, homeDir: string): ModelsFileLocation {
+  if (engine === 'omp') {
+    const dir = join(homeDir, '.omp', 'agent')
+    const yaml = OMP_MODELS_BASENAMES.find((name) => existsSync(join(dir, name)))
+    if (yaml) return { dir, file: join(dir, yaml), name: yaml, format: 'yaml' }
+    if (existsSync(join(dir, PI_MODELS_BASENAME))) {
+      return { dir, file: join(dir, PI_MODELS_BASENAME), name: PI_MODELS_BASENAME, format: 'json' }
+    }
+    const name = OMP_MODELS_BASENAMES[0]
+    return { dir, file: join(dir, name), name, format: 'yaml' }
+  }
+  const dir = join(homeDir, '.pi', 'agent')
+  return { dir, file: join(dir, PI_MODELS_BASENAME), name: PI_MODELS_BASENAME, format: 'json' }
+}
+
+/**
+ * Parse a models file's raw text. YAML is a superset of JSON, so the YAML
+ * parser also accepts a legacy JSON payload sitting in a `.yml` file. An
+ * empty or comment-only YAML document (and a bare `providers:` key) is an
+ * empty config, not an error — a user may `touch` the file before editing.
+ * Throws on malformed input — callers own the error presentation.
+ */
+export function parseModelsFile(raw: string, format: ModelsFileFormat): unknown {
+  if (format === 'json') return JSON.parse(raw)
+  const parsed: unknown = parseYaml(raw)
+  if (parsed === null || parsed === undefined) return { providers: {} }
+  if (typeof parsed === 'object' && 'providers' in parsed && (parsed as { providers: unknown }).providers === null) {
+    return { ...parsed, providers: {} }
+  }
+  return parsed
+}
+
+export function serializeModelsFile(config: ModelsConfig, format: ModelsFileFormat): string {
+  if (format === 'json') return JSON.stringify(config, null, 2) + '\n'
+  return stringifyYaml(config)
+}
+
+/** Shared shape check: a models config is an object with a `providers` map. */
+export function isModelsConfig(value: unknown): value is ModelsConfig {
+  if (typeof value !== 'object' || value === null) return false
+  const providers = (value as { providers?: unknown }).providers
+  return typeof providers === 'object' && providers !== null && !Array.isArray(providers)
+}
+
+/** The message the Custom Models editor shows, in the interface language. */
+export function describeModelsReadFailure(fileName: string, failure: ModelsReadFailure): string {
+  switch (failure.kind) {
+    case 'unreadable':
+      return t('models.readFailure.unreadable', { file: fileName, detail: failure.detail })
+    case 'invalid-syntax':
+      return failure.format === 'json'
+        ? t('models.readFailure.invalidJson', { file: fileName, detail: failure.detail })
+        : t('models.readFailure.invalidYaml', { file: fileName, detail: failure.detail })
+    case 'missing-providers':
+      return t('models.readFailure.missingProviders', { file: fileName })
+  }
+}

package/apps/sessrumnir/src/main/notes-manager.test.ts

@@ -0,0 +1,64 @@
+import assert from 'node:assert/strict'
+import { test } from 'node:test'
+import { mkdtemp } from 'fs/promises'
+import { tmpdir } from 'os'
+import { join } from 'path'
+import { configureGuiDataDir } from './app-data-paths'
+import { NotesManager, NoteNotFoundError, NoteValidationError } from './notes-manager'
+
+async function freshManager(): Promise<NotesManager> {
+  const dir = await mkdtemp(join(tmpdir(), 'pi-notes-'))
+  configureGuiDataDir(dir)
+  return new NotesManager()
+}
+
+test('create normalizes fields and defaults scope to global', async () => {
+  const mgr = await freshManager()
+  const note = await mgr.create({ title: '  Hi  ', body: ' body ', tags: ['#A', 'a', 'B'], scope: '' })
+  assert.equal(note.title, 'Hi')
+  assert.equal(note.body, 'body')
+  assert.deepEqual(note.tags, ['a', 'b'])
+  assert.equal(note.scope, 'global')
+  assert.ok(note.id && note.createdAt && note.updatedAt)
+})
+
+test('create rejects empty title or body', async () => {
+  const mgr = await freshManager()
+  await assert.rejects(() => mgr.create({ title: '   ', body: 'x', tags: [], scope: 'global' }), NoteValidationError)
+  await assert.rejects(() => mgr.create({ title: 'x', body: '   ', tags: [], scope: 'global' }), NoteValidationError)
+})
+
+test('update merges, revalidates, and bumps updatedAt', async () => {
+  const mgr = await freshManager()
+  const note = await mgr.create({ title: 'a', body: 'b', tags: [], scope: 'global' })
+  const updated = await mgr.update(note.id, { title: 'renamed' })
+  assert.equal(updated.title, 'renamed')
+  assert.equal(updated.body, 'b')
+  assert.ok(updated.updatedAt >= note.updatedAt)
+  await assert.rejects(() => mgr.update('missing-id', { title: 'x' }), NoteNotFoundError)
+})
+
+test('remove deletes and rejects unknown id', async () => {
+  const mgr = await freshManager()
+  const note = await mgr.create({ title: 'a', body: 'b', tags: [], scope: 'global' })
+  await mgr.remove(note.id)
+  assert.deepEqual(await mgr.list(), [])
+  await assert.rejects(() => mgr.remove(note.id), NoteNotFoundError)
+})
+
+test('reassignToGlobal moves workspace-scoped notes to global', async () => {
+  const mgr = await freshManager()
+  await mgr.create({ title: 'ws', body: 'b', tags: [], scope: 'ws-1' })
+  await mgr.create({ title: 'keep', body: 'b', tags: [], scope: 'ws-2' })
+  await mgr.reassignToGlobal('ws-1')
+  const notes = await mgr.list()
+  assert.equal(notes.find((n) => n.title === 'ws')!.scope, 'global')
+  assert.equal(notes.find((n) => n.title === 'keep')!.scope, 'ws-2')
+})
+
+test('notes persist across manager instances', async () => {
+  const mgr = await freshManager()
+  await mgr.create({ title: 'persisted', body: 'b', tags: [], scope: 'global' })
+  const reloaded = new NotesManager()
+  assert.equal((await reloaded.list()).length, 1)
+})

package/apps/sessrumnir/src/main/notes-manager.ts

@@ -0,0 +1,183 @@
+import { readFile, writeFile, mkdir } from 'fs/promises'
+import { join } from 'path'
+import { existsSync } from 'fs'
+import { randomUUID } from 'crypto'
+import { getGuiDataPath } from './app-data-paths'
+import type { Note, NoteInput, NoteUpdate, NoteScope } from '../shared/ipc-contracts'
+import { t } from '../shared/i18n'
+
+/**
+ * Notes store — reusable prompts and agent commands.
+ *
+ * A single global store: every note carries a `scope` (`'global'` or a
+ * workspace id) so the renderer can present a merged view of global notes plus
+ * the active workspace's notes. Persisted to the GUI data directory, mirroring
+ * the SessionTagManager pattern (lazy load, in-memory cache, errors logged).
+ */
+
+const NOTES_FILE_NAME = 'notes.json'
+
+const GLOBAL_SCOPE: NoteScope = 'global'
+const MAX_TITLE_LENGTH = 120
+const MAX_BODY_LENGTH = 20000
+const MAX_TAG_LENGTH = 32
+
+interface NotesFile {
+  notes: Note[]
+}
+
+/** Thrown when an update/remove targets a note id that doesn't exist. */
+export class NoteNotFoundError extends Error {
+  constructor(public readonly id: string) {
+    super(t('errors.notes.notFound', { id }))
+    this.name = 'NoteNotFoundError'
+  }
+}
+
+/** Thrown when create/update input fails validation. */
+export class NoteValidationError extends Error {
+  constructor(message: string) {
+    super(message)
+    this.name = 'NoteValidationError'
+  }
+}
+
+interface NormalizedFields {
+  title: string
+  body: string
+  tags: string[]
+  scope: NoteScope
+}
+
+export class NotesManager {
+  private notesPath: string
+  private cache: Note[] = []
+  private loaded = false
+
+  constructor() {
+    this.notesPath = getGuiDataPath(NOTES_FILE_NAME)
+  }
+
+  async list(): Promise<Note[]> {
+    await this.ensureLoaded()
+    return this.cache.map((note) => ({ ...note }))
+  }
+
+  async create(input: NoteInput): Promise<Note> {
+    await this.ensureLoaded()
+    const fields = this.normalize(input)
+    const now = Date.now()
+    const note: Note = {
+      id: randomUUID(),
+      ...fields,
+      createdAt: now,
+      updatedAt: now,
+    }
+    this.cache.push(note)
+    await this.save()
+    return { ...note }
+  }
+
+  async update(id: string, patch: NoteUpdate): Promise<Note> {
+    await this.ensureLoaded()
+    const index = this.cache.findIndex((note) => note.id === id)
+    if (index === -1) throw new NoteNotFoundError(id)
+
+    const current = this.cache[index]
+    // Validate the merged result so partial updates are checked the same way.
+    const fields = this.normalize({
+      title: patch.title ?? current.title,
+      body: patch.body ?? current.body,
+      tags: patch.tags ?? current.tags,
+      scope: patch.scope ?? current.scope,
+    })
+
+    const updated: Note = {
+      ...current,
+      ...fields,
+      updatedAt: Date.now(),
+    }
+    this.cache[index] = updated
+    await this.save()
+    return { ...updated }
+  }
+
+  async remove(id: string): Promise<void> {
+    await this.ensureLoaded()
+    const index = this.cache.findIndex((note) => note.id === id)
+    if (index === -1) throw new NoteNotFoundError(id)
+    this.cache.splice(index, 1)
+    await this.save()
+  }
+
+  /**
+   * Reassign every note scoped to `workspaceId` back to global so notes never
+   * orphan on a deleted workspace. Called when a workspace is removed.
+   */
+  async reassignToGlobal(workspaceId: string): Promise<void> {
+    await this.ensureLoaded()
+    let changed = false
+    const now = Date.now()
+    for (const note of this.cache) {
+      if (note.scope === workspaceId) {
+        note.scope = GLOBAL_SCOPE
+        note.updatedAt = now
+        changed = true
+      }
+    }
+    if (changed) await this.save()
+  }
+
+  private normalize(input: NoteInput): NormalizedFields {
+    const title = input.title.trim()
+    if (title.length === 0) throw new NoteValidationError(t('errors.notes.titleRequired'))
+    const body = input.body.trim()
+    if (body.length === 0) throw new NoteValidationError(t('errors.notes.bodyRequired'))
+
+    const scope = typeof input.scope === 'string' && input.scope.trim().length > 0
+      ? input.scope.trim()
+      : GLOBAL_SCOPE
+
+    const tags = [...new Set(
+      input.tags
+        .map((tag) => tag.trim().toLowerCase().replace(/^#/, ''))
+        .filter((tag) => tag.length > 0 && tag.length <= MAX_TAG_LENGTH)
+    )]
+
+    return {
+      title: title.slice(0, MAX_TITLE_LENGTH),
+      body: body.slice(0, MAX_BODY_LENGTH),
+      tags,
+      scope,
+    }
+  }
+
+  private async ensureLoaded(): Promise<void> {
+    if (this.loaded) return
+
+    try {
+      if (existsSync(this.notesPath)) {
+        const data = await readFile(this.notesPath, 'utf-8')
+        const parsed = JSON.parse(data) as Partial<NotesFile>
+        this.cache = Array.isArray(parsed.notes) ? parsed.notes : []
+      }
+    } catch {
+      this.cache = []
+    }
+
+    this.loaded = true
+  }
+
+  private async save(): Promise<void> {
+    try {
+      const dir = join(this.notesPath, '..')
+      if (!existsSync(dir)) {
+        await mkdir(dir, { recursive: true })
+      }
+      const store: NotesFile = { notes: this.cache }
+      await writeFile(this.notesPath, JSON.stringify(store, null, 2), 'utf-8')
+    } catch (err) {
+      console.error('Failed to save notes:', err)
+    }
+  }
+}

package/apps/sessrumnir/src/main/notify-decision.test.ts

@@ -0,0 +1,39 @@
+import assert from 'node:assert/strict'
+import { test } from 'node:test'
+import { shouldNotify } from './notify-decision'
+
+const BASE = {
+  enabled: true,
+  windowFocused: false,
+  eventWorkspaceId: 'ws-1',
+  activeWorkspaceId: 'ws-1',
+}
+
+test('disabled setting suppresses everything', () => {
+  assert.equal(shouldNotify({ ...BASE, enabled: false }), false)
+  assert.equal(
+    shouldNotify({ ...BASE, enabled: false, eventWorkspaceId: 'ws-2', windowFocused: false }),
+    false,
+  )
+})
+
+test('unknown event workspace never notifies', () => {
+  assert.equal(shouldNotify({ ...BASE, eventWorkspaceId: null }), false)
+})
+
+test('focused window suppresses only the active workspace', () => {
+  assert.equal(shouldNotify({ ...BASE, windowFocused: true }), false)
+  assert.equal(shouldNotify({ ...BASE, windowFocused: true, eventWorkspaceId: 'ws-2' }), true)
+})
+
+test('unfocused window notifies for active and background workspaces', () => {
+  assert.equal(shouldNotify({ ...BASE, windowFocused: false }), true)
+  assert.equal(shouldNotify({ ...BASE, windowFocused: false, eventWorkspaceId: 'ws-2' }), true)
+})
+
+test('no active workspace still notifies for a background event', () => {
+  assert.equal(
+    shouldNotify({ ...BASE, activeWorkspaceId: null, windowFocused: true }),
+    true,
+  )
+})

package/apps/sessrumnir/src/main/notify-decision.ts

@@ -0,0 +1,25 @@
+/**
+ * Pure decision for desktop notifications, mirroring tray-decision.ts: no
+ * Electron imports so the matrix is unit-testable.
+ */
+export interface NotifyParams {
+  /** The desktopNotifications setting. */
+  enabled: boolean
+  /** Whether the app window currently has OS focus. */
+  windowFocused: boolean
+  /** Workspace the event happened in (null when unknown). */
+  eventWorkspaceId: string | null
+  activeWorkspaceId: string | null
+}
+
+/**
+ * Notify unless the user is already looking at the workspace in question: a
+ * focused window suppresses events from the active workspace only, while an
+ * unfocused window notifies for everything (the user is in another app).
+ */
+export function shouldNotify(params: NotifyParams): boolean {
+  if (!params.enabled) return false
+  if (params.eventWorkspaceId === null) return false
+  if (params.windowFocused && params.eventWorkspaceId === params.activeWorkspaceId) return false
+  return true
+}

package/apps/sessrumnir/src/main/omp-fork-points.test.ts

@@ -0,0 +1,119 @@
+import assert from 'node:assert/strict'
+import { mkdtemp, rm, stat, utimes, writeFile } from 'node:fs/promises'
+import { tmpdir } from 'node:os'
+import { join } from 'node:path'
+import { test } from 'node:test'
+import { clearForkPointsCache, forkPointFromLine, readForkPoints, readForkPointsCached } from './omp-fork-points'
+
+// Mirrors the OMP v3 session record shapes.
+
+const titleLine = JSON.stringify({ type: 'title', v: 1, title: '', pad: ' '.repeat(40) })
+const headerLine = JSON.stringify({ type: 'session', version: 3, id: 'abc', cwd: '/p' })
+
+const userEntry = (id: string, text: string): string =>
+  JSON.stringify({
+    type: 'message',
+    id,
+    parentId: 'p0',
+    timestamp: '2026-08-24T20:05:17.716Z',
+    message: { role: 'user', content: [{ type: 'text', text }], attribution: 'user' },
+  })
+
+const assistantEntry = (id: string): string =>
+  JSON.stringify({
+    type: 'message',
+    id,
+    parentId: 'p1',
+    message: { role: 'assistant', content: [{ type: 'text', text: 'done' }], stopReason: 'stop' },
+  })
+
+const toolResultEntry = (id: string): string =>
+  JSON.stringify({
+    type: 'message',
+    id,
+    parentId: 'p2',
+    message: { role: 'toolResult', content: [{ type: 'text', text: 'output' }] },
+  })
+
+test('forkPointFromLine extracts a user message entry', () => {
+  assert.deepEqual(forkPointFromLine(userEntry('41e43649', 'create a test.md file')), {
+    entryId: '41e43649',
+    text: 'create a test.md file',
+  })
+})
+
+test('forkPointFromLine ignores non-user and malformed records', () => {
+  assert.equal(forkPointFromLine(assistantEntry('04b37a9d')), null)
+  assert.equal(forkPointFromLine(toolResultEntry('a1b2c3d4')), null)
+  assert.equal(forkPointFromLine(titleLine), null)
+  assert.equal(forkPointFromLine(headerLine), null)
+  assert.equal(forkPointFromLine(''), null)
+  assert.equal(forkPointFromLine('not json'), null)
+})
+
+test('forkPointFromLine drops user entries without an id', () => {
+  const noId = JSON.stringify({
+    type: 'message',
+    message: { role: 'user', content: [{ type: 'text', text: 'hi' }] },
+  })
+  assert.equal(forkPointFromLine(noId), null)
+})
+
+test('readForkPoints returns user messages in file order', async () => {
+  const dir = await mkdtemp(join(tmpdir(), 'omp-fork-points-'))
+  try {
+    const path = join(dir, 'session.jsonl')
+    const lines = [
+      titleLine,
+      headerLine,
+      userEntry('aaaa1111', 'first prompt'),
+      assistantEntry('bbbb2222'),
+      toolResultEntry('cccc3333'),
+      userEntry('dddd4444', 'second prompt'),
+    ]
+    await writeFile(path, `${lines.join('\n')}\n`, 'utf-8')
+    assert.deepEqual(await readForkPoints(path), [
+      { entryId: 'aaaa1111', text: 'first prompt' },
+      { entryId: 'dddd4444', text: 'second prompt' },
+    ])
+  } finally {
+    await rm(dir, { recursive: true, force: true })
+  }
+})
+
+test('readForkPoints returns [] for a missing file', async () => {
+  assert.deepEqual(await readForkPoints('/nonexistent/session.jsonl'), [])
+})
+
+test('readForkPointsCached re-reads only when the file changes', async () => {
+  const dir = await mkdtemp(join(tmpdir(), 'omp-fork-points-cache-'))
+  try {
+    clearForkPointsCache()
+    const path = join(dir, 'session.jsonl')
+    // utimes stores whole milliseconds, so pin both writes to one instant.
+    const pinned = new Date('2026-01-01T00:00:00.000Z')
+    await writeFile(path, `${headerLine}\n${userEntry('aaaa1111', 'first')}\n`, 'utf-8')
+    await utimes(path, pinned, pinned)
+    assert.deepEqual(await readForkPointsCached(path), [{ entryId: 'aaaa1111', text: 'first' }])
+
+    // Same mtime and size: served from cache even though the bytes differ.
+    await writeFile(path, `${headerLine}\n${userEntry('bbbb2222', 'firsT')}\n`, 'utf-8')
+    await utimes(path, pinned, pinned)
+    assert.equal((await stat(path)).mtimeMs, pinned.getTime())
+    assert.deepEqual(await readForkPointsCached(path), [{ entryId: 'aaaa1111', text: 'first' }])
+
+    // A real append changes size and mtime: re-read.
+    await writeFile(path, `${headerLine}\n${userEntry('bbbb2222', 'second')}\n${userEntry('cccc3333', 'third')}\n`, 'utf-8')
+    assert.deepEqual(await readForkPointsCached(path), [
+      { entryId: 'bbbb2222', text: 'second' },
+      { entryId: 'cccc3333', text: 'third' },
+    ])
+  } finally {
+    clearForkPointsCache()
+    await rm(dir, { recursive: true, force: true })
+  }
+})
+
+test('readForkPointsCached returns [] for a missing file', async () => {
+  assert.deepEqual(await readForkPointsCached('/nonexistent/session.jsonl'), [])
+})