@harness-mix/cli 0.1.4 → 0.1.5

package/scripts/native-protocol-test.cjs

@@ -21,9 +21,23 @@ async function main() {
   runtime.adapters.set('pi', adapter); runtime.status.pi = { available: true };
   const events = [];
   const section = { id: 'test-pinned-section', name: 'Pinned', appearance: null };
-  const bridge = new NativeProtocol(runtime, event => events.push(event), async method => {
-    assert.equal(method, 'threadSection/list');
-    return { data: [section], nextCursor: null };
+  const officialRequests = [];
+  const bridge = new NativeProtocol(runtime, event => events.push(event), async (method, params) => {
+    officialRequests.push({ method, params });
+    if (method === 'threadSection/list') return { data: [section], nextCursor: null };
+    if (method === 'account/read') return { account: { type: 'chatgpt', email: 'native@example.com', planType: 'plus' }, requiresOpenaiAuth: true };
+    if (method === 'account/rateLimits/read') return {
+      rateLimits: {
+        primary: { usedPercent: 33, windowDurationMins: 300, resetsAt: 1_800_000_000 },
+        secondary: { usedPercent: 29, windowDurationMins: 10080, resetsAt: 1_800_604_800 },
+      },
+      rateLimitResetCredits: { availableCount: 0, credits: [] },
+    };
+    if (method === 'account/login/start') return { type: 'chatgptDeviceCode', loginId: 'native-login', verificationUrl: 'https://auth.example.com/device', userCode: 'ABCD-EFGH' };
+    if (method === 'account/login/cancel') return { status: 'canceled' };
+    if (method === 'account/logout') return {};
+    if (method === 'account/rateLimitResetCredit/consume') return { outcome: 'reset' };
+    throw new Error(`Unexpected official request: ${method}`);
   });
   try {
     const catalogModels = [{ id: 'shared', provider: 'a' }, { id: 'shared', provider: 'b' }, { id: 'unique', provider: 'a' }];
@@ -51,6 +65,48 @@ async function main() {
     const schemaPath = path.join(root, 'schemas.cjs');
     await esbuild.build({ entryPoints: ['src/native-ui/shared-contracts/src/index.ts'], outfile: schemaPath, bundle: true, platform: 'node', format: 'cjs', logLevel: 'silent' });
     const schemas = require(schemaPath);
+    const version = await bridge.request('harness-mix/runtime/version');
+    assert.equal(version.version, require('../package.json').version, 'About page reads the installed package version');
+    const accounts = await bridge.request('codexhost/account/list');
+    schemas.codexAccountListResultSchema.parse(accounts);
+    assert.equal(accounts.accounts[0].email, 'native@example.com', 'Official account/read is projected into Account management');
+    assert.equal(accounts.accounts[0].authenticated, true);
+    assert.equal(accounts.accounts[0].management, 'native');
+    const accountUsage = await bridge.request('codexhost/account/usage/inspect', { accountId: 'official-codex' });
+    schemas.codexAccountUsageResultSchema.parse(accountUsage);
+    assert.equal(accountUsage.usage.planFiveHourUsedPercent, 33);
+    assert.equal(accountUsage.usage.planSevenDayUsedPercent, 29);
+    assert.equal(accountUsage.accountCredits.periodType, 'five_hour');
+    assert.equal(accountUsage.accountCredits.productUsage[0].product, '7-day window');
+    const login = await bridge.request('codexhost/account/login/start', { accountId: 'official-codex' });
+    schemas.codexAccountLoginStartResultSchema.parse(login);
+    assert.equal(login.userCode, 'ABCD-EFGH');
+    assert.deepEqual(await bridge.request('codexhost/account/login/cancel', { accountId: 'official-codex', loginId: 'native-login' }), { cancelled: true });
+    const loggedOut = await bridge.request('codexhost/account/logout');
+    schemas.codexAccountMutationResultSchema.parse(loggedOut);
+    assert.equal(loggedOut.account.authenticated, false);
+    let openedCodexThread = null;
+    const codexAdapter = {
+      manifest: { id: 'codex', name: 'Codex', capabilities: { streaming: true, models: true, approvals: true, questions: true, resume: true } },
+      async describe() { return { models: [{ id: 'gpt-test', name: 'GPT Test', provider: 'openai' }], thinkingLevels: [], permissionModes: [] }; },
+      async open(input) { openedCodexThread = input.thread; return { nativeSessionId: 'isolated-native-session', model: input.thread.options.model }; },
+      async send() {}, async cancel() {}, async close() {},
+    };
+    runtime.adapters.set('codex', codexAdapter);
+    runtime.status.codex = { available: true };
+    bridge.codexAccounts.close();
+    bridge.codexAccounts = {
+      executionContext(accountId) {
+        assert.equal(accountId, 'account-work');
+        return { accountId, codexHome: path.join(root, 'isolated-codex-home') };
+      },
+      close() {},
+    };
+    const isolated = await bridge.request('thread/start', { cwd: root, model: 'gpt-test', __codexhostAccountId: 'account-work' });
+    assert.equal(decodeRoute(isolated.thread.model).harnessId, 'codex-harness', 'An isolated Codex Account becomes an owned Codex adapter Thread');
+    assert.equal(openedCodexThread.options.accountId, 'account-work');
+    assert.equal(openedCodexThread.options.codexHome, path.join(root, 'isolated-codex-home'));
+    assert.equal(openedCodexThread.options.model.id, 'gpt-test');
     const inspection = await bridge.inspect('pi');
     schemas.harnessInspectionSchema.parse(inspection);
     assert.equal(inspection.catalog.defaultThinkingOptionId, 'high', 'Declared default thinking level projects to the catalog');
@@ -142,7 +198,25 @@ async function main() {
     assert.ok(runtime.execution.isRunning(threadId) && runtime.threads.find(t => t.id === threadId).currentTurn.id === current, 'Stale steering never cancels the running Turn');
     emit({ kind: 'completed', finalAnswer: true });
     await wait(() => !runtime.execution.isRunning(threadId) && !runtime.threads.find(t => t.id === threadId).reviewPending && !runtime.sending.has(threadId));
-    assert.equal(await bridge.request('thread/start', { model: 'official-model' }), undefined, 'Official Codex requests pass through');
+    assert.equal(await bridge.request('thread/start', { model: 'official-model' }), undefined, 'Official Codex thread/start passes through');
+    for (const [method, params] of [
+      ['thread/read', { threadId: 'official-thread', includeTurns: true }],
+      ['thread/resume', { threadId: 'official-thread' }],
+      ['turn/start', { threadId: 'official-thread', input: [{ type: 'text', text: 'continue' }] }],
+      ['turn/interrupt', { threadId: 'official-thread', turnId: 'official-turn' }],
+      ['thread/fork', { threadId: 'official-thread', lastTurnId: 'official-turn' }],
+      ['thread/compact/start', { threadId: 'official-thread' }],
+    ]) {
+      assert.equal(await bridge.request(method, params), undefined, `Official Codex ${method} passes through`);
+    }
+    assert.deepEqual(await bridge.request('codexhost/thread/ownership/list', { threadIds: ['official-thread', threadId] }), {
+      threads: [
+        { threadId: 'official-thread', owner: 'codex' },
+        { threadId, owner: 'external', harnessId: 'pi' },
+      ],
+    }, 'Official and Harness-managed threads keep separate ownership');
+    const runtimeInspection = await bridge.request('harness-mix/runtime/inspect');
+    assert.deepEqual(runtimeInspection.codex, { mode: 'official-passthrough', managedRoute: 'codex-harness' });
     adapter.listCommands = async () => [{ id: 'compact', action: 'execute', label: 'Compact' }];
     let compactCalls = 0;
     adapter.executeCommand = async (_session, id, hooks) => {

package/scripts/native-secret-test.cjs

@@ -20,8 +20,8 @@ const helper = [
   assert.equal(redactText('ghp_ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789'), '[redacted]');
   assert.equal(redactText('skeleton key'), 'skeleton key'); // no false positive on prose
   assert.deepEqual(
-    redact({ token: 'x', name: 'ok', nested: { api_key: 'y', list: ['Bearer zzzzzzzzzzzz'] } }),
-    { token: '[redacted]', name: 'ok', nested: { api_key: '[redacted]', list: ['[redacted]'] } },
+    redact({ token: 'x', name: 'ok', userCode: 'ABCD-EFGH', loginId: 'login-1', verificationUrl: 'https://auth.example/device', nested: { api_key: 'y', list: ['Bearer zzzzzzzzzzzz'] } }),
+    { token: '[redacted]', name: 'ok', userCode: '[redacted]', loginId: '[redacted]', verificationUrl: '[redacted]', nested: { api_key: '[redacted]', list: ['[redacted]'] } },
   );
 
   if (!helper) {

package/scripts/native-shim-test.cjs

@@ -10,6 +10,7 @@ const { terminateTree } = require('../src/main/native/process-utils');
 async function main() {
   const work = fs.mkdtempSync(path.join(os.tmpdir(), 'hm shim spaces-'));
   const host = path.join(work, 'fixture host.cjs');
+  const stockProbe = path.join(work, 'stock probe.cjs');
   const env = { ...process.env, HARNESS_MIX_NODE_PATH: process.execPath,
     CODEXHOST_STOCK_CODEX_PATH: process.execPath, HARNESS_MIX_HOST_SCRIPT: host, CODEX_CLI_PATH: 'must-be-removed' };
   let child;
@@ -19,8 +20,23 @@ if (process.env.CODEX_CLI_PATH) process.exit(90);
 readline.createInterface({ input: process.stdin }).on('line', line => {
   process.stdout.write(JSON.stringify({ text: line, args: process.argv.slice(2) }) + '\\n');
 }).on('close', () => process.exit(0));`);
-    assert.equal(execFileSync(nativePaths().shim, ['--version'], { env, encoding: 'utf8', timeout: 10000 }).trim(), process.version);
-    child = spawn(nativePaths().shim, ['app-server', 'argument with spaces'], { env, stdio: ['pipe', 'pipe', 'pipe'] });
+    fs.writeFileSync(stockProbe, `process.stdout.write(JSON.stringify(process.argv.slice(1))); process.exit(0);`);
+    const passthrough = args => execFileSync(nativePaths().shim, args, { env, encoding: 'utf8', timeout: 10000 }).trim();
+    assert.equal(passthrough(['--version']), process.version);
+    const probeEnv = { ...env, NODE_OPTIONS: [process.env.NODE_OPTIONS, `--require=${JSON.stringify(stockProbe)}`].filter(Boolean).join(' ') };
+    const probeStock = args => JSON.parse(execFileSync(nativePaths().shim, args, { env: probeEnv, encoding: 'utf8', timeout: 10000 }));
+    const assertStock = (args, message) => {
+      const observed = probeStock(args);
+      assert.equal(observed.length, args.length, message);
+      assert.equal(path.basename(observed[0]), args[0], message);
+      assert.deepEqual(observed.slice(1), args.slice(1), message);
+    };
+    assertStock(['app-server', 'proxy'], 'app-server proxy stays on the official CLI');
+    assertStock(['app-server', 'daemon'], 'app-server daemon stays on the official CLI');
+    assertStock(['app-server', '--future-option'], 'unknown app-server forms fail open to the official CLI');
+    assertStock(['exec', 'app-server'], 'an argument named app-server is not treated as the subcommand');
+    const serverArgs = ['-c', 'feature.label=argument with spaces', 'app-server', '--listen', 'stdio://', '--analytics-default-enabled'];
+    child = spawn(nativePaths().shim, serverArgs, { env, stdio: ['pipe', 'pipe', 'pipe'] });
     let stdout = '', stderr = '';
     child.stdout.on('data', chunk => { stdout += chunk; });
     child.stderr.on('data', chunk => { stderr += chunk; });
@@ -31,8 +47,8 @@ readline.createInterface({ input: process.stdin }).on('line', line => {
     });
     child.stdin.end('你好 Linux/macOS\n');
     assert.equal(await done, 0, stderr);
-    assert.deepEqual(JSON.parse(stdout), { text: '你好 Linux/macOS', args: ['app-server', 'argument with spaces'] });
-    console.log('PASS: compiled Shim routing, Unicode stdio, spaced arguments, environment and EOF');
+    assert.deepEqual(JSON.parse(stdout), { text: '你好 Linux/macOS', args: serverArgs });
+    console.log('PASS: precise app-server routing, official management passthrough, Unicode stdio, arguments, environment and EOF');
   } finally {
     if (child && child.exitCode === null) await terminateTree(child.pid);
     fs.rmSync(work, { recursive: true, force: true });

package/scripts/native-ui-smoke.cjs

@@ -12,7 +12,7 @@ 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 { 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 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 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}`);
@@ -82,13 +82,69 @@ app.whenReady().then(async () => {
   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);
+  const handoffView = await win.webContents.executeJavaScript(`(() => {
+    globalThis.handoffRequest = null;
+    globalThis.testHandoff = NativeUI.mountRendererHarnessHandoff('smoke', request => { globalThis.handoffRequest = request; });
+    globalThis.testAgentPicker = NativeUI.mountRendererAgentPicker('handoff-entry', ['codex','pi','claude-code'], target => testHandoff.open('pi', target, 'zh-CN'), () => {}, () => {});
+    document.body.append(testAgentPicker.root);
+    NativeUI.renderRendererAgentPicker(testAgentPicker, {agent:'pi',phase:'locked'}, 'ready', false, {pi:'ready','claude-code':'ready'});
+    testAgentPicker.trigger.click();
+    testAgentPicker.options['claude-code'].button.click();
+    testHandoff.note.value = '按上一位给出的方案继续执行';
+    return { open:testHandoff.dialog.open, title:testHandoff.dialog.querySelector('h2').textContent, text:testHandoff.dialog.textContent, pickerLabel:testAgentPicker.trigger.getAttribute('aria-label'), targetEnabled:!testAgentPicker.options['claude-code'].button.disabled };
+  })()`);
+  assert.equal(handoffView.open, true);
+  assert.equal(handoffView.title, '接力当前任务');
+  assert.match(handoffView.text, /Pi.*Claude Code/s);
+  assert.match(handoffView.text, /对话记录和文件现场/);
+  assert.match(handoffView.pickerLabel, /Hand off task from Pi/);
+  assert.equal(handoffView.targetEnabled, true);
+  await new Promise(resolve => setTimeout(resolve, 100));
+  fs.writeFileSync(path.join(out, 'harness-handoff.png'), (await win.webContents.capturePage()).toPNG());
+  const handoffRequest = await win.webContents.executeJavaScript(`(() => { testHandoff.confirm.click(); const request = globalThis.handoffRequest; testHandoff.close(); testHandoff.dispose(); return request; })()`);
+  assert.deepEqual(handoffRequest, {
+    from:'pi', to:'claude-code', note:'按上一位给出的方案继续执行', intent:'continue',
+    includes:{ conversation:true, plan:true, evidence:true, files:true, unresolved:true },
+  });
+  await win.webContents.executeJavaScript('testAgentPicker.dispose()');
   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());
+  const settingsResult = await win.webContents.executeJavaScript(`(async () => {
+    document.body.innerHTML = '';
+    const messages = NativeUI.rendererSettingsMessages('zh-CN');
+    const account = { accountId:'official-codex', label:'native@example.com', email:'native@example.com', planType:'plus', codexHome:'C:/Users/test/.codex', active:true, isDefault:true, authenticated:true, management:'native' };
+    const client = {
+      listCodexAccounts: async () => ({ accounts:[account] }),
+      refreshCodexAccounts: async () => ({ accounts:[account] }),
+      inspectCodexAccountUsage: async () => ({ accountId:account.accountId, usage:{planFiveHourUsedPercent:33,planSevenDayUsedPercent:29}, accountCredits:{usedPercent:33,periodType:'five_hour',productUsage:[{product:'7-day window',usagePercent:29}]} }),
+      createCodexAccount: async () => ({account}), deleteCodexAccount: async () => ({deletedAccountId:account.accountId}), activateCodexAccount: async () => ({account}),
+      startCodexAccountLogin: async () => { throw new Error('not expected'); }, cancelCodexAccountLogin: async () => ({cancelled:true}), logoutCodexAccount: async () => ({account:{...account,email:undefined,authenticated:false}}),
+    };
+    const shell = NativeUI.installRendererSettingsShell([
+      NativeUI.createAccountsSettingsPage(messages, () => client),
+      NativeUI.aboutPage(messages, () => ({ readCurrentVersion:async () => ({version:'0.1.4'}), checkUpdate:async () => { throw new Error('not expected'); } })),
+    ], messages, document);
+    shell.openSettings(undefined, 'accounts');
+    await new Promise(resolve => setTimeout(resolve, 150));
+    const shadow = shell.root.shadowRoot;
+    return { text:shadow.textContent, addHidden:[...shadow.querySelectorAll('button')].find(button => button.textContent.includes('添加账号'))?.hidden };
+  })()`);
+  assert.match(settingsResult.text, /native.*example\.com/s);
+  assert.match(settingsResult.text, /Plus/);
+  assert.equal(settingsResult.addHidden, true);
+  fs.writeFileSync(path.join(out, 'settings-account.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));
+    return globalThis.__codexhostSettingsShellV1.root.shadowRoot.textContent;
+  })()`);
+  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 selection and all project Harness/model SVGs load');
+  console.log('PASS: real Electron native picker, graphical Harness handoff, official Account/Usage, live About version and all project Harness/model SVGs load');
   app.quit();
 }).catch(error => { console.error(error); app.exit(1); });

package/scripts/publish-native-package.cjs

@@ -14,13 +14,16 @@ const pkg = path.join(work, 'package');
 fs.mkdirSync(path.join(pkg, 'bin'), { recursive: true });
 const version = JSON.parse(fs.readFileSync(path.join(root, 'package.json'), 'utf8')).version;
 const names = platform === 'win32' ? ['harness-mix-shim.exe', 'harness-mix-appx.exe', 'harness-mix-secret.exe'] : ['harness-mix-shim'];
-for (const name of names) {
-  const source = path.join(output, name);
-  if (!fs.existsSync(source)) throw new Error(`Missing ${source}; build the target runtime first`);
-  fs.copyFileSync(source, path.join(pkg, 'bin', name));
+const sourceOnly = flags.includes('--source-only');
+if (!sourceOnly) {
+  for (const name of names) {
+    const source = path.join(output, name);
+    if (!fs.existsSync(source)) throw new Error(`Missing ${source}; build the target runtime first (or use --source-only)`);
+    fs.copyFileSync(source, path.join(pkg, 'bin', name));
+  }
 }
 fs.writeFileSync(path.join(pkg, 'package.json'), JSON.stringify({
-  name: `@harness-mix/native-${key}`, version, description: `Harness Mix native runtime for ${key}`,
+  name: `@harness-mix/native-${key}`, version, description: `Harness Mix native runtime for ${key}${sourceOnly ? ' (source-only; build locally)' : ''}`,
   license: 'Apache-2.0', os: [platform], cpu: [arch], files: ['bin'], publishConfig: { access: 'public' },
 }, null, 2) + '\n');
 fs.writeFileSync(path.join(pkg, 'README.md'), `# @harness-mix/native-${key}\n\nNative runtime selected automatically by @harness-mix/cli.\n`);

package/scripts/support/integrations-mcp-fixture.cjs

@@ -0,0 +1,15 @@
+// Local read-only MCP server used by the native integration acceptance probe.
+const readline = require('node:readline');
+const fs = require('node:fs');
+readline.createInterface({ input: process.stdin }).on('line', line => {
+  let request; try { request = JSON.parse(line); } catch { return; }
+  if (process.argv[2]) fs.appendFileSync(process.argv[2], `${request.method}\n`);
+  if (request.id === undefined) return;
+  let result;
+  if (request.method === 'initialize') result = { protocolVersion: request.params.protocolVersion, capabilities: { tools: {} }, serverInfo: { name: 'harness-mix-integration-probe', version: '1.0.0' } };
+  else if (request.method === 'tools/list') result = { tools: [{ name: 'integration_probe', description: 'Return a fixed test token without side effects.', inputSchema: { type: 'object', properties: {}, additionalProperties: false }, annotations: { readOnlyHint: true, destructiveHint: false, openWorldHint: false } }] };
+  else if (request.method === 'tools/call') result = { content: [{ type: 'text', text: 'HARNESS_MIX_MCP_OK' }] };
+  else if (request.method === 'ping') result = {};
+  else { process.stdout.write(`${JSON.stringify({ jsonrpc: '2.0', id: request.id, error: { code: -32601, message: 'Unknown method' } })}\n`); return; }
+  process.stdout.write(`${JSON.stringify({ jsonrpc: '2.0', id: request.id, result })}\n`);
+});

package/scripts/switch-harness-test.cjs

@@ -2,6 +2,7 @@ const assert = require('node:assert/strict');
 const fs = require('node:fs/promises');
 const path = require('node:path');
 const { HostRuntime } = require('../src/main/host/runtime');
+const { CAP, buildHandoffContext } = require('../src/main/host/handoff');
 
 /**
  * 跨 Harness 原地切换（switchHarness）脚本级测试：
@@ -33,6 +34,19 @@ function fakeHarness(id, name) {
 }
 
 async function main() {
+  const longSolution = `方案开头-${'x'.repeat(5000)}-方案结尾`;
+  const optimized = buildHandoffContext({
+    cwd: 'E:/project', title: '登录重构', messages: [
+      { role: 'user', text: '先分析问题' },
+      { role: 'assistant', text: '初步判断' },
+      { role: 'user', text: '给出完整方案' },
+      { role: 'assistant', text: longSolution },
+    ],
+  });
+  assert.deepEqual(optimized.conversationTail.map(message => message.role), ['user', 'assistant', 'user', 'assistant']);
+  assert.equal(optimized.conversationTail.at(-1).text, longSolution, '最新方案应获得更大的交接预算');
+  assert.ok(optimized.conversationTail.reduce((sum, message) => sum + message.text.length, 0) <= CAP.totalChars);
+
   await fs.mkdir('output', { recursive: true });
   const root = await fs.mkdtemp(path.resolve('output/switch-harness-'));
   const rt = new HostRuntime({ dataDirectory: path.join(root, 'data') });
@@ -71,6 +85,12 @@ async function main() {
     assert.equal(thread.harnessChain[0].nativeSessionId, aNativeId);
     assert.equal(thread.pendingHandoff.fromHarnessId, 'a');
     assert.equal(thread.pendingHandoff.note, '优先把测试补完');
+    assert.match(thread.pendingHandoff.checkpointId, /^handoff_[a-f0-9]{24}$/);
+    const firstCheckpointId = thread.pendingHandoff.checkpointId;
+    const checkpointBeforeSend = rt.handoffs.get(thread.id, firstCheckpointId);
+    assert.equal(checkpointBeforeSend.intent, 'continue');
+    assert.equal(checkpointBeforeSend.fileState.files.some(file => file.path === 'src/login.ts' && file.changeType === 'added'), true);
+    assert.equal(rt.handoffs.owned(thread.id, firstCheckpointId).status, 'checkpoint-created');
     assert.equal(thread.restore, false, '新 Harness 上是全新原生会话');
     assert.equal(rt.sessions.has(thread.id), false, '切换后旧原生会话已关闭');
     assert.equal(a.state.closed, 1);
@@ -87,11 +107,12 @@ async function main() {
     assert.match(b.state.sent[0], /untrusted historical data/);
     assert.match(b.state.sent[0], /帮我重构登录模块/);
     assert.match(b.state.sent[0], /Alpha 回复/);
-    assert.match(b.state.sent[0], /added src\/login\.ts/);
+    assert.match(b.state.sent[0], /"path":"src\/login\.ts","changeType":"added"/);
     assert.match(b.state.sent[0], /优先把测试补完/);
     const visible = thread.messages.filter(m => m.role === 'user').at(-1);
     assert.equal(visible.text, '继续', '信封不进用户可见消息');
     assert.equal(thread.pendingHandoff, undefined, '信封发送成功后标记已清除');
+    assert.equal(rt.handoffs.owned(thread.id, firstCheckpointId).status, 'active');
 
     // 5) 第二轮起不再注入
     await rt.send(thread.id, '第二步');
@@ -123,6 +144,9 @@ async function main() {
     await settle(thread.id);
     await assert.rejects(rt.switchHarness(thread.id, 'a'), /已经在该 Harness/);
     await assert.rejects(rt.switchHarness(thread.id, 'Nope'), /未知 Harness/);
+    rt.status.b = { available: false, detail: '测试连接不可用' };
+    await assert.rejects(rt.switchHarness(thread.id, 'b'), /测试连接不可用/);
+    rt.status.b = { available: true };
     const draft = await rt.createThread({ harnessId: 'a', cwd: root, ephemeral: true });
     await assert.rejects(rt.switchHarness(draft.id, 'b'), /草稿任务/);
     const child = await rt.createThread({ harnessId: 'a', cwd: root, parentThreadId: thread.id });
@@ -138,6 +162,8 @@ async function main() {
     // 重启恢复的真正契约是持久化的 harnessId + nativeSessionId（指向 A 的原生会话）。
     assert.equal(persisted.nativeSessionId, aNativeId);
     assert.equal(persisted.restore, undefined);
+    const persistedCheckpoints = JSON.parse(await fs.readFile(path.join(root, 'data', 'handoff', 'checkpoints.json'), 'utf8'));
+    assert.equal(persistedCheckpoints.some(row => row.checkpointId === firstCheckpointId && row.status === 'active'), true);
 
     console.log('PASS: in-place harness switch → one-shot context envelope → switch-back native resume, guards and persistence');
   } finally { await rt.close(); }

package/src/main/adapters/acp.js

@@ -53,11 +53,10 @@ function acpAdapter({ id, name, bin, args, executable = false, images = false, f
         }
       },
       async describe() { return { models: null, thinkingLevels: [], permissionModes: [] }; },
-      async open({ thread, emit, diagnostic = () => {}, collaboration }) {
+      async open({ thread, emit, diagnostic = () => {}, collaboration, managedMcp = [] }) {
         const cli = command(args);
         const session = { cwd: thread.cwd, nativeSessionId: null, collaborationEnabled: !!collaboration,
-          mcpServers: collaboration ? [{ name: 'harness-mix', command: collaboration.command, args: collaboration.args,
-            env: Object.entries(collaboration.env).map(([name, value]) => ({ name, value })) }] : [],
+          mcpServers: require('./managed-mcp').acpServers(managedMcp, collaboration),
           state: { configOptions: [], models: null, modes: null, commands: [], usage: undefined, loading: true }, pendingApprovals: new Map(), tools: new Map(), emit };
         session.process = new JsonlProcess(cli.command, cli.args, { cwd: thread.cwd }, {
           onDiagnostic: diagnostic,
@@ -186,6 +185,7 @@ function acpAdapter({ id, name, bin, args, executable = false, images = false, f
     };
     return adapter;
   }
+  manifest.integrations = { mcp: true };
   return { manifest, create };
 }
 module.exports = { acpAdapter, catalog };

package/src/main/adapters/antigravity.js

@@ -639,27 +639,21 @@ class QuestionBridge {
       CODEXHOST_AGY_QUESTION_CLIENT: `"${clientPath.replaceAll('\\', '/')}"`,
     };
 
-    if (options.collaboration) {
+    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: {
-          'harness-mix': {
-            command: options.collaboration.command,
-            args: options.collaboration.args,
-            env: options.collaboration.env,
-          },
-        },
+        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;
@@ -823,7 +817,7 @@ function create(emit, options = {}) {
       });
     },
 
-    async open({ thread, emit: emitEvent, diagnostic, collaboration }) {
+    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);
@@ -836,7 +830,8 @@ function create(emit, options = {}) {
         model,
         thinkingLevel,
         permissionMode,
-        collaboration: collaboration || null,
+        collaboration: collaboration || null,
+        managedMcp,
         collaborationEnabled: !!collaboration,
         activeTurn: null,
         bridge: null,
@@ -858,7 +853,8 @@ function create(emit, options = {}) {
       const bridge = await QuestionBridge.create({
         approvals,
         emit: emitEvent,
-        collaboration: session.collaboration,
+        collaboration: session.collaboration,
+        managedMcp: session.managedMcp,
       });
       session.bridge = bridge;
 
@@ -1349,7 +1345,8 @@ function create(emit, options = {}) {
   };
 }
 
-module.exports = {
+manifest.integrations = { mcp: true };
+module.exports = {
   manifest,
   create,
   parseModelsOutput,

package/src/main/adapters/claude.js

@@ -245,7 +245,7 @@ async function loadSdk() {
 }
 
 /** 建立一个常驻 SDK 会话（open 与 fork 共用）：构造 query、启动事件泵 */
-function spawnSession(sdk, { cwd, resumeId, newSessionId, permissionMode, modelId, effort, emit, collaboration, onPlanLimit }) {
+function spawnSession(sdk, { cwd, resumeId, newSessionId, permissionMode, modelId, effort, emit, collaboration, managedMcp = [], onPlanLimit }) {
   const input = new MessageQueue();
   const session = {
     nativeSessionId: resumeId || newSessionId,
@@ -265,7 +265,8 @@ function spawnSession(sdk, { cwd, resumeId, newSessionId, permissionMode, modelI
     prompt: input,
     options: {
       cwd,
-      ...(collaboration ? { mcpServers: { 'harness-mix': collaboration } } : {}),
+      mcpServers: require('./managed-mcp').namedServers(managedMcp, collaboration),
+      settingSources: ['user', 'project', 'local'],
       ...(resumeId ? { resume: resumeId } : {}),
       ...(!resumeId && newSessionId ? { sessionId: newSessionId } : {}),
       ...(effort ? { effort } : {}),
@@ -373,7 +374,11 @@ function create() {
         : { available: true, detail: "Agent SDK 就绪（内置原生 CLI；未检测到独立 claude 命令）" };
     },
 
-    async open({ thread, emit, collaboration }) {
+    async inspectIntegrations(session) {
+      const rows = await session.query.mcpServerStatus();
+      return rows.map(row => ({ name: row.name, status: row.status, tools: (row.tools || []).map(t => t.name) }));
+    },
+    async open({ thread, emit, collaboration, managedMcp }) {
       const sdk = await loadSdk();
       return spawnSession(sdk, {
         cwd: thread.cwd,
@@ -384,6 +389,7 @@ function create() {
         modelId: thread.options?.model?.id,
         emit,
         collaboration,
+        managedMcp,
         onPlanLimit,
       });
     },
@@ -509,6 +515,7 @@ function create() {
   };
 }
 
+manifest.integrations = { mcp: true, skills: { global: ['.claude/skills'], project: ['.claude/skills'], overrides: { '.claude/skills': { env: 'CLAUDE_CONFIG_DIR', suffix: 'skills' } } } };
 module.exports = {
   manifest,
   create,

package/src/main/adapters/codex-app-server.js

@@ -1,6 +1,6 @@
 const { JsonlProcess, cliSpawn } = require('../host/jsonl');
 
-let shared;
+const shared = new Map();
 
 /**
  * A single native Codex app-server connection shared by every Codex thread.
@@ -8,16 +8,18 @@ let shared;
  * traffic to the Adapter session that registered the native thread id.
  */
 class CodexAppServer {
-  constructor(diagnostic) {
+  constructor(diagnostic, codexHome) {
     this.refs = 0;
     this.routes = new Map();
     this.notifications = new Set();
     this.diagnostics = new Set(diagnostic ? [diagnostic] : []);
     this.closed = false;
+    this.codexHome = codexHome ? require('node:path').resolve(codexHome) : null;
     // The Desktop-bundled CLI and the PATH CLI can be different versions.
     const executable = process.env.HARNESS_MIX_CODEX_EXECUTABLE || process.env.CODEXHOST_STOCK_CODEX_PATH;
     const { command, args } = executable ? { command: executable, args: ['app-server', '--listen', 'stdio://'] } : cliSpawn('codex', ['app-server', '--stdio']);
-    this.process = new JsonlProcess(command, args, {}, {
+    const env = { ...process.env, ...(this.codexHome ? { CODEX_HOME: this.codexHome } : {}) };
+    this.process = new JsonlProcess(command, args, { env }, {
       onEvent: (message) => this.#notification(message),
       onRequest: (message) => this.#request(message),
       onDiagnostic: (line) => this.#diagnostic(line),
@@ -36,16 +38,21 @@ class CodexAppServer {
     });
   }
 
-  static async acquire(diagnostic) {
-    if (!shared || shared.closed) shared = new CodexAppServer(diagnostic);
-    else if (diagnostic) shared.diagnostics.add(diagnostic);
-    shared.refs++;
+  static async acquire(diagnostic, codexHome) {
+    const key = codexHome ? require('node:path').resolve(codexHome).toLowerCase() : '<default>';
+    let server = shared.get(key);
+    if (!server || server.closed) {
+      server = new CodexAppServer(diagnostic, codexHome);
+      server.sharedKey = key;
+      shared.set(key, server);
+    } else if (diagnostic) server.diagnostics.add(diagnostic);
+    server.refs++;
     try {
-      await shared.ready;
-      return shared;
+      await server.ready;
+      return server;
     } catch (error) {
-      shared.refs--;
-      if (shared.refs === 0) shared.stop();
+      server.refs--;
+      if (server.refs === 0) server.stop();
       throw error;
     }
   }
@@ -78,7 +85,7 @@ class CodexAppServer {
     this.routes.clear();
     this.notifications.clear();
     this.process.stop();
-    if (shared === this) shared = undefined;
+    if (this.sharedKey && shared.get(this.sharedKey) === this) shared.delete(this.sharedKey);
   }
 
   #route(message) {
@@ -112,7 +119,7 @@ class CodexAppServer {
     this.closed = true;
     for (const route of this.routes.values()) route.onExit?.(error);
     this.routes.clear();
-    if (shared === this) shared = undefined;
+    if (this.sharedKey && shared.get(this.sharedKey) === this) shared.delete(this.sharedKey);
   }
 }
 

package/src/main/adapters/codex.js

@@ -356,10 +356,11 @@ function create() {
         : { available: true, detail: String(result.stdout).trim() };
     },
 
-    async open({ thread, emit, diagnostic, collaboration }) {
-      const host = await CodexAppServer.acquire(diagnostic);
+    async open({ thread, emit, diagnostic, collaboration, managedMcp = [] }) {
+      const host = await CodexAppServer.acquire(diagnostic, thread.options?.codexHome);
       try {
-        const options = { ...threadOptions(thread), ...(collaboration ? { config: { 'mcp_servers.harness-mix': collaboration } } : {}) };
+        const servers = require('./managed-mcp').namedServers(managedMcp, collaboration);
+        const options = { ...threadOptions(thread), ...(Object.keys(servers).length ? { config: Object.fromEntries(Object.entries(servers).map(([name, value]) => [`mcp_servers.${name}`, value])) } : {}) };
         const result = thread.restore
           ? await host.request('thread/resume', { threadId: thread.nativeSessionId, ...options })
           : await host.request('thread/start', options);
@@ -521,7 +522,7 @@ function create() {
     async fork(source, { emit, diagnostic, message }) {
       const lastTurnId = message?.coreTurn?.nativeTurnRef?.turnId ?? message?.coreTurn?.nativeTurnRef?.checkpointId;
       if (message && !lastTurnId) throw new Error('这条回复缺少 Codex 原生 Turn ID，无法精确分支');
-      const host = await CodexAppServer.acquire(diagnostic);
+      const host = await CodexAppServer.acquire(diagnostic, source.options?.codexHome);
       try {
         const result = await host.request('thread/fork', {
           threadId: source.nativeSessionId,
@@ -556,4 +557,5 @@ function create() {
   };
 }
 
+manifest.integrations = { mcp: true, skills: { global: ['.agents/skills'], project: ['.agents/skills'] } };
 module.exports = { manifest, create, projectNotification, queueRequest, usageView, modelView };

package/src/main/adapters/dsh.js

@@ -431,7 +431,7 @@ function create() {
   }).create();
   const openWeb = web.open.bind(web);
   web.open = async context => {
-    if (!context.collaboration) return openWeb(context);
+    if (!context.collaboration && !context.managedMcp?.length) return openWeb(context);
     const session = await acp.open(context);
     session.dshAcpLead = true;
     return session;
@@ -443,4 +443,5 @@ function create() {
   return web;
 }
 
+manifest.integrations = { mcp: true };
 module.exports = { manifest, create, projectWireEvent, flattenCatalog };