@phenx-inc/ctlsurf 0.17.2 → 0.17.3

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.3",
   "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,15 @@
+const { spawnSync } = require('node:child_process')
+const { detectCapability } = require('./check-work-map-gpu.cjs')
+
+// 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. */ }
+
+detectCapability({ desktop: true }).then(capability => {
+  console.log(capability.state === '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.`)
+}).catch(() => {})

package/scripts/prepare-work-map.py

@@ -0,0 +1,37 @@
+"""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')
+    args = parser.parse_args()
+    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 not python.exists():
+        subprocess.run(['uv', 'venv', '--python', '3.12', str(root / 'env')], env=env, check=True)
+    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)
+    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/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) })