@ghostlygawd/hangar 0.2.0

package/lib/git.js

@@ -0,0 +1,96 @@
+import { execFile } from 'node:child_process'
+
+/** Run git with args in cwd. Resolves {ok, stdout, stderr, code}; never rejects. */
+export function git(args, cwd) {
+  return new Promise((resolve) => {
+    execFile('git', args, { cwd, windowsHide: true, maxBuffer: 16 * 1024 * 1024 }, (err, stdout, stderr) => {
+      resolve({
+        ok: !err,
+        code: err?.code ?? 0,
+        stdout: String(stdout).trimEnd(),
+        stderr: String(stderr).trimEnd(),
+      })
+    })
+  })
+}
+
+/** True only for the top-level directory of a working tree. */
+export async function isRepoRoot(dir) {
+  const r = await git(['rev-parse', '--show-toplevel'], dir)
+  if (!r.ok) return false
+  return normalize(r.stdout) === normalize(dir)
+}
+
+function normalize(p) {
+  return p.replace(/[\\/]+$/, '').replace(/\//g, '\\').toLowerCase()
+}
+
+/** The repo's default branch: origin/HEAD if known, else main/master if present, else current. */
+export async function defaultBranch(repoDir) {
+  const remote = await git(['symbolic-ref', '--short', 'refs/remotes/origin/HEAD'], repoDir)
+  if (remote.ok) return remote.stdout.replace(/^origin\//, '')
+  for (const candidate of ['main', 'master']) {
+    const r = await git(['show-ref', '--verify', '--quiet', `refs/heads/${candidate}`], repoDir)
+    if (r.ok) return candidate
+  }
+  const current = await git(['branch', '--show-current'], repoDir)
+  return current.stdout || 'main'
+}
+
+export async function currentBranch(dir) {
+  const r = await git(['branch', '--show-current'], dir)
+  return r.stdout
+}
+
+export async function isDirty(dir) {
+  const r = await git(['status', '--porcelain'], dir)
+  return { dirty: r.ok && r.stdout.length > 0, detail: r.stdout }
+}
+
+/** [ahead, behind] of branch relative to base. */
+export async function aheadBehind(repoDir, branch, base) {
+  const r = await git(['rev-list', '--left-right', '--count', `${base}...${branch}`], repoDir)
+  if (!r.ok) return { ahead: 0, behind: 0 }
+  const [behind, ahead] = r.stdout.split(/\s+/).map(Number)
+  return { ahead: ahead || 0, behind: behind || 0 }
+}
+
+/** Files changed / insertions / deletions of branch vs base (three-dot: since divergence). */
+export async function diffStat(repoDir, branch, base) {
+  const r = await git(['diff', '--shortstat', `${base}...${branch}`], repoDir)
+  const out = { files: 0, insertions: 0, deletions: 0 }
+  if (!r.ok || !r.stdout) return out
+  const files = r.stdout.match(/(\d+) files? changed/)
+  const ins = r.stdout.match(/(\d+) insertions?/)
+  const del = r.stdout.match(/(\d+) deletions?/)
+  if (files) out.files = Number(files[1])
+  if (ins) out.insertions = Number(ins[1])
+  if (del) out.deletions = Number(del[1])
+  return out
+}
+
+/** True when branch is fully merged into base. */
+export async function isMerged(repoDir, branch, base) {
+  const r = await git(['merge-base', '--is-ancestor', branch, base], repoDir)
+  return r.ok
+}
+
+/** Parse `git worktree list --porcelain` into [{path, branch, head}]. */
+export async function worktrees(repoDir) {
+  const r = await git(['worktree', 'list', '--porcelain'], repoDir)
+  if (!r.ok) return []
+  const out = []
+  let entry = null
+  for (const line of r.stdout.split('\n')) {
+    if (line.startsWith('worktree ')) {
+      if (entry) out.push(entry)
+      entry = { path: line.slice('worktree '.length), branch: null, head: null }
+    } else if (line.startsWith('branch ') && entry) {
+      entry.branch = line.slice('branch '.length).replace(/^refs\/heads\//, '')
+    } else if (line.startsWith('HEAD ') && entry) {
+      entry.head = line.slice('HEAD '.length)
+    }
+  }
+  if (entry) out.push(entry)
+  return out
+}

package/lib/launch.js

@@ -0,0 +1,81 @@
+import { execFile, spawn } from 'node:child_process'
+import { claudeHomeFor } from './paths.js'
+
+/** Active windows Hangar opened this run: id → {pid, cwd, profile, startedAt} */
+export const launched = new Map()
+let nextId = 1
+
+function hasWindowsTerminal() {
+  return new Promise((resolve) => {
+    execFile('where.exe', ['wt'], { windowsHide: true }, (err) => resolve(!err))
+  })
+}
+
+/** Single-quote a string for embedding in a PowerShell single-quoted literal. */
+function psq(s) {
+  return `'${String(s).replace(/'/g, "''")}'`
+}
+
+/** The interactive PowerShell command that sets the profile, cd's in, and starts claude. */
+export function buildInner({ cwd, profile = 'default', prompt = '' }) {
+  const env = profile !== 'default' ? `$env:CLAUDE_CONFIG_DIR=${psq(claudeHomeFor(profile))}; ` : ''
+  const claudeArgs = prompt ? ` ${psq(prompt)}` : ''
+  return `${env}Set-Location ${psq(cwd)}; claude${claudeArgs}`
+}
+
+/**
+ * Windows Terminal parses `;` in its own command line as a tab/pane delimiter,
+ * so the inner command's semicolons would split into separate tabs — setting
+ * CLAUDE_CONFIG_DIR in one and starting claude (under the wrong account) in
+ * another. Passing the command as a base64 `-EncodedCommand` blob means wt sees
+ * no bare `;` at all. Verified: base64 is [A-Za-z0-9+/=] only.
+ */
+export function wtLaunchArgs(cwd, inner) {
+  const encoded = Buffer.from(inner, 'utf16le').toString('base64')
+  return ['-w', '0', 'nt', '-d', cwd, 'powershell', '-NoExit', '-NoProfile', '-ExecutionPolicy', 'Bypass', '-EncodedCommand', encoded]
+}
+
+/**
+ * Open a REAL interactive Claude Code window. Never headless, never SDK:
+ * a visible terminal the user can type in, exactly like opening it by hand.
+ * Returns {ok, id, pid?} — pid is known on the PowerShell-window path.
+ */
+export async function launchSession({ cwd, profile = 'default', prompt = '' }) {
+  const inner = buildInner({ cwd, profile, prompt })
+
+  if (await hasWindowsTerminal()) {
+    // wt opens its own window tree; PID of the session shell isn't directly addressable — liveness is best-effort
+    const child = spawn('wt', wtLaunchArgs(cwd, inner), {
+      detached: true, stdio: 'ignore', windowsHide: false,
+    })
+    child.unref()
+    const id = `w${nextId++}`
+    launched.set(id, { id, pid: null, cwd, profile, startedAt: new Date().toISOString(), via: 'wt' })
+    return { ok: true, id, pid: null }
+  }
+
+  // Plain PowerShell window via Start-Process -PassThru so we learn the real PID.
+  const outer = `$p = Start-Process -FilePath 'powershell' -ArgumentList @('-NoExit','-NoProfile','-ExecutionPolicy','Bypass','-Command',${psq(inner)}) -WorkingDirectory ${psq(cwd)} -PassThru; $p.Id`
+  const pid = await new Promise((resolve) => {
+    execFile('powershell', ['-NoProfile', '-Command', outer], { windowsHide: true }, (err, stdout) => {
+      const n = parseInt(String(stdout).trim(), 10)
+      resolve(err || !Number.isFinite(n) ? null : n)
+    })
+  })
+  if (pid === null) return { ok: false, error: 'Failed to open a PowerShell window for the session.' }
+  const id = `w${nextId++}`
+  launched.set(id, { id, pid, cwd, profile, startedAt: new Date().toISOString(), via: 'powershell' })
+  return { ok: true, id, pid }
+}
+
+export function liveness() {
+  const out = []
+  for (const s of launched.values()) {
+    let alive = null
+    if (s.pid != null) {
+      try { process.kill(s.pid, 0); alive = true } catch { alive = false }
+    }
+    out.push({ ...s, alive })
+  }
+  return out
+}

package/lib/limits.js

@@ -0,0 +1,55 @@
+/**
+ * Limit detection over structured fields ONLY. Message text is never read —
+ * a transcript whose *content* talks about rate limits must never trigger.
+ * Ported from the proven detector; pure function, no IO.
+ *
+ * Returns { kind, resetsAt? } or null.
+ */
+export function detectLimit(msg) {
+  if (!msg || typeof msg !== 'object') return null
+
+  // 1. explicit rate-limit event with rejected status
+  if (msg.type === 'rate_limit_event') {
+    const info = msg.rate_limit_info
+    if (info && info.status === 'rejected') {
+      const kind = info.rateLimitType ? `rate_limit_event:${info.rateLimitType}` : 'rate_limit_event:rejected'
+      return { kind, resetsAt: toIso(info.resetsAt) }
+    }
+    return null
+  }
+
+  // 2. api retry caused by a rate limit (429); 529 overload is transient and never parks
+  if (msg.type === 'system' && msg.subtype === 'api_retry') {
+    if (msg.error === 'rate_limit' || msg.error_status === 429) {
+      return { kind: 'api_retry:rate_limit', resetsAt: undefined }
+    }
+    return null
+  }
+
+  // 3. assistant turn flagged with a structured rate-limit error
+  if (msg.type === 'assistant' && msg.error === 'rate_limit') {
+    return { kind: 'assistant:rate_limit', resetsAt: undefined }
+  }
+
+  // 4. terminal result blocked by a limit
+  if (
+    msg.type === 'result' &&
+    msg.terminal_reason === 'blocking_limit' &&
+    msg.subtype !== 'success' &&
+    msg.is_error === true
+  ) {
+    return { kind: 'result:blocking_limit', resetsAt: undefined }
+  }
+
+  return null
+}
+
+function toIso(value) {
+  if (typeof value !== 'number' || !Number.isFinite(value)) return undefined
+  const ms = value >= 1e12 ? value : value * 1000
+  try {
+    return new Date(ms).toISOString()
+  } catch {
+    return undefined
+  }
+}

package/lib/paths.js

@@ -0,0 +1,40 @@
+import os from 'node:os'
+import path from 'node:path'
+
+/** Root for all Hangar state. Never inside a repo, never inside ~/.claude. */
+export const HANGAR_HOME = process.env.HANGAR_HOME || path.join(os.homedir(), '.hangar')
+
+export const CONFIG_FILE = path.join(HANGAR_HOME, 'config.json')
+export const REPOS_FILE = path.join(HANGAR_HOME, 'repos.json')
+export const PROFILES_FILE = path.join(HANGAR_HOME, 'profiles.json')
+export const PARKED_FILE = path.join(HANGAR_HOME, 'parked.json')
+
+/** Where profile config homes live. The "default" profile is the user's normal ~/.claude. */
+export const PROFILE_HOMES = path.join(HANGAR_HOME, 'profiles')
+
+/** The one canonical default config — reused by the server, the CLI, and the tunnel. */
+export const DEFAULT_CONFIG = { port: 4870, bind: '127.0.0.1', token: '', defaultProfile: 'default' }
+
+export function defaultClaudeHome() {
+  return process.env.CLAUDE_CONFIG_DIR || path.join(os.homedir(), '.claude')
+}
+
+/** Config home for a profile name. "default" → the user's normal claude home. */
+export function claudeHomeFor(profileName) {
+  if (!profileName || profileName === 'default') return defaultClaudeHome()
+  return path.join(PROFILE_HOMES, profileName)
+}
+
+/** Claude Code's transcript root for a given config home. */
+export function projectsDirFor(claudeHome) {
+  return path.join(claudeHome, 'projects')
+}
+
+/**
+ * Claude Code names each project's transcript directory by replacing every
+ * non-alphanumeric character of the absolute cwd with '-'.
+ * Verified against real ~/.claude/projects entries on Windows.
+ */
+export function mungeCwd(absPath) {
+  return absPath.replace(/[^a-zA-Z0-9]/g, '-')
+}

package/lib/profiles.js

@@ -0,0 +1,58 @@
+import fs from 'node:fs'
+import { JsonStore } from './store.js'
+import { PROFILES_FILE, PROFILE_HOMES, claudeHomeFor } from './paths.js'
+import path from 'node:path'
+
+const SAFE_NAME = /^[a-zA-Z0-9][a-zA-Z0-9._-]{0,31}$/
+// Registry entries must never carry anything credential-shaped.
+const CREDENTIALISH = /credential|token|api[_-]?key|secret|password|auth|bearer/i
+
+export const profilesStore = new JsonStore(PROFILES_FILE, { version: 1, profiles: [] })
+
+export function validProfileName(name) {
+  return SAFE_NAME.test(name) && !name.includes('..') && name !== 'default'
+}
+
+/** Reject any entry that smells like a credential made it into the registry. */
+export function validateRegistry(reg) {
+  if (!reg || typeof reg !== 'object' || !Array.isArray(reg.profiles)) return 'registry malformed'
+  for (const p of reg.profiles) {
+    for (const key of Object.keys(p)) {
+      if (CREDENTIALISH.test(key)) return `field "${key}" looks credential-like; profiles carry names only`
+    }
+    if (typeof p.name !== 'string' || !SAFE_NAME.test(p.name)) return `profile name "${p.name}" is not a safe segment`
+  }
+  return null
+}
+
+/** All profiles, always including the implicit default. */
+export function listProfiles() {
+  const err = validateRegistry(profilesStore.data)
+  const extras = err ? [] : profilesStore.data.profiles
+  return [
+    { name: 'default', displayName: 'Default (~/.claude)', home: claudeHomeFor('default'), implicit: true },
+    ...extras.map((p) => ({ ...p, home: claudeHomeFor(p.name), implicit: false })),
+  ]
+}
+
+export function addProfile(name, displayName) {
+  if (!validProfileName(name)) {
+    return { ok: false, status: 400, error: `Invalid profile name "${name}".` }
+  }
+  if (profilesStore.data.profiles.some((p) => p.name === name)) {
+    return { ok: true, existed: true }
+  }
+  const entry = { name, addedAt: new Date().toISOString() }
+  if (displayName) entry.displayName = String(displayName)
+  profilesStore.update((d) => d.profiles.push(entry))
+  fs.mkdirSync(path.join(PROFILE_HOMES, name), { recursive: true })
+  return { ok: true, existed: false, home: claudeHomeFor(name) }
+}
+
+export function removeProfile(name) {
+  if (name === 'default') return { ok: false, status: 400, error: 'The default profile cannot be removed.' }
+  const before = profilesStore.data.profiles.length
+  profilesStore.update((d) => { d.profiles = d.profiles.filter((p) => p.name !== name) })
+  // the config home on disk is left alone — it may hold a login; removing tracking is not destroying credentials
+  return { ok: true, removed: profilesStore.data.profiles.length < before }
+}

package/lib/spaces.js

@@ -0,0 +1,155 @@
+import fs from 'node:fs'
+import path from 'node:path'
+import {
+  git, defaultBranch, isDirty, aheadBehind, diffStat, isMerged, worktrees,
+} from './git.js'
+
+export const SPACES_DIR = '.hangar-spaces'
+const NAME_RE = /^[a-zA-Z0-9][a-zA-Z0-9._-]{0,63}$/
+
+export function validSpaceName(name) {
+  return NAME_RE.test(name) && !name.includes('..')
+}
+
+function spacesRoot(repoPath) {
+  return path.join(repoPath, SPACES_DIR)
+}
+
+export function spacePath(repoPath, name) {
+  return path.join(spacesRoot(repoPath), name)
+}
+
+/** Keep spaces invisible to the repo's own status without touching .gitignore. */
+function ensureExcluded(repoPath) {
+  const excludeFile = path.join(repoPath, '.git', 'info', 'exclude')
+  try {
+    const current = fs.existsSync(excludeFile) ? fs.readFileSync(excludeFile, 'utf8') : ''
+    if (!current.split(/\r?\n/).includes(`${SPACES_DIR}/`)) {
+      fs.mkdirSync(path.dirname(excludeFile), { recursive: true })
+      fs.appendFileSync(excludeFile, `${current.endsWith('\n') || current === '' ? '' : '\n'}${SPACES_DIR}/\n`)
+    }
+  } catch {
+    // a worktree-style .git file or odd layout — exclusion is cosmetic, never fatal
+  }
+}
+
+export async function listSpaces(repoPath) {
+  const root = spacesRoot(repoPath)
+  const [all, base] = await Promise.all([worktrees(repoPath), defaultBranch(repoPath)])
+  const mine = all.filter((w) => normalize(w.path).startsWith(normalize(root) + path.sep.toLowerCase()))
+  return Promise.all(mine.map(async (w) => {
+    const [dirty, ab, stat, merged] = await Promise.all([
+      isDirty(w.path),
+      w.branch ? aheadBehind(repoPath, w.branch, base) : { ahead: 0, behind: 0 },
+      w.branch ? diffStat(repoPath, w.branch, base) : { files: 0, insertions: 0, deletions: 0 },
+      w.branch ? isMerged(repoPath, w.branch, base) : false,
+    ])
+    return {
+      name: path.basename(w.path),
+      path: w.path,
+      branch: w.branch,
+      base,
+      dirty: dirty.dirty,
+      dirtyDetail: dirty.detail,
+      ahead: ab.ahead,
+      behind: ab.behind,
+      diff: stat,
+      merged,
+      deletable: merged && !dirty.dirty,
+    }
+  }))
+}
+
+export async function createSpace(repoPath, name) {
+  if (!validSpaceName(name)) {
+    return { ok: false, status: 400, error: `Invalid space name "${name}". Use letters, digits, dot, dash, underscore (max 64).` }
+  }
+  const target = spacePath(repoPath, name)
+  if (fs.existsSync(target)) {
+    return { ok: false, status: 409, error: `Space "${name}" already exists.` }
+  }
+  ensureExcluded(repoPath)
+  const base = await defaultBranch(repoPath)
+  const branch = `space/${name}`
+  const r = await git(['worktree', 'add', target, '-b', branch, base], repoPath)
+  if (!r.ok) {
+    return { ok: false, status: 500, error: `git worktree add failed: ${r.stderr || r.stdout}` }
+  }
+  return { ok: true, name, path: target, branch, base }
+}
+
+/** True only when `p` resolves strictly inside `root` (after normalization). */
+function isInside(root, p) {
+  return normalize(p).startsWith(normalize(root) + '\\')
+}
+
+/**
+ * The provably-safe rule: delete only when merged into base AND clean.
+ * Force is a separate, explicit path that must echo the space name back.
+ *
+ * Worktree safety is SACRED, so the delete path is validated as strictly as
+ * the create path: the name is checked, the resolved target must live inside
+ * this repo's .hangar-spaces root, and we refuse to touch the default-branch
+ * checkout or anything that escapes the spaces dir.
+ */
+export async function deleteSpace(repoPath, name, { force = false, confirm = '' } = {}) {
+  if (!validSpaceName(name)) {
+    return { ok: false, status: 400, error: `Invalid space name "${name}". Use letters, digits, dot, dash, underscore (max 64).` }
+  }
+  const root = spacesRoot(repoPath)
+  const target = spacePath(repoPath, name)
+  // containment: the resolved target must live strictly inside this repo's spaces root
+  if (!isInside(root, target)) {
+    return { ok: false, status: 400, error: `Refusing to delete "${name}": it resolves outside ${SPACES_DIR}.` }
+  }
+
+  const all = await worktrees(repoPath)
+  const entry = all.find((w) => normalize(w.path) === normalize(target))
+  if (!entry) return { ok: false, status: 404, error: `Space "${name}" not found.` }
+
+  // SACRED, belt-and-braces: only ever remove a worktree that physically lives
+  // under this repo's .hangar-spaces, never the repo checkout, never the default branch.
+  if (!isInside(root, entry.path)) {
+    return { ok: false, status: 403, error: `Refusing to remove a worktree outside ${SPACES_DIR}.` }
+  }
+  if (normalize(entry.path) === normalize(repoPath)) {
+    return { ok: false, status: 403, error: 'Refusing to remove the repository checkout itself.' }
+  }
+
+  const base = await defaultBranch(repoPath)
+  if (entry.branch && entry.branch === base) {
+    return { ok: false, status: 403, error: `Refusing to remove a worktree with the default branch ("${base}") checked out.` }
+  }
+
+  const dirty = await isDirty(target)
+  const merged = entry.branch ? await isMerged(repoPath, entry.branch, base) : false
+
+  if (!force) {
+    if (dirty.dirty) {
+      return { ok: false, status: 409, error: `Space "${name}" has uncommitted changes:\n${dirty.detail}` }
+    }
+    if (!entry.branch) {
+      return { ok: false, status: 409, error: `Space "${name}" is on a detached HEAD (no branch). Commit to a branch, or force-delete to discard it.` }
+    }
+    if (!merged) {
+      return { ok: false, status: 409, error: `Branch "${entry.branch}" is not merged into ${base}. Merge it first, or force-delete to discard it.` }
+    }
+  } else if (confirm !== name) {
+    return { ok: false, status: 400, error: `Force-delete requires confirm to equal the space name ("${name}").` }
+  }
+
+  const discarded = force ? { dirty: dirty.dirty, unmerged: !merged, dirtyDetail: dirty.detail } : null
+  const rm = await git(['worktree', 'remove', force ? '--force' : '--no-force', target], repoPath)
+  if (!rm.ok) return { ok: false, status: 500, error: `git worktree remove failed: ${rm.stderr}` }
+  let warning = null
+  if (entry.branch) {
+    const br = await git(['branch', force ? '-D' : '-d', entry.branch], repoPath)
+    if (!br.ok) warning = `Space removed, but branch "${entry.branch}" could not be deleted: ${br.stderr || br.stdout}`
+  }
+  await git(['worktree', 'prune'], repoPath)
+  return { ok: true, name, discarded, ...(warning ? { warning } : {}) }
+}
+
+function normalize(p) {
+  return p.replace(/\//g, '\\').replace(/\\+$/, '').toLowerCase()
+}

package/lib/store.js

@@ -0,0 +1,48 @@
+import fs from 'node:fs'
+import path from 'node:path'
+
+/**
+ * One JSON file, loaded once, written atomically (temp + rename).
+ * Rename retries cover Windows AV/indexer EPERM blips.
+ */
+export class JsonStore {
+  constructor(filePath, fallback) {
+    this.filePath = filePath
+    this.fallback = fallback
+    this.data = this.#load()
+  }
+
+  #load() {
+    try {
+      const raw = fs.readFileSync(this.filePath, 'utf8')
+      return JSON.parse(raw)
+    } catch {
+      return structuredClone(this.fallback)
+    }
+  }
+
+  save() {
+    fs.mkdirSync(path.dirname(this.filePath), { recursive: true })
+    const tmp = `${this.filePath}.${process.pid}.tmp`
+    fs.writeFileSync(tmp, JSON.stringify(this.data, null, 2))
+    for (let attempt = 0; ; attempt++) {
+      try {
+        fs.renameSync(tmp, this.filePath)
+        return
+      } catch (err) {
+        if (attempt >= 4) {
+          try { fs.unlinkSync(tmp) } catch { /* best effort */ }
+          throw err
+        }
+        const wait = 25 * 2 ** attempt
+        Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, wait)
+      }
+    }
+  }
+
+  update(fn) {
+    fn(this.data)
+    this.save()
+    return this.data
+  }
+}

package/lib/sysinfo.js

@@ -0,0 +1,78 @@
+import si from 'systeminformation'
+
+const HISTORY = 150 // ~5 minutes at 2s
+
+/** Samples the machine on a fixed cadence and keeps a short history ring. */
+export class SystemMonitor {
+  /**
+   * @param {(event: object) => void} emit
+   * @param {() => boolean} shouldSample — false skips sampling entirely (nobody watching)
+   */
+  constructor(emit, shouldSample = () => true) {
+    this.emit = emit
+    this.shouldSample = shouldSample
+    this.history = []
+    this.current = null
+    this.processes = []
+    this.timer = null
+    this.procTimer = null
+  }
+
+  start() {
+    this.timer = setInterval(() => { if (this.shouldSample()) this.#sample().catch(() => {}) }, 2000)
+    // the process sweep is a heavy WMI query — keep it rare and viewer-gated
+    this.procTimer = setInterval(() => { if (this.shouldSample()) this.#sampleProcs().catch(() => {}) }, 10000)
+    this.#sample().catch(() => {})
+  }
+
+  stop() {
+    clearInterval(this.timer)
+    clearInterval(this.procTimer)
+  }
+
+  async #sample() {
+    const [load, mem, net, disk] = await Promise.all([
+      si.currentLoad(),
+      si.mem(),
+      si.networkStats().catch(() => []),
+      si.fsSize().catch(() => []),
+    ])
+    const point = {
+      ts: Date.now(),
+      cpu: round(load.currentLoad),
+      cores: load.cpus?.map((c) => round(c.load)) ?? [],
+      memUsed: mem.active,
+      memTotal: mem.total,
+      netRx: net[0]?.rx_sec ?? 0,
+      netTx: net[0]?.tx_sec ?? 0,
+      disks: disk.map((d) => ({ fs: d.fs, used: d.used, size: d.size })),
+    }
+    this.current = point
+    this.history.push({ ts: point.ts, cpu: point.cpu, memUsed: point.memUsed })
+    if (this.history.length > HISTORY) this.history.shift()
+    this.emit({ type: 'sys', point })
+  }
+
+  async #sampleProcs() {
+    const procs = await si.processes()
+    const interesting = /^(claude|node|git|powershell|wt|windowsterminal)/i
+    this.processes = procs.list
+      .filter((p) => interesting.test(p.name))
+      .sort((a, b) => b.cpu - a.cpu)
+      .slice(0, 25)
+      .map((p) => ({ pid: p.pid, name: p.name, cpu: round(p.cpu), memRss: p.memRss, command: clip(p.command, 140) }))
+  }
+
+  snapshot() {
+    return { current: this.current, history: this.history, processes: this.processes }
+  }
+}
+
+function round(n) {
+  return Math.round((n ?? 0) * 10) / 10
+}
+
+function clip(s, n) {
+  s = String(s ?? '')
+  return s.length > n ? `${s.slice(0, n)}…` : s
+}