@kabmo-labs/kabmo 0.0.0-stage → 0.0.1

package/src/shared/lib/omp/session/prewarm-misc.test.ts

@@ -0,0 +1,326 @@
+/**
+ * @license
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * The leftover edges of the omp bridge: the prewarm trigger that must never
+ * block the UI, the telemetry content profiler whose badges the raw-messages
+ * panel renders, the additive column migration, the generated UI password, the
+ * synchronous transaction wrapper, and the persisted access-mode read. Each is
+ * small but each fails user-visibly: a prewarm that throws on an offline
+ * browser, a profiler that mislabels a tool, a migration that aborts startup,
+ * a transaction that commits a failed write.
+ */
+
+import { afterAll, beforeAll, describe, expect, test } from 'bun:test';
+import { mkdtempSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { removeDir } from '@/test-support/remove-dir';
+
+import { GENERATED_PASSWORD_LENGTH, PASSWORD_ALPHABET, UI_PASSWORD_ENV, generatePassword } from '@/shared/lib/auth/password';
+import { withTransaction } from '@/shared/lib/db/transaction.server';
+import { loadPersistedAccessMode } from '@/shared/lib/omp/config/access-mode.server';
+import { ACCESS_MODE_SETTING_KEY, DEFAULT_APPROVAL_MODE } from '@/shared/lib/omp/config/access-mode';
+import { TYPE_ORDER, contentProfile } from '@/shared/lib/omp/session/telemetry-blocks';
+import { spawnCwdForNewSession, triggerSessionPrewarm } from '@/shared/lib/omp/session/prewarm';
+import { migrateSessionStreamStateColumns } from '@/shared/lib/omp/session/schema-migrations';
+import { createDb } from '@/server/lib/db/client';
+import { hashPassword, verifyPassword } from '@/server/lib/auth/config';
+import { getDb } from '@/server/db.server';
+
+describe('triggerSessionPrewarm', () => {
+  /** The runner's own fetch, reached through `Bun` so a stub leaked onto the global cannot be mistaken for it. */
+const originalFetch = Bun.fetch;
+  const calls: Array<{ url: string; method?: string; body: unknown }> = [];
+  const post = (url: unknown, init?: { method?: string; body?: string }) => {
+    calls.push({ url: String(url), method: init?.method, body: JSON.parse(String(init?.body)) });
+    return Promise.resolve(new Response('{}', { status: 200 }));
+  };
+
+  beforeAll(() => { globalThis.fetch = post as unknown as typeof fetch; });
+  afterAll(() => { globalThis.fetch = originalFetch; });
+
+  test('posts the cwd, and the access mode only when one is given', () => {
+    calls.length = 0;
+    triggerSessionPrewarm('/tmp/project');
+    triggerSessionPrewarm('/tmp/project', 'yolo');
+    expect(calls).toEqual([
+      { url: '/api/agent/prewarm', method: 'POST', body: { cwd: '/tmp/project' } },
+      { url: '/api/agent/prewarm', method: 'POST', body: { cwd: '/tmp/project', accessMode: 'yolo' } },
+    ]);
+  });
+
+  test('an empty cwd sends nothing', () => {
+    calls.length = 0;
+    triggerSessionPrewarm('');
+    expect(calls).toEqual([]);
+  });
+
+  test('a rejected request is swallowed — prewarm must never reach the UI', () => {
+    // Fire-and-forget: the function returns undefined synchronously and the
+    // module attaches its own catch, so the rejection never becomes an
+    // unhandled one that would surface as a test-run error.
+    calls.length = 0;
+    globalThis.fetch = (() => Promise.reject(new Error('offline'))) as unknown as typeof fetch;
+    expect(triggerSessionPrewarm('/tmp/project')).toBeUndefined();
+    expect(calls).toEqual([]);
+    globalThis.fetch = post as unknown as typeof fetch;
+  });
+});
+
+describe('spawnCwdForNewSession', () => {
+  const folders = [
+    { id: 1, name: 'alpha', project_path: '/work/alpha', sessions: [{ id: 's-1' }] },
+    { id: 2, name: 'beta', project_path: null, sessions: [] },
+    { id: 3, name: 'gamma', project_path: '/work/gamma' },
+  ];
+
+  test('an explicit folder id wins, resolved loosely by string form', () => {
+    expect(spawnCwdForNewSession(folders, null, 3)).toBe('/work/gamma');
+    expect(spawnCwdForNewSession(folders, null, '3')).toBe('/work/gamma');
+  });
+
+  test('an unknown folder id yields no cwd rather than the wrong one', () => {
+    expect(spawnCwdForNewSession(folders, null, 99)).toBeNull();
+  });
+
+  test('otherwise the folder owning the active session is used', () => {
+    expect(spawnCwdForNewSession(folders, 's-1')).toBe('/work/alpha');
+  });
+
+  test('without a session match the first folder WITH a project path is used', () => {
+    // Neither the active session nor an id matched, so the first folder that
+    // carries a project path (alpha) wins; folder 2 has none.
+    expect(spawnCwdForNewSession(folders, 'unknown-session')).toBe('/work/alpha');
+  });
+
+  test('a matched folder with no project path falls back to its name', () => {
+    const sessionFolder = [{ id: 2, name: 'beta', project_path: null, sessions: [{ id: 's-9' }] }];
+    expect(spawnCwdForNewSession(sessionFolder, 's-9')).toBe('beta');
+    expect(spawnCwdForNewSession(sessionFolder, null, 2)).toBe('beta');
+  });
+
+  test('no matching folder at all yields null', () => {
+    expect(spawnCwdForNewSession([{ id: 2, name: 'beta', project_path: null }], null)).toBeNull();
+  });
+
+  test('no folders at all yields null', () => {
+    expect(spawnCwdForNewSession([], null)).toBeNull();
+    expect(spawnCwdForNewSession([], 's-1', 1)).toBeNull();
+  });
+});
+
+describe('contentProfile', () => {
+  test('the badge order is fixed', () => {
+    expect(TYPE_ORDER).toEqual(['reasoning', 'text', 'bash', 'read', 'edit', 'search', 'web', 'tool']);
+  });
+
+  test('a plain string is text, blank strings are nothing', () => {
+    expect(contentProfile('hello')).toEqual({ parts: ['text'], toolCalls: 0, toolChars: 0 });
+    expect(contentProfile('   ')).toEqual({ parts: [], toolCalls: 0, toolChars: 0 });
+    expect(contentProfile(undefined)).toEqual({ parts: [], toolCalls: 0, toolChars: 0 });
+  });
+
+  test('block types map to their badges, in TYPE_ORDER not arrival order', () => {
+    const profile = contentProfile([
+      { type: 'toolCall', name: 'read_file', arguments: { path: '/x' } },
+      { type: 'thinking', thinking: 'hmm' },
+      { type: 'text', text: 'hi' },
+    ]);
+    expect(profile.parts).toEqual(['reasoning', 'text', 'read']);
+    expect(profile.toolCalls).toBe(1);
+    expect(profile.toolChars).toBe(JSON.stringify({ path: '/x' }).length);
+  });
+
+  test('tool names pick the coarse category by keyword', () => {
+    const name = (tool: string) => contentProfile([{ type: 'toolCall', name: tool, arguments: {} }]).parts[0];
+    expect(name('bash')).toBe('bash');
+    expect(name('run_command')).toBe('bash');
+    expect(name('write_file')).toBe('edit');
+    expect(name('apply_patch')).toBe('edit');
+    expect(name('read_file')).toBe('read');
+    expect(name('web_search')).toBe('search');
+    expect(name('fetch_url')).toBe('web');
+    expect(name('mystery_tool')).toBe('tool');
+    expect(name(undefined as unknown as string)).toBe('tool');
+  });
+
+  test('toolResults, commands and code all count toward toolChars', () => {
+    const result = { type: 'toolResult', content: 'ok' };
+    expect(contentProfile([result]).toolChars).toBe(JSON.stringify(result).length);
+    expect(contentProfile([{ type: 'text', command: 'ls -la' }])).toMatchObject({ parts: ['text', 'bash'], toolChars: 6 });
+    expect(contentProfile([{ type: 'text', code: 'x = 1' }]).toolChars).toBe(5);
+  });
+
+  test('malformed blocks are skipped without throwing', () => {
+    const circular: Record<string, unknown> = { type: 'toolCall', name: 'bash' };
+    circular.arguments = circular;
+    expect(contentProfile([null, 'nope', 42, circular])).toEqual({ parts: ['bash'], toolCalls: 1, toolChars: 0 });
+  });
+});
+
+describe('migrateSessionStreamStateColumns', () => {
+  test('issues the additive owner, provider, and model columns', async () => {
+    const statements: string[] = [];
+    await migrateSessionStreamStateColumns({ exec: async (sql: string) => { statements.push(sql); } } as never);
+    expect(statements).toEqual([
+      'ALTER TABLE session_stream_state ADD COLUMN owner_pid INTEGER;',
+      'ALTER TABLE session_stream_state ADD COLUMN model_provider TEXT;',
+      'ALTER TABLE session_stream_state ADD COLUMN model_id TEXT;',
+    ]);
+  });
+
+  test('an already-present column is not an error', async () => {
+    // A fresh install gets the column from the DDL; the ALTER throws there and
+    // the migration must still resolve, having issued each statement once.
+    let attempts = 0;
+    await migrateSessionStreamStateColumns({
+      exec: async () => { attempts += 1; throw new Error('duplicate column name: owner_pid'); },
+    } as never);
+    expect(attempts).toBe(3);
+  });
+});
+
+describe('generatePassword', () => {
+  test('the alphabet is the 55 unambiguous characters', () => {
+    expect(PASSWORD_ALPHABET).toBe('ABCDEFGHJKLMNPQRSTUVWXYZabcdefghjkmnpqrstuvwxyz23456789');
+    expect(PASSWORD_ALPHABET).toHaveLength(55);
+    expect(PASSWORD_ALPHABET).not.toMatch(/[IOil01o]/);
+    expect(UI_PASSWORD_ENV).toBe('KABMO_UI_PASSWORD');
+    expect(GENERATED_PASSWORD_LENGTH).toBe(16);
+  });
+
+  test('a default password is 16 alphabet characters, and two differ', () => {
+    const first = generatePassword();
+    expect(first).toHaveLength(GENERATED_PASSWORD_LENGTH);
+    expect([...first].every((char) => PASSWORD_ALPHABET.includes(char))).toBe(true);
+    expect(generatePassword()).not.toBe(first);
+  });
+
+  test('an explicit length is honoured, floats floored', () => {
+    expect(generatePassword(1)).toHaveLength(1);
+    expect(generatePassword(64)).toHaveLength(64);
+    expect(generatePassword(7.9)).toHaveLength(7);
+  });
+
+  test('a nonsensical length falls back to the default', () => {
+    expect(generatePassword(0)).toHaveLength(GENERATED_PASSWORD_LENGTH);
+    expect(generatePassword(-3)).toHaveLength(GENERATED_PASSWORD_LENGTH);
+    expect(generatePassword(Number.NaN)).toHaveLength(GENERATED_PASSWORD_LENGTH);
+    expect(generatePassword(Number.POSITIVE_INFINITY)).toHaveLength(GENERATED_PASSWORD_LENGTH);
+  });
+});
+
+describe('withTransaction', () => {
+  const dir = mkdtempSync(join(tmpdir(), 'omp-tx-'));
+  const db = createDb(join(dir, 'tx.sqlite'));
+
+  beforeAll(async () => {
+    await db.exec('CREATE TABLE t (id INTEGER PRIMARY KEY, value TEXT NOT NULL)');
+  });
+
+  afterAll(() => {
+    db.raw.close();
+    removeDir(dir);
+  });
+
+  test('commits on success and returns the callback value', async () => {
+    const returned = withTransaction(db, () => {
+      db.raw.exec("INSERT INTO t (value) VALUES ('kept')");
+      return 'result';
+    });
+    expect(returned).toBe('result');
+    expect(await db.get<{ value: string }>('SELECT value FROM t WHERE value = ?', ['kept'])).toEqual({ value: 'kept' });
+  });
+
+  test('rolls back and rethrows when the callback throws', async () => {
+    const failure = new Error('write failed');
+    expect(() => withTransaction(db, () => {
+      db.raw.exec("INSERT INTO t (value) VALUES ('discarded')");
+      throw failure;
+    })).toThrow(failure);
+    expect(await db.get('SELECT value FROM t WHERE value = ?', ['discarded'])).toBeNull();
+    // The connection is still usable after the rollback.
+    expect(await db.all('SELECT value FROM t')).toEqual([{ value: 'kept' }]);
+  });
+});
+
+describe('hashPassword / verifyPassword', () => {
+  test('a hash verifies its own password and rejects a different one', async () => {
+    const hash = await hashPassword('correct horse battery staple');
+    expect(await verifyPassword('correct horse battery staple', hash)).toBe(true);
+    expect(await verifyPassword('correct horse battery stapl', hash)).toBe(false);
+    expect(await verifyPassword('', hash)).toBe(false);
+  });
+
+  test('the same password hashes differently each run (salted)', async () => {
+    const [first, second] = await Promise.all([hashPassword('same'), hashPassword('same')]);
+    expect(first).not.toBe(second);
+    expect(await verifyPassword('same', first)).toBe(true);
+    expect(await verifyPassword('same', second)).toBe(true);
+  });
+
+  test('an empty stored hash reads as a wrong password, not a crash', async () => {
+    // Reported separately: a NON-empty malformed hash throws on this runtime
+    // rather than answering false (see bugsFound), so only the empty case is
+    // pinned here.
+    expect(await verifyPassword('anything', '')).toBe(false);
+  });
+});
+
+describe('loadPersistedAccessMode', () => {
+  const dir = mkdtempSync(join(tmpdir(), 'omp-access-'));
+  const env = { path: Bun.env.KABMO_DB_PATH, db: Bun.env.DB_PATH, mock: Bun.env.MOCK, sync: Bun.env.SYNC_WORKSPACE };
+  const slotKey = '__kabmoDb' as const;
+  const savedSlot = (globalThis as Record<string, unknown>)[slotKey];
+
+  beforeAll(() => {
+    // The db handle is cached on globalThis across test files in one process;
+    // drop any handle another file opened so this file opens its own temp db.
+    (globalThis as Record<string, unknown>)[slotKey] = { promise: null, resolved: null };
+    Bun.env.KABMO_DB_PATH = join(dir, 'access.sqlite');
+    delete Bun.env.DB_PATH;
+    delete Bun.env.MOCK;
+    Bun.env.SYNC_WORKSPACE = 'false';
+  });
+
+  afterAll(() => {
+    // CLOSE the handle this block opened through `getDb()` before restoring the
+    // slot and deleting the tree; a bare slot restore abandons it, and Windows
+    // then fails the delete with EBUSY on the still-open connection.
+    globalThis.__kabmoDb?.resolved?.raw.close();
+    (globalThis as Record<string, unknown>)[slotKey] = savedSlot;
+    const restore = (key: 'KABMO_DB_PATH' | 'DB_PATH' | 'MOCK' | 'SYNC_WORKSPACE', value: string | undefined) => {
+      if (value === undefined) delete Bun.env[key];
+      else Bun.env[key] = value;
+    };
+    restore('KABMO_DB_PATH', env.path);
+    restore('DB_PATH', env.db);
+    restore('MOCK', env.mock);
+    restore('SYNC_WORKSPACE', env.sync);
+    removeDir(dir);
+  });
+
+  test('a missing row falls back to the default', async () => {
+    expect(await loadPersistedAccessMode()).toBe(DEFAULT_APPROVAL_MODE);
+  });
+
+  test('reads the bare mode string the settings writer stores', async () => {
+    // The generic writer stores non-objects with String(value): the row is
+    // `yolo`, not `"yolo"`, so a JSON.parse would be wrong here.
+    const db = await getDb();
+    await db.run('INSERT OR REPLACE INTO app_settings (key, value) VALUES (?, ?)', [ACCESS_MODE_SETTING_KEY, 'yolo']);
+    expect(await loadPersistedAccessMode()).toBe('yolo');
+    await db.run('INSERT OR REPLACE INTO app_settings (key, value) VALUES (?, ?)', [ACCESS_MODE_SETTING_KEY, 'sudo']);
+    expect(await loadPersistedAccessMode()).toBe(DEFAULT_APPROVAL_MODE);
+  });
+
+  test('any database error falls back to the default', async () => {
+    const db = await getDb();
+    await db.exec('ALTER TABLE app_settings RENAME TO app_settings_hidden');
+    expect(await loadPersistedAccessMode()).toBe(DEFAULT_APPROVAL_MODE);
+    await db.exec('ALTER TABLE app_settings_hidden RENAME TO app_settings');
+  });
+});

package/src/shared/lib/omp/session/prewarm.ts

@@ -0,0 +1,41 @@
+/**
+ * Client-side trigger for the server's prewarm pool: asking Kabmo server
+ * to start an idle `omp --mode rpc-ui` process for a project cwd before the
+ * first prompt is sent. Fired when the user opens a new (pending) session —
+ * the seconds between the click and the first send then hide the omp boot.
+ *
+ * Fire-and-forget by contract: a failed or slow prewarm must never block or
+ * error the UI. The next send spawns cold in that case, exactly as before.
+ */
+
+export function triggerSessionPrewarm(cwd: string, accessMode?: string): void {
+  if (!cwd) return;
+  fetch('/api/agent/prewarm', {
+    method: 'POST',
+    headers: { 'Content-Type': 'application/json' },
+    body: JSON.stringify({ cwd, ...(accessMode ? { accessMode } : {}) }),
+  }).catch(() => {});
+}
+
+export interface PrewarmFolderShape {
+  id: number | string;
+  name: string;
+  project_path?: string | null;
+  sessions?: { id: number | string }[];
+}
+
+/** Resolve the folder whose context a new session will inherit — the folder
+ *  owning the active session, falling back to the first bound folder. Matches
+ *  the cwd resolution of the send path, so the prewarmed process is spawned in
+ *  the directory the eventual spawn will actually use. */
+export function spawnCwdForNewSession(
+  folders: PrewarmFolderShape[],
+  activeSessionId: string | number | null,
+  folderId?: number | string,
+): string | null {
+  const target = folderId !== undefined
+    ? folders.find((f) => String(f.id) === String(folderId))
+    : folders.find((f) => f.sessions?.some((s) => String(s.id) === String(activeSessionId)))
+      ?? folders.find((f) => Boolean(f.project_path));
+  return target?.project_path || target?.name || null;
+}

package/src/shared/lib/omp/session/proc.test.ts

@@ -0,0 +1,256 @@
+/**
+ * @license
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * `proc://` parsing and result normalization.
+ *
+ * The grammar is omp's own (`internal-urls/proc-protocol.ts`): the bare URL
+ * lists, `<id>` reads, and only `/kill` and `/mode` are actions. The result
+ * shapes below are verbatim `details.proc` bags measured across 298 real calls
+ * in the author's session store, plus the legacy top-level `hub` shape omp
+ * used before the device existed.
+ */
+
+import { describe, expect, test } from 'bun:test';
+import {
+  bashServiceOf,
+  daemonTone,
+  formatProcDuration,
+  jobTone,
+  parseProcUrl,
+  procOpLabel,
+  procPathOf,
+  procUptime,
+  procViewOf,
+} from '@/shared/lib/omp/session/proc';
+
+describe('parseProcUrl', () => {
+  test('reads the bare listing', () => {
+    expect(parseProcUrl('proc://')).toEqual({ id: '', action: 'read' });
+  });
+
+  test('reads an id', () => {
+    expect(parseProcUrl('proc://kabmo-dev')).toEqual({ id: 'kabmo-dev', action: 'read' });
+  });
+
+  test('reads the two actions', () => {
+    expect(parseProcUrl('proc://kabmo-dev/kill')).toEqual({ id: 'kabmo-dev', action: 'kill' });
+    expect(parseProcUrl('proc://kabmo-dev/mode')).toEqual({ id: 'kabmo-dev', action: 'mode' });
+  });
+
+  test('ignores a query, a hash and a trailing slash', () => {
+    expect(parseProcUrl('proc://bg_1/kill?x=1')).toEqual({ id: 'bg_1', action: 'kill' });
+    expect(parseProcUrl('proc://bg_1/#frag')).toEqual({ id: 'bg_1', action: 'read' });
+    expect(parseProcUrl('proc://bg_1/kill/')).toEqual({ id: 'bg_1', action: 'kill' });
+  });
+
+  test('rejects another scheme', () => {
+    expect(parseProcUrl('xd://lsp')).toBeUndefined();
+    expect(parseProcUrl('src/x.ts')).toBeUndefined();
+    expect(parseProcUrl(undefined)).toBeUndefined();
+  });
+});
+
+describe('procPathOf', () => {
+  test('prefers the result target over the arguments', () => {
+    expect(procPathOf({ target: 'proc://a', input: { path: 'proc://b' } })).toBe('proc://a');
+  });
+
+  test('falls back to the arguments path', () => {
+    expect(procPathOf({ input: { path: 'proc://a' } })).toBe('proc://a');
+  });
+
+  test('returns undefined for a file write', () => {
+    expect(procPathOf({ target: 'src/x.ts', input: { path: 'src/x.ts' } })).toBeUndefined();
+  });
+});
+
+describe('procViewOf — write /kill of a service', () => {
+  test('reads the op and the daemon snapshot', () => {
+    const view = procViewOf({
+      target: 'proc://kabmo-dev/kill',
+      input: { path: 'proc://kabmo-dev/kill' },
+      details: {
+        proc: {
+          action: 'stop',
+          daemon: {
+            name: 'kabmo-dev',
+            id: '7bf84d40',
+            state: 'exited',
+            startedAt: 1_791_433_388_038,
+            exitedAt: 1_791_434_377_079,
+            exitCode: 0,
+            restartCount: 0,
+            outputBytes: 4540,
+            persist: false,
+            detached: false,
+          },
+        },
+      },
+    });
+    expect(view?.op).toBe('stop');
+    expect(view?.daemon).toMatchObject({ name: 'kabmo-dev', state: 'exited', exitCode: 0 });
+    expect(procUptime(view!.daemon!, 0)?.label).toBe('16m 29s');
+  });
+
+  test('reads a stdin payload', () => {
+    const view = procViewOf({
+      target: 'proc://kabmo-dev',
+      details: { proc: { action: 'stdin', daemon: { name: 'kabmo-dev', state: 'ready', pid: 22985 }, input: '{"kill":true}' } },
+    });
+    expect(view?.op).toBe('stdin');
+    expect(view?.input).toBe('{"kill":true}');
+    expect(view?.daemon?.pid).toBe(22985);
+  });
+
+  test('reads a mode write', () => {
+    const view = procViewOf({
+      target: 'proc://kabmo-3599/mode',
+      details: { proc: { action: 'mode', daemon: { name: 'kabmo-3599', state: 'ready', persist: true }, mode: 'persist' } },
+    });
+    expect(view?.op).toBe('mode');
+    expect(view?.mode).toBe('persist');
+  });
+});
+
+describe('procViewOf — read', () => {
+  test('reads one service with its log and terminal rows', () => {
+    const view = procViewOf({
+      target: 'proc://ompdev',
+      details: {
+        proc: {
+          daemon: { name: 'ompdev', state: 'failed', startedAt: 1, exitedAt: 2, exitCode: 1 },
+          log: '$ bun run dev\nboom',
+          terminalRows: ['$ bun run dev', 'boom'],
+        },
+      },
+    });
+    expect(view?.daemon?.state).toBe('failed');
+    expect(view?.terminalRows).toEqual(['$ bun run dev', 'boom']);
+  });
+
+  test('reads the listing', () => {
+    const view = procViewOf({
+      target: 'proc://',
+      details: {
+        proc: {
+          jobs: [{ id: 'bg_1', type: 'bash', status: 'running', label: 'bun run probe.ts', durationMs: 1200 }],
+          agents: [{ id: 'Sleeper', activity: 'thinking', ageMs: 4200, live: true }],
+          daemons: [{ name: 'omp.lsp.mux', state: 'ready', pid: 400 }],
+        },
+      },
+    });
+    expect(view?.jobs).toHaveLength(1);
+    expect(view?.daemons).toHaveLength(1);
+    expect(view?.agents).toHaveLength(1);
+    expect(view?.id).toBeUndefined();
+  });
+
+  test('reads one background job', () => {
+    const view = procViewOf({
+      target: 'proc://bg_10',
+      details: { proc: { job: { id: 'bg_10', type: 'bash', status: 'running', label: 'probe', durationMs: 147_461 }, log: '' } },
+    });
+    expect(view?.job?.id).toBe('bg_10');
+    expect(view?.daemon).toBeUndefined();
+  });
+
+  test('reads a job cancellation', () => {
+    const view = procViewOf({
+      target: 'proc://bg_2/kill',
+      details: {
+        proc: {
+          op: 'cancel',
+          jobs: [{ id: 'bg_2', type: 'bash', status: 'cancelled', label: 'smoke', durationMs: 81_289 }],
+          cancelled: [{ id: 'bg_2', status: 'cancelled' }],
+        },
+      },
+    });
+    expect(view?.op).toBe('cancel');
+    expect(view?.cancelled).toEqual([{ id: 'bg_2', status: 'cancelled' }]);
+  });
+});
+
+describe('procViewOf — legacy hub shape', () => {
+  test('reads a daemon off the top level of details', () => {
+    const view = procViewOf({
+      target: 'proc://kabmo-dev',
+      details: { op: 'start', daemon: { name: 'kabmo-dev', state: 'ready', pid: 22985 } },
+    });
+    expect(view?.op).toBe('start');
+    expect(view?.daemon?.state).toBe('ready');
+  });
+
+  test('reads a job list off the top level of details', () => {
+    const view = procViewOf({
+      details: { op: 'jobs', jobs: [{ id: 'bg_1', status: 'running' }], meta: {} },
+    });
+    expect(view?.jobs).toHaveLength(1);
+  });
+
+  test('returns undefined for an unrelated tool result', () => {
+    expect(procViewOf({ target: 'src/x.ts', details: { diff: '+1' } })).toBeUndefined();
+  });
+});
+
+describe('bashServiceOf', () => {
+  test('reads a service launch off a bash result', () => {
+    const service = bashServiceOf({ details: { service: { name: 'kabmo-dev', state: 'ready', ready: true, timedOut: false, pid: 22985 } } });
+    expect(service).toMatchObject({ name: 'kabmo-dev', state: 'ready', pid: 22985 });
+  });
+
+  test('returns undefined for a plain command', () => {
+    expect(bashServiceOf({ details: { exitCode: 0 } })).toBeUndefined();
+  });
+});
+
+describe('tones and durations', () => {
+  test('maps daemon states', () => {
+    expect(daemonTone('ready')).toBe('ok');
+    expect(daemonTone('running')).toBe('ok');
+    expect(daemonTone('failed')).toBe('error');
+    expect(daemonTone('starting')).toBe('warn');
+    expect(daemonTone('exited')).toBe('muted');
+    expect(daemonTone(undefined)).toBe('muted');
+  });
+
+  test('maps job statuses', () => {
+    expect(jobTone('completed')).toBe('ok');
+    expect(jobTone('failed')).toBe('error');
+    expect(jobTone('cancelled')).toBe('warn');
+    expect(jobTone('running')).toBe('muted');
+  });
+
+  test('formats a duration at each scale', () => {
+    expect(formatProcDuration(840)).toBe('840ms');
+    expect(formatProcDuration(45_000)).toBe('45s');
+    expect(formatProcDuration(123_000)).toBe('2m 3s');
+    expect(formatProcDuration(3_930_000)).toBe('1h 5m');
+  });
+
+  test('an exited service reports the span it RAN, not the time since it started', () => {
+    const uptime = procUptime({ startedAt: 1000, exitedAt: 2000 }, 999_999);
+    expect(uptime?.ms).toBe(1000);
+    expect(uptime?.label).toBe('1s');
+  });
+
+  test('a live service reports the time since it started', () => {
+    expect(procUptime({ startedAt: 1000 }, 5000)?.ms).toBe(4000);
+  });
+
+  test('no start time means no uptime', () => {
+    expect(procUptime({})).toBeUndefined();
+  });
+
+  test('labels each op', () => {
+    expect(procOpLabel('stop')).toBe('stop');
+    expect(procOpLabel('kill')).toBe('stop');
+    expect(procOpLabel('stdin')).toBe('stdin');
+    expect(procOpLabel('mode')).toBe('mode');
+    expect(procOpLabel('cancel')).toBe('cancel');
+    expect(procOpLabel('list')).toBe('list');
+    expect(procOpLabel('read')).toBe('list');
+  });
+});