@harness-mix/cli 0.1.5 → 0.1.7

package/scripts/native-sidebar-test.cjs

@@ -21,6 +21,13 @@ 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 archivedThread = { id: 'archived-ext', archived: true, createdAt: 15 };
+const pageWithArchived = { data: [{ id: 'official', createdAt: 20 }, archivedThread], nextCursor: null };
+const mergedWithoutArchived = mergeThreadPage(pageWithArchived, [archivedThread], { archived: false }, t => t);
+assert.deepEqual(mergedWithoutArchived.data.map(t => t.id), ['official']);
+const mergedWithArchived = mergeThreadPage({ data: [{ id: 'official-archived', archived: true, createdAt: 20 }, archivedThread], nextCursor: null }, [archivedThread], { archived: true }, t => t);
+assert.deepEqual(mergedWithArchived.data.map(t => t.id), ['official-archived', 'archived-ext']);
+
 const root = fs.mkdtempSync(path.resolve('output/native-runtime-cache-test-'));
 const resources = path.join(root, 'resources');
 const cache = path.join(root, 'cache');

package/scripts/native-skill-roots-test.cjs

@@ -0,0 +1,90 @@
+const assert = require('node:assert/strict');
+const fs = require('node:fs/promises');
+const os = require('node:os');
+const path = require('node:path');
+const { ParityObserver } = require('./support/parity-observer.cjs');
+const { HostRuntime } = require('../src/main/host/runtime');
+
+// 用户可见契约：打开原生会话时，先为每个 Harness 创建缺失的原生技能根目录，
+// 这样刚安装、从未运行过的 Harness 也能立即被 Harness Mix 发现并安装技能。
+// 单个目录创建失败只提示、不阻断会话；项目作用域不可用时退化为全局根目录。
+
+const skills = { global: ['.test-harness/skills'], project: ['.agents/skills'] };
+const sleep = ms => new Promise(resolve => setTimeout(resolve, ms));
+async function until(fn) { for (let i = 0; i < 200; i++) { if (fn()) return; await sleep(10); } throw new Error('timed out'); }
+
+function stubAdapter(id, onOpen) {
+  return {
+    manifest: { id, name: 'Test Harness', capabilities: {}, integrations: { mcp: false, skills: JSON.parse(JSON.stringify(skills)) } },
+    async open(input) { onOpen?.(input); return {}; },
+    async send() {}, async cancel() {}, async respond() {}, async close() {},
+  };
+}
+
+async function main() {
+  const directory = await fs.mkdtemp(path.join(os.tmpdir(), 'hm-skill-roots-'));
+  const workspace = path.join(directory, 'workspace');
+  const home = path.join(directory, 'home');
+  await fs.mkdir(workspace); await fs.mkdir(home);
+
+  const rt = new HostRuntime({ observer: new ParityObserver(), dataDirectory: directory });
+  await rt.store.load();
+  rt.integrations.home = home;
+  rt.integrations.environment = {};
+
+  // 1) 缺失的技能目录在会话打开时被创建（全局 + 项目）。
+  let opened = 0, emit = null;
+  const adapter = stubAdapter('test-harness', input => { opened++; emit = input.emit; });
+  rt.adapters.set(adapter.manifest.id, adapter);
+  rt.status[adapter.manifest.id] = { available: true };
+  const thread = await rt.createThread({ harnessId: adapter.manifest.id, cwd: workspace });
+  const toasts = [];
+  rt.subscribe(event => { if (event.type === 'toast') toasts.push(event); });
+  await rt.send(thread.id, 'hello');
+  assert.equal(opened, 1, 'native session opened');
+  for (const root of [path.join(home, '.test-harness', 'skills'), path.join(workspace, '.agents', 'skills')]) {
+    assert.equal((await fs.stat(root)).isDirectory(), true, `${root} created on launch`);
+  }
+  assert.deepEqual(toasts, [], 'a successful launch reports no skill-root failure');
+  emit({ kind: 'completed', finalAnswer: true });
+  await until(() => thread.status === 'ready' && !thread.reviewPending);
+
+  // 2) 已存在的根目录被复用，重复打开不会失败。
+  await fs.mkdir(path.join(home, '.test-harness', 'skills', 'existing'), { recursive: true });
+  await rt.send(thread.id, 'again');
+  assert.equal(opened, 1, 'same thread reuses the native session');
+  emit({ kind: 'completed', finalAnswer: true });
+  await until(() => thread.status === 'ready' && !thread.reviewPending);
+  assert.equal((await fs.stat(path.join(home, '.test-harness', 'skills', 'existing'))).isDirectory(), true, 'existing skill content untouched');
+
+  // 3) 无法创建的根目录只提示并跳过，会话照常打开。
+  const blockedHome = path.join(directory, 'blocked-home');
+  await fs.mkdir(path.join(blockedHome, '.test-harness'), { recursive: true });
+  await fs.writeFile(path.join(blockedHome, '.test-harness', 'skills'), 'not a directory');
+  const blockedWorkspace = path.join(directory, 'blocked-workspace');
+  await fs.mkdir(blockedWorkspace);
+  const blocked = new HostRuntime({ observer: new ParityObserver(), dataDirectory: path.join(directory, 'blocked-data') });
+  await blocked.store.load();
+  blocked.integrations.home = blockedHome;
+  blocked.integrations.environment = {};
+  let blockedOpened = 0;
+  const blockedAdapter = stubAdapter('test-harness', () => { blockedOpened++; });
+  blocked.adapters.set(blockedAdapter.manifest.id, blockedAdapter);
+  blocked.status[blockedAdapter.manifest.id] = { available: true };
+  const blockedThread = await blocked.createThread({ harnessId: blockedAdapter.manifest.id, cwd: blockedWorkspace });
+  const blockedToasts = [];
+  console.log('DBG blocked.integrations.home =', blocked.integrations.home);
+  console.log('DBG global root stat type =', (await fs.lstat(path.join(blockedHome, '.test-harness', 'skills'))).isFile() ? 'FILE' : 'other');
+  blocked.subscribe(event => { if (event.type === 'toast') blockedToasts.push(event); });
+  await blocked.send(blockedThread.id, 'hello');
+  assert.equal(blockedOpened, 1, 'session still opens when a skill root cannot be created');
+  assert.equal(blocked.sessions.has(blockedThread.id), true, 'native session attached despite the uncreatable root');
+  assert.equal(blockedThread.error, undefined, 'no session error from the uncreatable root');
+  assert.equal((await fs.stat(path.join(blockedWorkspace, '.agents', 'skills'))).isDirectory(), true, 'the remaining root is still created');
+  console.log('TOASTS:', JSON.stringify(blockedToasts.map(t => ({ type: t.type, level: t.level, text: String(t.text).slice(0, 140) }))));
+  assert.equal(blockedToasts.filter(event => /原生技能目录准备失败/.test(event.text)).length, 1, 'the skipped root is reported once');
+
+  console.log('native skill roots: created on session open, reused when present, and never fatal PASS');
+  await fs.rm(directory, { recursive: true, force: true });
+}
+main().catch(error => { console.error(error); process.exitCode = 1; });

package/scripts/native-ui-smoke.cjs

@@ -12,13 +12,20 @@ app.whenReady().then(async () => {
   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 { mountRendererAgentPicker, renderRendererAgentPicker } from './src/native-ui/renderer-extension/src/renderer-agent-picker.ts'; export { mountRendererModelPicker, renderRendererModelPicker } from './src/native-ui/renderer-extension/src/renderer-model-picker.ts'; export { mountRendererHarnessHandoff } from './src/native-ui/renderer-extension/src/renderer-harness-handoff.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'; export { createAccountsSettingsPage } from './src/native-ui/renderer-extension/src/settings/accounts-page.ts'; export { aboutPage } from './src/native-ui/renderer-extension/src/settings/pages.ts'; export { rendererSettingsMessages } from './src/native-ui/renderer-extension/src/settings/localization.ts'; export { installRendererSettingsShell } from './src/native-ui/renderer-extension/src/settings/shell.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 bundle = await esbuild.build({ stdin: { contents: `export { createRendererAgentIcon } from './src/native-ui/renderer-extension/src/renderer-agent-icon.ts'; export { mountRendererAgentPicker, renderRendererAgentPicker } from './src/native-ui/renderer-extension/src/renderer-agent-picker.ts'; export { mountRendererModelPicker, renderRendererModelPicker } from './src/native-ui/renderer-extension/src/renderer-model-picker.ts'; export { mountRendererHarnessHandoff } from './src/native-ui/renderer-extension/src/renderer-harness-handoff.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'; export { installRendererSettingsLifecycle } from './src/native-ui/renderer-extension/src/harness-mix-settings.ts'; export { createAccountsSettingsPage } from './src/native-ui/renderer-extension/src/settings/accounts-page.ts'; export { createStorageSettingsPage } from './src/native-ui/renderer-extension/src/settings/storage-page.ts'; export { aboutPage } from './src/native-ui/renderer-extension/src/settings/pages.ts'; export { rendererSettingsMessages } from './src/native-ui/renderer-extension/src/settings/localization.ts'; export { installRendererSettingsShell } from './src/native-ui/renderer-extension/src/settings/shell.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 liveSettingsPages = await win.webContents.executeJavaScript(`(() => {
+    const lifecycle = NativeUI.installRendererSettingsLifecycle(window, {});
+    const pageIds = globalThis.__codexhostSettingsShellV1.registry.pages.map(page => page.id);
+    lifecycle.dispose();
+    return pageIds;
+  })()`);
+  assert.deepEqual(liveSettingsPages, ['connections', 'accounts', 'mcp', 'skills', 'session-import', 'storage', 'updates', 'about']);
   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 protocol = new NativeProtocol({ threads: nativeThreads, getThread: id => nativeThreads.find(thread => thread.id === id), 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 () => {
@@ -126,6 +133,10 @@ app.whenReady().then(async () => {
     };
     const shell = NativeUI.installRendererSettingsShell([
       NativeUI.createAccountsSettingsPage(messages, () => client),
+      NativeUI.createStorageSettingsPage(messages, () => ({
+        inspectStorage:async () => ({storageSchemaVersion:3,threadCount:12,loadedThreadCount:2,indexBytes:2048,recordBytes:5242880,recordCount:12,legacyBytes:0}),
+        optimizeStorage:async () => ({before:{storageSchemaVersion:3,threadCount:12,loadedThreadCount:2,indexBytes:2048,recordBytes:5242880,recordCount:12,legacyBytes:0},after:{storageSchemaVersion:3,threadCount:12,loadedThreadCount:2,indexBytes:2048,recordBytes:4194304,recordCount:12,legacyBytes:0}}),
+      })),
       NativeUI.aboutPage(messages, () => ({ readCurrentVersion:async () => ({version:'0.1.4'}), checkUpdate:async () => { throw new Error('not expected'); } })),
     ], messages, document);
     shell.openSettings(undefined, 'accounts');
@@ -135,8 +146,16 @@ app.whenReady().then(async () => {
   })()`);
   assert.match(settingsResult.text, /native.*example\.com/s);
   assert.match(settingsResult.text, /Plus/);
-  assert.equal(settingsResult.addHidden, true);
+  assert.equal(settingsResult.addHidden, false, 'multi-account Add Account action remains visible');
   fs.writeFileSync(path.join(out, 'settings-account.png'), (await win.webContents.capturePage()).toPNG());
+  const storageText = await win.webContents.executeJavaScript(`(async () => {
+    globalThis.__codexhostSettingsShellV1.openSettings(undefined, 'storage');
+    await new Promise(resolve => setTimeout(resolve, 100));
+    return globalThis.__codexhostSettingsShellV1.root.shadowRoot.textContent;
+  })()`);
+  assert.match(storageText, /Schema v3/);
+  assert.match(storageText, /12 个任务/);
+  fs.writeFileSync(path.join(out, 'settings-storage.png'), (await win.webContents.capturePage()).toPNG());
   const aboutText = await win.webContents.executeJavaScript(`(async () => {
     globalThis.__codexhostSettingsShellV1.openSettings(undefined, 'about');
     await new Promise(resolve => setTimeout(resolve, 100));
@@ -145,6 +164,6 @@ app.whenReady().then(async () => {
   assert.match(aboutText, /v0\.1\.4/);
   fs.writeFileSync(path.join(out, 'settings-about.png'), (await win.webContents.capturePage()).toPNG());
   win.destroy();
-  console.log('PASS: real Electron native picker, graphical Harness handoff, official Account/Usage, live About version and all project Harness/model SVGs load');
+  console.log('PASS: real Electron native picker, graphical Harness handoff, official Account/Usage, sharded Storage metrics, live About version and all project Harness/model SVGs load');
   app.quit();
 }).catch(error => { console.error(error); app.exit(1); });

package/scripts/projector-test.cjs

@@ -129,6 +129,19 @@ test('usage.updated：upsert usage item + thread.usage 合并', () => {
   assert.deepStrictEqual(thread.usage, { inputTokens: 10, outputTokens: 5 });
 });
 
+test('verification.updated：终态 Turn 可追加并更新可审计验证报告', () => {
+  const { core } = coreWithThread();
+  const turn = core.createTurn({ threadId: 'thread_1' });
+  core.dispatch({ threadId: 'thread_1', turnId: turn.id, type: 'turn.started' });
+  core.dispatch({ threadId: 'thread_1', turnId: turn.id, type: 'turn.completed' });
+  core.dispatch({ threadId: 'thread_1', turnId: turn.id, type: 'verification.updated', payload: { report: { reportId: 'r1', status: 'failed' } } });
+  const item = core.getItemsForTurn(turn.id).find(candidate => candidate.type === 'verification_report');
+  assert.strictEqual(item.report.status, 'failed');
+  core.dispatch({ threadId: 'thread_1', turnId: turn.id, type: 'verification.updated', payload: { report: { reportId: 'r2', status: 'passed' } } });
+  assert.strictEqual(core.getItemsForTurn(turn.id).filter(candidate => candidate.type === 'verification_report').length, 1);
+  assert.strictEqual(item.report.status, 'passed');
+});
+
 test('snapshot / reset', () => {
   const { core } = coreWithThread();
   const turn = core.createTurn({ threadId: 'thread_1' });

package/scripts/storage-verification-test.cjs

@@ -0,0 +1,78 @@
+const assert = require('node:assert/strict');
+const os = require('node:os');
+const path = require('node:path');
+const { promises: fs } = require('node:fs');
+const { Store } = require('../src/main/host/store');
+const { compactThread, hydrateThread, storageProjection } = require('../src/main/host/thread-storage');
+const { VerificationGates, normalizePolicy } = require('../src/main/host/verification-gates');
+const { ThreadStore } = require('../src/main/host/thread-store');
+
+(async () => {
+  const root = await fs.mkdtemp(path.join(os.tmpdir(), 'harness-mix-storage-'));
+  try {
+    const turn = { id: 'turn-1', threadId: 'thread-1', status: 'completed', itemIds: ['answer-1'], createdAt: 1, updatedAt: 2, startedAt: 1, completedAt: 2, lastSequence: 2, nativeTurnRef: {} };
+    const item = { id: 'answer-1', threadId: 'thread-1', turnId: 'turn-1', type: 'agent_message', status: 'completed', content: 'large answer '.repeat(1000), createdAt: 1, updatedAt: 2, nativeRef: {} };
+    const coreThread = { id: 'thread-1', workspaceId: root, harnessId: 'fixture', status: 'idle', activeTurnId: null, nativeSessionRef: {}, metadata: {}, usage: {}, createdAt: 1, updatedAt: 2 };
+    const thread = { id: 'thread-1', title: 'fixture', cwd: root, harnessId: 'fixture', nativeSessionId: 'native-1', status: 'ready', connectionStatus: 'ready', createdAt: 1,
+      messages: [{ id: 'user-1', role: 'user', text: 'hello', at: 1 }, { id: 'turn-1', role: 'assistant', coreTurnId: 'turn-1', coreTurn: turn, coreItems: [item], text: item.content, thinking: '', at: 1, endedAt: 2, stopReason: 'completed' }],
+      tools: [], pendingApprovals: [], coreThread, currentTurn: turn, coreState: { version: 1, thread: coreThread, turns: [turn], items: [item] } };
+    await fs.writeFile(path.join(root, 'threads.json'), JSON.stringify([thread]));
+    const store = new Store(root, 'threads.json', { schemaVersion: 2, serialize: compactThread, deserialize: hydrateThread, backup: true });
+    const loaded = await store.load();
+    assert.equal(loaded[0].messages[1].text, item.content, 'legacy array remains readable');
+    await store.save(loaded);
+    const persisted = JSON.parse(await fs.readFile(path.join(root, 'threads.json'), 'utf8'));
+    assert.equal(persisted.schemaVersion, 2);
+    assert.equal(persisted.threads[0].messages[1].text, undefined, 'derived assistant text is not duplicated');
+    assert.equal(persisted.threads[0].coreState.items[0].content, item.content, 'authoritative Core content is preserved');
+    assert.ok((await fs.stat(path.join(root, 'threads.json.bak'))).size > 0, 'legacy store is backed up during migration');
+    const projection = storageProjection(loaded);
+    assert.ok(projection.savedBytes > 0);
+    const shardedRoot = await fs.mkdtemp(path.join(os.tmpdir(), 'harness-mix-sharded-'));
+    await fs.writeFile(path.join(shardedRoot, 'threads.json'), JSON.stringify({ schemaVersion: 2, threads: [compactThread(thread)] }));
+    const sharded = new ThreadStore(shardedRoot);
+    const migration = await sharded.loadIndex();
+    assert.equal(migration[0]._storageStub, undefined, 'legacy records load fully for one-time migration');
+    migration[0].status = 'working';
+    migration[0].connectionStatus = 'busy';
+    await sharded.save(migration);
+    const stubs = await sharded.loadIndex();
+    assert.equal(stubs[0]._storageStub, true);
+    assert.equal(stubs[0].status, 'interrupted', 'cold startup never presents a stale running task');
+    assert.equal(stubs[0].connectionStatus, 'ready');
+    assert.equal(stubs[0].messages.length, 0, 'cold index does not load transcript bodies');
+    sharded.hydrateInto(stubs[0]);
+    assert.equal(stubs[0].coreState.items[0].content, item.content);
+    assert.equal((await sharded.inspectFiles()).recordCount, 1);
+    assert.ok((await fs.stat(path.join(shardedRoot, 'threads.json.bak'))).size > 0, 'monolithic source remains recoverable');
+    await fs.rm(shardedRoot, { recursive: true, force: true });
+    const unsupportedRoot = await fs.mkdtemp(path.join(os.tmpdir(), 'harness-mix-storage-schema-'));
+    await fs.writeFile(path.join(unsupportedRoot, 'threads.json'), JSON.stringify({ schemaVersion: 99, threads: [] }));
+    await assert.rejects(new Store(unsupportedRoot, 'threads.json', { schemaVersion: 2 }).load(), /Unsupported thread store schema/);
+    await fs.rm(unsupportedRoot, { recursive: true, force: true });
+
+    const fakeRuntime = {
+      core: { getTurn: () => turn, getItemsForTurn: () => [item], dispatch: () => {} },
+      execution: { lastTurn: () => turn, sync: () => {} },
+    };
+    const gates = new VerificationGates(fakeRuntime);
+    gates.configure(thread, { mode: 'required', checks: { cleanWorkingTree: false }, commands: [{ id: 'node', command: `"${process.execPath}" -e "process.exit(0)"`, timeoutMs: 10_000 }] });
+    assert.throws(() => gates.assertSatisfied(thread, '交付'), /未通过/);
+    const passed = await gates.run(thread);
+    assert.equal(passed.status, 'passed');
+    assert.match(passed.contentDigest, /^[a-f0-9]{64}$/);
+    assert.equal(gates.inspect(thread).satisfied, true);
+    const stale = gates.invalidate(thread, 'test state changed');
+    assert.equal(stale.status, 'stale');
+    assert.equal(gates.inspect(thread).satisfied, false, 'required reports become stale after task state changes');
+    gates.configure(thread, { mode: 'advisory', commands: [`"${process.execPath}" -e "process.exit(3)"`] });
+    const failed = await gates.run(thread);
+    assert.equal(failed.status, 'failed');
+    assert.equal(gates.inspect(thread).satisfied, true, 'advisory failures do not block delivery');
+    assert.throws(() => normalizePolicy({ commands: [{ command: '' }] }), /Invalid verification command/);
+    assert.throws(() => normalizePolicy({ commands: [{ command: 'tool --token sk-1234567890abcdef' }] }), /credential-like data/);
+    console.log('PASS: schema v2 compact migration, backup, storage metrics and configurable verification gates');
+  } finally {
+    await fs.rm(root, { recursive: true, force: true });
+  }
+})().catch(error => { console.error(error); process.exitCode = 1; });

package/scripts/switch-harness-test.cjs

@@ -154,7 +154,7 @@ async function main() {
 
     // 8) 持久化：threads.json 里切换链完整（含原生会话引用，供重启后惰性恢复）
     await rt.store.save(rt.threads);
-    const persisted = JSON.parse(await fs.readFile(path.join(root, 'data', 'threads.json'), 'utf8')).find(t => t.id === thread.id);
+    const persisted = (await rt.store.load()).find(t => t.id === thread.id);
     assert.equal(persisted.harnessId, 'a');
     assert.deepEqual(persisted.harnessChain.map(e => e.harnessId), ['a', 'b']);
     assert.equal(persisted.harnessChain[0].nativeSessionId, aNativeId);

package/scripts/test-live-mentions.cjs

@@ -0,0 +1,152 @@
+const http = require('node:http');
+const fs = require('node:fs/promises');
+const path = require('node:path');
+
+function getJson(url) {
+  return new Promise((resolve, reject) => {
+    http.get(url, res => {
+      let data = '';
+      res.on('data', c => (data += c));
+      res.on('end', () => { try { resolve(JSON.parse(data)); } catch (e) { reject(e); } });
+    }).on('error', reject);
+  });
+}
+
+async function main() {
+  const port = process.argv[2] || '57989';
+  const targets = await getJson(`http://127.0.0.1:${port}/json/list`);
+  const page = targets.find(t => t.type === 'page' && t.url === 'app://-/index.html');
+  if (!page) throw new Error('main page not found');
+  const ws = new WebSocket(page.webSocketDebuggerUrl);
+  await new Promise((res, rej) => { ws.onopen = res; ws.onerror = rej; });
+
+  let id = 0;
+  const pending = new Map();
+  ws.onmessage = ev => {
+    const msg = JSON.parse(ev.data);
+    if (msg.id && pending.has(msg.id)) { pending.get(msg.id)(msg); pending.delete(msg.id); }
+  };
+  const send = (method, params) => new Promise(res => {
+    const i = ++id;
+    pending.set(i, res);
+    ws.send(JSON.stringify({ id: i, method, params }));
+  });
+
+  const evaluate = async expr => {
+    const result = await send('Runtime.evaluate', { expression: expr, returnByValue: true, awaitPromise: true });
+    if (result.result?.exceptionDetails) {
+      throw new Error(JSON.stringify(result.result.exceptionDetails));
+    }
+    return result.result?.result?.value;
+  };
+
+  console.log('Waiting for probe to mount...');
+  await evaluate(`(async () => {
+    for (let i = 0; i < 50; i++) {
+      if (window.__codexhostRendererBindingProbeV1 && document.querySelector('.ProseMirror')) break;
+      await new Promise(r => setTimeout(r, 100));
+    }
+  })()`);
+
+  const directClientTest = await evaluate(`(async () => {
+    try {
+      const probe = window.__codexhostRendererBindingProbeV1;
+      return {
+        hasProbe: !!probe,
+        probeKeys: probe ? Object.keys(probe) : []
+      };
+    } catch (e) {
+      return { error: e.message, stack: e.stack };
+    }
+  })()`);
+  console.log('Direct client test:', JSON.stringify(directClientTest, null, 2));
+
+  console.log('Focusing editor and positioning caret at end...');
+  await evaluate(`(() => {
+    const editor = document.querySelector('.ProseMirror');
+    if (!editor) return;
+    editor.focus();
+    const p = editor.querySelector('p') || editor;
+    const sel = window.getSelection();
+    const range = document.createRange();
+    range.selectNodeContents(p);
+    range.collapse(false);
+    sel?.removeAllRanges();
+    sel?.addRange(range);
+  })()`);
+
+  // Send input via CDP
+  console.log('Sending CDP input for #...');
+  await send('Input.insertText', { text: '#' });
+  await new Promise(r => setTimeout(r, 600));
+
+  const menuInfo = await evaluate(`(() => {
+    const menu = document.querySelector('[data-harness-mix-mentions]');
+    const tabs = [...document.querySelectorAll('[data-harness-mix-mentions] [role="tab"]')].map(t => t.textContent.trim());
+    const options = [...document.querySelectorAll('[data-harness-mix-mentions] [role="option"]')].map(opt => {
+      const name = opt.querySelector('span[style*="font-weight:600"]')?.textContent || opt.innerText;
+      const desc = opt.querySelector('span[style*="font-size:11px"]')?.textContent || '';
+      return { name, desc, disabled: opt.hasAttribute('disabled') };
+    });
+    return {
+      lastMentionDebug: window.__lastMentionDebug,
+      menuHidden: menu ? menu.hidden : true,
+      menuDisplay: menu ? menu.style.display : null,
+      menuRect: menu ? { left: menu.style.left, top: menu.style.top, bottom: menu.style.bottom } : null,
+      tabs,
+      optionCount: options.length,
+      sampleOptions: options.slice(0, 8)
+    };
+  })()`);
+  console.log('Menu state after typing #:', JSON.stringify(menuInfo, null, 2));
+
+  // Capture screenshot with popup open
+  const shot1 = await send('Page.captureScreenshot', { format: 'png' });
+  const data1 = shot1.result?.data || shot1.data;
+  if (data1) {
+    await fs.mkdir('output', { recursive: true });
+    await fs.writeFile(path.resolve('output/live-hash-mentions.png'), Buffer.from(data1, 'base64'));
+    console.log('Saved output/live-hash-mentions.png');
+  }
+
+  // 2. Select an agent (e.g. click first option) and verify badge styling
+  const state2 = await evaluate(`(async () => {
+    const firstOption = document.querySelector('[data-harness-mix-mentions] [role="option"]:not([disabled])');
+    if (firstOption) {
+      firstOption.click();
+      await new Promise(r => setTimeout(r, 200));
+    }
+    const badges = [...document.querySelectorAll('[data-harness-mix-selected-mentions] [data-harness-mix-mention-badge]')].map(b => ({
+      text: b.textContent.trim(),
+      title: b.title,
+      color: b.style.color
+    }));
+    const containerHasAttr = document.querySelector('[data-harness-mix-has-mentions="true"]') !== null;
+    return { badges, containerHasAttr };
+  })()`);
+  console.log('State after selecting agent:', JSON.stringify(state2, null, 2));
+
+  // Capture screenshot with badge in input box
+  const shot2 = await send('Page.captureScreenshot', { format: 'png' });
+  const data2 = shot2.result?.data || shot2.data;
+  if (data2) {
+    await fs.writeFile(path.resolve('output/live-hash-selected-badge.png'), Buffer.from(data2, 'base64'));
+    console.log('Saved output/live-hash-selected-badge.png');
+  }
+
+  // 3. Clear badge so we leave the UI clean
+  await evaluate(`(() => {
+    const badge = document.querySelector('[data-harness-mix-selected-mentions] [data-harness-mix-mention-badge]');
+    if (badge) badge.click();
+    const editor = document.querySelector('[contenteditable="true"], .ProseMirror, textarea');
+    if (editor && !editor.value) editor.textContent = '';
+  })()`);
+
+  ws.close();
+  console.log('Done!');
+}
+
+main().catch(err => {
+  console.error(err);
+  process.exit(1);
+});

package/src/main/adapters/antigravity.js

@@ -639,21 +639,21 @@ class QuestionBridge {
       CODEXHOST_AGY_QUESTION_CLIENT: `"${clientPath.replaceAll('\\', '/')}"`,
     };
 
-    if (options.collaboration || options.managedMcp?.length) {
+    if (options.collaboration || options.managedMcp?.length) {
       const pluginDir = path.join(dir, '.agents', 'plugins', 'harness-mix');
       const plainPluginDir = path.join(dir, 'plugins', 'harness-mix');
       await fs.promises.mkdir(pluginDir, { recursive: true });
       await fs.promises.mkdir(plainPluginDir, { recursive: true });
       const pluginManifest = JSON.stringify({ name: 'harness-mix-collaboration', description: 'Harness Mix Multi-agent Collaboration' }, null, 2);
       const mcpConfig = JSON.stringify({
-        mcpServers: require('./managed-mcp').namedServers(options.managedMcp, options.collaboration),
+        mcpServers: require('./managed-mcp').namedServers(options.managedMcp, options.collaboration),
       }, null, 2);
       await fs.promises.writeFile(path.join(pluginDir, 'plugin.json'), pluginManifest, 'utf8');
       await fs.promises.writeFile(path.join(pluginDir, 'mcp_config.json'), mcpConfig, 'utf8');
       await fs.promises.writeFile(path.join(plainPluginDir, 'plugin.json'), pluginManifest, 'utf8');
       await fs.promises.writeFile(path.join(plainPluginDir, 'mcp_config.json'), mcpConfig, 'utf8');
       await fs.promises.writeFile(path.join(dir, '.agents', 'mcp_config.json'), mcpConfig, 'utf8');
-      Object.assign(bridge.environment, options.collaboration?.env || {});
+      Object.assign(bridge.environment, options.collaboration?.env || {});
     }
 
     return bridge;
@@ -817,7 +817,7 @@ function create(emit, options = {}) {
       });
     },
 
-    async open({ thread, emit: emitEvent, diagnostic, collaboration, managedMcp = [] }) {
+    async open({ thread, emit: emitEvent, diagnostic, collaboration, managedMcp = [] }) {
       // Do not start a second agy process while a real turn may be starting.
       // Quota is loaded only by the explicit account/usage refresh path below.
       await restoreLegacyClipboardAttachments(thread);
@@ -830,8 +830,8 @@ function create(emit, options = {}) {
         model,
         thinkingLevel,
         permissionMode,
-        collaboration: collaboration || null,
-        managedMcp,
+        collaboration: collaboration || null,
+        managedMcp,
         collaborationEnabled: !!collaboration,
         activeTurn: null,
         bridge: null,
@@ -853,15 +853,12 @@ function create(emit, options = {}) {
       const bridge = await QuestionBridge.create({
         approvals,
         emit: emitEvent,
-        collaboration: session.collaboration,
-        managedMcp: session.managedMcp,
+        collaboration: session.collaboration,
+        managedMcp: session.managedMcp,
       });
       session.bridge = bridge;
 
       let effectivePrompt = prompt ?? '';
-      if (session.collaborationEnabled) {
-        effectivePrompt = `[多 Agent 协作系统已就绪。你作为主协调者，可调用已注入的 MCP 工具：delegate_to_agent(agent_type, task) 向其他已注册的 Harness（如 @pi、@claude-code、@codex、@deepseek-harness 等）委派子任务，使用 get_delegation_status(task_ids) 等待结果，使用 update_agent_plan(steps) 设定与更新分步计划。]\n\n${effectivePrompt}`;
-      }
       const { imageEntries, extraDirs } = await prepareImageAttachments(attachments?.images, session.cwd);
       if (imageEntries.length) {
         const imageNotice = [
@@ -1211,15 +1208,18 @@ function create(emit, options = {}) {
     },
 
     async cancel(session) {
-      if (session.activeTurn?.child) {
-        void terminateTree(session.activeTurn.child.pid);
+      if (session.activeTurn) {
+        session.activeTurn.completed = true;
+        if (session.activeTurn.child) {
+          void terminateTree(session.activeTurn.child.pid);
+        }
+        session.activeTurn.resolve?.();
+        session.activeTurn = null;
       }
       if (session.bridge) {
         await session.bridge.dispose().catch(() => {});
         session.bridge = null;
       }
-      session.activeTurn?.resolve?.();
-      session.activeTurn = null;
     },
 
     async respond(session, requestId, response) {
@@ -1345,8 +1345,11 @@ function create(emit, options = {}) {
   };
 }
 
-manifest.integrations = { mcp: true };
-module.exports = {
+// https://antigravity.google/docs/skills/#where-skills-live
+// Single assignment: an earlier declaration used to be silently overwritten here,
+// which dropped Antigravity's native skill roots from the manifest.
+manifest.integrations = { mcp: true, skills: { global: ['.gemini/config/skills'], project: ['.agents/skills'] } };
+module.exports = {
   manifest,
   create,
   parseModelsOutput,