k0-board 0.1.0

package/platform/darwin/service.js

@@ -0,0 +1,143 @@
+import fs from 'node:fs'
+import os from 'node:os'
+import path from 'node:path'
+import { run, runQuiet, which } from '../shared/run.js'
+
+/**
+ * Background services, launchd edition.
+ *
+ * Two agents: the server, and the menu bar icon. Both run in the user's own session — never
+ * as root — which is why the installer refuses to be run with sudo: as uid 0 the agents
+ * would land in the `gui/0` domain, where menu bar apps do not exist at all.
+ */
+
+const LAUNCHCTL = () => which('launchctl', ['/bin/launchctl'])
+const AGENTS = path.join(os.homedir(), 'Library', 'LaunchAgents')
+
+export const SERVER_LABEL = 'com.k0.server'
+export const TRAY_LABEL = 'com.k0.menubar'
+
+const plistPath = (label) => path.join(AGENTS, `${label}.plist`)
+const domain = () => `gui/${process.getuid()}`
+
+const escapeXml = (s) =>
+  String(s).replace(/[<>&'"]/g, (c) => ({ '<': '&lt;', '>': '&gt;', '&': '&amp;', "'": '&apos;', '"': '&quot;' })[c])
+
+function plist({ label, argv, port, logDir, workingDirectory, env = {} }) {
+  const args = argv.map((a) => `    <string>${escapeXml(a)}</string>`).join('\n')
+  const wd = workingDirectory
+    ? `  <key>WorkingDirectory</key>\n  <string>${escapeXml(workingDirectory)}</string>\n`
+    : ''
+  const extraEnv = Object.entries(env)
+    .map(([k, v]) => `    <key>${escapeXml(k)}</key>\n    <string>${escapeXml(v)}</string>`)
+    .join('\n')
+  return `<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+  <key>Label</key>
+  <string>${escapeXml(label)}</string>
+  <key>ProgramArguments</key>
+  <array>
+${args}
+  </array>
+  <key>EnvironmentVariables</key>
+  <dict>
+    <key>K0_PORT</key>
+    <string>${escapeXml(String(port))}</string>
+${extraEnv}
+  </dict>
+${wd}  <key>RunAtLoad</key>
+  <true/>
+  <key>KeepAlive</key>
+  <true/>
+  <key>StandardOutPath</key>
+  <string>${escapeXml(path.join(logDir, label + '.out.log'))}</string>
+  <key>StandardErrorPath</key>
+  <string>${escapeXml(path.join(logDir, label + '.err.log'))}</string>
+</dict>
+</plist>
+`
+}
+
+/**
+ * `bootout` fails when the service is not there, which here is normal rather than an error.
+ * But it also returns IMMEDIATELY, while the service takes another moment to actually leave
+ * the domain — the time for the process to die and launchd to reap it. A `bootstrap` fired
+ * into that gap finds the label still occupied and fails with "Bootstrap failed: 5:
+ * Input/output error", which explains nothing to anybody. So we wait for it to be really
+ * gone. Measured: it happens within a tenth of a second.
+ */
+async function unload(label) {
+  await runQuiet(LAUNCHCTL(), ['bootout', `${domain()}/${label}`])
+  for (let i = 0; i < 50; i++) {
+    const out = await runQuiet(LAUNCHCTL(), ['print', `${domain()}/${label}`])
+    if (!out) return
+    await new Promise((r) => setTimeout(r, 100))
+  }
+}
+
+/** And even then launchd can still be halfway through: retry a few times before believing it. */
+async function load(file) {
+  for (let i = 0; i < 5; i++) {
+    try {
+      await run(LAUNCHCTL(), ['bootstrap', domain(), file])
+      return
+    } catch {
+      await new Promise((r) => setTimeout(r, 500))
+    }
+  }
+  // Let the last attempt speak: if that one fails too, the reason needs reading.
+  await run(LAUNCHCTL(), ['bootstrap', domain(), file])
+}
+
+export async function install({ node, entry, port, logDir, tray, appDir }) {
+  fs.mkdirSync(AGENTS, { recursive: true })
+  fs.mkdirSync(logDir, { recursive: true })
+
+  // launchd does not get a login shell's PATH: absolute paths only.
+  fs.writeFileSync(
+    plistPath(SERVER_LABEL),
+    plist({ label: SERVER_LABEL, argv: [node, entry], port, logDir, workingDirectory: appDir })
+  )
+  await unload(SERVER_LABEL)
+  await load(plistPath(SERVER_LABEL))
+
+  if (tray && fs.existsSync(tray)) {
+    // The tray calls back into the command line when Terminal quits, and under launchd it would
+    // never find a version-managed node on the PATH: the interpreter's real path is handed to it.
+    fs.writeFileSync(
+      plistPath(TRAY_LABEL),
+      plist({ label: TRAY_LABEL, argv: [tray], port, logDir, env: { K0_NODE: node } })
+    )
+    await unload(TRAY_LABEL)
+    await load(plistPath(TRAY_LABEL))
+  }
+}
+
+export async function uninstall() {
+  for (const label of [SERVER_LABEL, TRAY_LABEL]) {
+    await unload(label)
+    try {
+      fs.unlinkSync(plistPath(label))
+    } catch {
+      /* never installed: nothing to remove */
+    }
+  }
+}
+
+export async function restart() {
+  await runQuiet(LAUNCHCTL(), ['kickstart', '-k', `${domain()}/${SERVER_LABEL}`])
+}
+
+export async function status() {
+  const out = await runQuiet(LAUNCHCTL(), ['print', `${domain()}/${SERVER_LABEL}`])
+  return { running: /state = running/.test(out) }
+}
+
+export const describe = () => [
+  { path: plistPath(SERVER_LABEL), what: 'a background service that starts k0 when you log in' },
+  { path: plistPath(TRAY_LABEL), what: 'a background service for the menu bar icon' },
+]
+
+export const capabilities = { autostart: true }

package/platform/darwin/shell.js

@@ -0,0 +1,59 @@
+import fs from 'node:fs'
+import os from 'node:os'
+import path from 'node:path'
+import { run, runSyncQuiet, which } from '../shared/run.js'
+
+const OPEN = () => which('open', ['/usr/bin/open'])
+
+export const revealInFileManager = (abs) => run(OPEN(), ['-R', abs], { timeout: 4000 })
+
+export const openBrowser = (url) => run(OPEN(), [url], { timeout: 4000 })
+
+/**
+ * A Chromium-family browser that can print, or nothing.
+ *
+ * Absolute paths first, as everywhere else: the server runs from a LaunchAgent with a thin
+ * PATH. When there is no browser at all the module says so and the rest keeps working —
+ * printing and downloading the file as it is do not come through here.
+ */
+const CHROME_CANDIDATES = [
+  '/Applications/Google Chrome.app/Contents/MacOS/Google Chrome',
+  '/Applications/Google Chrome Canary.app/Contents/MacOS/Google Chrome Canary',
+  '/Applications/Chromium.app/Contents/MacOS/Chromium',
+  '/Applications/Brave Browser.app/Contents/MacOS/Brave Browser',
+  '/Applications/Microsoft Edge.app/Contents/MacOS/Microsoft Edge',
+]
+
+export const findChrome = () => CHROME_CANDIDATES.find((p) => fs.existsSync(p)) || null
+
+/**
+ * Directories under $HOME that are never projects. These are macOS's own, and they are in
+ * English on disk whatever language the Finder shows them in.
+ */
+export const homeSkipList = () =>
+  new Set([
+    'Library', 'Applications', 'Desktop', 'Documents', 'Downloads',
+    'Movies', 'Music', 'Pictures', 'Public', 'Sites',
+  ])
+
+let claudeBin = null
+
+/**
+ * Where Claude Code is. The known install locations first, then a login shell — which is
+ * what finds it when it came from a version manager whose PATH only exists inside a shell.
+ */
+export function findClaude() {
+  if (claudeBin) return claudeBin
+  const candidates = [
+    path.join(os.homedir(), '.local/bin/claude'),
+    '/usr/local/bin/claude',
+    '/opt/homebrew/bin/claude',
+  ]
+  for (const c of candidates) if (fs.existsSync(c)) return (claudeBin = c)
+  const shell = process.env.SHELL || '/bin/zsh'
+  const fromShell = runSyncQuiet(shell, ['-lc', 'command -v claude']).trim()
+  claudeBin = fromShell || which('claude') || 'claude'
+  return claudeBin
+}
+
+export const capabilities = { revealInFileManager: true }

package/platform/darwin/terminal.js

@@ -0,0 +1,324 @@
+import { execFileSync } from 'node:child_process'
+import { run, runQuiet, which } from '../shared/run.js'
+
+/**
+ * Terminal.app, driven by AppleScript.
+ *
+ * This is the reference implementation of the terminal contract, and the only one where
+ * every capability is available: macOS lets a script open a window, place it, resize it,
+ * rename it, read back what is printed in it and paste into it. The other platforms each
+ * give up something.
+ */
+
+const OSASCRIPT = () => which('osascript', ['/usr/bin/osascript'])
+const PBCOPY = () => which('pbcopy', ['/usr/bin/pbcopy'])
+const PBPASTE = () => which('pbpaste', ['/usr/bin/pbpaste'])
+
+/** Escape for an AppleScript string literal. */
+const asq = (s) => String(s).replace(/\\/g, '\\\\').replace(/"/g, '\\"')
+
+/** How much of the free screen area a window takes: the rest is margin. */
+const COVERAGE = 0.86
+
+/** In driving mode the terminal has to be readable from across the room. */
+export const DRIVING_FONT_SIZE = 22
+
+/**
+ * The profile's font size, asked once and then remembered. It is what we go back to when
+ * driving mode is switched off; hard-coding a 12 here would be right today and wrong the
+ * day you change your Terminal profile.
+ */
+let defaultFont = null
+export async function defaultFontSize() {
+  if (defaultFont) return defaultFont
+  const out = await runQuiet(OSASCRIPT(), ['-e', 'tell application "Terminal" to get font size of default settings'])
+  defaultFont = Number(String(out).trim()) || 12
+  return defaultFont
+}
+
+/**
+ * The piece of AppleScript that decides where a window goes and how big it is. It is written
+ * once because two callers need it — the one that opens a new window and the one that puts
+ * them back after the screen changes — and the rule has to be the same for both: otherwise
+ * the first time a monitor is unplugged every window would change size for no reason.
+ *
+ * Leaves `x1`, `y1`, `w` and `h` behind, which is what `bounds` needs.
+ */
+const GEOMETRY = `
+use framework "AppKit"
+use scripting additions
+
+-- visibleFrame is already net of the menu bar and the Dock, so the margin computed
+-- below never ends up underneath either of them.
+set scr to current application's NSScreen's mainScreen()
+set frameH to item 2 of item 2 of (scr's frame() as list)
+set {{vx, vy}, {vw, vh}} to (scr's visibleFrame() as list)
+set w to round (vw * ${COVERAGE})
+set h to round (vh * ${COVERAGE})
+set x1 to round (vx + (vw - w) / 2)
+-- NSScreen counts from the bottom, Terminal from the top: this converts between them.
+set y1 to round (frameH - (vy + vh) + (vh - h) / 2)
+`
+
+/**
+ * Opens a new Terminal.app window, centres it on screen, and only then runs the command in
+ * it. Returns the window id, which is what lets us bring it back to the front later.
+ *
+ * The order is everything:
+ * - the screen is read BEFORE `activate`, because `mainScreen` is whichever screen holds the
+ *   focused window: before, that is the one you are working on; after, it would be whichever
+ *   screen Terminal already had a window on;
+ * - the font size is set BEFORE the bounds, because Terminal keeps rows and columns when the
+ *   font changes and resizes the window to match — doing it afterwards would eat the size we
+ *   had just set;
+ * - the window is sized BEFORE the command runs, so Claude Code's interface is born at the
+ *   right size instead of having to redraw itself halfway through starting up.
+ */
+export async function open({ command, title, fontSize }) {
+  const font = fontSize ?? (await defaultFontSize())
+  const script = `${GEOMETRY}
+tell application "Terminal"
+  activate
+  do script ""
+  set win to front window
+  set font size of tab 1 of win to ${font}
+  set bounds of win to {x1, y1, x1 + w, y1 + h}
+  do script "${asq(command)}" in tab 1 of win
+  -- The card's name in the title bar, not the command line with the session id in it.
+  set custom title of tab 1 of win to "${asq(title)}"
+  set winId to id of win
+end tell
+return winId as string`
+  const stdout = await run(OSASCRIPT(), ['-e', script], { timeout: 30000 })
+  return stdout.trim()
+}
+
+const ids = (handles) => [...new Set((handles || []).map(Number).filter(Boolean))]
+
+/**
+ * One `osascript` for every window, each in its own `try`.
+ *
+ * The per-window `try` is there so that one window closed by hand in the meantime does not
+ * take all the others down with it. And there is deliberately **no `activate`**: opening a
+ * window needs Terminal in front, touching one that is already open does not — otherwise
+ * every time you switch driving mode on or plug in a monitor, Terminal would jump in front
+ * of whatever you were doing.
+ */
+async function forEachWindow(preamble, body, list) {
+  const blocks = list.map((id) => `\n  try${body(id)}\n  end try`).join('')
+  try {
+    await run(OSASCRIPT(), ['-e', `${preamble}\ntell application "Terminal"${blocks}\nend tell`])
+    return { touched: list.length }
+  } catch {
+    return { touched: 0 } // Terminal is not running at all: there is nothing to touch
+  }
+}
+
+/**
+ * Changes the font size of windows that are already open — which is what happens when
+ * driving mode goes on or off.
+ *
+ * **Every window stays exactly where and as it is.** That is worth saying because it is not
+ * free: Terminal.app keeps rows and columns when the font changes and resizes the window
+ * accordingly — going from 12 to 22 more than doubles it. So the bounds are read first, the
+ * font is changed, and the bounds are put back: **its own** bounds, not the centred ones.
+ * k0's windows have rarely stayed where they were born — you move them, widen them, drag one
+ * to the other monitor — and turning on driving mode is not the moment to sweep them all
+ * back to the middle of the screen without being asked.
+ *
+ * What genuinely changes is how much text fits: at 22 points, fewer rows.
+ */
+export async function setFont(handles, size) {
+  const list = ids(handles)
+  if (!list.length) return { touched: 0 }
+  const font = size ?? (await defaultFontSize())
+  return forEachWindow(
+    '',
+    (id) => `
+    set b to bounds of window id ${id}
+    set font size of tab 1 of window id ${id} to ${font}
+    set bounds of window id ${id} to b`,
+    list
+  )
+}
+
+/**
+ * Puts the windows back in the middle of the screen at their usual size: what is needed when
+ * the screen changes underneath them — a monitor plugged in or unplugged, a different
+ * resolution — and the windows stay where they were, out of place or off screen.
+ *
+ * Here gathering them back to the centre is the point: they all end up where they were born,
+ * as they were on the first day. The geometry is computed once for all of them, so none ends
+ * up on a different screen from its siblings.
+ */
+export async function relayout(handles) {
+  const list = ids(handles)
+  if (!list.length) return { touched: 0 }
+  return forEachWindow(GEOMETRY, (id) => `\n    set bounds of window id ${id} to {x1, y1, x1 + w, y1 + h}`, list)
+}
+
+/**
+ * Rewrites the name in the window's title bar. Works on a live session too: a title set from
+ * outside takes precedence over the one Claude Code keeps writing for itself.
+ *
+ * It is the only way to make the name follow a live session immediately — inside Claude Code
+ * the real name catches up when the session ends, which is when the transcript stops having
+ * an owner.
+ */
+export async function setTitle(handle, title) {
+  const id = Number(handle)
+  if (!id) return false
+  try {
+    await run(OSASCRIPT(), [
+      '-e',
+      `tell application "Terminal" to set custom title of tab 1 of window id ${id} to "${asq(title)}"`,
+    ])
+    return true
+  } catch {
+    return false // window is closed: nothing to rename
+  }
+}
+
+/**
+ * Brings the card's window back to the front, un-minimising it if it was parked.
+ * Keeps you from losing track of which terminal is which.
+ */
+export async function focus(handle) {
+  const id = Number(handle)
+  if (!id) return { ok: false, error: 'This card has no terminal window of its own' }
+  const script = `
+tell application "Terminal"
+  activate
+  set w to window id ${id}
+  set miniaturized of w to false
+  set index of w to 1
+end tell`
+  try {
+    await run(OSASCRIPT(), ['-e', script])
+    return { ok: true }
+  } catch {
+    return { ok: false, error: 'That window is gone' }
+  }
+}
+
+/**
+ * Closes a card's terminal: stops the session first, then closes the window.
+ *
+ * The order is not a detail. Closing a window that still has `claude` inside it makes macOS
+ * put up the "terminate running processes" dialog and sit there waiting: the window does not
+ * close and Terminal stops answering commands. With the process stopped first, the window
+ * goes quietly.
+ */
+export async function close({ handle, pid }) {
+  if (pid) {
+    try {
+      process.kill(pid, 'SIGTERM')
+      // A moment to leave gracefully, but not much of one.
+      for (let i = 0; i < 20; i++) {
+        await new Promise((r) => setTimeout(r, 100))
+        try {
+          process.kill(pid, 0)
+        } catch {
+          break // gone
+        }
+      }
+    } catch {
+      /* already dead, or not ours: carry on either way */
+    }
+  }
+  const id = Number(handle)
+  if (!id) return { closed: false }
+  try {
+    await run(OSASCRIPT(), [
+      '-e',
+      `tell application "Terminal" to close (every window whose id is ${id}) saving no`,
+    ])
+    return { closed: true }
+  } catch {
+    return { closed: false } // already closed by hand: perfectly fine
+  }
+}
+
+/** What is printed in the window right now. This is how k0 knows the interface is ready. */
+export async function readScreen(handle) {
+  const id = Number(handle)
+  if (!id) return null
+  try {
+    const stdout = await run(OSASCRIPT(), [
+      '-e',
+      `tell application "Terminal" to get contents of tab 1 of window id ${id}`,
+    ])
+    return stdout
+  } catch {
+    return null // window is gone
+  }
+}
+
+/**
+ * Writes the prompt into the window and leaves it there, unsent: you press Enter.
+ *
+ * It goes through the clipboard and a Cmd+V because inside the interface a typed newline
+ * would send the message, while a paste stays one block. The simulated keystroke needs
+ * macOS's Accessibility permission, though; without it the caller falls back to `type`.
+ */
+export async function paste(text, handle) {
+  let previous = ''
+  try {
+    previous = execFileSync(PBPASTE(), { encoding: 'utf8' })
+  } catch {
+    /* clipboard unreadable: never mind, there is nothing to put back */
+  }
+  execFileSync(PBCOPY(), { input: text })
+  const script = `
+tell application "Terminal"
+  activate
+  try
+    set index of window id ${Number(handle) || 1} to 1
+  end try
+end tell
+delay 0.2
+tell application "System Events" to keystroke "v" using command down`
+  try {
+    await run(OSASCRIPT(), ['-e', script])
+    return { pasted: true }
+  } catch (err) {
+    // No Accessibility permission: put back the clipboard we borrowed.
+    try {
+      execFileSync(PBCOPY(), { input: previous })
+    } catch {
+      /* better not to insist */
+    }
+    return { pasted: false, error: String(err.stderr || err.message).trim() }
+  }
+}
+
+/**
+ * Writes the prompt into the terminal and sends it, with no simulated keystrokes and no
+ * permissions: Terminal.app itself types it into the window. It always adds the Enter —
+ * there is provably no way to hold it back and leave the text clean — so the session starts
+ * here. This is the safety net when Accessibility has not been granted: better to start than
+ * to stall.
+ */
+export async function type(text, handle) {
+  const id = Number(handle)
+  if (!id) return { written: false }
+  try {
+    await run(OSASCRIPT(), [
+      '-e',
+      `tell application "Terminal" to do script "${asq(text)}" in tab 1 of window id ${id}`,
+    ])
+    return { written: true }
+  } catch (err) {
+    return { written: false, error: String(err.stderr || err.message).trim() }
+  }
+}
+
+export const capabilities = {
+  windows: true,
+  font: true,
+  readScreen: true,
+  pasteWithoutSending: true,
+  title: true,
+}
+
+export { posixCommand as buildCommand } from '../shared/command.js'

package/platform/index.js

@@ -0,0 +1,97 @@
+import { NO_CAPABILITIES } from './contract.js'
+
+/**
+ * Picks the adapter for the machine k0 is running on.
+ *
+ * The import is dynamic because the three adapters reach for things that only exist on their
+ * own platform, and a static import would pull all three into every process. `await` at the
+ * top level of a module is fine here: the server does nothing before this resolves anyway.
+ *
+ * An unknown platform is not an error, it is a diagnosis. k0 loads, the board comes up, and
+ * every capability reads false with a note explaining that this system has no adapter — which
+ * is a far more useful thing to hand somebody on FreeBSD than a stack trace.
+ */
+const adapters = {
+  darwin: () => import('./darwin/index.js'),
+  linux: () => import('./linux/index.js'),
+  win32: () => import('./win32/index.js'),
+}
+
+const load = adapters[process.platform]
+
+const unsupported = {
+  name: process.platform,
+  capabilities: NO_CAPABILITIES,
+  notes: {
+    platform:
+      `k0 has no adapter for ${process.platform} yet. The board and the file viewer work, but ` +
+      'k0 cannot open terminals, keep the machine awake, or install itself as a service here. ' +
+      'Adding a platform means filling in one directory under platform/ — see CONTRIBUTING.md.',
+  },
+  terminal: {
+    open: async () => {
+      throw new Error(`k0 cannot open terminals on ${process.platform} yet.`)
+    },
+    setTitle: async () => false,
+    setFont: async () => ({ touched: 0 }),
+    relayout: async () => ({ touched: 0 }),
+    focus: async () => ({ ok: false, error: `Not supported on ${process.platform}` }),
+    close: async () => ({ closed: false }),
+    readScreen: async () => null,
+    paste: async () => ({ pasted: false }),
+    type: async () => ({ written: false }),
+    defaultFontSize: async () => 12,
+  },
+  power: {
+    state: async () => ({ onAcPower: true, charge: null }),
+    inhibit: () => {},
+    release: () => {},
+    setLidSleepBlocked: async () => {},
+    lidSleepBlocked: async () => false,
+    releaseSync: () => {},
+  },
+  metrics: {
+    processes: async () => new Map(),
+    memory: async () => ({ total: 0, used: 0, app: 0, wired: 0, compressed: 0, cached: 0 }),
+    swap: async () => ({ total: 0, used: 0 }),
+    pressureLevel: async () => 1,
+  },
+  shell: {
+    revealInFileManager: async () => {},
+    openBrowser: async () => {},
+    findChrome: () => null,
+    homeSkipList: () => new Set(),
+    findClaude: () => 'claude',
+  },
+  service: {
+    install: async () => {
+      throw new Error(`k0 cannot install a background service on ${process.platform} yet.`)
+    },
+    uninstall: async () => {},
+    restart: async () => {},
+    status: async () => ({ running: false }),
+    describe: () => [],
+  },
+  extras: [],
+}
+
+const platform = load ? { ...unsupported, ...(await load()) } : unsupported
+
+export default platform
+export const { name, capabilities, notes, terminal, power, metrics, shell, service, extras } = platform
+
+/**
+ * Is this capability available here? Takes a dotted path, so callers read as a question:
+ * `can('terminal.readScreen')`.
+ */
+export const can = (dotted) =>
+  dotted.split('.').reduce((node, key) => (node == null ? undefined : node[key]), capabilities) === true
+
+/** Why it is not, in a sentence meant for the user. */
+export const why = (dotted) => notes[dotted] || null
+
+/**
+ * Everything the board needs to grey out what this machine cannot do, and say why.
+ * Sent with /api/board so the interface never has to guess.
+ */
+export const report = () => ({ name, capabilities, notes })

package/platform/linux/index.js

@@ -0,0 +1,60 @@
+import path from 'node:path'
+import { fileURLToPath } from 'node:url'
+import * as tmux from '../shared/tmux.js'
+import * as power from './power.js'
+import * as metrics from './metrics.js'
+import * as shell from './shell.js'
+import * as service from './service.js'
+import { NO_CAPABILITIES } from '../contract.js'
+import { which } from '../shared/run.js'
+
+export const name = 'Linux'
+
+export const terminal = tmux
+
+export const trayScript = path.join(path.dirname(fileURLToPath(import.meta.url)), 'tray.py')
+
+export const capabilities = {
+  ...NO_CAPABILITIES,
+  terminal: tmux.capabilities(),
+  power: power.capabilities(),
+  metrics: metrics.capabilities(),
+  service: service.capabilities(),
+  tray: !!which('python3'),
+  revealInFileManager: shell.capabilities().revealInFileManager,
+}
+
+export const notes = {
+  ...power.notes,
+  ...metrics.notes,
+  ...service.notes,
+  ...(capabilities.terminal.readScreen
+    ? {}
+    : {
+        'terminal.readScreen':
+          'tmux was not found. k0 drives terminals through tmux on Linux — without it, it ' +
+          'cannot open a session, read when Claude Code is ready, or place your prompt. ' +
+          'Install tmux and run `k0-board doctor` again.',
+      }),
+  ...(capabilities.terminal.windows
+    ? {}
+    : {
+        'terminal.windows': tmux.isWayland()
+          ? 'Wayland does not let one application move another’s windows, by design. k0 opens ' +
+            'terminals but cannot place, resize or raise them; your compositor decides where ' +
+            'they go.'
+          : 'Install xdotool (or wmctrl) to let k0 place and raise terminal windows.',
+      }),
+  'terminal.font':
+    'Font size belongs to your terminal emulator and every one of them spells it differently, ' +
+    'so driving mode enlarges the board but not the terminals. Set a bigger font in your ' +
+    'emulator’s own preferences if you want both.',
+  ...(capabilities.tray
+    ? {}
+    : { tray: 'python3 with PyGObject is needed for a tray icon. The board works without it.' }),
+}
+
+export { power, metrics, shell, service }
+
+/** Nothing on Linux reaches outside k0's own files, so there is nothing to consent to. */
+export const extras = []