@harness-mix/cli 0.1.3

package/scripts/native-sidebar-test.cjs

@@ -0,0 +1,88 @@
+const assert = require('node:assert/strict');
+const fs = require('node:fs');
+const path = require('node:path');
+const { includesThread, mergeThreadPage } = require('../src/main/native/thread-list');
+const { cacheCodexRuntime } = require('../src/main/native/launcher');
+
+const thread = { id: 'external', title: 'Pi session', cwd: 'E:/project', createdAt: 10 };
+for (const query of [
+  { sectionId: 'pinned' }, { ancestorThreadId: 'external' }, { parentThreadId: 'external' },
+  { sourceKinds: ['subAgentThreadSpawn'] }, { modelProviders: ['openai'] },
+  { cwd: ['E:/other'] }, { archived: true }, { searchTerm: 'missing' }, { projectId: 'other' },
+]) assert.equal(includesThread(thread, query), false, JSON.stringify(query));
+for (const query of [{}, { sectionId: null }, { cwd: ['E:/project'] }, { searchTerm: 'PI' }, { modelProviders: [] }]) {
+  assert.equal(includesThread(thread, query), true, JSON.stringify(query));
+}
+assert.equal(includesThread({ ...thread, ephemeral: true }, {}), false);
+assert.equal(includesThread({ ...thread, section: { id: 'pinned' } }, { sectionId: 'pinned' }), true);
+const page = { data: [{ id: 'official', createdAt: 20 }, thread], nextCursor: 'next' };
+const merged = mergeThreadPage(page, [thread], {}, t => t);
+assert.deepEqual(merged.data.map(t => t.id), ['official', 'external']);
+assert.equal(merged.nextCursor, 'next');
+assert.equal(mergeThreadPage(page, [thread], { cursor: 'next' }, t => t), page);
+
+const root = fs.mkdtempSync(path.resolve('output/native-runtime-cache-test-'));
+const resources = path.join(root, 'resources');
+const cache = path.join(root, 'cache');
+fs.mkdirSync(resources); fs.mkdirSync(cache);
+for (const name of ['codex.exe', 'codex-code-mode-host.exe', 'codex-command-runner.exe', 'codex-windows-sandbox-setup.exe', 'rg.exe']) {
+  fs.writeFileSync(path.join(resources, name), `fixture:${name}`);
+}
+fs.writeFileSync(path.join(resources, 'unrelated.exe'), 'unrelated');
+fs.copyFileSync(path.join(resources, 'codex.exe'), path.join(cache, 'codex.exe'));
+cacheCodexRuntime(resources, cache);
+assert.equal(fs.existsSync(path.join(cache, 'unrelated.exe')), false);
+assert.equal(fs.readFileSync(path.join(cache, 'codex-code-mode-host.exe'), 'utf8'), 'fixture:codex-code-mode-host.exe');
+fs.truncateSync(path.join(cache, 'codex-code-mode-host.exe'), 0);
+cacheCodexRuntime(resources, cache);
+assert.ok(fs.statSync(path.join(cache, 'codex-code-mode-host.exe')).size > 0);
+console.log('PASS: section/tree filters, deduplication, and incomplete Codex runtime cache repair');
+
+async function testPrewarm() {
+  const file = path.join(root, 'prewarm.cjs');
+  await require('esbuild').build({ entryPoints: ['src/native-ui/desktop-control/src/renderer-draft-prewarm-runtime.ts'], outfile: file, bundle: true, platform: 'node', format: 'cjs', logLevel: 'silent' });
+  const { installDraftPrewarmPolicyBridge } = require(file);
+  const sent = [];
+  const prewarmed = [];
+  const bridge = { sendRequest: (method, params) => sent.push({ method, params }), prewarmThreadStart: params => prewarmed.push(params) };
+  const manager = { onNotification() {}, onRequest() {}, dispatchAppServerResponse() {} };
+  const target = {};
+  installDraftPrewarmPolicyBridge(manager, bridge, 'local', target, { discardAllPrewarmedThreads() {} });
+  const policy = target.__codexhostDraftPrewarmPolicyV1;
+  for (const harness of ['pi', 'claude-code', 'deepseek-harness', 'antigravity']) {
+    policy.select(`codexhost/${harness}-native`);
+    bridge.prewarmThreadStart({ cwd: 'E:/project', model: 'gpt-test' });
+    bridge.sendRequest('thread/start', { cwd: 'E:/project', model: 'gpt-test' });
+    assert.equal(prewarmed.at(-1).ephemeral, true);
+    assert.equal(prewarmed.at(-1).model, `codexhost/${harness}-native`);
+    assert.equal(sent.at(-1).params.ephemeral, undefined);
+  }
+  bridge.prewarmThreadStart({ ephemeral: true, model: 'gpt-title' });
+  assert.equal(prewarmed.at(-1).model, 'gpt-title', 'Internal ephemeral Codex tasks retain their own model');
+  policy.select(null);
+  bridge.prewarmThreadStart({ model: 'gpt-test' });
+  assert.deepEqual(prewarmed.at(-1), { model: 'gpt-test' });
+  policy.dispose();
+  console.log('PASS: all four external prewarm routes stay ephemeral; actual starts and Codex internal tasks are preserved');
+  const sidebarFile = path.join(root, 'sidebar.cjs');
+  await require('esbuild').build({ entryPoints: ['src/native-ui/renderer-extension/src/renderer-sidebar-agent-icons.ts'], outfile: sidebarFile, bundle: true, platform: 'node', format: 'cjs', alias: { '@codexhost/shared-contracts': path.resolve('src/native-ui/shared-contracts/src/index.ts') }, loader: { '.png': 'dataurl', '.svg': 'dataurl' }, logLevel: 'silent' });
+  const { installRendererSidebarAgentIcons } = require(sidebarFile);
+  let cleared = 0;
+  let agent = null;
+  let resolveOwnership;
+  const row = { isConnected: () => true, hostId: () => 'local', threadId: () => 'test', draftId: () => null, render: value => { agent = value; }, clear: () => { agent = null; cleared++; } };
+  const control = installRendererSidebarAgentIcons({ dom: { rows: () => [row], observe: () => () => {}, clear() {} }, getClient: () => ({ listThreadOwnership: () => new Promise(resolve => { resolveOwnership = resolve; }) }) });
+  const settle = () => new Promise(resolve => setImmediate(resolve));
+  await settle(); resolveOwnership({ threads: [{ threadId: 'test', owner: 'codex' }] }); await settle();
+  assert.equal(agent, 'codex');
+  const clearsBeforeRefresh = cleared;
+  control.refresh(); await settle();
+  assert.equal(agent, 'codex');
+  assert.equal(cleared, clearsBeforeRefresh, 'Retain the visible icon while background ownership is unresolved');
+  resolveOwnership({ threads: [{ threadId: 'test', owner: 'external', harnessId: 'pi' }] }); await settle();
+  assert.equal(agent, 'pi');
+  assert.equal(cleared, clearsBeforeRefresh, 'Replace identity without an empty frame');
+  control.dispose();
+  console.log('PASS: sidebar revalidation preserves icons until authoritative ownership arrives');
+}
+testPrewarm().catch(error => { console.error(error); process.exitCode = 1; });

package/scripts/native-ui-smoke.cjs

@@ -0,0 +1,94 @@
+const { app, BrowserWindow } = require('electron');
+const fs = require('node:fs');
+const path = require('node:path');
+const assert = require('node:assert/strict');
+const esbuild = require('esbuild');
+const { getAllIconsDictionary, MODEL_FAMILIES } = require('../src/main/native/icons');
+app.disableHardwareAcceleration();
+
+app.whenReady().then(async () => {
+  const out = path.resolve('output/native-ui-smoke');
+  fs.mkdirSync(out, { recursive: true });
+  const icons = getAllIconsDictionary();
+  icons.harnesses['claude-code'] = icons.harnesses.claude;
+  icons.harnesses['deepseek-harness'] = icons.harnesses.dsh;
+  const bundle = await esbuild.build({ stdin: { contents: `export { createRendererAgentIcon } from './src/native-ui/renderer-extension/src/renderer-agent-icon.ts'; export { mountRendererModelPicker, renderRendererModelPicker } from './src/native-ui/renderer-extension/src/renderer-model-picker.ts'; export { restoredThreadOwnership } from './src/native-ui/renderer-extension/src/renderer-binding-probe.ts'; export { installRendererSidebarAgentIcons } from './src/native-ui/renderer-extension/src/renderer-sidebar-agent-icons.ts';`, resolveDir: process.cwd() }, bundle: true, alias: { '@codexhost/shared-contracts': path.resolve('src/native-ui/shared-contracts/src/index.ts') }, platform: 'browser', format: 'iife', globalName: 'NativeUI', write: false, loader: { '.svg': 'dataurl', '.png': 'dataurl', '.css': 'text' }, logLevel: 'silent' });
+  const win = new BrowserWindow({ show: false, width: 900, height: 650, webPreferences: { contextIsolation: true, sandbox: true, offscreen: true, backgroundThrottling: false } });
+  await win.loadURL('data:text/html,<html><head><style>body{background:%2317191d;color:white;font:16px Arial;padding:40px}button{background:%23272a30;color:white;border:0;padding:12px}img{vertical-align:middle}main{display:flex;gap:25px;margin-bottom:40px}</style></head><body><h2>Harness Mix native components</h2><main></main></body></html>');
+  await win.webContents.executeJavaScript(`globalThis.__HARNESS_MIX_ICONS__=${JSON.stringify(icons)};globalThis.__HARNESS_MIX_MODEL_FAMILIES__=${JSON.stringify(MODEL_FAMILIES.map(f => ({ id: f.id, pattern: f.regex.source })))};${bundle.outputFiles[0].text}`);
+  const { NativeProtocol } = require('../src/main/native/protocol');
+  const nativeThreads = ['pi', 'claude', 'dsh', 'antigravity'].map((harnessId, index) => ({ id: 'sidebar-' + index, harnessId, model: { id: 'model-' + index, provider: 'native' }, options: {} }));
+  const protocol = new NativeProtocol({ threads: nativeThreads, subscribe: () => () => {}, core: { subscribe: () => () => {} }, describe: async () => ({}), getCapabilities: () => ({}) }, () => {});
+  const inspections = await Promise.all(nativeThreads.map(thread => protocol.request('codexhost/thread/inspect', { threadId: thread.id })));
+  await win.webContents.executeJavaScript(`globalThis.testInspections=${JSON.stringify(inspections)}`);
+  const result = await win.webContents.executeJavaScript(`(async () => {
+    const agents = ['codex','pi','claude-code','deepseek-harness','antigravity','omp','opencode','grok'];
+    const restored = testInspections.map(inspection => NativeUI.restoredThreadOwnership(inspection));
+    const sidebar = document.createElement('aside'); document.body.append(sidebar);
+    sidebar.style.cssText = 'margin:24px 0;padding:16px;border:1px solid #555;line-height:30px';
+    for (const [index, agent] of agents.entries()) {
+      const row = document.createElement('div');
+      const attrs = { 'data-app-action-sidebar-thread-row': 'true', 'data-app-action-sidebar-thread-id': 'local:row-' + index, 'data-app-action-sidebar-thread-host-id': 'local' };
+      for (const [key, value] of Object.entries(attrs)) row.setAttribute(key, value);
+      row.innerHTML = '<span data-thread-title-trigger><span data-thread-title>' + agent + ' session</span></span>';
+      row.__reactFiber$test = { memoizedProps: { conversationId: 'row-' + index, dataAttributes: attrs } };
+      sidebar.append(row);
+    }
+    const decoration = NativeUI.installRendererSidebarAgentIcons({ getClient: () => ({ listThreadOwnership: async ({threadIds}) => ({threads: threadIds.map(threadId => { const agent = agents[Number(threadId.slice(4))]; return agent === 'codex' ? {threadId, owner:'codex'} : {threadId, owner:'external', harnessId:agent}; })}) }) });
+    await new Promise(resolve => setTimeout(resolve, 50));
+    const sidebarIcons = [...sidebar.querySelectorAll('[data-codexhost-sidebar-agent-icon]')].map(icon => icon.getAttribute('data-codexhost-sidebar-agent-icon'));
+    // Rescan a React-updated row: no duplicate icon and no loss of ownership.
+    decoration.refresh(); await new Promise(resolve => setTimeout(resolve, 50));
+    const sidebarIconCount = sidebar.querySelectorAll('[data-codexhost-sidebar-agent-icon]').length;
+    globalThis.testSidebarDecoration = decoration;
+    for(const agent of agents) { const el=document.createElement('div'); el.append(NativeUI.createRendererAgentIcon(agent,28),document.createTextNode(' '+agent));document.querySelector('main').append(el); }
+    let selected;
+    const picker=NativeUI.mountRendererModelPicker('test',id=>selected=id,()=>{});
+    globalThis.testModelPicker = picker;
+    document.body.append(picker.root);
+    NativeUI.renderRendererModelPicker(picker,{status:'ready',selected:{id:'a'},catalog:{models:[{ref:{id:'a'},label:'Claude Sonnet'},{ref:{id:'b'},label:'DeepSeek'},{ref:{id:'c'},label:'Gemini'}],thinkingOptions:[]}},true);
+    picker.trigger.click();
+    const option=picker.options.get('b').button;
+    option.click();
+    picker.close(); picker.trigger.click();
+    const levels = [{id:'low',label:'Low'},{id:'high',label:'High'}];
+    const view = {status:'ready',selected:{id:'a'},catalog:{models:[{ref:{id:'a'},label:'Claude Sonnet'}, {ref:{id:'b'},label:'DeepSeek',supportedThinkingOptionIds:['low','high']}],thinkingOptions:levels}};
+    let thinking;
+    const flow=NativeUI.mountRendererModelPicker('flow', id=>{ view.selected={id}; NativeUI.renderRendererModelPicker(flow,view,true); },id=>{thinking=id;view.selectedThinkingOptionId=id;NativeUI.renderRendererModelPicker(flow,view,true);});
+    document.body.append(flow.root);
+    NativeUI.renderRendererModelPicker(flow,view,true);
+    flow.trigger.click();
+    const modelFirst = flow.menu.dataset.twoColumn === 'false';
+    flow.options.get('b').button.click();
+    const stayedOpen = flow.menu.matches(':popover-open');
+    const modelRect = flow.options.get('b').button.getBoundingClientRect();
+    const thinkingRect = flow.thinkingOptions.get('high').button.getBoundingClientRect();
+    const thinkingOnRight = thinkingRect.left >= modelRect.right;
+    flow.thinkingOptions.get('high').button.click();
+    const confirmed = flow.thinkingOptions.get('high').button.getAttribute('aria-checked') === 'true';
+    const closedAfterThinking = !flow.menu.matches(':popover-open');
+    flow.trigger.click();
+    const reopenedModelFirst = flow.menu.dataset.twoColumn === 'false';
+    flow.dispose();
+    await Promise.all([...document.images].map(i=>i.decode()));
+    return {selected,modelFirst,stayedOpen,thinkingOnRight,thinking,confirmed,closedAfterThinking,reopenedModelFirst,restored,sidebarIcons,sidebarIconCount,icons:[...document.images].map(i=>i.dataset.harnessMixIcon),loaded:[...document.images].every(i=>i.naturalWidth>0)};
+  })()`);
+  assert.equal(result.selected, 'b');
+  for (const key of ['modelFirst','stayedOpen','thinkingOnRight','confirmed','closedAfterThinking','reopenedModelFirst']) assert.equal(result[key], true, key);
+  assert.equal(result.thinking, 'high');
+  assert.equal(result.loaded, true);
+  assert.deepEqual(result.sidebarIcons, ['codex','pi','claude-code','deepseek-harness','antigravity','omp','opencode','grok']);
+  assert.equal(result.sidebarIconCount, 8);
+  assert.deepEqual(result.restored.map(item => item.agent), ['pi','claude-code','deepseek-harness','antigravity']);
+  assert.deepEqual(result.restored.map(item => item.model), inspections.map(item => item.effectiveModel));
+  for (const id of ['harnesses/codex','harnesses/pi','harnesses/claude-code','harnesses/deepseek-harness','harnesses/antigravity','models/claude','models/deepseek','models/gemini']) assert.ok(result.icons.includes(id), id);
+  await win.webContents.executeJavaScript('testModelPicker.trigger.click();document.querySelector("main").style.flexWrap="wrap"');
+  await new Promise(resolve => setTimeout(resolve, 300));
+  fs.writeFileSync(path.join(out, 'native-components.png'), (await win.webContents.capturePage()).toPNG());
+  await win.webContents.executeJavaScript(`document.body.style.background='#fff';document.body.style.color='#17191d';document.querySelector('main').style.flexWrap='wrap'`);
+  await new Promise(resolve => setTimeout(resolve, 100));
+  fs.writeFileSync(path.join(out, 'native-components-light.png'), (await win.webContents.capturePage()).toPNG());
+  win.destroy();
+  console.log('PASS: real Electron native picker selection and all project Harness/model SVGs load');
+  app.quit();
+}).catch(error => { console.error(error); app.exit(1); });

package/scripts/native-update-apply-test.cjs

@@ -0,0 +1,215 @@
+// Update v2 coverage: state file / lock / channel detection / semver, plus the
+// runUpdateFlow orchestration with mocked deps. Fully offline; no real npm/git.
+const assert = require('node:assert/strict');
+const fs = require('node:fs');
+const os = require('node:os');
+const path = require('node:path');
+const {
+  acquireLock, compareVersions, detectChannel, markBootOk, readState, writeState,
+} = require('../src/main/native/update-state');
+const { fetchLatestVersion, runUpdateFlow } = require('../src/main/native/updater');
+
+const tmp = prefix => fs.mkdtempSync(path.join(os.tmpdir(), prefix));
+const quiet = () => {};
+const delay = () => Promise.resolve();
+const fetchVersion = version => async () => ({
+  ok: true, status: 200,
+  json: async () => ({ 'dist-tags': { latest: version } }),
+  headers: { get: () => null },
+});
+const npmFixture = (version = '0.1.0') => {
+  const root = path.join(tmp('hm-npm-'), 'node_modules', 'harness-mix');
+  fs.mkdirSync(root, { recursive: true });
+  fs.writeFileSync(path.join(root, 'package.json'), JSON.stringify({ name: 'harness-mix', version }));
+  return root;
+};
+const npmRun = (root, { install = { status: 0 } } = {}) => (cmd, args) => {
+  if (args[0] === 'root') return { status: 0, stdout: `${path.dirname(root)}\n` };
+  if (args[0] === 'config') return { status: 0, stdout: 'https://registry.test/\n' };
+  if (args[0] === 'install') return install;
+  return { status: 0, stdout: '' };
+};
+
+(async () => {
+  // --- semver / channel detection ---
+  assert.equal(compareVersions('0.2.0', '0.1.1'), 1);
+  assert.equal(compareVersions('0.1.1', '0.1.1'), 0);
+  assert.equal(compareVersions('0.1.10', '0.1.9'), 1);
+  assert.equal(compareVersions('0.10.0', '0.9.9'), 1);
+  assert.equal(compareVersions('0.2.0-rc.1', '0.2.0'), -1);
+  assert.equal(compareVersions('0.2.0', '0.2.0-rc.1'), 1);
+
+  const gitRoot = tmp('hm-git-');
+  fs.mkdirSync(path.join(gitRoot, '.git'));
+  assert.equal(detectChannel(gitRoot), 'git');
+  assert.equal(detectChannel(npmFixture()), 'npm');
+  assert.equal(detectChannel(tmp('hm-plain-')), 'portable');
+
+  // --- state file tolerates corruption; lock lifecycle incl. stale reap ---
+  const data = tmp('hm-data-');
+  fs.writeFileSync(path.join(data, 'update-state.json'), '{not json');
+  assert.equal(readState(data).phase, 'idle');
+  const release = acquireLock(data, 'test');
+  assert.throws(() => acquireLock(data, 'test'), /更新锁/);
+  release();
+  acquireLock(data, 'test')();
+  fs.writeFileSync(path.join(data, 'update.lock'), JSON.stringify({ pid: process.pid, ts: Date.now() - 31 * 60 * 1000, op: 'stale' }));
+  acquireLock(data, 'test')(); // stale locks are reaped even when the pid still lives
+  writeState(data, { ...readState(data), appliedVersion: '0.2.0', appliedAt: Date.now() - 1000, attempts: 3 });
+  markBootOk(data);
+  assert.equal(readState(data).attempts, 0);
+  assert.ok(readState(data).lastBootOkAt > 0);
+
+  // --- fetchLatestVersion: etag cache answers 304 from disk ---
+  {
+    const dir = tmp('hm-etag-');
+    const first = await fetchLatestVersion({
+      registry: 'https://registry.test/', dataDir: dir,
+      fetchImpl: async () => ({ ok: true, status: 200, json: async () => ({ 'dist-tags': { latest: '9.9.9' } }), headers: { get: name => (name === 'etag' ? '"e1"' : null) } }),
+    });
+    assert.equal(first, '9.9.9');
+    const second = await fetchLatestVersion({
+      registry: 'https://registry.test/', dataDir: dir,
+      fetchImpl: async () => ({ ok: false, status: 304, headers: { get: () => null } }),
+    });
+    assert.equal(second, '9.9.9');
+  }
+
+  // --- npm: update available -> applied, restart required ---
+  {
+    const root = npmFixture();
+    const dir = tmp('hm-flow-');
+    const calls = [];
+    const run = (cmd, args) => { calls.push(args.join(' ')); return npmRun(root)(cmd, args); };
+    let stopped = 0;
+    const outcome = await runUpdateFlow({
+      root, dataDir: dir, log: quiet, stopDesktop: async () => { stopped += 1; }, mode: 'apply',
+      deps: { run, fetchImpl: fetchVersion('0.2.0'), delay, env: {} },
+    });
+    assert.equal(outcome.updated, true);
+    assert.equal(outcome.to, '0.2.0');
+    assert.equal(outcome.restartRequired, true);
+    assert.equal(stopped, 1);
+    assert.ok(calls.some(call => call.startsWith('install -g harness-mix@0.2.0')));
+    const state = readState(dir);
+    assert.equal(state.appliedVersion, '0.2.0');
+    assert.equal(state.prevVersion, '0.1.0');
+    assert.equal(state.phase, 'idle');
+  }
+
+  // --- npm: install failure -> pending for the next launch, never blocks ---
+  {
+    const root = npmFixture();
+    const dir = tmp('hm-flow-');
+    const outcome = await runUpdateFlow({
+      root, dataDir: dir, log: quiet, stopDesktop: async () => {}, mode: 'apply',
+      deps: { run: npmRun(root, { install: { status: 1, stderr: 'EBUSY: file locked' } }), fetchImpl: fetchVersion('0.2.0'), delay, env: {} },
+    });
+    assert.equal(outcome.updated, false);
+    assert.equal(outcome.pending, '0.2.0');
+    assert.equal(outcome.restartRequired, undefined);
+    assert.equal(readState(dir).pendingVersion, '0.2.0');
+  }
+
+  // --- npm: registry offline -> failed, launch continues ---
+  {
+    const root = npmFixture();
+    const dir = tmp('hm-flow-');
+    const outcome = await runUpdateFlow({
+      root, dataDir: dir, log: quiet, stopDesktop: async () => {}, mode: 'apply',
+      deps: { run: npmRun(root), fetchImpl: async () => { throw new Error('getaddrinfo ENOTFOUND'); }, delay, env: {} },
+    });
+    assert.equal(outcome.failed, true);
+    assert.equal(outcome.restartRequired, undefined);
+  }
+
+  // --- update lock held elsewhere -> skip without touching the desktop ---
+  {
+    const root = npmFixture();
+    const dir = tmp('hm-flow-');
+    fs.writeFileSync(path.join(dir, 'update.lock'), JSON.stringify({ pid: process.pid, ts: Date.now(), op: 'other' }));
+    let stopped = 0;
+    const outcome = await runUpdateFlow({
+      root, dataDir: dir, log: quiet, stopDesktop: async () => { stopped += 1; }, mode: 'apply',
+      deps: { run: npmRun(root), fetchImpl: fetchVersion('0.2.0'), delay, env: {} },
+    });
+    assert.equal(outcome.failed, true);
+    assert.equal(outcome.reason, 'lock');
+    assert.equal(stopped, 0);
+  }
+
+  // --- crash loop: second failed boot rolls back to prevVersion ---
+  {
+    const root = npmFixture('0.2.0'); // the installed tree currently runs 0.2.0
+    const dir = tmp('hm-flow-');
+    writeState(dir, { ...readState(dir), channel: 'npm', appliedVersion: '0.2.0', prevVersion: '0.1.0', appliedAt: Date.now() - 1000, lastBootOkAt: 0, attempts: 1 });
+    const calls = [];
+    const run = (cmd, args) => { calls.push(args.join(' ')); return npmRun(root)(cmd, args); };
+    const outcome = await runUpdateFlow({
+      root, dataDir: dir, log: quiet, stopDesktop: async () => {}, mode: 'apply',
+      deps: { run, fetchImpl: async () => { throw new Error('offline'); }, delay, env: {} },
+    });
+    assert.equal(outcome.rolledBack, true);
+    assert.equal(outcome.restartRequired, true);
+    assert.ok(calls.some(call => call.startsWith('install -g harness-mix@0.1.0')));
+    const state = readState(dir);
+    assert.equal(state.appliedVersion, null);
+    assert.equal(state.prevVersion, null);
+    assert.equal(state.attempts, 0);
+  }
+
+  // --- git: fast-forward applies and asks for a restart ---
+  {
+    const root = tmp('hm-git-flow-');
+    fs.mkdirSync(path.join(root, '.git'), { recursive: true });
+    fs.writeFileSync(path.join(root, 'package.json'), JSON.stringify({ name: 'harness-mix', version: '0.1.1' }));
+    const dir = tmp('hm-flow-');
+    const script = {
+      'rev-parse HEAD': 'aaa111\n',
+      'rev-parse --abbrev-ref': 'origin/main\n',
+      fetch: '',
+      'rev-parse origin/main': 'bbb222\n',
+      'merge-base': 'aaa111\n',
+      status: '',
+      'diff --name-only': 'docs/x.md\n',
+      'merge --ff-only': '',
+    };
+    const calls = [];
+    const exec = (cmd, args) => {
+      const key = args.join(' ');
+      calls.push(key);
+      for (const [prefix, stdout] of Object.entries(script)) if (key.startsWith(prefix)) return { status: 0, stdout, stderr: '' };
+      return { status: 0, stdout: '', stderr: '' };
+    };
+    const outcome = await runUpdateFlow({
+      root, dataDir: dir, log: quiet, stopDesktop: async () => {}, mode: 'apply',
+      deps: { gitExec: exec, delay, env: {} },
+    });
+    assert.equal(outcome.updated, true);
+    assert.equal(outcome.restartRequired, true);
+    assert.ok(calls.some(call => call.startsWith('merge --ff-only')));
+    assert.equal(readState(dir).appliedVersion, 'bbb222');
+    assert.equal(readState(dir).prevVersion, 'aaa111');
+  }
+
+  // --- git: interrupted apply is repaired from preUpdateHead ---
+  {
+    const root = tmp('hm-git-repair-');
+    fs.mkdirSync(path.join(root, '.git'), { recursive: true });
+    fs.writeFileSync(path.join(root, 'package.json'), JSON.stringify({ name: 'harness-mix', version: '0.1.1' }));
+    const dir = tmp('hm-flow-');
+    writeState(dir, { ...readState(dir), channel: 'git', phase: 'applying', preUpdateHead: 'aaa111', appliedVersion: 'bbb222' });
+    const calls = [];
+    const exec = (cmd, args) => { calls.push(args.join(' ')); return { status: 0, stdout: '', stderr: '' }; };
+    const outcome = await runUpdateFlow({
+      root, dataDir: dir, log: quiet, stopDesktop: async () => {}, mode: 'apply',
+      deps: { gitExec: exec, delay, env: {} },
+    });
+    assert.equal(outcome.repaired, true);
+    assert.equal(outcome.restartRequired, true);
+    assert.ok(calls.some(call => call.startsWith('reset --hard aaa111')));
+    assert.equal(readState(dir).phase, 'idle');
+  }
+
+  console.log('native-update-apply: semver/channel/state/lock/etag/npm-apply/pending/offline/lock-skip/crash-loop-rollback/git-ff/git-repair all covered');
+})().catch(error => { console.error(error); process.exitCode = 1; });

package/scripts/native-updater-test.cjs

@@ -0,0 +1,109 @@
+// Native auto-updater decision coverage: every remote state and hook trigger path.
+const assert = require('node:assert/strict');
+const { autoUpdate } = require('../src/main/native/updater');
+
+function fakeGit(script) {
+  const calls = [];
+  const exec = (cmd, args) => {
+    const key = args.join(' ');
+    calls.push(key);
+    for (const [pattern, response] of Object.entries(script)) {
+      if (key.startsWith(pattern)) {
+        if (response instanceof Error) return { status: 1, stdout: '', stderr: response.message };
+        return { status: 0, stdout: response, stderr: '' };
+      }
+    }
+    return { status: 0, stdout: '', stderr: '' };
+  };
+  return { calls, exec };
+}
+
+const base = {
+  'rev-parse HEAD': 'aaa111\n',
+  'rev-parse --abbrev-ref': 'origin/main\n',
+  'fetch': '',
+  'merge-base': 'aaa111\n',
+  'status': '',
+};
+
+(async () => {
+  // 1. Up to date: no merge, no hooks.
+  {
+    const { exec } = fakeGit({ ...base, 'rev-parse origin/main': 'aaa111\n' });
+    const outcome = await autoUpdate({ root: '.', log: () => {}, exec, hooks: { install: () => assert.fail('install'), build: () => assert.fail('build') } });
+    assert.deepEqual(outcome, { updated: false, state: 'current' });
+  }
+
+  // 2. Local ahead: skip.
+  {
+    const { exec } = fakeGit({ ...base, 'rev-parse origin/main': 'bbb222\n', 'merge-base': 'bbb222\n' });
+    const outcome = await autoUpdate({ root: '.', log: () => {}, exec });
+    assert.equal(outcome.updated, false);
+    assert.equal(outcome.state, 'ahead');
+  }
+
+  // 3. Diverged: skip.
+  {
+    const { exec } = fakeGit({ ...base, 'rev-parse origin/main': 'bbb222\n', 'merge-base': 'ccc333\n' });
+    const outcome = await autoUpdate({ root: '.', log: () => {}, exec });
+    assert.equal(outcome.updated, false);
+    assert.equal(outcome.state, 'diverged');
+  }
+
+  // 4. Dirty tree: skip, merge never attempted.
+  {
+    const { exec, calls } = fakeGit({ ...base, 'rev-parse origin/main': 'bbb222\n', 'status': ' M src/main/native/protocol.js\n' });
+    const outcome = await autoUpdate({ root: '.', log: () => {}, exec });
+    assert.equal(outcome.state, 'dirty');
+    assert.ok(!calls.some(c => c.startsWith('merge --ff-only')));
+  }
+
+  // 5. Fast-forward available with dependency change: merge + install + rebuild.
+  {
+    const { exec, calls } = fakeGit({
+      ...base,
+      'rev-parse origin/main': 'bbb222\n',
+      'diff --name-only aaa111 bbb222': 'package.json\nsrc/main/native/updater.js\n',
+    });
+    let installed = 0, rebuilt = 0;
+    const outcome = await autoUpdate({ root: '.', log: () => {}, exec, hooks: { install: () => installed++, build: () => rebuilt++ } });
+    assert.equal(outcome.updated, true);
+    assert.equal(outcome.from, 'aaa111');
+    assert.equal(outcome.to, 'bbb222');
+    assert.equal(installed, 1);
+    assert.equal(rebuilt, 1);
+    assert.ok(calls.some(c => c.startsWith('merge --ff-only origin/main')));
+  }
+
+  // 6. Fast-forward with docs-only change: no install, no rebuild.
+  {
+    const { exec } = fakeGit({
+      ...base,
+      'rev-parse origin/main': 'bbb222\n',
+      'diff --name-only aaa111 bbb222': 'docs/native-codex.md\n',
+    });
+    const outcome = await autoUpdate({ root: '.', log: () => {}, exec, hooks: { install: () => assert.fail('install'), build: () => assert.fail('build') } });
+    assert.equal(outcome.updated, true);
+    assert.equal(outcome.installed, false);
+    assert.equal(outcome.rebuilt, false);
+  }
+
+  // 7. Fetch failure (offline): tolerated, never throws.
+  {
+    const { exec } = fakeGit({ 'fetch': new Error('Could not resolve host') });
+    const outcome = await autoUpdate({ root: '.', log: () => {}, exec });
+    assert.equal(outcome.updated, false);
+    assert.equal(outcome.failed, true);
+  }
+
+  // 8. Hook failure rolls back to the pre-merge head and never blocks launch.
+  {
+    const { exec, calls } = fakeGit({ ...base, 'rev-parse origin/main': 'bbb222\n', 'diff --name-only aaa111 bbb222': 'package.json\n' });
+    const outcome = await autoUpdate({ root: '.', log: () => {}, exec, hooks: { install: () => { throw new Error('npm install failed'); }, build: () => {} } });
+    assert.equal(outcome.updated, false);
+    assert.equal(outcome.failed, true);
+    assert.ok(calls.some(c => c.startsWith('reset --hard aaa111')));
+  }
+
+  console.log('native-updater: current/ahead/diverged/dirty/ff/ff-docs-only/offline/rollback all covered');
+})().catch(error => { console.error(error); process.exitCode = 1; });

package/scripts/native-vendor-adapters-test.cjs

@@ -0,0 +1,88 @@
+const assert = require('node:assert/strict');
+const oc = require('../src/main/adapters/opencode');
+const grok = require('../src/main/adapters/grok');
+const pi = require('../src/main/adapters/pi');
+(async () => {
+  const events = [], calls = [];
+  const session = { nativeSessionId: 's', emit: e => events.push(e), state: { active: true, userMessages: new Set(), parts: new Map(), text: new Map(), permissions: new Map(), questions: new Map() } };
+  const event = (type, properties) => oc.projectEvent(session, { type, properties: { sessionID: 's', ...properties } }, session.emit);
+  event('message.updated', { info: { role: 'user', id: 'u' } });
+  event('message.part.updated', { part: { id: 'up', messageID: 'u', type: 'text', text: 'do not echo' } });
+  event('message.part.updated', { part: { id: 'p', messageID: 'a', type: 'text', text: 'A' } });
+  event('message.part.delta', { partID: 'p', field: 'text', delta: 'B' });
+  oc.projectPart(session, { id: 'p', messageID: 'a', type: 'text', text: 'AB' }, session.emit);
+  assert.equal(events.filter(e => e.kind === 'text-delta').map(e => e.text).join(''), 'AB');
+  event('question.asked', { id: 'q', questions: [{ question: 'Choose', options: [{ label: 'yes' }] }] });
+  assert.equal(events.at(-1).kind, 'approval');
+  let fail = true;
+  session.host = { request: async (...args) => { if (fail) throw new Error('network'); calls.push(args); } };
+  const adapter = oc.create();
+  await assert.rejects(adapter.respond(session, 'q:0', { value: 'yes' }));
+  assert.equal(session.state.questions.get('q').index, 0);
+  fail = false;
+  await adapter.respond(session, 'q:0', { value: 'yes' });
+  assert.deepEqual(calls.at(-1)[2], { answers: [['yes']] });
+  event('permission.asked', { id: 'perm', permission: 'shell', patterns: ['test'] });
+  await assert.rejects(adapter.respond(session, 'perm', { value: 'invented' }));
+  await adapter.respond(session, 'perm', { optionId: 'always' });
+  assert.deepEqual(calls.at(-1)[2], { reply: 'always' });
+  assert.deepEqual(grok.projectUsage({ input_tokens: 12, outputTokens: 3, signature: 'private', costUsdTicks: 5 }), { inputTokens: 12, outputTokens: 3 });
+  const piFailure = pi.project({ type: 'agent_end', willRetry: false, messages: [{ role: 'assistant', stopReason: 'error', errorMessage: 'native quota exhausted' }] });
+  assert.equal(piFailure.kind, 'error'); assert.match(piFailure.message, /quota exhausted/);
+  let answer;
+  const gs = { pendingApprovals: new Map([['r', { options: [{ optionId: 'native-always', kind: 'allow_always' }], resolve: v => { answer = v; } }]]) };
+  await assert.rejects(grok.create().respond(gs, 'r', { optionId: 'fake' }));
+  await grok.create().respond(gs, 'r', { optionId: 'native-always' });
+  assert.equal(grok.manifest.capabilities.attachments, true);
+  const grokCalls = [];
+  const grokSession = { nativeSessionId: 'grok-1', state: { agentCapabilities: {} }, process: { request: async (method, params) => { grokCalls.push({ method, params }); return { stopReason: 'end_turn', _meta: { promptId: 'p1' } }; } } };
+  await grok.create().send(grokSession, 'hi', { emit: () => {} }, { images: [{ data: 'AA==', mime: 'image/png' }] });
+  assert.equal(grokCalls[0].method, 'session/prompt');
+  assert.deepEqual(grokCalls[0].params.prompt, [{ type: 'text', text: 'hi' }, { type: 'image', data: 'AA==', mimeType: 'image/png' }]);
+
+  // Grok auto-compaction update parsing
+  const updateStarted = grok.parseGrokCompactionUpdate({ sessionUpdate: 'auto_compact_started', tokens_used: 400000, context_window: 500000 });
+  assert.deepEqual(updateStarted, { type: 'started', tokensUsed: 400000, contextWindowTokens: 500000 });
+  const updateCompleted = grok.parseGrokCompactionUpdate({ sessionUpdate: 'auto_compact_completed', tokens_before: 400000, tokens_after: 12000, context_window: 500000 });
+  assert.deepEqual(updateCompleted, { type: 'completed', outcome: 'succeeded', tokensBefore: 400000, tokensAfter: 12000, contextWindowTokens: 500000 });
+  const updateFailed = grok.parseGrokCompactionUpdate({ sessionUpdate: 'auto_compact_failed', error_message: 'compaction error' });
+  assert.deepEqual(updateFailed, { type: 'completed', outcome: 'failed', errorMessage: 'compaction error' });
+  const updateCancelled = grok.parseGrokCompactionUpdate({ sessionUpdate: 'auto_compact_cancelled' });
+  assert.deepEqual(updateCancelled, { type: 'completed', outcome: 'cancelled' });
+
+  // Grok commands & manual compact
+  const grokAdapterInst = grok.create();
+  const grokCmds = await grokAdapterInst.listCommands(grokSession);
+  assert.ok(grokCmds.some(c => c.id === 'compact' && c.action === 'execute'));
+
+  // Test /compact interception in send()
+  const grokCompactEmits = [];
+  grokCalls.length = 0;
+  grokSession.process.request = async (method, params) => {
+    grokCalls.push({ method, params });
+    return { outcome: 'succeeded', tokensBefore: 50000, tokensAfter: 5000 };
+  };
+  await grokAdapterInst.send(grokSession, '/compact keep recent tests', { emit: e => grokCompactEmits.push(e) });
+  assert.equal(grokCalls[0].method, 'x.ai/compact_conversation');
+  assert.deepEqual(grokCalls[0].params, { sessionId: 'grok-1', userContext: 'keep recent tests' });
+  assert.ok(grokCompactEmits.some(e => e.kind === 'compaction' && e.state === 'completed' && e.outcome === 'succeeded'));
+  assert.ok(grokCompactEmits.some(e => e.kind === 'usage' && e.usage.tokens === 5000));
+
+  // Test EventNormalizer compaction mapping
+  const { EventNormalizer } = require('../src/main/harness-adapter/event-normalizer');
+  const normalizer = new EventNormalizer({ threadId: 't-comp' });
+  normalizer.beginTurn('turn-c', 'test compact');
+  const normEvents = normalizer.normalize({ kind: 'compaction', tokensBefore: 50000, tokensAfter: 5000 });
+  assert.equal(normEvents.length, 2);
+  assert.equal(normEvents[0].type, 'item.started');
+  assert.equal(normEvents[0].payload.type, 'context_compaction');
+  assert.equal(normEvents[0].payload.tokensBefore, 50000);
+  assert.equal(normEvents[1].type, 'item.completed');
+
+  // Test projectItem mapping
+  const { projectItem } = require('../src/main/native/protocol');
+  const projected = projectItem({ id: 'norm-item-1', type: 'context_compaction' });
+  assert.deepEqual(projected, { id: 'norm-item-1', type: 'contextCompaction' });
+
+  console.log('Native adapters: streaming deduplication, user suppression, question retry, exact native approvals, sanitized usage, grok images, grok compaction & UI projection PASS');
+})().catch(error => { console.error(error); process.exitCode = 1; });

package/scripts/openclaw-acp-probe.cjs

@@ -0,0 +1,39 @@
+// 一次性探针：spawn `openclaw acp`，发 ACP initialize，打印能力面后退出。
+const { spawn } = require('node:child_process');
+const fs = require('node:fs');
+const os = require('node:os');
+const path = require('node:path');
+
+const { cliSpawn } = require('../src/main/host/jsonl');
+const cfg = JSON.parse(fs.readFileSync(path.join(os.homedir(), '.openclaw', 'openclaw.json'), 'utf8'));
+const token = cfg?.gateway?.auth?.token;
+
+const args = ['acp'];
+if (token) args.push('--token', token);
+const cli = cliSpawn('openclaw', args);
+const child = spawn(cli.command, cli.args, { windowsHide: true, stdio: ['pipe', 'pipe', 'pipe'] });
+let buf = '';
+child.stdout.on('data', (c) => {
+  buf += c;
+  let idx;
+  while ((idx = buf.indexOf('\n')) >= 0) {
+    const line = buf.slice(0, idx).trim();
+    buf = buf.slice(idx + 1);
+    if (!line) continue;
+    try {
+      const msg = JSON.parse(line);
+      console.log('RECV:', JSON.stringify(msg).slice(0, 2000));
+      if (msg.id === 0) {
+        // 再试一个 session/new 看 resume 面
+        send({ jsonrpc: '2.0', id: 1, method: 'session/new', params: { cwd: process.cwd(), mcpServers: [] } });
+      } else if (msg.id === 1 || msg.id === 2) {
+        setTimeout(() => { child.kill(); process.exit(0); }, 500);
+      }
+    } catch { console.log('NONJSON:', line.slice(0, 200)); }
+  }
+});
+child.stderr.on('data', (c) => { const s = String(c).trim(); if (s) console.log('STDERR:', s.slice(0, 300)); });
+child.on('exit', (code) => { console.log('EXIT', code); process.exit(0); });
+function send(msg) { child.stdin.write(JSON.stringify(msg) + '\n'); }
+send({ jsonrpc: '2.0', id: 0, method: 'initialize', params: { protocolVersion: 1, clientCapabilities: { fs: { readTextFile: true, writeTextFile: true }, terminal: true } } });
+setTimeout(() => { console.log('TIMEOUT'); child.kill(); process.exit(1); }, 25000);