@zerwiz/ymir 0.1.33 → 0.1.35

package/apps/sessrumnir/src/main/agent-detection.ts

@@ -0,0 +1,114 @@
+import { existsSync } from 'fs'
+import { join, delimiter as PATH_DELIMITER } from 'path'
+import { spawnSync } from 'child_process'
+import type { CouncilAgentId } from '../shared/council-config'
+import { COUNCIL_AGENT_IDS } from '../shared/council-config'
+import { buildNpmPrefixCommand } from './cmd-escape'
+import { getPiCli } from './pi-rpc-manager'
+
+const IS_WINDOWS = process.platform === 'win32'
+
+/** Base executable name per council agent. */
+export const AGENT_BINARIES: Record<CouncilAgentId, string> = {
+  pi: 'pi',
+  claude: 'claude',
+  codex: 'codex',
+}
+
+export interface DetectedAgent {
+  id: CouncilAgentId
+  found: boolean
+  path: string | null
+}
+
+interface PlatformInfo {
+  isWindows: boolean
+  home: string
+  env: NodeJS.ProcessEnv
+}
+
+/** Common install locations to probe, ordered most- to least-likely. Pure. */
+export function candidatePaths(id: CouncilAgentId, platform: PlatformInfo): string[] {
+  const base = AGENT_BINARIES[id]
+  const { isWindows, home, env } = platform
+  const out: string[] = []
+  if (isWindows) {
+    const appData = env.APPDATA ?? ''
+    const localAppData = env.LOCALAPPDATA ?? ''
+    if (appData) out.push(join(appData, 'npm', `${base}.cmd`))
+    if (localAppData) out.push(join(localAppData, 'npm', `${base}.cmd`))
+    out.push(join('C:\\Program Files', 'nodejs', `${base}.cmd`))
+  } else {
+    out.push(join('/opt/homebrew/bin', base))
+    out.push(join('/usr/local/bin', base))
+    out.push(join('/usr/bin', base))
+    out.push(join(home, '.local/bin', base))
+    out.push(join(home, '.npm-global/bin', base))
+  }
+  return out
+}
+
+function whichInPath(name: string): string | null {
+  const pathDirs = (process.env.PATH ?? '').split(PATH_DELIMITER).filter(Boolean)
+  const exts = IS_WINDOWS
+    ? (process.env.PATHEXT ?? '.COM;.EXE;.BAT;.CMD').split(';').map((e) => e.toLowerCase())
+    : ['']
+  for (const dir of pathDirs) {
+    for (const ext of exts) {
+      const candidate = join(dir, name + ext)
+      if (existsSync(candidate)) return candidate
+    }
+  }
+  return null
+}
+
+function npmGlobalPrefix(): string | null {
+  try {
+    const command = buildNpmPrefixCommand(IS_WINDOWS)
+    const result = spawnSync(command.file, command.args, {
+      encoding: 'utf-8',
+      shell: IS_WINDOWS,
+      timeout: 5000,
+    })
+    if (result.status === 0 && result.stdout) {
+      const prefix = result.stdout.trim()
+      if (prefix && existsSync(prefix)) return prefix
+    }
+  } catch {
+    // npm not on PATH — ignore
+  }
+  return null
+}
+
+function resolveAgent(id: CouncilAgentId): string | null {
+  if (id === 'pi') {
+    const configured = getPiCli()
+    if (configured.found) return configured.script
+  }
+  const base = AGENT_BINARIES[id]
+  // 1. PATH (respects PATHEXT on Windows)
+  const fromPath = whichInPath(base)
+  if (fromPath) return fromPath
+  // 2. npm global prefix
+  const prefix = npmGlobalPrefix()
+  if (prefix) {
+    const candidates = IS_WINDOWS
+      ? [join(prefix, `${base}.cmd`)]
+      : [join(prefix, 'bin', base)]
+    for (const c of candidates) if (existsSync(c)) return c
+  }
+  // 3. common locations
+  const home = process.env.HOME ?? process.env.USERPROFILE ?? ''
+  for (const c of candidatePaths(id, { isWindows: IS_WINDOWS, home, env: process.env })) {
+    if (existsSync(c)) return c
+  }
+  return null
+}
+
+/** Detect every known consultant agent on this machine. */
+export function detectAgents(): DetectedAgent[] {
+  return COUNCIL_AGENT_IDS.map((id) => {
+    const path = resolveAgent(id)
+    return { id, found: path !== null, path }
+  })
+}

package/apps/sessrumnir/src/main/app-data-paths.test.ts

@@ -0,0 +1,90 @@
+import assert from 'node:assert/strict'
+import { test } from 'node:test'
+import { mkdir, mkdtemp, readFile, writeFile } from 'fs/promises'
+import { existsSync } from 'fs'
+import { join, resolve } from 'path'
+import { tmpdir } from 'os'
+import {
+  GUI_DATA_ENV_VAR,
+  GUI_DATA_FILES,
+  getCanonicalUserDataDir,
+  getExternalGuiDataDir,
+  getGuiDataPath,
+  getLegacyGuiDataPath,
+  getLegacyGuiDataDirs,
+  migrateLegacyGuiData,
+} from './app-data-paths'
+
+test('getCanonicalUserDataDir appends the canonical dir name', () => {
+  assert.equal(getCanonicalUserDataDir('/home/test/.config'), '/home/test/.config/sessrumnir')
+  assert.equal(
+    getCanonicalUserDataDir('/Users/test/Library/Application Support'),
+    '/Users/test/Library/Application Support/sessrumnir'
+  )
+  assert.equal(
+    getCanonicalUserDataDir('C:\\Users\\test\\AppData\\Roaming'),
+    'C:\\Users\\test\\AppData\\Roaming/sessrumnir'
+  )
+})
+
+test('getLegacyGuiDataDirs lists home and electron legacy dirs', () => {
+  assert.deepEqual(
+    getLegacyGuiDataDirs({ homeDir: '/home/test', appDataDir: '/home/test/.config' }),
+    [
+      '/home/test/.pi-desktop-gui',
+      '/home/test/.config/PI Desktop',
+      '/home/test/.config/pi-desktop-gui',
+    ]
+  )
+})
+
+test('getExternalGuiDataDir returns the externally-set override as an absolute path', () => {
+  assert.equal(getExternalGuiDataDir({}), undefined)
+  assert.equal(getExternalGuiDataDir({ [GUI_DATA_ENV_VAR]: '' }), undefined)
+  assert.equal(
+    getExternalGuiDataDir({ [GUI_DATA_ENV_VAR]: '/tmp/pi-desktop-scratch' }),
+    '/tmp/pi-desktop-scratch'
+  )
+  assert.equal(
+    getExternalGuiDataDir({ [GUI_DATA_ENV_VAR]: 'scratch-profile' }),
+    resolve('scratch-profile')
+  )
+})
+
+test('getGuiDataPath / getLegacyGuiDataPath resolve under the right root', () => {
+  assert.equal(
+    getGuiDataPath('settings.json', { userDataDir: '/home/test/.config/pi-desktop' }),
+    '/home/test/.config/pi-desktop/settings.json'
+  )
+  assert.equal(
+    getLegacyGuiDataPath('settings.json', { homeDir: '/home/test' }),
+    '/home/test/.pi-desktop-gui/settings.json'
+  )
+  const userDataDir = '/home/test/.config/pi-desktop'
+  for (const fileName of GUI_DATA_FILES) {
+    assert.equal(getGuiDataPath(fileName, { userDataDir }), join(userDataDir, fileName))
+  }
+})
+
+test('migrateLegacyGuiData copies legacy files but never overwrites existing', async () => {
+  const tmp = await mkdtemp(join(tmpdir(), 'pi-desktop-app-data-'))
+  const homeDir = join(tmp, 'home')
+  const appDataDir = join(tmp, 'config')
+  const userDataDir = getCanonicalUserDataDir(appDataDir)
+  const legacySettings = join(appDataDir, 'pi-desktop-gui', 'settings.json')
+  const targetSettings = getGuiDataPath('settings.json', { userDataDir })
+
+  await mkdir(join(legacySettings, '..'), { recursive: true })
+  await writeFile(legacySettings, '{"theme":"light"}', 'utf-8')
+
+  await migrateLegacyGuiData({ homeDir, appDataDir, userDataDir })
+  assert.equal(await readFile(targetSettings, 'utf-8'), '{"theme":"light"}')
+
+  // A second migration must not clobber an already-migrated file.
+  await writeFile(legacySettings, '{"theme":"dark"}', 'utf-8')
+  await writeFile(targetSettings, '{"theme":"current"}', 'utf-8')
+  await migrateLegacyGuiData({ homeDir, userDataDir })
+  assert.equal(await readFile(targetSettings, 'utf-8'), '{"theme":"current"}')
+
+  assert.equal(existsSync(join(appDataDir, 'pi-desktop-gui')), true)
+})

package/apps/sessrumnir/src/main/app-data-paths.ts

@@ -0,0 +1,95 @@
+import { copyFile, mkdir } from 'fs/promises'
+import { existsSync } from 'fs'
+import { dirname, join, resolve } from 'path'
+
+export const GUI_DATA_ENV_VAR = 'PI_DESKTOP_USER_DATA_DIR'
+export const CANONICAL_GUI_DATA_DIR_NAME = 'sessrumnir'
+export const LEGACY_GUI_DATA_DIR_NAME = '.pi-desktop-gui'
+export const LEGACY_ELECTRON_GUI_DATA_DIR_NAMES = ['PI Desktop', 'pi-desktop-gui'] as const
+
+export const GUI_DATA_FILES = [
+  'archived-sessions.json',
+  'notes.json',
+  'session-auto-tags.json',
+  'session-tags.json',
+  'settings.json',
+  'workspaces.json',
+] as const
+
+export type GuiDataFileName = typeof GUI_DATA_FILES[number]
+
+interface PathOptions {
+  homeDir?: string
+  appDataDir?: string
+  userDataDir?: string
+}
+
+interface MigrationOptions extends PathOptions {
+  files?: readonly string[]
+}
+
+function getHomeDir(options?: PathOptions): string {
+  return options?.homeDir ?? process.env.HOME ?? process.env.USERPROFILE ?? ''
+}
+
+export function configureGuiDataDir(userDataDir: string): void {
+  process.env[GUI_DATA_ENV_VAR] = userDataDir
+}
+
+// Startup reads this before configureGuiDataDir() overwrites the env var, so
+// an override set by the launching process (test harness, portable install)
+// wins over the canonical appData-derived directory.
+export function getExternalGuiDataDir(env: NodeJS.ProcessEnv = process.env): string | undefined {
+  const external = env[GUI_DATA_ENV_VAR]
+  return external ? resolve(external) : undefined
+}
+
+export function getCanonicalUserDataDir(appDataDir: string): string {
+  return join(appDataDir, CANONICAL_GUI_DATA_DIR_NAME)
+}
+
+export function getLegacyGuiDataDirs(options?: PathOptions): string[] {
+  const dirs = [join(getHomeDir(options), LEGACY_GUI_DATA_DIR_NAME)]
+
+  if (options?.appDataDir) {
+    for (const dirName of LEGACY_ELECTRON_GUI_DATA_DIR_NAMES) {
+      dirs.push(join(options.appDataDir, dirName))
+    }
+  }
+
+  return dirs
+}
+
+export function getGuiDataDir(options?: PathOptions): string {
+  const configured = options?.userDataDir ?? process.env[GUI_DATA_ENV_VAR]
+  if (configured) return configured
+  return join(getHomeDir(options), LEGACY_GUI_DATA_DIR_NAME)
+}
+
+export function getGuiDataPath(fileName: string, options?: PathOptions): string {
+  return join(getGuiDataDir(options), fileName)
+}
+
+export function getLegacyGuiDataPath(fileName: string, options?: PathOptions): string {
+  return join(getHomeDir(options), LEGACY_GUI_DATA_DIR_NAME, fileName)
+}
+
+export async function migrateLegacyGuiData(options: MigrationOptions): Promise<void> {
+  const userDataDir = getGuiDataDir(options)
+  await mkdir(userDataDir, { recursive: true })
+
+  for (const fileName of options.files ?? GUI_DATA_FILES) {
+    const targetPath = getGuiDataPath(fileName, options)
+
+    if (existsSync(targetPath)) continue
+
+    for (const legacyDir of getLegacyGuiDataDirs(options)) {
+      const legacyPath = join(legacyDir, fileName)
+      if (!existsSync(legacyPath)) continue
+
+      await mkdir(dirname(targetPath), { recursive: true })
+      await copyFile(legacyPath, targetPath)
+      break
+    }
+  }
+}

package/apps/sessrumnir/src/main/app-log.test.ts

@@ -0,0 +1,114 @@
+import assert from 'node:assert/strict'
+import { test } from 'node:test'
+import { mkdtemp, readFile, writeFile, stat } from 'fs/promises'
+import { tmpdir } from 'os'
+import { join } from 'path'
+import { AppLog, MAX_LOG_BYTES, RECENT_LIMIT, describeLogDetail } from './app-log'
+import type { AppLogEntry } from '../shared/ipc-contracts'
+
+async function makeLogPath(): Promise<string> {
+  const base = await mkdtemp(join(tmpdir(), 'app-log-'))
+  return join(base, 'app-log.jsonl')
+}
+
+function entryLine(entry: AppLogEntry): string {
+  return JSON.stringify(entry) + '\n'
+}
+
+test('records entries with described detail and returns them oldest first', async () => {
+  const log = new AppLog({ logPath: await makeLogPath(), now: () => 1000 })
+  log.error('pi', 'spawn failed', new Error('ENOENT: pi not found'))
+  log.warn('git', 'status failed', { code: 128 })
+  log.info('app', 'started')
+
+  const recent = log.getRecent()
+  assert.equal(recent.length, 3)
+  assert.equal(recent[0].level, 'error')
+  assert.equal(recent[0].scope, 'pi')
+  assert.match(recent[0].detail ?? '', /ENOENT: pi not found/)
+  assert.equal(recent[1].detail, '{"code":128}')
+  assert.equal(recent[2].detail, undefined)
+  assert.equal(recent[2].ts, 1000)
+})
+
+test('caps the in-memory ring at RECENT_LIMIT keeping the newest entries', async () => {
+  const log = new AppLog({ logPath: await makeLogPath() })
+  for (let i = 0; i < RECENT_LIMIT + 25; i++) {
+    log.info('test', `message ${i}`)
+  }
+  const recent = log.getRecent()
+  assert.equal(recent.length, RECENT_LIMIT)
+  assert.equal(recent[0].message, 'message 25')
+  assert.equal(recent[recent.length - 1].message, `message ${RECENT_LIMIT + 24}`)
+})
+
+test('flushSync persists pending entries as JSONL', async () => {
+  const logPath = await makeLogPath()
+  const log = new AppLog({ logPath })
+  log.error('pi', 'pre-flight failed', 'binary missing')
+  log.flushSync()
+
+  const persisted = await log.readPersisted()
+  assert.equal(persisted.length, 1)
+  assert.equal(persisted[0].message, 'pre-flight failed')
+  assert.equal(persisted[0].detail, 'binary missing')
+
+  // A second flush with nothing pending must not duplicate entries.
+  log.flushSync()
+  assert.equal((await log.readPersisted()).length, 1)
+})
+
+test('debounced async flush writes without an explicit flushSync', async () => {
+  const logPath = await makeLogPath()
+  const log = new AppLog({ logPath, flushDelayMs: 10 })
+  log.warn('git', 'diff failed')
+
+  await new Promise((resolve) => setTimeout(resolve, 100))
+  const persisted = await log.readPersisted()
+  assert.equal(persisted.length, 1)
+  assert.equal(persisted[0].message, 'diff failed')
+})
+
+test('seeds the ring from the existing file tail, skipping corrupt lines', async () => {
+  const logPath = await makeLogPath()
+  const prior: AppLogEntry = { ts: 1, level: 'error', scope: 'app', message: 'old crash' }
+  const wrongShape = JSON.stringify({ ts: 'not-a-number', level: 'error' }) + '\n'
+  await writeFile(logPath, entryLine(prior) + 'not json{\n' + wrongShape, 'utf-8')
+
+  const log = new AppLog({ logPath })
+  log.info('app', 'started')
+
+  const recent = log.getRecent()
+  assert.equal(recent.length, 2)
+  assert.equal(recent[0].message, 'old crash')
+  assert.equal(recent[1].message, 'started')
+})
+
+test('rotates the file to .1 when it exceeds the size cap', async () => {
+  const logPath = await makeLogPath()
+  const bigEntry: AppLogEntry = { ts: 1, level: 'info', scope: 'x', message: 'y'.repeat(1024) }
+  const lines = entryLine(bigEntry).repeat(Math.ceil(MAX_LOG_BYTES / 1024) + 8)
+  await writeFile(logPath, lines, 'utf-8')
+
+  const log = new AppLog({ logPath })
+  log.info('app', 'after rotation')
+  log.flushSync()
+
+  const rotated = await stat(`${logPath}.1`)
+  assert.ok(rotated.size > MAX_LOG_BYTES)
+  const fresh = await readFile(logPath, 'utf-8')
+  const freshLines = fresh.trim().split('\n')
+  assert.equal(freshLines.length, 1)
+  assert.match(freshLines[0], /after rotation/)
+})
+
+test('describeLogDetail stringifies errors, objects, and passthrough strings', () => {
+  assert.equal(describeLogDetail(undefined), undefined)
+  assert.equal(describeLogDetail(null), undefined)
+  assert.equal(describeLogDetail('plain'), 'plain')
+  assert.match(describeLogDetail(new Error('boom')) ?? '', /boom/)
+  assert.equal(describeLogDetail({ a: 1 }), '{"a":1}')
+  const circular: Record<string, unknown> = {}
+  circular.self = circular
+  assert.equal(describeLogDetail(circular), '[object Object]')
+})

package/apps/sessrumnir/src/main/app-log.ts

@@ -0,0 +1,210 @@
+import { appendFile, rename, readFile, mkdir, stat } from 'fs/promises'
+import { appendFileSync, existsSync, mkdirSync, renameSync, statSync, readFileSync } from 'fs'
+import { dirname } from 'path'
+import { getGuiDataPath } from './app-data-paths'
+import type { AppLogEntry } from '../shared/ipc-contracts'
+
+export const LOG_FILE_NAME = 'app-log.jsonl'
+/** Entries kept in memory (and read back from the file tail) for diagnostics. */
+export const RECENT_LIMIT = 200
+const SAVE_DEBOUNCE_MS = 2000
+/** When the log file grows past this, it is rotated to `<name>.1`. */
+export const MAX_LOG_BYTES = 512 * 1024
+
+interface AppLogDeps {
+  /** Test override; production resolves lazily via getGuiDataPath. */
+  logPath?: string
+  now?: () => number
+  /** Test override for the write debounce. */
+  flushDelayMs?: number
+}
+
+function isAppLogEntry(value: unknown): value is AppLogEntry {
+  if (typeof value !== 'object' || value === null) return false
+  const entry = value as Record<string, unknown>
+  return (
+    typeof entry.ts === 'number' &&
+    (entry.level === 'info' || entry.level === 'warn' || entry.level === 'error') &&
+    typeof entry.scope === 'string' &&
+    typeof entry.message === 'string' &&
+    (entry.detail === undefined || typeof entry.detail === 'string')
+  )
+}
+
+/** Stringify arbitrary thrown values / extra context for the detail field. */
+export function describeLogDetail(detail: unknown): string | undefined {
+  if (detail === undefined || detail === null) return undefined
+  if (detail instanceof Error) return detail.stack ?? detail.message
+  if (typeof detail === 'string') return detail
+  try {
+    return JSON.stringify(detail)
+  } catch {
+    return String(detail)
+  }
+}
+
+function parseLogLines(text: string): AppLogEntry[] {
+  const entries: AppLogEntry[] = []
+  for (const line of text.split('\n')) {
+    if (!line.trim()) continue
+    try {
+      const parsed: unknown = JSON.parse(line)
+      if (isAppLogEntry(parsed)) entries.push(parsed)
+    } catch {
+      // Skip lines corrupted by a crash mid-append.
+    }
+  }
+  return entries
+}
+
+/**
+ * Main-process application log: bounded in-memory ring for the diagnostics
+ * view plus a debounced JSONL file in the GUI data dir so errors survive into
+ * packaged builds (where the launching terminal's console output is lost).
+ */
+export class AppLog {
+  private readonly logPathOverride?: string
+  private readonly now: () => number
+  private readonly flushDelayMs: number
+  // Resolved lazily: the production singleton is constructed at import time,
+  // before index.ts calls configureGuiDataDir() to set the userData path.
+  private resolvedLogPath: string | null = null
+  private recent: AppLogEntry[] = []
+  private pending: AppLogEntry[] = []
+  private seeded = false
+  private flushTimer: NodeJS.Timeout | null = null
+
+  constructor(deps: AppLogDeps = {}) {
+    this.logPathOverride = deps.logPath
+    this.now = deps.now ?? Date.now
+    this.flushDelayMs = deps.flushDelayMs ?? SAVE_DEBOUNCE_MS
+  }
+
+  private logPath(): string {
+    if (this.logPathOverride) return this.logPathOverride
+    return (this.resolvedLogPath ??= getGuiDataPath(LOG_FILE_NAME))
+  }
+
+  info(scope: string, message: string, detail?: unknown): void {
+    this.log('info', scope, message, detail)
+  }
+
+  warn(scope: string, message: string, detail?: unknown): void {
+    this.log('warn', scope, message, detail)
+  }
+
+  error(scope: string, message: string, detail?: unknown): void {
+    this.log('error', scope, message, detail)
+  }
+
+  log(level: AppLogEntry['level'], scope: string, message: string, detail?: unknown): void {
+    this.ensureSeeded()
+    const entry: AppLogEntry = { ts: this.now(), level, scope, message }
+    const described = describeLogDetail(detail)
+    if (described !== undefined) entry.detail = described
+    this.recent.push(entry)
+    if (this.recent.length > RECENT_LIMIT) this.recent.splice(0, this.recent.length - RECENT_LIMIT)
+    this.pending.push(entry)
+    this.scheduleFlush()
+  }
+
+  /** Recent entries, oldest first, including the previous run's file tail. */
+  getRecent(): AppLogEntry[] {
+    this.ensureSeeded()
+    return [...this.recent]
+  }
+
+  // Seed the ring from the existing file's tail so diagnostics can show what
+  // happened before a crash/restart, not just the current run.
+  private ensureSeeded(): void {
+    if (this.seeded) return
+    this.seeded = true
+    try {
+      const text = readFileSync(this.logPath(), 'utf-8')
+      this.recent = parseLogLines(text).slice(-RECENT_LIMIT)
+    } catch {
+      // No prior log file (or unreadable) — start empty.
+    }
+  }
+
+  private scheduleFlush(): void {
+    if (this.flushTimer) return
+    this.flushTimer = setTimeout(() => {
+      this.flushTimer = null
+      void this.flushAsync()
+    }, this.flushDelayMs)
+    // The debounce timer must never keep the process alive; quit paths call
+    // flushSync explicitly.
+    this.flushTimer.unref?.()
+  }
+
+  private async flushAsync(): Promise<void> {
+    if (this.pending.length === 0) return
+    // Entries stay in `pending` until the write completes, so a quit-time
+    // flushSync landing mid-write can still persist them (a rare duplicate
+    // batch beats losing the final errors of a run).
+    const batch = this.pending.length
+    const lines = this.pending.slice(0, batch).map((entry) => JSON.stringify(entry)).join('\n') + '\n'
+    const path = this.logPath()
+    try {
+      const dir = dirname(path)
+      if (!existsSync(dir)) await mkdir(dir, { recursive: true })
+      await this.rotateIfNeeded()
+      await appendFile(path, lines, 'utf-8')
+      this.pending.splice(0, batch)
+    } catch (err) {
+      // Nowhere better to report a log-write failure than the console; the
+      // entries stay pending and ride the next flush.
+      console.error('[app-log] Failed to write log file:', err)
+    }
+  }
+
+  /** Synchronous flush for quit paths. */
+  flushSync(): void {
+    if (this.flushTimer) {
+      clearTimeout(this.flushTimer)
+      this.flushTimer = null
+    }
+    if (this.pending.length === 0) return
+    const lines = this.pending.map((entry) => JSON.stringify(entry)).join('\n') + '\n'
+    const path = this.logPath()
+    try {
+      const dir = dirname(path)
+      if (!existsSync(dir)) mkdirSync(dir, { recursive: true })
+      this.rotateIfNeededSync()
+      appendFileSync(path, lines, 'utf-8')
+      this.pending = []
+    } catch (err) {
+      console.error('[app-log] Failed to write log file:', err)
+    }
+  }
+
+  private async rotateIfNeeded(): Promise<void> {
+    const path = this.logPath()
+    try {
+      if ((await stat(path)).size > MAX_LOG_BYTES) await rename(path, `${path}.1`)
+    } catch {
+      // Missing file — nothing to rotate.
+    }
+  }
+
+  private rotateIfNeededSync(): void {
+    const path = this.logPath()
+    try {
+      if (statSync(path).size > MAX_LOG_BYTES) renameSync(path, `${path}.1`)
+    } catch {
+      // Missing file — nothing to rotate.
+    }
+  }
+
+  /** Test hook: read the persisted file (post-flush) as parsed entries. */
+  async readPersisted(): Promise<AppLogEntry[]> {
+    try {
+      return parseLogLines(await readFile(this.logPath(), 'utf-8'))
+    } catch {
+      return []
+    }
+  }
+}
+
+export const appLog = new AppLog()

package/apps/sessrumnir/src/main/archived-sessions.test.ts

@@ -0,0 +1,50 @@
+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 { ArchivedSessionsManager } from './archived-sessions'
+
+async function freshDir(): Promise<void> {
+  const dir = await mkdtemp(join(tmpdir(), 'pi-archived-'))
+  configureGuiDataDir(dir)
+}
+
+test('archive then isArchived reflects state', async () => {
+  await freshDir()
+  const mgr = new ArchivedSessionsManager()
+  assert.equal(await mgr.isArchived('s1'), false)
+  await mgr.archive('s1')
+  assert.equal(await mgr.isArchived('s1'), true)
+})
+
+test('archive persists across manager instances', async () => {
+  await freshDir()
+  await new ArchivedSessionsManager().archive('s2')
+  const reloaded = new ArchivedSessionsManager()
+  assert.equal(await reloaded.isArchived('s2'), true)
+  assert.deepEqual(Object.keys(await reloaded.getAll()), ['s2'])
+})
+
+test('unarchive and forget remove the entry', async () => {
+  await freshDir()
+  const mgr = new ArchivedSessionsManager()
+  await mgr.archive('a')
+  await mgr.archive('b')
+  await mgr.unarchive('a')
+  assert.equal(await mgr.isArchived('a'), false)
+  assert.equal(await mgr.isArchived('b'), true)
+  await mgr.forget('b')
+  assert.deepEqual(await mgr.getAll(), {})
+})
+
+test('archive is idempotent and unarchive of absent is a no-op', async () => {
+  await freshDir()
+  const mgr = new ArchivedSessionsManager()
+  await mgr.archive('x')
+  const first = (await mgr.getAll()).x
+  await mgr.archive('x')
+  assert.equal((await mgr.getAll()).x, first, 'archive must not overwrite the timestamp')
+  await mgr.unarchive('missing') // must not throw
+})