@harness-mix/cli 0.1.11 → 0.1.12

package/scripts/integrations-test.cjs

@@ -119,8 +119,8 @@ async function main() {
   const globalOnly = await blocked.ensureSkillRoots({ cwd: 'relative-not-absolute' }, adapters.get('codex'), {});
   assert.equal(globalOnly.length, 1);
   // Exercise the real protocol dispatcher without starting native processes.
-  assert.equal((await NativeProtocol.prototype.request.call({ runtime }, 'codexhost/integrations/catalog', {})).harnesses.length, 17);
-  assert.equal((await NativeProtocol.prototype.request.call({ runtime }, 'codexhost/integrations/list', local)).skills.length, 3);
+  assert.equal((await NativeProtocol.prototype.request.call({ runtime }, 'harnessmix/integrations/catalog', {})).harnesses.length, 17);
+  assert.equal((await NativeProtocol.prototype.request.call({ runtime }, 'harnessmix/integrations/list', local)).skills.length, 3);
   console.log('integrations: scope precedence, persistence, native status projection, no credential fields, unsupported capabilities, skill install/disable/restore, links, and protocol PASS');
 }
 main().catch(error => { console.error(error); process.exitCode = 1; });

package/scripts/integrations-ui-smoke.cjs

@@ -17,10 +17,10 @@ app.whenReady().then(async () => {
   const preload = path.join(out, 'preload.cjs');
   await fs.writeFile(preload, `const {contextBridge,ipcRenderer}=require('electron');contextBridge.exposeInMainWorld('integrationTest',{request:(method,params)=>ipcRenderer.invoke('integrations-test',method,params)});`);
   ipcMain.handle('integrations-test', (_event, method, params) => {
-    assert.ok(method.startsWith('codexhost/integrations/'));
+    assert.ok(method.startsWith('harnessmix/integrations/'));
     return NativeProtocol.prototype.request.call({ runtime }, method, params);
   });
-  const build = await esbuild.build({ stdin: { contents: `export {createMcpSettingsPage,createSkillsSettingsPage} from './src/native-ui/renderer-extension/src/settings/integrations-page.ts'; export {mountRendererSettingsShell} from './src/native-ui/renderer-extension/src/settings/shell.ts'; export {createRendererSettingsPageRegistry} from './src/native-ui/renderer-extension/src/settings/core.ts'; export {rendererSettingsMessages} from './src/native-ui/renderer-extension/src/settings/localization.ts'; export {createRendererIntegrationsClient} from './src/native-ui/renderer-extension/src/renderer-integrations-client.ts';`, resolveDir: process.cwd() }, bundle: true, platform: 'browser', format: 'iife', globalName: 'IntegrationUI', write: false, alias: { '@codexhost/shared-contracts': path.resolve('src/native-ui/shared-contracts/src/index.ts') }, loader: { '.svg': 'dataurl', '.png': 'dataurl', '.css': 'text' } });
+  const build = await esbuild.build({ stdin: { contents: `export {createMcpSettingsPage,createSkillsSettingsPage} from './src/native-ui/renderer-extension/src/settings/integrations-page.ts'; export {mountRendererSettingsShell} from './src/native-ui/renderer-extension/src/settings/shell.ts'; export {createRendererSettingsPageRegistry} from './src/native-ui/renderer-extension/src/settings/core.ts'; export {rendererSettingsMessages} from './src/native-ui/renderer-extension/src/settings/localization.ts'; export {createRendererIntegrationsClient} from './src/native-ui/renderer-extension/src/renderer-integrations-client.ts';`, resolveDir: process.cwd() }, bundle: true, platform: 'browser', format: 'iife', globalName: 'IntegrationUI', write: false, alias: { '@harnessmix/shared-contracts': path.resolve('src/native-ui/shared-contracts/src/index.ts') }, loader: { '.svg': 'dataurl', '.png': 'dataurl', '.css': 'text' } });
   const consoleProblems = [];
   const win = new BrowserWindow({ show: false, width: 1100, height: 900, webPreferences: { preload, contextIsolation: true, sandbox: true, offscreen: true } });
   win.webContents.on('console-message', (_event, details) => { if (details.level === 'error' || details.level === 'warning') consoleProblems.push(details.message); });
@@ -74,7 +74,7 @@ app.whenReady().then(async () => {
     await fs.writeFile(path.join(out, 'settings.png'), overviewImage);
     await fs.writeFile(path.join(out, 'skills.png'), overviewImage);
     await win.webContents.executeJavaScript(`(async()=>{
-      const root=document.querySelector('[data-codexhost-settings-shell]').shadowRoot;
+      const root=document.querySelector('[data-harnessmix-settings-shell]').shadowRoot;
       root.querySelector('button[data-page-id="mcp"]').click();
       const wait=async predicate=>{for(let i=0;i<100;i++){if(predicate())return;await new Promise(r=>setTimeout(r,30));}throw Error('MCP screenshot timed out');};
       await wait(()=>root.querySelector('select')?.options.length===17&&!root.querySelector('select').disabled);
@@ -92,7 +92,7 @@ app.whenReady().then(async () => {
     await new Promise(r => setTimeout(r, 60));
     await fs.writeFile(path.join(out, 'mcp-matrix.png'), (await win.webContents.capturePage()).toPNG());
     await win.webContents.executeJavaScript(`(async()=>{
-      const root=document.querySelector('[data-codexhost-settings-shell]').shadowRoot;
+      const root=document.querySelector('[data-harnessmix-settings-shell]').shadowRoot;
       const byHarnessBtn=Array.from(root.querySelectorAll('.settings-mcp-tabs button')).find(b=>b.textContent.includes('Harness'));
       byHarnessBtn?.click();
       const wait=async predicate=>{for(let i=0;i<100;i++){if(predicate())return;await new Promise(r=>setTimeout(r,30));}throw Error('MCP switch timed out');};
@@ -101,7 +101,7 @@ app.whenReady().then(async () => {
     await new Promise(r => setTimeout(r, 60));
     await fs.writeFile(path.join(out, 'mcp-overview.png'), (await win.webContents.capturePage()).toPNG());
     await win.webContents.executeJavaScript(`(async()=>{
-      const root=document.querySelector('[data-codexhost-settings-shell]').shadowRoot;
+      const root=document.querySelector('[data-harnessmix-settings-shell]').shadowRoot;
       const [harness,scope]=root.querySelectorAll('select');
       harness.value='claude';harness.dispatchEvent(new Event('change'));
       const wait=async predicate=>{for(let i=0;i<100;i++){if(predicate())return;await new Promise(r=>setTimeout(r,30));}throw Error('MCP reload timed out');};
@@ -111,7 +111,7 @@ app.whenReady().then(async () => {
     })()`);
     await fs.writeFile(path.join(out, 'mcp.png'), (await win.webContents.capturePage()).toPNG());
     await win.webContents.executeJavaScript(`(async()=>{
-      const root=document.querySelector('[data-codexhost-settings-shell]').shadowRoot;
+      const root=document.querySelector('[data-harnessmix-settings-shell]').shadowRoot;
       const mcpRow=Array.from(root.querySelectorAll('.settings-integrations-row')).find(r=>r.querySelector('strong')?.textContent?.includes('ui-probe'));
       mcpRow.querySelector('button').click();
       const wait=async predicate=>{for(let i=0;i<100;i++){if(predicate())return;await new Promise(r=>setTimeout(r,30));}throw Error('MCP editor timed out');};

package/scripts/native-config-test.cjs

@@ -7,16 +7,16 @@ const { isCodexTaskEnvironment, readLiveHostInstance } = require('../src/main/na
 
 const directory = fs.mkdtempSync(path.join(os.tmpdir(), 'harness-mix-config-'));
 try {
-  const source = { CODEXHOST_DATA_DIR: directory, CODEXHOST_PI_COMMAND: 'C:\\Native tools\\pi.cmd', PRIVATE_TEST_VALUE: 'do-not-persist' };
+  const source = { HARNESSMIX_DATA_DIR: directory, HARNESSMIX_PI_COMMAND: 'C:\\Native tools\\pi.cmd', PRIVATE_TEST_VALUE: 'do-not-persist' };
   const env = nativeEnvironment(source);
-  assert.equal(source.CODEXHOST_DEFAULT_AGENT, undefined, 'Input environment is not mutated');
-  assert.equal(env.CODEXHOST_DEFAULT_AGENT, 'codex');
+  assert.equal(source.HARNESSMIX_DEFAULT_AGENT, undefined, 'Input environment is not mutated');
+  assert.equal(env.HARNESSMIX_DEFAULT_AGENT, 'codex');
   saveNativeSettings(env);
   const saved = JSON.parse(fs.readFileSync(path.join(directory, 'harness-mix-settings.json'), 'utf8'));
-  assert.deepEqual(saved, { CODEXHOST_PI_COMMAND: source.CODEXHOST_PI_COMMAND });
-  assert.equal(nativeEnvironment({ CODEXHOST_DATA_DIR: directory }).CODEXHOST_PI_COMMAND, source.CODEXHOST_PI_COMMAND,
+  assert.deepEqual(saved, { HARNESSMIX_PI_COMMAND: source.HARNESSMIX_PI_COMMAND });
+  assert.equal(nativeEnvironment({ HARNESSMIX_DATA_DIR: directory }).HARNESSMIX_PI_COMMAND, source.HARNESSMIX_PI_COMMAND,
     'AppX child recovers command settings from the data directory');
-  assert.equal(nativeEnvironment({ CODEXHOST_DATA_DIR: directory, CODEXHOST_PI_COMMAND: 'D:\\other\\pi.cmd' }).CODEXHOST_PI_COMMAND,
+  assert.equal(nativeEnvironment({ HARNESSMIX_DATA_DIR: directory, HARNESSMIX_PI_COMMAND: 'D:\\other\\pi.cmd' }).HARNESSMIX_PI_COMMAND,
     'D:\\other\\pi.cmd', 'Explicit environment takes priority');
   for (const file of Object.values(nativePaths())) assert.ok(fs.statSync(file).isFile(), file);
   const runtimeDirectory = path.join(directory, 'runtime');

package/scripts/native-job-object-test.cjs

@@ -54,7 +54,7 @@ const alive = pid => {
       ...process.env,
       HARNESS_MIX_HOST_SCRIPT: fixture,
       HARNESS_MIX_NODE_PATH: process.execPath,
-      CODEXHOST_STOCK_CODEX_PATH: process.execPath,
+      HARNESSMIX_STOCK_CODEX_PATH: process.execPath,
       FAKE_HOST_PIDS: pidFile,
     },
     stdio: ['ignore', 'ignore', 'pipe'],

package/scripts/native-protocol-test.cjs

@@ -74,22 +74,22 @@ async function main() {
     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');
+    const accounts = await bridge.request('harnessmix/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' });
+    const accountUsage = await bridge.request('harnessmix/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' });
+    const login = await bridge.request('harnessmix/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');
+    assert.deepEqual(await bridge.request('harnessmix/account/login/cancel', { accountId: 'official-codex', loginId: 'native-login' }), { cancelled: true });
+    const loggedOut = await bridge.request('harnessmix/account/logout');
     schemas.codexAccountMutationResultSchema.parse(loggedOut);
     assert.equal(loggedOut.account.authenticated, false);
     let openedCodexThread = null;
@@ -109,30 +109,36 @@ async function main() {
       },
       close() {},
     };
-    const isolated = await bridge.request('thread/start', { cwd: root, model: 'gpt-test', __codexhostAccountId: 'account-work' });
+    const isolated = await bridge.request('thread/start', { cwd: root, model: 'gpt-test', __harnessmixAccountId: '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.deepEqual(inspection.capabilities.workspace, { git: true, worktree: true, finalDiff: true, nativeDiff: false, nativePatch: false });
     assert.equal(inspection.catalog.defaultThinkingOptionId, 'high', 'Declared default thinking level projects to the catalog');
     assert.ok(inspection.catalog.models.every(m => m.supportedThinkingOptionIds?.join(',') === 'high,low'), 'Every catalog model carries the selectable thinking set');
-    schemas.harnessPluginListResultSchema.parse(await bridge.request('codexhost/harness/plugins/list'));
+    schemas.harnessPluginListResultSchema.parse(await bridge.request('harnessmix/harness/plugins/list'));
     const started = await bridge.request('thread/start', { cwd: root, model: routeModel('pi') });
     const threadId = started.thread.id;
+    const threadInspection = await bridge.request('harnessmix/thread/inspect', { threadId });
+    schemas.threadInspectionSchema.parse(threadInspection);
+    assert.equal(threadInspection.workspace.hostManaged, true);
+    assert.equal(threadInspection.workspace.finalDiff.source, 'snapshot');
+    assert.equal(threadInspection.workspace.worktree.available, true);
     assert.equal(started.thread.sessionId, threadId, 'Desktop session identity is the host thread, not a native session id');
-    assert.equal(started.thread.model, 'codexhost/pi-native');
+    assert.equal(started.thread.model, 'harnessmix/pi-native');
     const { includesThread } = require('../src/main/native/thread-list');
     const storedThread = runtime.threads.find(t => t.id === threadId);
-    const hostCommands = await bridge.request('codexhost/thread/commands/inspect', { threadId });
+    const hostCommands = await bridge.request('harnessmix/thread/commands/inspect', { threadId });
     assert.ok(hostCommands.commands.some(command => command.id === 'verify'));
     assert.ok(hostCommands.commands.some(command => command.id === 'gate'));
-    const gate = await bridge.request('codexhost/thread/verification/configure', { threadId, policy: { mode: 'required', checks: { cleanWorkingTree: false } } });
+    const gate = await bridge.request('harnessmix/thread/verification/configure', { threadId, policy: { mode: 'required', checks: { cleanWorkingTree: false } } });
     assert.equal(gate.policy.mode, 'required');
     assert.equal(gate.satisfied, false);
-    assert.equal((await bridge.request('codexhost/thread/verification/get', { threadId })).policy.mode, 'required');
-    const storage = await bridge.request('codexhost/storage/inspect');
+    assert.equal((await bridge.request('harnessmix/thread/verification/get', { threadId })).policy.mode, 'required');
+    const storage = await bridge.request('harnessmix/storage/inspect');
     assert.equal(storage.schemaVersion, 2);
     assert.ok(storage.threadCount >= 1);
     assert.equal(includesThread(storedThread, { sectionId: section.id }), false);
@@ -155,7 +161,7 @@ async function main() {
     await bridge.request('turn/interrupt', { threadId: prewarmed.thread.id });
     await wait(() => !runtime.threads.find(t => t.id === prewarmed.thread.id).reviewPending && !runtime.sending.has(prewarmed.thread.id));
     emit = emits[0]; // 恢复主线程的事件源（open 顺序：主线程序，预热线程后）
-    schemas.threadInspectionSchema.parse(await bridge.request('codexhost/thread/inspect', { threadId }));
+    schemas.threadInspectionSchema.parse(await bridge.request('harnessmix/thread/inspect', { threadId }));
     const turn = await bridge.request('turn/start', { threadId, input: [{ type: 'text', text: 'test' }], approvalPolicy: 'never', sandboxPolicy: { type: 'dangerFullAccess' } });
     // turn/start 在 currentTurn 建立后即返回，adapter.send 的调用在其后；等待透传到达
     await wait(() => sendExtras.at(-1)?.turnPermissions != null);
@@ -252,7 +258,7 @@ async function main() {
     ]) {
       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] }), {
+    assert.deepEqual(await bridge.request('harnessmix/thread/ownership/list', { threadIds: ['official-thread', threadId] }), {
       threads: [
         { threadId: 'official-thread', owner: 'codex' },
         { threadId, owner: 'external', harnessId: 'pi' },
@@ -267,25 +273,25 @@ async function main() {
       hooks.emit({ kind: 'usage', usage: { input: 20, output: 5, cacheRead: 10, tokens: 30, contextWindow: 100, cost: 0.01 } });
       hooks.emit({ kind: 'completed', finalAnswer: true });
     };
-    const command = await bridge.request('codexhost/thread/command/execute', { threadId, commandId: 'compact' });
+    const command = await bridge.request('harnessmix/thread/command/execute', { threadId, commandId: 'compact' });
     schemas.threadCommandExecuteResultSchema.parse(command);
     await wait(() => compactCalls === 1 && !runtime.threads.find(t => t.id === threadId).reviewPending && !runtime.sending.has(threadId));
-    const usage = await bridge.request('codexhost/thread/usage/inspect', { threadId });
+    const usage = await bridge.request('harnessmix/thread/usage/inspect', { threadId });
     schemas.threadUsageInspectionSchema.parse(usage);
     assert.equal(usage.usage.inputTokens, 20);
     assert.equal(usage.usage.contextUsagePercent, 30);
-    assert.ok(events.some(e => e.method === 'codexhost/thread/usage/updated' && e.params.usage?.cachedInputTokens === 10));
-    await assert.rejects(bridge.request('codexhost/thread/command/execute', { threadId, commandId: 'missing' }), /不支持此指令/);
+    assert.ok(events.some(e => e.method === 'harnessmix/thread/usage/updated' && e.params.usage?.cachedInputTokens === 10));
+    await assert.rejects(bridge.request('harnessmix/thread/command/execute', { threadId, commandId: 'missing' }), /不支持此指令/);
     // ===== 新 Harness 路由：omp / opencode / grok 的 legacy 传输串解码与投影 =====
-    assert.equal(routeModel('omp'), 'codexhost/omp-native');
-    assert.equal(routeModel('opencode'), 'codexhost/opencode-native');
-    assert.equal(routeModel('grok'), 'codexhost/grok-native');
-    assert.deepEqual(decodeRoute('codexhost/omp-native'), { harnessId: 'omp' });
-    assert.deepEqual(decodeRoute('codexhost/omp-native@model-x@high'), { harnessId: 'omp', model: { id: 'model-x' }, thinkingOptionId: 'high' }, 'OMP 两段式 = model@thinking');
-    assert.deepEqual(decodeRoute('codexhost/omp-native@model-x@approve@high'), { harnessId: 'omp', model: { id: 'model-x' }, permissionModeId: 'approve', thinkingOptionId: 'high' }, 'OMP 三段式 = model@permission@thinking');
-    assert.deepEqual(decodeRoute('codexhost/opencode-native@m@perm'), { harnessId: 'opencode', model: { id: 'm' }, permissionModeId: 'perm' });
-    assert.deepEqual(decodeRoute('codexhost/grok-native@m@@think'), { harnessId: 'grok', model: { id: 'm' }, thinkingOptionId: 'think' });
-    assert.throws(() => decodeRoute('codexhost/omp-native@a@b@c@d'), /Invalid native Harness route/);
+    assert.equal(routeModel('omp'), 'harnessmix/omp-native');
+    assert.equal(routeModel('opencode'), 'harnessmix/opencode-native');
+    assert.equal(routeModel('grok'), 'harnessmix/grok-native');
+    assert.deepEqual(decodeRoute('harnessmix/omp-native'), { harnessId: 'omp' });
+    assert.deepEqual(decodeRoute('harnessmix/omp-native@model-x@high'), { harnessId: 'omp', model: { id: 'model-x' }, thinkingOptionId: 'high' }, 'OMP 两段式 = model@thinking');
+    assert.deepEqual(decodeRoute('harnessmix/omp-native@model-x@approve@high'), { harnessId: 'omp', model: { id: 'model-x' }, permissionModeId: 'approve', thinkingOptionId: 'high' }, 'OMP 三段式 = model@permission@thinking');
+    assert.deepEqual(decodeRoute('harnessmix/opencode-native@m@perm'), { harnessId: 'opencode', model: { id: 'm' }, permissionModeId: 'perm' });
+    assert.deepEqual(decodeRoute('harnessmix/grok-native@m@@think'), { harnessId: 'grok', model: { id: 'm' }, thinkingOptionId: 'think' });
+    assert.throws(() => decodeRoute('harnessmix/omp-native@a@b@c@d'), /Invalid native Harness route/);
     // ===== 跨 Harness 协作：委派 → 消息 → 等待 → 级联取消 =====
     const childEmits = [];
     let childSend;
@@ -298,11 +304,11 @@ async function main() {
       async close() {} };
     runtime.adapters.set('claude', childAdapter); runtime.status.claude = { available: true };
     // Host 级 /delegate 指令出现在命令目录中（insert 型，填入输入框）
-    const commandList = await bridge.request('codexhost/thread/commands/inspect', { threadId });
+    const commandList = await bridge.request('harnessmix/thread/commands/inspect', { threadId });
     assert.ok(commandList.commands.some(c => c.invocation === '/delegate' && c.argumentMode === 'text'), 'Host 级 /delegate 指令应出现在命令目录');
     // 委派：协议入口创建子任务线程并挂起父线程协作 Turn
     childSend = hooks => { hooks.emit({ kind: 'text-delta', text: '子任务结论' }); hooks.emit({ kind: 'completed', finalAnswer: true }); };
-    const delegated = await bridge.request('codexhost/thread/delegate', { threadId, harnessId: 'claude-code', task: '审查代码' });
+    const delegated = await bridge.request('harnessmix/thread/delegate', { threadId, harnessId: 'claude-code', task: '审查代码' });
     schemas.threadDelegationResultSchema.parse(delegated);
     assert.equal(delegated.turn.status, 'inProgress', '委派后父线程协作 Turn 保持活动');
     assert.ok(delegated.turn?.id, 'Delegation starts a parent collaboration Turn');
@@ -322,13 +328,13 @@ async function main() {
     assert.equal(delegateTool.status, 'completed', '子任务结算后协作工具项完成');
     assert.ok(String(delegateTool.output).includes('子任务结论'), '协作工具项携带子任务最终答复');
     // 消息链：向同一子任务跟进（复用既有子线程）
-    const followUp = await bridge.request('codexhost/thread/message', { threadId, childThreadId: childId, text: '再检查一遍' });
+    const followUp = await bridge.request('harnessmix/thread/message', { threadId, childThreadId: childId, text: '再检查一遍' });
     schemas.threadDelegationResultSchema.parse(followUp);
     await wait(() => !runtime.execution.isRunning(threadId));
     assert.deepEqual(childAdapter.sendCalls, ['审查代码', '再检查一遍'], '跟进消息进入同一子任务');
     assert.equal(followUp.childThreadId, childId);
     // 循环防护：子任务不能继续委派
-    await assert.rejects(bridge.request('codexhost/thread/delegate', { threadId: childId, harnessId: 'pi', task: 'x' }), /暂不支持继续委派/);
+    await assert.rejects(bridge.request('harnessmix/thread/delegate', { threadId: childId, harnessId: 'pi', task: 'x' }), /暂不支持继续委派/);
     // 斜杠通道：/delegate 文本走同一委派链路
     childSend = hooks => { hooks.emit({ kind: 'text-delta', text: '斜杠委派完成' }); hooks.emit({ kind: 'completed', finalAnswer: true }); };
     const slashTurn = await bridge.request('turn/start', { threadId, input: [{ type: 'text', text: '/delegate claude 用斜杠通道' }] });
@@ -338,7 +344,7 @@ async function main() {
     await assert.rejects(bridge.request('turn/start', { threadId, input: [{ type: 'text', text: '/delegate' }] }), /用法：\/delegate/);
     // 级联取消：中断父线程协作 Turn ⇒ 子任务被取消
     childSend = () => new Promise(() => {}); // 子任务永不自行结算
-    const stuck = await bridge.request('codexhost/thread/delegate', { threadId, harnessId: 'claude', task: '长跑任务' });
+    const stuck = await bridge.request('harnessmix/thread/delegate', { threadId, harnessId: 'claude', task: '长跑任务' });
     assert.ok(runtime.execution.isRunning(threadId), '父线程协作 Turn 等待子任务');
     await bridge.request('turn/interrupt', { threadId });
     await wait(() => !runtime.execution.isRunning(threadId) && !runtime.execution.isRunning(stuck.childThreadId));
@@ -350,8 +356,8 @@ async function main() {
     await assert.rejects(bridge.request('thread/fork', { threadId, excludeTurns: true }), /Ephemeral fork is not supported/);
     await assert.rejects(bridge.request('thread/start', { cwd: root, model: routeModel('pi'), ephemeral: true, threadSource: 'thread_description' }), /Ephemeral background thread is not supported/);
     // Worktree 隔离工作区丢弃与推送协议接口
-    await assert.rejects(bridge.request('codexhost/thread/workspace/discard', { threadId }), /该任务未使用 Worktree 隔离工作区/);
-    await assert.rejects(bridge.request('codexhost/thread/workspace/push', { threadId }), /该任务未使用 Worktree 隔离工作区/);
+    await assert.rejects(bridge.request('harnessmix/thread/workspace/discard', { threadId }), /该任务未使用 Worktree 隔离工作区/);
+    await assert.rejects(bridge.request('harnessmix/thread/workspace/push', { threadId }), /该任务未使用 Worktree 隔离工作区/);
     const dummyWorktreeThread = await bridge.request('thread/start', { cwd: root, model: routeModel('pi') });
     const dummyThreadId = dummyWorktreeThread.thread.id;
     const dummyWorkspaceDir = path.join(root, 'dummy-wt');
@@ -362,12 +368,12 @@ async function main() {
       root: dummyWorkspaceDir,
       cwd: dummyWorkspaceDir,
       source: root,
-      branch: 'codexhost/test-wt-branch',
+      branch: 'harnessmix/test-wt-branch',
     };
-    await assert.rejects(bridge.request('codexhost/thread/workspace/push', { threadId: dummyThreadId }), /git/i);
-    const discardResult = await bridge.request('codexhost/thread/workspace/discard', { threadId: dummyThreadId });
+    await assert.rejects(bridge.request('harnessmix/thread/workspace/push', { threadId: dummyThreadId }), /git/i);
+    const discardResult = await bridge.request('harnessmix/thread/workspace/discard', { threadId: dummyThreadId });
     assert.equal(discardResult.discarded, true);
-    assert.equal(discardResult.branch, 'codexhost/test-wt-branch');
+    assert.equal(discardResult.branch, 'harnessmix/test-wt-branch');
     assert.equal(dummyTargetThread.workspace, undefined, 'Discard deletes thread.workspace');
 
     // 消息排队（thread/queue/add, list, update, reorder, delete, start）能力验证

package/scripts/native-rollback-test.cjs

@@ -20,7 +20,7 @@ const wait = async fn => { for (let n = 0; n < 400; n++) { if (fn()) return; awa
   runtime.adapters.set('pi', adapter); runtime.status.pi = { available: true };
   const bridge = new NativeProtocol(runtime, () => {});
   try {
-    const { thread } = await bridge.request('thread/start', { cwd: root, model: 'codexhost/pi-native' });
+    const { thread } = await bridge.request('thread/start', { cwd: root, model: 'harnessmix/pi-native' });
     for (const text of ['kept', 'removed']) {
       await bridge.request('turn/start', { threadId: thread.id, input: [{ type: 'text', text }] });
       await wait(() => !runtime.execution.isRunning(thread.id) && !runtime.threads[0].reviewPending);

package/scripts/native-secret-test.cjs

@@ -31,7 +31,7 @@ const helper = [
 
   // --- real helper: DPAPI vault round-trip on a temp data dir ---
   const data = fs.mkdtempSync(path.join(os.tmpdir(), 'hm-secret-'));
-  const env = { ...process.env, CODEXHOST_DATA_DIR: data };
+  const env = { ...process.env, HARNESSMIX_DATA_DIR: data };
   const call = (args, input) => execFileSync(helper, args, { encoding: 'utf8', windowsHide: true, env, input });
   call(['set', 'demo.token'], 'super-secret-value');
   assert.equal(call(['get', 'demo.token']), 'super-secret-value');

package/scripts/native-shim-test.cjs

@@ -12,7 +12,7 @@ async function main() {
   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' };
+    HARNESSMIX_STOCK_CODEX_PATH: process.execPath, HARNESS_MIX_HOST_SCRIPT: host, CODEX_CLI_PATH: 'must-be-removed' };
   let child;
   try {
     fs.writeFileSync(host, `const readline = require('node:readline');

package/scripts/native-sidebar-test.cjs

@@ -55,13 +55,13 @@ async function testPrewarm() {
   const manager = { onNotification() {}, onRequest() {}, dispatchAppServerResponse() {} };
   const target = {};
   installDraftPrewarmPolicyBridge(manager, bridge, 'local', target, { discardAllPrewarmedThreads() {} });
-  const policy = target.__codexhostDraftPrewarmPolicyV1;
+  const policy = target.__harnessmixDraftPrewarmPolicyV1;
   for (const harness of ['pi', 'claude-code', 'deepseek-harness', 'antigravity']) {
-    policy.select(`codexhost/${harness}-native`);
+    policy.select(`harnessmix/${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(prewarmed.at(-1).model, `harnessmix/${harness}-native`);
     assert.equal(sent.at(-1).params.ephemeral, undefined);
   }
   bridge.prewarmThreadStart({ ephemeral: true, model: 'gpt-title' });
@@ -72,7 +72,7 @@ async function testPrewarm() {
   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' });
+  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: { '@harnessmix/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;

package/scripts/native-ui-smoke.cjs

@@ -12,13 +12,13 @@ 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 { 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 { createSkinSettingsPage } from './src/native-ui/renderer-extension/src/settings/skin-market.ts'; export { applyRendererSkin } from './src/native-ui/renderer-extension/src/settings/skin-runtime.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', '.webp': '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 { createSkinSettingsPage } from './src/native-ui/renderer-extension/src/settings/skin-market.ts'; export { applyRendererSkin } from './src/native-ui/renderer-extension/src/settings/skin-runtime.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: { '@harnessmix/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', '.webp': '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);
+    const pageIds = globalThis.__harnessmixSettingsShellV1.registry.pages.map(page => page.id);
     lifecycle.dispose();
     return pageIds;
   })()`);
@@ -26,7 +26,7 @@ app.whenReady().then(async () => {
   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, 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 })));
+  const inspections = await Promise.all(nativeThreads.map(thread => protocol.request('harnessmix/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'];
@@ -43,10 +43,10 @@ app.whenReady().then(async () => {
     }
     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'));
+    const sidebarIcons = [...sidebar.querySelectorAll('[data-harnessmix-sidebar-agent-icon]')].map(icon => icon.getAttribute('data-harnessmix-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;
+    const sidebarIconCount = sidebar.querySelectorAll('[data-harnessmix-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;
@@ -150,16 +150,16 @@ app.whenReady().then(async () => {
   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');
+    globalThis.__harnessmixSettingsShellV1.openSettings(undefined, 'storage');
     await new Promise(resolve => setTimeout(resolve, 100));
-    return globalThis.__codexhostSettingsShellV1.root.shadowRoot.textContent;
+    return globalThis.__harnessmixSettingsShellV1.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 skinResult = await win.webContents.executeJavaScript(`(async () => {
-    globalThis.__codexhostSettingsShellV1.openSettings(undefined, 'skins');
-    const shadow = globalThis.__codexhostSettingsShellV1.root.shadowRoot;
+    globalThis.__harnessmixSettingsShellV1.openSettings(undefined, 'skins');
+    const shadow = globalThis.__harnessmixSettingsShellV1.root.shadowRoot;
     const firstButton = shadow.querySelector('button[data-skin-action="styler-nocturne-studio"]');
     const mikuButton = shadow.querySelector('button[data-skin-action="miku-488137"]');
     firstButton.click();
@@ -180,16 +180,16 @@ app.whenReady().then(async () => {
     assert.equal(skinResult.bundledPreviewCount, 16);
     fs.writeFileSync(path.join(out, 'settings-skins.png'), (await win.webContents.capturePage()).toPNG());
     await win.webContents.executeJavaScript(`(() => {
-      const shadow = globalThis.__codexhostSettingsShellV1.root.shadowRoot;
+      const shadow = globalThis.__harnessmixSettingsShellV1.root.shadowRoot;
       const page = shadow.querySelector('.settings-page');
       page.scrollTop = page.scrollHeight;
     })()`);
     await new Promise(resolve => setTimeout(resolve, 100));
     fs.writeFileSync(path.join(out, 'settings-skins-discovery.png'), (await win.webContents.capturePage()).toPNG());
   const aboutText = await win.webContents.executeJavaScript(`(async () => {
-    globalThis.__codexhostSettingsShellV1.openSettings(undefined, 'about');
+    globalThis.__harnessmixSettingsShellV1.openSettings(undefined, 'about');
     await new Promise(resolve => setTimeout(resolve, 100));
-    return globalThis.__codexhostSettingsShellV1.root.shadowRoot.textContent;
+    return globalThis.__harnessmixSettingsShellV1.root.shadowRoot.textContent;
   })()`);
   assert.match(aboutText, /v0\.1\.4/);
   fs.writeFileSync(path.join(out, 'settings-about.png'), (await win.webContents.capturePage()).toPNG());