npm - @zerwiz/ymir - Versions diffs - 0.1.34 → 0.1.35 - Mend

@zerwiz/ymir 0.1.34 → 0.1.35

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (929) hide show

package/apps/sessrumnir/src/renderer/src/utils/theme.test.ts ADDED Viewed

@@ -0,0 +1,174 @@
+import { test } from 'node:test'
+import assert from 'node:assert/strict'
+import { readFileSync } from 'node:fs'
+import { dirname, join } from 'node:path'
+import { fileURLToPath } from 'node:url'
+import { runInNewContext } from 'node:vm'
+import { DEFAULT_SETTINGS } from '../../../shared/default-settings'
+import { BUILTIN_THEMES } from '../themes'
+import {
+  BOOT_THEME_STORAGE_KEY,
+  applyThemeSettings,
+  getAppliedThemeId,
+  registerThemes,
+  rememberBootTheme,
+  resolveSystemThemeSlot,
+  resolveThemeId,
+  subscribeAppliedTheme,
+} from './theme'
+// theme.ts reads the OS preference through matchMedia, writes CSS vars to
+// <html>, and remembers the boot theme in localStorage; node has none of
+// these, so stub the minimum surface those calls touch.
+let prefersDark = false
+const storage = new Map<string, string>()
+Object.assign(globalThis, {
+  window: { matchMedia: () => ({ matches: prefersDark }) },
+  document: {
+    documentElement: {
+      style: { setProperty() {}, removeProperty() {}, colorScheme: '' },
+      classList: { toggle() {} },
+    },
+  },
+  localStorage: {
+    getItem: (key: string) => storage.get(key) ?? null,
+    setItem: (key: string, value: string) => { storage.set(key, value) },
+  },
+})
+const BOOT_SCRIPT = readFileSync(join(dirname(fileURLToPath(import.meta.url)), '../../public/theme-boot.js'), 'utf8')
+interface BootResult {
+  vars: Record<string, string>
+  colorScheme: string
+  lightClass: boolean
+}
+// Runs the pre-paint boot script the way index.html does, against the value
+// rememberBootTheme left in storage and the given OS preference.
+function runBootScript(osPrefersDark: boolean, stored = storage.get(BOOT_THEME_STORAGE_KEY) ?? null): BootResult {
+  const result: BootResult = { vars: {}, colorScheme: '', lightClass: false }
+  const style = {
+    setProperty: (key: string, value: string) => { result.vars[key] = value },
+    set colorScheme(value: string) { result.colorScheme = value },
+  }
+  runInNewContext(BOOT_SCRIPT, {
+    window: { matchMedia: () => ({ matches: osPrefersDark }) },
+    localStorage: { getItem: () => stored },
+    document: {
+      documentElement: {
+        style,
+        classList: { toggle: (name: string, on: boolean) => { if (name === 'light') result.lightClass = on } },
+      },
+    },
+  })
+  return result
+}
+const SYSTEM_WITH_GRUVBOX = { theme: 'system', systemLightTheme: 'breeze-light', systemDarkTheme: 'gruvbox' }
+function builtinFile(id: string) {
+  const theme = BUILTIN_THEMES.find((candidate) => candidate.id === id)
+  assert.ok(theme, `missing built-in theme ${id}`)
+  return theme.file
+}
+test('System is the default theme', () => {
+  assert.equal(DEFAULT_SETTINGS.theme, 'system')
+})
+test('the default System themes are built-in themes of the matching kind', () => {
+  assert.equal(builtinFile(DEFAULT_SETTINGS.systemLightTheme).kind, 'light')
+  assert.equal(builtinFile(DEFAULT_SETTINGS.systemDarkTheme).kind, 'dark')
+})
+test('a concrete theme id resolves to itself', () => {
+  assert.equal(resolveThemeId('nord'), 'nord')
+})
+test('System resolves to the chosen light theme when the OS prefers light', () => {
+  prefersDark = false
+  applyThemeSettings(SYSTEM_WITH_GRUVBOX)
+  assert.equal(resolveThemeId('system'), 'breeze-light')
+})
+test('System resolves to the chosen dark theme when the OS prefers dark', () => {
+  prefersDark = true
+  applyThemeSettings(SYSTEM_WITH_GRUVBOX)
+  assert.equal(resolveThemeId('system'), 'gruvbox')
+})
+test('a missing System theme falls back to the built-in default for its slot', () => {
+  assert.equal(resolveSystemThemeSlot('dark', 'deleted-theme'), DEFAULT_SETTINGS.systemDarkTheme)
+})
+test('a System theme of the other kind falls back to the built-in default for its slot', () => {
+  assert.equal(resolveSystemThemeSlot('light', 'gruvbox'), DEFAULT_SETTINGS.systemLightTheme)
+})
+test('a registered user theme of the matching kind fills a System slot', () => {
+  registerThemes([{ id: 'my-dusk', file: { ...builtinFile('gruvbox'), name: 'My Dusk' } }])
+  assert.equal(resolveSystemThemeSlot('dark', 'my-dusk'), 'my-dusk')
+})
+test('applying System notifies subscribers with the theme it resolved to', () => {
+  prefersDark = true
+  applyThemeSettings({ ...SYSTEM_WITH_GRUVBOX, theme: 'light' })
+  const notified: string[] = []
+  const unsubscribe = subscribeAppliedTheme(() => notified.push(getAppliedThemeId() ?? ''))
+  applyThemeSettings(SYSTEM_WITH_GRUVBOX)
+  unsubscribe()
+  assert.deepEqual(notified, ['gruvbox'])
+  assert.equal(getAppliedThemeId(), 'gruvbox')
+})
+test('re-applying the same theme still notifies subscribers', () => {
+  applyThemeSettings({ ...SYSTEM_WITH_GRUVBOX, theme: 'nord' })
+  let notified = 0
+  const unsubscribe = subscribeAppliedTheme(() => { notified++ })
+  applyThemeSettings({ ...SYSTEM_WITH_GRUVBOX, theme: 'nord' })
+  unsubscribe()
+  assert.equal(notified, 1)
+})
+test('the boot script paints the remembered System dark theme on a dark OS', () => {
+  rememberBootTheme(SYSTEM_WITH_GRUVBOX)
+  const boot = runBootScript(true)
+  assert.equal(boot.vars['--color-app'], builtinFile('gruvbox').seeds.app)
+  assert.equal(boot.vars['--color-primary'], builtinFile('gruvbox').seeds.text)
+  assert.equal(boot.colorScheme, 'dark')
+  assert.equal(boot.lightClass, false)
+})
+test('the boot script paints the remembered System light theme on a light OS', () => {
+  rememberBootTheme(SYSTEM_WITH_GRUVBOX)
+  const boot = runBootScript(false)
+  assert.equal(boot.vars['--color-app'], builtinFile('breeze-light').seeds.app)
+  assert.equal(boot.colorScheme, 'light')
+  assert.equal(boot.lightClass, true)
+})
+test('the boot script paints a concrete theme the same on either OS', () => {
+  rememberBootTheme({ ...SYSTEM_WITH_GRUVBOX, theme: 'nord' })
+  assert.deepEqual(runBootScript(false), runBootScript(true))
+  assert.equal(runBootScript(false).vars['--color-app'], builtinFile('nord').seeds.app)
+})
+test('a missing concrete theme is remembered as the fallback theme', () => {
+  rememberBootTheme({ ...SYSTEM_WITH_GRUVBOX, theme: 'deleted-theme' })
+  assert.equal(runBootScript(false).vars['--color-app'], builtinFile('dark').seeds.app)
+})
+// With nothing remembered (first launch), the body must not paint the dark
+// stylesheet default; a transparent app color lets the OS-mode canvas show.
+test('without a remembered theme the boot script shows the OS-mode canvas', () => {
+  const boot = runBootScript(false, null)
+  assert.deepEqual(boot.vars, { '--color-app': 'transparent' })
+  assert.equal(boot.colorScheme, 'light')
+})
+test('the boot script ignores a corrupt remembered theme', () => {
+  const boot = runBootScript(true, '{not json')
+  assert.deepEqual(boot.vars, { '--color-app': 'transparent' })
+  assert.equal(boot.colorScheme, 'dark')
+})

package/apps/sessrumnir/src/renderer/src/utils/theme.ts ADDED Viewed

@@ -0,0 +1,159 @@
+import type { AppSettings } from '../../../shared/ipc-contracts'
+import { DEFAULT_SETTINGS } from '../../../shared/default-settings'
+import type { ThemeFile } from '../../../shared/theme/theme-file'
+import { resolveThemeVars } from '../../../shared/theme/resolve'
+import { cssVarForToken } from '../../../shared/theme/tokens'
+import { BUILTIN_THEMES } from '../themes'
+import { applyThemeVars } from '../theme/engine'
+export interface RegisteredTheme { id: string; file: ThemeFile }
+export type ThemeKind = ThemeFile['kind']
+export type ThemeSettings = Pick<AppSettings, 'theme' | 'systemLightTheme' | 'systemDarkTheme'>
+export const SYSTEM_THEME_ID = 'system'
+const FALLBACK_THEME_ID = 'dark'
+const DARK_SCHEME_QUERY = '(prefers-color-scheme: dark)'
+const SYSTEM_THEME_DEFAULTS: Readonly<Record<ThemeKind, string>> = {
+  light: DEFAULT_SETTINGS.systemLightTheme,
+  dark: DEFAULT_SETTINGS.systemDarkTheme,
+}
+// Read by src/renderer/public/theme-boot.js before the first paint; keep the
+// key and the BootPaint shape in sync with that script.
+export const BOOT_THEME_STORAGE_KEY = 'pi-desktop.boot-theme'
+const APP_COLOR_VAR = cssVarForToken('app')
+const TEXT_COLOR_VAR = cssVarForToken('primary')
+interface BootPaint { app: string; text: string; kind: ThemeKind }
+const BUILTIN_IDS = new Set(BUILTIN_THEMES.map((t) => t.id))
+const registry = new Map<string, ThemeFile>(BUILTIN_THEMES.map((t) => [t.id, t.file]))
+let appliedVarKeys: string[] = []
+// The themes 'system' maps to, set by applyThemeSettings from the saved
+// settings or the unsaved draft, so every applyTheme('system') honors them.
+let systemThemes: Record<ThemeKind, string> = { ...SYSTEM_THEME_DEFAULTS }
+let appliedThemeId: string | null = null
+const appliedThemeListeners = new Set<() => void>()
+// Additive: adds or updates the given themes. Use for a single fresh
+// add/update (import, URL install, editor save) where nothing needs removing.
+export function registerThemes(themes: ReadonlyArray<RegisteredTheme>): void {
+  for (const theme of themes) registry.set(theme.id, theme.file)
+}
+// Authoritative reconcile against the full user-theme set from themes.list():
+// drops every current user (non-built-in) entry, then re-adds the given ones,
+// so a deleted or renamed-away theme leaves the dropdown without an app
+// restart. Built-in entries are never touched.
+export function setUserThemes(themes: ReadonlyArray<RegisteredTheme>): void {
+  for (const id of [...registry.keys()]) {
+    if (!BUILTIN_IDS.has(id)) registry.delete(id)
+  }
+  for (const theme of themes) registry.set(theme.id, theme.file)
+}
+export function getRegisteredThemes(): ReadonlyArray<RegisteredTheme> {
+  return [...registry.entries()].map(([id, file]) => ({ id, file }))
+}
+let systemThemeWatched = false
+let previewActive = false
+// While a live preview owns the document's theme variables (the theme editor),
+// external re-applies must yield or they overwrite the unsaved preview. The
+// editor sets this for its lifetime; watchSystemTheme checks it.
+export function setThemePreviewActive(active: boolean): void {
+  previewActive = active
+}
+// Re-applies the theme when the OS light/dark preference changes while the
+// app is open, but only when the currently-effective theme is 'system' and no
+// live preview is in progress. Subscribes once for the app's lifetime;
+// repeated calls are no-ops.
+export function watchSystemTheme(getEffectiveThemeId: () => string): void {
+  if (systemThemeWatched) return
+  systemThemeWatched = true
+  window.matchMedia(DARK_SCHEME_QUERY).addEventListener('change', () => {
+    if (previewActive) return
+    if (getEffectiveThemeId() === SYSTEM_THEME_ID) applyTheme(SYSTEM_THEME_ID)
+  })
+}
+// A System slot keeps the user's choice only while it names a registered
+// theme of the slot's kind. A deleted, renamed, or kind-flipped theme falls
+// back to the built-in default, so 'system' never lands on a missing theme.
+export function resolveSystemThemeSlot(kind: ThemeKind, themeId: string): string {
+  return registry.get(themeId)?.kind === kind ? themeId : SYSTEM_THEME_DEFAULTS[kind]
+}
+// Turns 'system' into the concrete theme id for the current OS preference;
+// any other id is already concrete.
+export function resolveThemeId(themeId: string): string {
+  if (themeId !== SYSTEM_THEME_ID) return themeId
+  const kind: ThemeKind = window.matchMedia(DARK_SCHEME_QUERY).matches ? 'dark' : 'light'
+  return resolveSystemThemeSlot(kind, systemThemes[kind])
+}
+function registeredOrFallback(themeId: string): string {
+  return registry.has(themeId) ? themeId : FALLBACK_THEME_ID
+}
+export function applyTheme(themeId: string): void {
+  const id = registeredOrFallback(resolveThemeId(themeId))
+  const file = registry.get(id)!
+  const html = document.documentElement
+  appliedVarKeys = applyThemeVars(html, resolveThemeVars(file), appliedVarKeys)
+  html.classList.toggle('light', file.kind === 'light')
+  html.style.colorScheme = file.kind
+  appliedThemeId = id
+  for (const listener of appliedThemeListeners) listener()
+}
+function bootPaint(themeId: string): BootPaint {
+  const file = registry.get(registeredOrFallback(themeId))!
+  const vars = resolveThemeVars(file)
+  return { app: vars[APP_COLOR_VAR], text: vars[TEXT_COLOR_VAR], kind: file.kind }
+}
+// Stores what theme-boot.js paints before the app loads: one entry per OS
+// mode, so a System theme still starts right after the OS switched between
+// launches. A concrete theme stores the same paint for both. Storage
+// failures only cost the pre-paint, so they are ignored.
+export function rememberBootTheme(settings: ThemeSettings): void {
+  const idFor = (kind: ThemeKind): string => settings.theme === SYSTEM_THEME_ID
+    ? resolveSystemThemeSlot(kind, kind === 'light' ? settings.systemLightTheme : settings.systemDarkTheme)
+    : settings.theme
+  const paints: Record<ThemeKind, BootPaint> = { light: bootPaint(idFor('light')), dark: bootPaint(idFor('dark')) }
+  try {
+    localStorage.setItem(BOOT_THEME_STORAGE_KEY, JSON.stringify(paints))
+  } catch {
+    // Private-mode or quota failure: the next launch paints the default.
+  }
+}
+// Applies a theme settings snapshot (saved or unsaved draft), recording its
+// System slots first so 'system' resolves to the user's light/dark choices.
+export function applyThemeSettings(settings: ThemeSettings): void {
+  systemThemes = { light: settings.systemLightTheme, dark: settings.systemDarkTheme }
+  applyTheme(settings.theme)
+}
+// The concrete id of the theme on screen, for consumers that restyle on an
+// OS light/dark switch, not only on a settings change. Shaped for
+// useSyncExternalStore.
+export function getAppliedThemeId(): string | null {
+  return appliedThemeId
+}
+// Listeners run after every applyTheme, even when the id is unchanged, so
+// an edited theme saved under its own id still reaches them.
+export function subscribeAppliedTheme(listener: () => void): () => void {
+  appliedThemeListeners.add(listener)
+  return () => {
+    appliedThemeListeners.delete(listener)
+  }
+}
+export function isLightTheme(themeId: string | null | undefined): boolean {
+  if (!themeId) return false
+  return registry.get(resolveThemeId(themeId))?.kind === 'light'
+}

package/apps/sessrumnir/src/renderer/src/utils/workflow-runs.test.ts ADDED Viewed

@@ -0,0 +1,130 @@
+import assert from 'node:assert/strict'
+import { test } from 'node:test'
+import {
+  canAbortRun,
+  canResumeRun,
+  filterRunsBySession,
+  filterRunsByWorkspace,
+  isTerminalRun,
+  isWorkflowActionAllowed,
+  resolveRunSessionId,
+  runActiveAgentCount,
+} from './workflow-runs'
+import type { WorkflowAgentStatus, WorkflowRunStatus, WorkflowRunSummary } from '../../../shared/ipc-contracts'
+const HEADER_UUID = '01a01a28-f010-7b29-8312-21ba523d9edf'
+const STEM = `2026-08-19T13-14-45-648Z_${HEADER_UUID}`
+function run(sessionId: string | undefined, workspaceId = 'ws'): WorkflowRunSummary {
+  return {
+    workspaceId,
+    workspaceName: 'ws',
+    cwd: '/tmp',
+    runId: sessionId ?? 'no-session',
+    workflowName: 'w',
+    sessionId,
+    status: 'completed',
+    phases: ['plan'],
+    startedAt: '2026-08-19T13:00:00.000Z',
+    updatedAt: '2026-08-19T13:10:00.000Z',
+    agents: [],
+  }
+}
+test('resolveRunSessionId prefers Pi header UUID over the filename stem', () => {
+  assert.equal(resolveRunSessionId(HEADER_UUID, STEM), HEADER_UUID)
+})
+test('resolveRunSessionId derives the UUID from the stem suffix when the header is missing', () => {
+  assert.equal(resolveRunSessionId(undefined, STEM), HEADER_UUID)
+})
+test('resolveRunSessionId never returns the raw stem (tags/archive key)', () => {
+  // A stem without the timestamp_ prefix has no derivable UUID.
+  assert.equal(resolveRunSessionId(undefined, 'not-a-uuid'), null)
+  assert.equal(resolveRunSessionId('', 'not-a-uuid'), null)
+})
+test('filterRunsBySession keeps only the requested session across different session IDs', () => {
+  const otherUuid = '01b2b3c4-d5e6-4f70-a8b9-0c1d2e3f4a5b'
+  const runs = [run(HEADER_UUID), run(otherUuid), run(HEADER_UUID), run(undefined)]
+  const filtered = filterRunsBySession(runs, HEADER_UUID)
+  assert.equal(filtered.length, 2)
+  assert.ok(filtered.every((r) => r.sessionId === HEADER_UUID))
+})
+test('filterRunsBySession with null is the global list', () => {
+  const runs = [run(HEADER_UUID), run('01b2b3c4-d5e6-4f70-a8b9-0c1d2e3f4a5b')]
+  assert.equal(filterRunsBySession(runs, null).length, 2)
+})
+test('filterRunsByWorkspace keeps only runs recorded in the requested workspace', () => {
+  const runs = [run(HEADER_UUID, 'ws-a'), run(HEADER_UUID, 'ws-b'), run(undefined, 'ws-a')]
+  const filtered = filterRunsByWorkspace(runs, 'ws-a')
+  assert.equal(filtered.length, 2)
+  assert.ok(filtered.every((r) => r.workspaceId === 'ws-a'))
+})
+test('filterRunsByWorkspace with null is the global list', () => {
+  const runs = [run(HEADER_UUID, 'ws-a'), run(HEADER_UUID, 'ws-b')]
+  assert.equal(filterRunsByWorkspace(runs, null).length, 2)
+})
+// ─── Terminal presentation ───────────────────────────────────────────────────
+test('isTerminalRun covers the finished statuses only', () => {
+  for (const status of ['completed', 'failed', 'aborted'] as WorkflowRunStatus[]) {
+    assert.equal(isTerminalRun(status), true, status)
+  }
+  for (const status of ['pending', 'running', 'paused', 'unknown'] as WorkflowRunStatus[]) {
+    assert.equal(isTerminalRun(status), false, status)
+  }
+})
+test('runActiveAgentCount reports zero active agents on terminal runs even with stale running agents', () => {
+  const agents = [
+    { status: 'running' as WorkflowAgentStatus },
+    { status: 'running' as WorkflowAgentStatus },
+    { status: 'done' as WorkflowAgentStatus },
+  ]
+  for (const status of ['completed', 'failed', 'aborted'] as WorkflowRunStatus[]) {
+    assert.equal(runActiveAgentCount(agents, status), 0, status)
+  }
+})
+test('runActiveAgentCount counts running agents only while the run is live', () => {
+  const agents = [
+    { status: 'running' as WorkflowAgentStatus },
+    { status: 'running' as WorkflowAgentStatus },
+    { status: 'done' as WorkflowAgentStatus },
+  ]
+  assert.equal(runActiveAgentCount(agents, 'running'), 2)
+  assert.equal(runActiveAgentCount(agents, 'paused'), 2)
+  assert.equal(runActiveAgentCount(agents, 'pending'), 2)
+})
+// ─── Control eligibility ─────────────────────────────────────────────────────
+/** The extension's allowedActions, spelled out for every run status. */
+const CONTROL_MATRIX: Record<WorkflowRunStatus, { stop: boolean; resume: boolean }> = {
+  pending: { stop: false, resume: true },
+  running: { stop: true, resume: false },
+  paused: { stop: true, resume: true },
+  completed: { stop: false, resume: false },
+  failed: { stop: false, resume: true },
+  aborted: { stop: false, resume: false },
+  unknown: { stop: false, resume: false },
+}
+test('the control matrix holds for every run status, through both entry points', () => {
+  for (const [name, expected] of Object.entries(CONTROL_MATRIX)) {
+    const status = name as WorkflowRunStatus
+    // The gate used by the main-process IPC handler...
+    assert.equal(isWorkflowActionAllowed('stop', status), expected.stop, `stop/${status}`)
+    assert.equal(isWorkflowActionAllowed('resume', status), expected.resume, `resume/${status}`)
+    // ...and the predicates the workflow components render with are the same
+    // implementation, so the two can never encode different rules.
+    assert.equal(canAbortRun(status), expected.stop, `canAbortRun/${status}`)
+    assert.equal(canResumeRun(status), expected.resume, `canResumeRun/${status}`)
+  }
+})

package/apps/sessrumnir/src/renderer/src/utils/workflow-runs.ts ADDED Viewed

@@ -0,0 +1,84 @@
+import type { WorkflowAgentStatus, WorkflowRunStatus, WorkflowRunSummary } from '../../../shared/ipc-contracts'
+/**
+ * Resolve the Pi session identifier used to scope workflow runs.
+ *
+ * Persisted runs carry `run.sessionId` = Pi's header UUID (e.g.
+ * `01a01a28-f010-7b29-8312-21ba523d9edf`), so a session-scoped filter must
+ * compare UUIDs. When a session row's header is unreadable, `piSessionId`
+ * is missing; the session filename stem (`<timestamp>_<uuid>`) is still a
+ * valid source because its suffix IS the UUID. The raw stem — the registry
+ * key used by tags/archive — never matches a run's `sessionId`.
+ *
+ * Returns null when no UUID can be derived (defensive; session files are
+ * always named `<timestamp>_<uuid>.jsonl`).
+ */
+export function resolveRunSessionId(
+  piSessionId: string | undefined,
+  sessionId: string
+): string | null {
+  if (piSessionId) return piSessionId
+  const underscore = sessionId.indexOf('_')
+  if (underscore <= 0 || underscore >= sessionId.length - 1) return null
+  return sessionId.slice(underscore + 1)
+}
+/**
+ * The single filter used by the workflow navigator. Global mode (`null`)
+ * returns every run; session mode matches `run.sessionId` exactly, so a
+ * scoped panel can never show another session's runs.
+ */
+export function filterRunsBySession(
+  runs: readonly WorkflowRunSummary[],
+  sessionId: string | null
+): WorkflowRunSummary[] {
+  return sessionId ? runs.filter((run) => run.sessionId === sessionId) : [...runs]
+}
+/**
+ * The workspace-scope filter for the sidebar's Activity → Workflows entry.
+ * Global mode (`null`) returns every run; workspace mode matches
+ * `run.workspaceId` exactly, so a scoped panel can never show another
+ * project's runs. Applied AFTER the session filter (session scope wins).
+ */
+export function filterRunsByWorkspace(
+  runs: readonly WorkflowRunSummary[],
+  workspaceId: string | null
+): WorkflowRunSummary[] {
+  return workspaceId ? runs.filter((run) => run.workspaceId === workspaceId) : [...runs]
+}
+// ─── Terminal presentation ───────────────────────────────────────────────────
+// Persisted runs can freeze in-flight agents and currentPhase when a run is
+// aborted/failed mid-flight. These helpers are presentation-only: the
+// persisted agent statuses are never rewritten, they just stop looking active.
+/** Run-level statuses that are finished; nothing below them is still spinning. */
+export const TERMINAL_RUN_STATUSES: ReadonlySet<WorkflowRunStatus> = new Set([
+  'completed',
+  'failed',
+  'aborted',
+])
+export function isTerminalRun(status: WorkflowRunStatus): boolean {
+  return TERMINAL_RUN_STATUSES.has(status)
+}
+/**
+ * Agents that should render as actively working. On a terminal run a stale
+ * persisted `running` agent is frozen, not active — count it as idle.
+ */
+export function runActiveAgentCount(
+  agents: ReadonlyArray<{ status: WorkflowAgentStatus }>,
+  runStatus: WorkflowRunStatus
+): number {
+  if (isTerminalRun(runStatus)) return 0
+  return agents.filter((agent) => agent.status === 'running').length
+}
+// ─── Control eligibility ─────────────────────────────────────────────────────
+// One implementation, in shared/, so the main-process dispatch gate and these
+// renderer call sites cannot encode different rules. Re-exported here because
+// the workflow components already consume it from this module.
+export { canAbortRun, canResumeRun, isWorkflowActionAllowed } from '../../../shared/workflow-control'

package/apps/sessrumnir/src/renderer/tsconfig.json ADDED Viewed

@@ -0,0 +1,24 @@
+{
+  "extends": "../../tsconfig.json",
+  "compilerOptions": {
+    "outDir": "../../out/renderer",
+    "rootDir": "../..",
+    "lib": ["ES2022", "DOM", "DOM.Iterable"],
+    "jsx": "react-jsx",
+    "composite": true,
+    "declaration": true,
+    "noUnusedLocals": false,
+    "noUnusedParameters": false
+  },
+  "include": [
+    "./**/*.ts",
+    "./**/*.tsx",
+    "../shared/**/*.ts",
+    "./src/themes/*.json",
+    "../../resources/permission-rules.ts",
+    "../../resources/permission-rules.test.ts",
+    "../../resources/permission-prompt-text.ts",
+    "../../resources/permission-prompt-text.test.ts",
+    "../../resources/locales/*/translation.json"
+  ]
+}

package/apps/sessrumnir/src/shared/agent-engine-label.test.ts ADDED Viewed

@@ -0,0 +1,45 @@
+import { test } from 'node:test'
+import assert from 'node:assert/strict'
+import {
+  DEFAULT_AGENT_ENGINE_LABEL,
+  DEFAULT_AGENT_ENGINE_NAME,
+  agentEngineLabel,
+  agentEngineName,
+} from './agent-engine-label'
+/**
+ * The status bar named "Pi" while OMP was the configured engine, because the
+ * label came from a store default that only a running agent ever corrected.
+ * Every surface that names the agent now reads this one map.
+ *
+ * Two names live here: the narrative name the Allfather reads (Brokk, for either
+ * engine) and the technical CLI name (Pi / OMP) that Diagnostics and Settings
+ * quote as fact.
+ */
+test('both engines read as the one narrative agent', () => {
+  assert.equal(agentEngineLabel('pi'), 'Brokk')
+  assert.equal(agentEngineLabel('omp'), 'Brokk')
+})
+test('the technical name keeps each CLI literal', () => {
+  assert.equal(agentEngineName('pi'), 'Pi')
+  assert.equal(agentEngineName('omp'), 'OMP')
+})
+test('an unknown engine has no name, so callers choose their own fallback', () => {
+  // Session rows show nothing rather than guess; the status bar falls back to
+  // the default. Returning a name here would tag rows with the wrong CLI.
+  assert.equal(agentEngineLabel(null), null)
+  assert.equal(agentEngineLabel(undefined), null)
+  assert.equal(agentEngineName(null), null)
+  assert.equal(agentEngineName(undefined), null)
+})
+test('the fallbacks are real names, not placeholders', () => {
+  // The permission extension renders the narrative fallback when the GUI told it nothing.
+  assert.equal(DEFAULT_AGENT_ENGINE_LABEL, 'Brokk')
+  assert.equal(DEFAULT_AGENT_ENGINE_NAME, 'Pi')
+  assert.equal(agentEngineLabel('pi'), DEFAULT_AGENT_ENGINE_LABEL)
+  assert.equal(agentEngineName('pi'), DEFAULT_AGENT_ENGINE_NAME)
+})

package/apps/sessrumnir/src/shared/agent-engine-label.ts ADDED Viewed

@@ -0,0 +1,53 @@
+import type { AgentEngineKind } from './ipc-contracts'
+/**
+ * Display names for the two agent CLIs.
+ *
+ * Two names exist for each engine:
+ *  - the NARRATIVE name the Allfather reads on conversational surfaces (status
+ *    bar, empty chat, permission prompt, "is working" indicators, notifications).
+ *    The agent is one figure — Brokk — whichever CLI carries the turn; the
+ *    choice of executable is an implementation detail, not a character.
+ *  - the TECHNICAL name for Diagnostics and Settings, where the literal
+ *    executable (Pi / OMP) is a machine fact and must be quoted exactly.
+ *
+ * Shared by both processes because several surfaces name the running agent —
+ * the status bar, the empty chat state, the session row tags, and the
+ * permission prompt the agent itself raises — and they must agree.
+ */
+const AGENT_ENGINE_LABELS: Record<AgentEngineKind, string> = {
+  pi: 'Brokk',
+  omp: 'Brokk',
+}
+const AGENT_ENGINE_NAMES: Record<AgentEngineKind, string> = {
+  pi: 'Pi',
+  omp: 'OMP',
+}
+/**
+ * Fallback for a caller that must render something. Used where the engine is
+ * not yet known but a name is unavoidable, such as a permission prompt raised
+ * before the GUI told the extension which engine it belongs to.
+ */
+export const DEFAULT_AGENT_ENGINE_LABEL = AGENT_ENGINE_LABELS.pi
+/** Fallback technical name for Diagnostics/Settings when the engine is unknown. */
+export const DEFAULT_AGENT_ENGINE_NAME = AGENT_ENGINE_NAMES.pi
+/**
+ * The narrative display name for an engine, or null when the engine is unknown.
+ * Callers that must render something choose their own fallback; callers that tag
+ * rows show nothing rather than guess.
+ */
+export function agentEngineLabel(engine: AgentEngineKind | null | undefined): string | null {
+  return engine ? AGENT_ENGINE_LABELS[engine] : null
+}
+/**
+ * The literal CLI name (Pi / OMP) for Diagnostics and Settings, or null when the
+ * engine is unknown. These surfaces quote the executable as a fact.
+ */
+export function agentEngineName(engine: AgentEngineKind | null | undefined): string | null {
+  return engine ? AGENT_ENGINE_NAMES[engine] : null
+}