@phenx-inc/ctlsurf 0.17.2 → 0.17.4

package/out/renderer/assets/{javascript-ChlyA1sf.js → javascript-BbOZOxq9.js}

@@ -1,5 +1,5 @@
-import { conf as conf$1, language as language$1 } from "./typescript-Do-98d_O.js";
-import "./index-Dm70hk5s.js";
+import { conf as conf$1, language as language$1 } from "./typescript-D5USKnLj.js";
+import "./index-RCAeuJTr.js";
 const conf = conf$1;
 const language = {
   // Set defaultToken to invalid to see what you do not tokenize yet

package/out/renderer/assets/{jsonMode-D1_oHzeN.js → jsonMode-CUvAeYcT.js}

@@ -1,6 +1,6 @@
-import { c as createWebWorker, l as languages, e as editor } from "./index-Dm70hk5s.js";
-import { f as DocumentFormattingEditProvider, g as DocumentRangeFormattingEditProvider, C as CompletionAdapter, H as HoverAdapter, b as DocumentSymbolAdapter, d as DocumentColorAdapter, F as FoldingRangeAdapter, S as SelectionRangeAdapter, e as DiagnosticsAdapter } from "./lspLanguageFeatures-Ckqu5ubG.js";
-import { a, D, h, R, c, i, j, t, k } from "./lspLanguageFeatures-Ckqu5ubG.js";
+import { c as createWebWorker, l as languages, e as editor } from "./index-RCAeuJTr.js";
+import { f as DocumentFormattingEditProvider, g as DocumentRangeFormattingEditProvider, C as CompletionAdapter, H as HoverAdapter, b as DocumentSymbolAdapter, d as DocumentColorAdapter, F as FoldingRangeAdapter, S as SelectionRangeAdapter, e as DiagnosticsAdapter } from "./lspLanguageFeatures-Ds-3nH9p.js";
+import { a, D, h, R, c, i, j, t, k } from "./lspLanguageFeatures-Ds-3nH9p.js";
 const STOP_WHEN_IDLE_FOR = 2 * 60 * 1e3;
 class WorkerManager {
   constructor(defaults) {

package/out/renderer/assets/{liquid-D4ftdy1G.js → liquid-DRIACo_s.js}

@@ -1,4 +1,4 @@
-import { l as languages } from "./index-Dm70hk5s.js";
+import { l as languages } from "./index-RCAeuJTr.js";
 const EMPTY_ELEMENTS = [
   "area",
   "base",

package/out/renderer/assets/{lspLanguageFeatures-Ckqu5ubG.js → lspLanguageFeatures-Ds-3nH9p.js}

@@ -1,4 +1,4 @@
-import { R as Range$1, l as languages, e as editor, U as Uri, M as MarkerSeverity } from "./index-Dm70hk5s.js";
+import { R as Range$1, l as languages, e as editor, U as Uri, M as MarkerSeverity } from "./index-RCAeuJTr.js";
 var DocumentUri;
 (function(DocumentUri2) {
   function is(value) {

package/out/renderer/assets/{mdx-B9wsVYSC.js → mdx-D76jlpLO.js}

@@ -1,4 +1,4 @@
-import { l as languages } from "./index-Dm70hk5s.js";
+import { l as languages } from "./index-RCAeuJTr.js";
 const conf = {
   comments: {
     blockComment: ["{/*", "*/}"]

package/out/renderer/assets/{python-e23tD6IS.js → python-CMuRPKJi.js}

@@ -1,4 +1,4 @@
-import { l as languages } from "./index-Dm70hk5s.js";
+import { l as languages } from "./index-RCAeuJTr.js";
 const conf = {
   comments: {
     lineComment: "#",

package/out/renderer/assets/{razor-CrDyXj3d.js → razor-DRoH5mal.js}

@@ -1,4 +1,4 @@
-import { l as languages } from "./index-Dm70hk5s.js";
+import { l as languages } from "./index-RCAeuJTr.js";
 const EMPTY_ELEMENTS = [
   "area",
   "base",

package/out/renderer/assets/{tsMode-BwGC5o4O.js → tsMode-dPJzgFD7.js}

@@ -1,4 +1,4 @@
-import { c as createWebWorker, e as editor, U as Uri, a as MarkerTag, M as MarkerSeverity, l as languages, t as typescriptDefaults, R as Range } from "./index-Dm70hk5s.js";
+import { c as createWebWorker, e as editor, U as Uri, a as MarkerTag, M as MarkerSeverity, l as languages, t as typescriptDefaults, R as Range } from "./index-RCAeuJTr.js";
 class WorkerManager {
   constructor(_modeId, _defaults) {
     this._modeId = _modeId;

package/out/renderer/assets/{typescript-Do-98d_O.js → typescript-D5USKnLj.js}

@@ -1,4 +1,4 @@
-import { l as languages } from "./index-Dm70hk5s.js";
+import { l as languages } from "./index-RCAeuJTr.js";
 const conf = {
   wordPattern: /(-?\d*\.\d\w*)|([^\`\~\!\@\#\%\^\&\*\(\)\-\=\+\[\{\]\}\\\|\;\:\'\"\,\.\<\>\/\?\s]+)/g,
   comments: {

package/out/renderer/assets/{xml-Dpdu5R3m.js → xml-qYg1wt2P.js}

@@ -1,4 +1,4 @@
-import { l as languages } from "./index-Dm70hk5s.js";
+import { l as languages } from "./index-RCAeuJTr.js";
 const conf = {
   comments: {
     blockComment: ["<!--", "-->"]

package/out/renderer/assets/{yaml-B0Zt7LCJ.js → yaml-Uc-CvnvL.js}

@@ -1,4 +1,4 @@
-import { l as languages } from "./index-Dm70hk5s.js";
+import { l as languages } from "./index-RCAeuJTr.js";
 const conf = {
   comments: {
     lineComment: "#"

package/out/renderer/index.html

@@ -106,8 +106,8 @@
     :root[data-theme='catppuccin-latte'] .boot-splash-title { color: #2f3145; }
     :root[data-theme='catppuccin-latte'] .boot-splash-label { color: #7c7f93; }
   </style>
-  <script type="module" crossorigin src="./assets/index-Dm70hk5s.js"></script>
-  <link rel="stylesheet" crossorigin href="./assets/index-CEjwKjtd.css">
+  <script type="module" crossorigin src="./assets/index-RCAeuJTr.js"></script>
+  <link rel="stylesheet" crossorigin href="./assets/index-CBWAeUYW.css">
 </head>
 <body>
   <div id="boot-splash">

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@phenx-inc/ctlsurf",
-  "version": "0.17.2",
+  "version": "0.17.4",
   "description": "Agent-agnostic terminal and desktop app for ctlsurf — run Claude Code, Codex, or any coding agent with live session logging and remote control",
   "main": "out/main/index.js",
   "bin": {
@@ -19,6 +19,8 @@
     "THIRD-PARTY-NOTICES.md"
   ],
   "scripts": {
+    "test:workmap": "node scripts/test-work-map-capability.cjs && node scripts/test-work-map.cjs",
+    "test:workmap:ui": "electron scripts/test-work-map-ui.cjs",
     "dev": "electron-vite dev",
     "dev:terminal": "esbuild src/main/headless.ts --bundle --platform=node --target=node18 --format=esm --outfile=out/headless/index.mjs --external:node-pty --external:ws --sourcemap && node out/headless/index.mjs",
     "build": "electron-vite build && npm run build:headless",
@@ -26,7 +28,7 @@
     "prepublishOnly": "npm run build",
     "preview": "electron-vite preview",
     "package": "electron-builder",
-    "postinstall": "node-gyp rebuild --directory=node_modules/node-pty 2>/dev/null || true"
+    "postinstall": "node scripts/postinstall.cjs"
   },
   "keywords": [
     "ctlsurf",

package/scripts/check-work-map-gpu.cjs

@@ -0,0 +1,62 @@
+// Shared by npm postinstall and the desktop startup check. No model/runtime downloads.
+
+function initialCapability({ desktop = false, platform = process.platform, arch = process.arch } = {}) {
+  if (!desktop) return { state: 'unavailable', reason: 'Work map is available only in the desktop app.' }
+  if (platform !== 'darwin' || arch !== 'arm64') return { state: 'unavailable', reason: 'Work map currently requires an Apple Silicon Mac with Metal GPU support.' }
+  return { state: 'checking', reason: 'Checking Apple GPU availability…' }
+}
+
+function appleGpuFromReport(report) {
+  if (!Array.isArray(report?.SPDisplaysDataType)) return null
+  return report.SPDisplaysDataType.find(gpu => {
+    const apple = gpu.spdisplays_vendor === 'sppci_vendor_Apple' || /^Apple M\d/i.test(gpu.sppci_model || gpu._name || '')
+    const metal = String(gpu.spdisplays_metal || gpu.spdisplays_metalsupport || gpu.spdisplays_mtlgpufamilysupport || '')
+    return apple && /supported|metal/i.test(metal) && !/unsupported|not.supported|unavailable/i.test(metal)
+  }) || null
+}
+
+function usableElectronGpu(info) {
+  if (info?.auxAttributes?.softwareRendering === true) return false
+  return Array.isArray(info?.gpuDevice) && info.gpuDevice.some(gpu => gpu.active === true
+    && (gpu.vendorId === 0x106b || /Apple/i.test(gpu.deviceString || gpu.vendorString || '')))
+}
+
+function readGpuReport() {
+  return new Promise((resolve, reject) => {
+    const { execFile } = require('node:child_process')
+    execFile('/usr/sbin/system_profiler', ['SPDisplaysDataType', '-json'], { timeout: 5000, maxBuffer: 1024 * 1024 }, (error, output) => {
+      if (error) { reject(error); return }
+      try { resolve(JSON.parse(output)) } catch (error) { reject(error) }
+    })
+  })
+}
+
+async function detectCapability(options = {}) {
+  const initial = initialCapability(options)
+  if (initial.state !== 'checking') return initial
+  try {
+    const gpu = appleGpuFromReport(await (options.readGpuReport || readGpuReport)())
+    if (!gpu) return { state: 'unavailable', reason: 'No Apple GPU with Metal support was detected.' }
+    if (options.verifyGpu) {
+      let timer
+      const usable = await Promise.race([
+        options.verifyGpu(),
+        new Promise(resolve => { timer = setTimeout(() => resolve(false), 5000) }),
+      ]).finally(() => clearTimeout(timer))
+      if (!usable) return { state: 'unavailable', reason: 'The Apple GPU is unavailable to the desktop app.' }
+    }
+    return { state: 'available', reason: null, gpuName: String(gpu.sppci_model || gpu._name || 'Apple GPU') }
+  } catch {
+    return { state: 'unavailable', reason: 'Apple GPU availability could not be verified. Work map is disabled for this launch.' }
+  }
+}
+
+module.exports = { initialCapability, appleGpuFromReport, usableElectronGpu, detectCapability }
+
+if (require.main === module) {
+  detectCapability({ desktop: true }).then(capability => {
+    console.log(capability.state === 'available'
+      ? `[ctlsurf] Work map hardware detected: ${capability.gpuName}. The desktop app checks GPU access again at startup.`
+      : `[ctlsurf] ${capability.reason} Other app features remain available.`)
+  }).catch(() => {}) // Optional feature detection never fails package installation.
+}

package/scripts/check-work-map-gpu.d.cts

@@ -0,0 +1,13 @@
+import type { MapCapability } from '../src/shared/workMap'
+
+interface CapabilityOptions {
+  desktop?: boolean
+  platform?: string
+  arch?: string
+  readGpuReport?: () => Promise<unknown>
+  verifyGpu?: () => Promise<boolean>
+}
+export function initialCapability(options?: CapabilityOptions): MapCapability
+export function appleGpuFromReport(report: unknown): Record<string, unknown> | null
+export function usableElectronGpu(info: unknown): boolean
+export function detectCapability(options?: CapabilityOptions): Promise<MapCapability>

package/scripts/postinstall.cjs

@@ -0,0 +1,44 @@
+const fs = require('node:fs')
+const { spawnSync } = require('node:child_process')
+const { detectCapability } = require('./check-work-map-gpu.cjs')
+const { banner, formatBytes, colors: { R, D, G, C } } = require('./setup-ui.cjs')
+const { MODEL_BYTES } = require('./work-map-setup.cjs')
+const { version } = require('../package.json')
+
+// Keep the existing best-effort native rebuild, including on Windows.
+try {
+  spawnSync(process.platform === 'win32' ? 'node-gyp.cmd' : 'node-gyp', ['rebuild', '--directory=node_modules/node-pty'], {
+    stdio: 'ignore', shell: process.platform === 'win32',
+  })
+} catch { /* The launcher also handles missing native builds. */ }
+
+// npm hides lifecycle-script output (foreground-scripts=false), so the banner is written
+// straight to the terminal. No terminal (CI, Windows, detached) → the plain log line only.
+function openTty() {
+  if (process.platform === 'win32' || process.env.CI) return null
+  try { return fs.openSync('/dev/tty', 'w') } catch { return null }
+}
+
+detectCapability({ desktop: true }).then(capability => {
+  const available = capability.state === 'available'
+  const tty = openTty()
+  if (tty === null) {
+    console.log(available
+      ? `[ctlsurf] Work map hardware detected: ${capability.gpuName}. GPU access is checked again by the desktop app.`
+      : `[ctlsurf] ${capability.reason} Other app features remain available.`)
+    return
+  }
+  const gpu = available
+    ? `${G}✓${R} ${capability.gpuName} · Metal ${D}— work map capable${R}`
+    : `${D}– ${capability.reason}${R}`
+  const next = available
+    ? `Electron runtime + optional work map model ${D}(Clef-Flash, ${formatBytes(MODEL_BYTES)})${R}`
+    : 'Electron runtime'
+  try {
+    fs.writeSync(tty, '\r\x1b[2K' + banner(version)
+      + `   ${G}✓${R} installed\n   ${gpu}\n\n`
+      + `   Run ${C}ctlsurf${R} to finish setup: ${next}\n\n`)
+  } finally {
+    fs.closeSync(tty)
+  }
+}).catch(() => {})

package/scripts/prepare-work-map.py

@@ -0,0 +1,49 @@
+"""Prepare only the local Clef-Flash engine. Requires uv and Python 3.12 on Apple Silicon."""
+import argparse
+import json
+from pathlib import Path
+import os
+import platform
+import subprocess
+import sys
+
+
+def main():
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument('--directory', type=Path, default=Path.home() / '.ctlsurf' / 'clef-flash')
+    parser.add_argument('--progress', action='store_true', help='print ::phase markers for the ctlsurf launcher')
+    args = parser.parse_args()
+
+    def phase(name):
+        if args.progress:
+            print(f'::phase {name}', flush=True)
+
+    if sys.platform != 'darwin' or platform.machine() != 'arm64':
+        parser.error('Local Clef-Flash requires an Apple Silicon Mac')
+    root = args.directory.resolve()
+    root.mkdir(parents=True, exist_ok=True)
+    python = root / 'env' / 'bin' / 'python'
+    model = root / 'model'
+    env = {**os.environ, 'UV_CACHE_DIR': str(root / 'uv'), 'HF_HOME': str(root / 'huggingface'),
+           'HF_HUB_DISABLE_TELEMETRY': '1', 'TOKENIZERS_PARALLELISM': 'false'}
+    if args.progress:
+        # The launcher measures bytes on disk; hf-xet only writes each file once it is complete.
+        env.update(HF_HUB_DISABLE_PROGRESS_BARS='1', HF_HUB_DISABLE_XET='1')
+    phase('env')
+    if not python.exists():
+        subprocess.run(['uv', 'venv', '--python', '3.12', str(root / 'env')], env=env, check=True)
+    phase('deps')
+    subprocess.run(['uv', 'pip', 'install', '--python', str(python), 'huggingface_hub',
+                    'mlx==0.32.3', 'mlx-lm==0.32.0', 'mlx-vlm==0.7.4'], env=env, check=True)
+    phase('model')
+    subprocess.run([str(python), '-c',
+                    'from huggingface_hub import snapshot_download; import sys; '
+                    'snapshot_download("mlx-community/clef-flash-8bit", '
+                    'revision="5a195dc147926b63b1d139691ed4480ca9f92c0e", local_dir=sys.argv[1], '
+                    'ignore_patterns=["*.png","*.jpg","*.parquet","*.csv","*.ipynb"])', str(model)], env=env, check=True)
+    print('\nUse these paths in Work map → Local model setup:')
+    print(json.dumps({'pythonPath': str(python), 'modelPath': str(model)}, indent=2))
+
+
+if __name__ == '__main__':
+    main()

package/scripts/setup-ui.cjs

@@ -0,0 +1,161 @@
+// Terminal UI shared by the npm postinstall banner and the launcher's first-run setup.
+// Live redraw only on a TTY; otherwise each step prints one plain line when it settles.
+
+const R = '\x1b[0m'
+const D = '\x1b[90m'
+const G = '\x1b[32m'
+const Y = '\x1b[33m'
+const C = '\x1b[36m'
+
+const LOGO = [
+  '╔═╗╔╦╗╦  ╔═╗╦ ╦╦═╗╔═╗',
+  '║   ║ ║  ╚═╗║ ║╠╦╝╠╣ ',
+  '╚═╝ ╩ ╩═╝╚═╝╚═╝╩╚═╚  ',
+]
+const LOGO_COLORS = [51, 45, 39] // 256-color cyan → blue, one per row
+
+function banner(version) {
+  const logo = LOGO.map((line, i) => `   \x1b[38;5;${LOGO_COLORS[i]}m${line}${R}`)
+  return ['', ...logo, `   ${D}the terminal that remembers · v${version}${R}`, '', ''].join('\n')
+}
+
+function formatBytes(n) {
+  if (n >= 1e9) return `${(n / 1e9).toFixed(1)} GB`
+  if (n >= 1e6) return `${Math.round(n / 1e6)} MB`
+  return `${Math.round(n / 1e3)} KB`
+}
+
+function formatDuration(ms) {
+  const s = Math.max(0, Math.round(ms / 1000))
+  const m = Math.floor(s / 60)
+  return m ? `${m}m${String(s % 60).padStart(2, '0')}s` : `${s}s`
+}
+
+const SPIN = '⠋⠙⠹⠸⠼⠴⠦⠧⠇⠏'
+const ICONS = {
+  pending: `${D}·${R}`, done: `${G}✓${R}`, fail: `${Y}✗${R}`,
+  warn: `${Y}!${R}`, skip: `${D}–${R}`, ask: `${C}?${R}`,
+}
+const SETTLED = new Set(['done', 'fail', 'warn', 'skip'])
+const BAR = 16
+const LABEL = 23
+
+// progress: undefined → no bar, null → indeterminate sweep, 0..1 → filled bar with percent
+function bar(progress, frame) {
+  if (progress === null) {
+    const span = BAR - 4
+    const pos = Math.abs((frame % (span * 2)) - span)
+    return `${D}▕${'░'.repeat(pos)}${C}▓██▓${D}${'░'.repeat(span - pos)}▏${R}`
+  }
+  const p = Math.min(1, Math.max(0, progress))
+  const n = Math.round(p * BAR)
+  return `${D}▕${C}${'█'.repeat(n)}${D}${'░'.repeat(BAR - n)}▏${R} ${String(Math.floor(p * 100)).padStart(3)}%`
+}
+
+// Pad or truncate to a visible width, skipping ANSI escapes.
+function fit(text, width) {
+  const parts = text.match(/\x1b\[[0-9;?]*[A-Za-z]|[\s\S]/gu) || []
+  const visible = parts.filter(p => p[0] !== '\x1b').length
+  let out = ''
+  let n = 0
+  for (const p of parts) {
+    if (p[0] === '\x1b') { out += p; continue }
+    if (visible > width && n === width - 1) { out += '…'; n++; break }
+    out += p
+    n++
+  }
+  return out + R + ' '.repeat(Math.max(0, width - n))
+}
+
+class Steps {
+  constructor(title, labels, out = process.stdout) {
+    this.title = title
+    this.out = out
+    this.live = !!out.isTTY
+    this.steps = labels.map(label => ({ label, state: 'pending', note: '', detail: '', progress: undefined, printed: false }))
+    this.drawn = 0
+    this.frame = 0
+    this.timer = null
+    this.onSigint = () => { this.finish(); this.out.write('\n'); process.exit(130) }
+  }
+
+  start() {
+    if (this.live) {
+      this.out.write('\x1b[?25l')
+      this.timer = setInterval(() => { this.frame++; this.render() }, 80)
+      process.on('SIGINT', this.onSigint)
+    }
+    this.render()
+    return this
+  }
+
+  set(i, patch) {
+    const step = this.steps[i]
+    Object.assign(step, patch)
+    if (!SETTLED.has(step.state)) step.printed = false
+    if (!this.live && SETTLED.has(step.state) && !step.printed) {
+      step.printed = true
+      const note = step.note ? `  ${D}${step.note}${R}` : ''
+      const detail = step.detail ? `\n      ${D}${step.detail}${R}` : ''
+      this.out.write(`  ${ICONS[step.state]} ${step.label}${note}${detail}\n`)
+    }
+    this.render()
+  }
+
+  row(step) {
+    const icon = step.state === 'run' ? `${C}${SPIN[this.frame % SPIN.length]}${R}` : ICONS[step.state]
+    const label = step.state === 'pending' ? `${D}${step.label}${R}` : step.label
+    let right = step.state === 'run' && step.progress !== undefined ? bar(step.progress, this.frame) + ' ' : ''
+    if (step.note) right += `${D}${step.note}${R}`
+    return `${icon} ${fit(label, LABEL)} ${right}`
+  }
+
+  render() {
+    if (!this.live) return
+    const width = Math.max(44, Math.min(68, (this.out.columns || 80) - 6))
+    const lines = [`${D}┌─ ${R}${this.title}${D} ${'─'.repeat(Math.max(0, width - 1 - this.title.length))}┐${R}`]
+    for (const step of this.steps) {
+      lines.push(`${D}│${R} ${fit(this.row(step), width)} ${D}│${R}`)
+      if (step.detail) lines.push(`${D}│${R} ${fit(`    ${D}${step.detail}`, width)} ${D}│${R}`)
+    }
+    lines.push(`${D}└${'─'.repeat(width + 2)}┘${R}`)
+    const up = this.drawn ? `\x1b[${this.drawn}A\r\x1b[J` : ''
+    this.out.write(up + lines.map(l => `  ${l}`).join('\n') + '\n')
+    this.drawn = lines.length
+  }
+
+  // Ask below the box, then fold the prompt lines back into the next redraw.
+  async confirm(lines, question, defaultYes = true) {
+    if (this.timer) { clearInterval(this.timer); this.timer = null }
+    this.render()
+    const text = lines.map(l => `     ${l}`).join('\n') + '\n'
+    if (this.live) this.out.write('\x1b[?25h')
+    this.out.write('\n' + text)
+    const answer = await new Promise(resolve => {
+      const readline = require('readline')
+      const rl = readline.createInterface({ input: process.stdin, output: this.out })
+      rl.on('SIGINT', () => { rl.close(); process.kill(process.pid, 'SIGINT') })
+      rl.question(`     ${question} ${D}${defaultYes ? '(Y/n)' : '(y/N)'}${R} `, a => { rl.close(); resolve(a.trim()) })
+    })
+    if (this.live) {
+      this.drawn += lines.length + 2
+      this.out.write('\x1b[?25l')
+      this.timer = setInterval(() => { this.frame++; this.render() }, 80)
+      this.render()
+    } else {
+      this.out.write('\n')
+    }
+    return answer ? /^y(es)?$/i.test(answer) : defaultYes
+  }
+
+  finish() {
+    if (this.timer) { clearInterval(this.timer); this.timer = null }
+    this.render()
+    if (this.live) {
+      this.out.write('\x1b[?25h')
+      process.removeListener('SIGINT', this.onSigint)
+    }
+  }
+}
+
+module.exports = { banner, formatBytes, formatDuration, Steps, colors: { R, D, G, Y, C } }

package/scripts/test-work-map-capability.cjs

@@ -0,0 +1,45 @@
+const assert = require('node:assert/strict')
+const { initialCapability, appleGpuFromReport, usableElectronGpu, detectCapability } = require('./check-work-map-gpu.cjs')
+
+async function main() {
+  const report = { SPDisplaysDataType: [{ _name: 'Apple M5 Max', spdisplays_vendor: 'sppci_vendor_Apple', spdisplays_metal: 'spdisplays_supported' }] }
+  assert(appleGpuFromReport(report))
+  assert(appleGpuFromReport({ SPDisplaysDataType: [{ _name: 'Apple M5 Max', spdisplays_mtlgpufamilysupport: 'spdisplays_metal4' }] }))
+  assert.equal(appleGpuFromReport({ SPDisplaysDataType: [{ ...report.SPDisplaysDataType[0], spdisplays_metal: 'spdisplays_unsupported' }] }), null)
+  assert.equal(appleGpuFromReport({ SPDisplaysDataType: [{ _name: 'Intel GPU', spdisplays_metal: 'spdisplays_supported' }] }), null)
+  assert.equal(appleGpuFromReport(null), null)
+  assert.equal(usableElectronGpu({ gpuDevice: [{ active: true, vendorId: 0x106b }] }), true)
+  assert.equal(usableElectronGpu({ gpuDevice: [{ active: true, vendorId: 0x106b }], auxAttributes: { softwareRendering: true } }), false)
+  assert.equal(usableElectronGpu({ gpuDevice: [{ active: false, vendorId: 0x106b }] }), false)
+
+  let probes = 0
+  const readGpuReport = async () => { probes++; return report }
+  for (const options of [
+    { desktop: false, platform: 'darwin', arch: 'arm64' },
+    { desktop: true, platform: 'darwin', arch: 'x64' },
+    { desktop: true, platform: 'win32', arch: 'arm64' },
+    { desktop: true, platform: 'linux', arch: 'x64' },
+  ]) {
+    assert.equal(initialCapability(options).state, 'unavailable')
+    assert.equal((await detectCapability({ ...options, readGpuReport })).state, 'unavailable')
+  }
+  assert.equal(probes, 0, 'terminal and unsupported platforms never launch a GPU probe')
+  const options = { desktop: true, platform: 'darwin', arch: 'arm64', readGpuReport }
+  assert.equal(initialCapability(options).state, 'checking')
+  assert.equal((await detectCapability({ ...options, verifyGpu: async () => true })).state, 'available')
+  assert.equal((await detectCapability({ ...options, verifyGpu: async () => false })).state, 'unavailable')
+  assert.equal((await detectCapability({ ...options, readGpuReport: async () => { throw new Error('probe failed') } })).state, 'unavailable')
+  // The headless output is ESM: importing shared detection must not execute CJS-only GPU code.
+  const fs = require('node:fs/promises')
+  const path = require('node:path')
+  const root = await fs.mkdtemp(path.join(require('node:os').tmpdir(), 'ctlsurf-gpu-esm-'))
+  try {
+    const file = path.join(root, 'probe.mjs')
+    await require('esbuild').build({ stdin: { contents: "export { initialCapability } from './scripts/check-work-map-gpu.cjs'", resolveDir: path.resolve(__dirname, '..') },
+      bundle: true, platform: 'node', format: 'esm', outfile: file })
+    const probe = await import(require('node:url').pathToFileURL(file).href)
+    assert.equal(probe.initialCapability({ desktop: false }).state, 'unavailable')
+  } finally { await fs.rm(root, { recursive: true, force: true }) }
+  console.log('PASS Apple Metal detection, desktop GPU access, software rendering, platform and terminal exclusions')
+}
+main().catch(error => { console.error(error); process.exitCode = 1 })

package/scripts/test-work-map-ui.cjs

@@ -0,0 +1,130 @@
+// Render the real panel in an isolated Electron window, with a deterministic IPC fixture.
+const { app, BrowserWindow } = require('electron')
+const { build } = require('esbuild')
+const fs = require('node:fs/promises')
+const path = require('node:path')
+const os = require('node:os')
+const assert = require('node:assert/strict')
+app.on('window-all-closed', () => {})
+
+async function main() {
+  const repo = path.resolve(__dirname, '..')
+  const temp = await fs.mkdtemp(path.join(os.tmpdir(), 'ctlsurf-map-ui-'))
+  app.setPath('userData', path.join(temp, 'profile'))
+  let win
+  try {
+    await build({ stdin: { resolveDir: repo, loader: 'tsx', contents: String.raw`
+      import React from 'react'; import {createRoot} from 'react-dom/client';
+      import {WorkMapPanel} from './src/renderer/components/WorkMapPanel';
+      import {WorkMapToggle} from './src/renderer/components/WorkMapToggle';
+      import './src/renderer/styles.css';
+      const ts = new Date().toISOString();
+      const evidence = (i) => [{id:'event-'+i,ts,kind:'tool',tool:'shell',toolId:'call-'+i,source:'rollout-example.jsonl',text:'npm run test -- terminal-scroll\nProcess exited with code 1'}];
+      const nodes = [
+        {id:'goal',parentId:null,kind:'goal',title:'Keep the terminal steady while reading older output',activity:'planning',status:'unknown',ts,evidence:[]},
+        {id:'branch',parentId:'goal',kind:'branch',title:'Terminal scrolling',activity:'planning',status:'unknown',ts,evidence:[]},
+        {id:'thought',parentId:'branch',kind:'step',title:'Preserve the reader’s position instead of forcing the viewport down.',focus:{text:'Preserve the reader’s position instead of forcing the viewport down',reason:'so new output does not interrupt reading older activity.'},activity:'thinking',intent:'decision',status:'unknown',ts,evidence:[{id:'thought-event',ts,kind:'thinking',source:'rollout-example.jsonl',text:'Preserve the reader’s position instead of forcing the viewport down, so new output does not interrupt reading older activity.'}],placement:'clef-flash',confidence:.93},
+        ...Array.from({length:28},(_,i)=>({id:'step-'+i,parentId:'branch',contextId:'thought',kind:'step',title:['Inspect the viewport and scroll listeners','Preserve the reader’s position during new output','Check terminal scroll regression'][i%3],activity:['investigating','editing','testing'][i%3],status:i===2?'failed':i===27?'running':'succeeded',ts,evidence:evidence(i),placement:'clef-flash',confidence:.93}))
+      ];
+      window.exampleNodes = nodes;
+      let capability={state:'available',reason:null,gpuName:'Test GPU'};
+      let capabilityListener;
+      window.emitCapability = (next) => {capability=next; capabilityListener?.(next);window.emitMap({capability:next,settings:{...snapshot.settings,enabled:next.state==='available'}})};
+      let snapshot = {revision:1,tabId:'test',agentName:'Codex',supported:true,ended:false,state:'busy',settings:{enabled:true,engine:'clef-flash',pythonPath:'/local/python',modelPath:'/local/clef-flash'},runtime:'ready',error:null,nodes,dropped:0,thinkingStatus:'available',capability};
+      let listener;
+      window.emitMap = (update) => { snapshot={...snapshot,...update,revision:snapshot.revision+1}; listener?.(snapshot); };
+      window.mapSnapshot = () => snapshot;
+      window.worker = {
+        getWorkMap:async()=>snapshot,
+        getWorkMapCapability:async()=>capability,
+        onWorkMapCapability:callback=>{capabilityListener=callback;return()=>{capabilityListener=null}},
+        getWorkMapSource:async(_,eventId)=>({source:'rollout-example.jsonl',text:'Earlier context before the choice.\n\nPreserve the reader’s position instead of forcing the viewport down, so new output does not interrupt reading older activity.\n\nLater context after the choice, which is not highlighted.'}),
+        setWorkMap:async(_,settings)=>{window.emitMap({settings:{...snapshot.settings,...settings}});return snapshot},
+        clearWorkMap:async()=>{window.emitMap({nodes:[]});return snapshot},
+        onWorkMapUpdate:callback=>{listener=callback;return()=>{listener=null}},
+      };
+      createRoot(document.getElementById('root')).render(<><WorkMapToggle visible onToggle={()=>{}} onUnavailable={()=>{}} /><div style={{flex:1,minHeight:0}}><WorkMapPanel tabId="test" /></div></>);
+    ` }, bundle: true, platform: 'browser', jsx: 'automatic', outfile: path.join(temp, 'panel.js') })
+    await fs.writeFile(path.join(temp, 'index.html'), `<!doctype html><html data-theme="tokyo-night"><head><meta charset="utf-8"><link rel="stylesheet" href="panel.css"><style>html,body,#root{height:100%;width:100%;margin:0;overflow:hidden}#root{display:flex;flex-direction:column}body{font-family:-apple-system,BlinkMacSystemFont,sans-serif}</style></head><body><div id="root"></div><script src="panel.js"></script></body></html>`)
+    await app.whenReady()
+    if (process.platform === 'darwin' && process.arch === 'arm64') {
+      const { detectCapability, usableElectronGpu } = require('./check-work-map-gpu.cjs')
+      const actual = await detectCapability({ desktop: true, verifyGpu: async () => usableElectronGpu(await app.getGPUInfo('complete')) })
+      assert.equal(actual.state, 'available', JSON.stringify(actual))
+      console.log('PASS actual desktop Apple GPU access:', actual.gpuName)
+    }
+    win = new BrowserWindow({ show: false, width: 430, height: 860, webPreferences: { backgroundThrottling: false } })
+    await win.loadFile(path.join(temp, 'index.html'))
+    const run = code => win.webContents.executeJavaScript(code)
+    await run(`new Promise(resolve=>setTimeout(resolve,150))`)
+    assert.equal(await run(`document.querySelectorAll('.work-map-step').length`), 29, 'choices and actions must share one thread')
+    assert.equal(await run(`document.querySelector('.work-map-view')`), null, 'there are no separate decision/activity tabs')
+    assert.match(await run(`document.querySelector('.work-map-reason').textContent`), /Why.*does not interrupt/)
+    assert.equal(await run(`document.querySelectorAll('.work-map-step.follows-intent').length`), 28)
+    const order = await run(`[...document.querySelectorAll('.work-map-step-title')].map(e=>e.textContent)`)
+    await run(`window.emitMap({nodes:[...window.mapSnapshot().nodes.map(n=>n.id==='step-1'?{...n,parentId:'other-topic'}:n),{id:'other-topic',kind:'branch',parentId:'goal',title:'Another topic',activity:'planning',status:'unknown',ts:new Date().toISOString(),evidence:[]}]})`)
+    await run(`new Promise(resolve=>setTimeout(resolve,30))`)
+    assert.deepEqual(await run(`[...document.querySelectorAll('.work-map-step-title')].map(e=>e.textContent)`), order, 'model topic changes cannot reorder the shared thread')
+    await run(`document.querySelector('.work-map-step-button').click()`)
+    await run(`new Promise(resolve=>setTimeout(resolve,30))`)
+    assert.match(await run(`document.querySelector('.work-map-evidence').textContent`), /Full thinking/)
+    assert.match(await run(`document.querySelector('.work-map-source-text').textContent`), /Earlier context.*\n[\s\S]*Later context/)
+    assert.equal(await run(`document.querySelectorAll('.work-map-source-text mark').length`), 2)
+    assert.match(await run(`document.querySelector('mark.choice').textContent`), /Preserve the reader/)
+    assert.match(await run(`document.querySelector('mark.reason').textContent`), /does not interrupt/)
+    assert.match(await run(`document.querySelector('.work-map-step.follows-intent').textContent`), /Follows thinking/)
+    assert.equal(await run(`document.querySelectorAll('.work-map-step').length`), 29)
+    assert.equal(await run(`document.querySelector('select').value`), 'clef-flash')
+    await run(`document.querySelector('.work-map-step-button').click()`)
+    await run(`new Promise(resolve=>setTimeout(resolve,30))`)
+    assert(await run(`(()=>{const el=document.querySelector('.work-map-scroll');return el.scrollHeight-el.scrollTop-el.clientHeight<5})()`))
+    await run(`document.querySelector('.work-map-scroll').scrollTop=0`)
+    await run(`new Promise(resolve=>setTimeout(resolve,80))`)
+    await run(`window.emitMap({nodes:[...window.mapSnapshot().nodes,{...window.mapSnapshot().nodes.filter(n=>n.kind==='step').at(-1),id:'new-step'}]})`)
+    await run(`new Promise(resolve=>setTimeout(resolve,80))`)
+    assert.equal(await run(`document.querySelector('.work-map-scroll').scrollTop`), 0, 'updates preserve scroll position while reading history')
+    assert(await run(`!!document.querySelector('.work-map-jump')`))
+    await run(`document.querySelector('.work-map-branch-heading').click()`)
+    await run(`new Promise(resolve=>setTimeout(resolve,30))`)
+    assert.equal(await run(`document.querySelectorAll('.work-map-step').length`), 0)
+    await run(`document.querySelector('.work-map-branch-heading').click()`)
+    await run(`new Promise(resolve=>setTimeout(resolve,30))`)
+    await run(`document.querySelector('.work-map-step-button').click()`)
+    await run(`new Promise(resolve=>setTimeout(resolve,30))`)
+    assert.match(await run(`document.querySelector('.work-map-evidence').textContent`), /rollout-example\.jsonl/)
+    assert.equal(await run(`document.querySelectorAll('.work-map-step.failed').length`), 1)
+    await run(`document.querySelector('[role=switch]').click()`)
+    await run(`new Promise(resolve=>setTimeout(resolve,30))`)
+    assert.equal(await run(`document.querySelector('[role=switch]').getAttribute('aria-checked')`), 'false')
+    await run(`document.querySelector('[role=switch]').click()`)
+    await run(`new Promise(resolve=>setTimeout(resolve,30))`)
+    await run(`document.querySelector('.work-map-scroll').scrollTop=0`)
+    await run(`new Promise(resolve=>setTimeout(resolve,30))`)
+    assert(await run(`document.documentElement.scrollWidth<=window.innerWidth`), 'no horizontal overflow at panel width')
+    const screenshot = process.env.WORK_MAP_SCREENSHOT || path.join(repo, 'experiments/live-map/.cache/work-map-panel.png')
+    await fs.mkdir(path.dirname(screenshot), { recursive: true })
+    await fs.writeFile(screenshot, (await win.webContents.capturePage()).toPNG())
+    await run(`document.querySelector('.work-map-footer button').click()`)
+    await run(`new Promise(resolve=>setTimeout(resolve,30))`)
+    assert.equal(await run(`document.querySelectorAll('.work-map-goal').length`), 0)
+    assert(await run(`!!document.querySelector('.work-map-empty')`))
+    await run(`window.emitMap({thinkingStatus:'unavailable',nodes:window.exampleNodes.filter(n=>n.id!=='thought')})`)
+    await run(`new Promise(resolve=>setTimeout(resolve,30))`)
+    assert.match(await run(`document.querySelector('.work-map-thinking-status').textContent`), /omits readable thinking/)
+    assert.equal(await run(`document.querySelectorAll('.work-map-step').length`), 28, 'activity remains visible when thinking is omitted')
+    assert.equal(await run(`document.querySelectorAll('.work-map-intent').length`), 0, 'tool activity must not become invented decisions when thinking is omitted')
+    for (const state of ['checking', 'unavailable']) {
+      await run(`window.emitCapability({state:${JSON.stringify(state)},reason:'GPU unavailable'})`)
+      await run(`new Promise(resolve=>setTimeout(resolve,30))`)
+      assert(await run(`document.querySelector('[aria-label="Work map"]').disabled`))
+      assert(await run(`document.querySelector('[role=switch]').disabled`))
+      assert(await run(`document.querySelector('select').disabled`))
+    }
+    console.log('PASS unified chronological thread, salient excerpts and reasons, source receipts, action links, omitted-thinking notice, controls and scroll')
+    console.log('Screenshot:', screenshot)
+  } finally {
+    win?.destroy()
+    await fs.rm(temp, { recursive: true, force: true, maxRetries: 3 })
+  }
+}
+main().then(() => app.exit(0), err => { console.error(err); app.exit(1) })