@harness-mix/cli 0.1.10 → 0.1.12

package/scripts/build-native.cjs

@@ -1,56 +1,74 @@
-const fs = require('node:fs');
-const path = require('node:path');
-const { execFileSync } = require('node:child_process');
+const fs = require('node:fs');
+const path = require('node:path');
+const { execFileSync } = require('node:child_process');
 const esbuild = require('esbuild');
 const os = require('node:os');
 const { executableName } = require('../src/main/native/platform');
-const { getAllIconsDictionary, MODEL_FAMILIES } = require('../src/main/native/icons');
-const root = path.resolve(__dirname, '..');
-const out = path.join(root, 'output/native-build');
-
-function cargoCommand() {
+const { getAllIconsDictionary, MODEL_FAMILIES } = require('../src/main/native/icons');
+const root = path.resolve(__dirname, '..');
+const out = path.join(root, 'output/native-build');
+
+function cargoCommand() {
   const candidates = ['cargo', path.join(os.homedir(), '.cargo/bin', executableName('cargo'))];
-  for (const candidate of candidates) {
-    try {
-      execFileSync(candidate, ['--version'], { stdio: 'ignore', windowsHide: true });
-      return candidate;
-    } catch { /* try the next candidate */ }
-  }
-  throw new Error('Rust toolchain (cargo) not found; install via https://rustup.rs (use the x86_64-pc-windows-gnu host when Visual Studio Build Tools are absent)');
-}
-
-async function main() {
-  fs.mkdirSync(out, { recursive: true });
-  const alias = { '@codexhost/shared-contracts': path.join(root, 'src/native-ui/shared-contracts/src/index.ts') };
-  const common = { bundle: true, alias, logLevel: 'warning', target: 'es2024' };
-  const icons = getAllIconsDictionary();
-  icons.harnesses['claude-code'] = icons.harnesses.claude;
-  icons.harnesses['deepseek-harness'] = icons.harnesses.dsh;
-  await esbuild.build({ ...common, entryPoints: ['src/native-ui/renderer-extension/src/production-entry.ts'],
-    platform: 'browser', format: 'iife', outfile: path.join(out, 'renderer-extension.js'),
+  for (const candidate of candidates) {
+    try {
+      execFileSync(candidate, ['--version'], { stdio: 'ignore', windowsHide: true });
+      return candidate;
+    } catch { /* try the next candidate */ }
+  }
+  throw new Error('Rust toolchain (cargo) not found; install via https://rustup.rs (use the x86_64-pc-windows-gnu host when Visual Studio Build Tools are absent)');
+}
+
+// A byte comparison is the only honest way to tell "the running executable is
+// already current" apart from "the running executable is stale".
+function sameContents(left, right) {
+  try {
+    if (fs.statSync(left).size !== fs.statSync(right).size) return false;
+    return fs.readFileSync(left).equals(fs.readFileSync(right));
+  } catch { return false; }
+}
+
+async function main() {
+  fs.mkdirSync(out, { recursive: true });
+  const alias = { '@harnessmix/shared-contracts': path.join(root, 'src/native-ui/shared-contracts/src/index.ts') };
+  const common = { bundle: true, alias, logLevel: 'warning', target: 'es2024' };
+  const icons = getAllIconsDictionary();
+  icons.harnesses['claude-code'] = icons.harnesses.claude;
+  icons.harnesses['deepseek-harness'] = icons.harnesses.dsh;
+  await esbuild.build({ ...common, entryPoints: ['src/native-ui/renderer-extension/src/production-entry.ts'],
+    platform: 'browser', format: 'iife', outfile: path.join(out, 'renderer-extension.js'),
     loader: { '.svg': 'dataurl', '.png': 'dataurl', '.webp': 'dataurl', '.css': 'text' },
-    banner: { js: `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 })))};` } });
-  await esbuild.build({ ...common, entryPoints: ['src/native-ui/desktop-control/src/release-main.ts'],
-    platform: 'node', format: 'esm', outfile: path.join(out, 'desktop-controller.mjs') });
+    banner: { js: `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 })))};` } });
+  await esbuild.build({ ...common, entryPoints: ['src/native-ui/desktop-control/src/release-main.ts'],
+    platform: 'node', format: 'esm', outfile: path.join(out, 'desktop-controller.mjs') });
   execFileSync(cargoCommand(), ['build', '--release', '--manifest-path', path.join(root, 'src/main/native/rs/Cargo.toml'),
     ...(process.platform === 'win32' ? [] : ['--package', 'harness-mix-shim'])], { stdio: 'inherit', windowsHide: true });
-  const target = path.join(root, 'src/main/native/rs/target/release');
+  const target = path.join(root, 'src/main/native/rs/target/release');
   for (const exe of process.platform === 'win32' ? ['harness-mix-shim.exe', 'harness-mix-appx.exe', 'harness-mix-secret.exe'] : ['harness-mix-shim']) {
-    const source = path.join(target, exe);
-    const destination = path.join(out, exe);
-    // An unchanged executable may be running while UI-only fixes are built.
-    try {
+    const source = path.join(target, exe);
+    const destination = path.join(out, exe);
+    try {
       fs.copyFileSync(source, destination);
       if (process.platform !== 'win32') fs.chmodSync(destination, 0o755);
-    } catch (err) {
-      if (err && err.code === 'EBUSY') {
-        console.warn(`[build:native] Notice: ${exe} is in use, keeping existing binary.`);
-      } else {
-        throw err;
-      }
-    }
-  }
-  fs.writeFileSync(path.join(out, 'node-path.txt'), process.execPath);
-  console.log('Harness Mix local Renderer, Desktop Controller and Shim built.');
-}
-main().catch(error => { console.error(error); process.exitCode = 1; });
+    } catch (err) {
+      if (err && err.code === 'EBUSY') {
+        // A running Codex Desktop holds the deployed binary. Keeping it is only
+        // safe when it is byte-identical: an unchanged executable may be running
+        // while UI-only fixes are built, but a changed one would leave the Shim
+        // and the kernel speaking different environments.
+        if (sameContents(source, destination)) {
+          console.warn(`[build:native] Notice: ${exe} is in use, keeping the identical deployed binary.`);
+        } else {
+          throw new Error(`[build:native] ${exe} is locked by a running Codex Desktop and its contents changed. ` +
+            'Close Codex Desktop (or run npm start from an external terminal) and build again, ' +
+            'otherwise the deployed Shim keeps speaking the previous protocol.');
+        }
+      } else {
+        throw err;
+      }
+    }
+  }
+  fs.writeFileSync(path.join(out, 'node-path.txt'), process.execPath);
+  console.log('Harness Mix local Renderer, Desktop Controller and Shim built.');
+}
+main().catch(error => { console.error(error); process.exitCode = 1; });

package/scripts/codex-accounts-test.cjs

@@ -64,7 +64,7 @@ async function main() {
     const login = await manager.startLogin(created.account.accountId);
     assert.equal(login.userCode, 'WXYZ-1234');
     server.notify({ method: 'account/login/completed', params: { loginId: login.loginId, success: true, error: null } });
-    assert.deepEqual(emitted.at(-1), { method: 'codexhost/account/login/completed', params: { accountId: created.account.accountId, loginId: login.loginId, success: true, error: null } });
+    assert.deepEqual(emitted.at(-1), { method: 'harnessmix/account/login/completed', params: { accountId: created.account.accountId, loginId: login.loginId, success: true, error: null } });
 
     const registry = fs.readFileSync(path.join(root, 'codex-accounts', 'accounts.json'), 'utf8');
     assert.equal(registry.includes('owner@example.com'), false, 'Registry must not persist native identity or credentials');

package/scripts/codex-accounts-ui-smoke.cjs

@@ -15,7 +15,7 @@ app.whenReady().then(async () => {
       resolveDir: process.cwd(),
     },
     bundle: true,
-    alias: { '@codexhost/shared-contracts': path.resolve('src/native-ui/shared-contracts/src/index.ts') },
+    alias: { '@harnessmix/shared-contracts': path.resolve('src/native-ui/shared-contracts/src/index.ts') },
     platform: 'browser',
     format: 'iife',
     globalName: 'AccountUI',

package/scripts/collaboration-recovery-test.cjs

@@ -59,14 +59,18 @@ async function main() {
 
   const rt = new HostRuntime({ dataDirectory: path.join(root, 'data') }); await rt.store.load();
   await rt.collaboration.initialize();
-  rt.collaboration.jobs.set('saved', { id: 'saved', owner: 'parent', agent: 'pi', childId: 'child', status: 'running', task: 'continue', workspace });
+  rt.collaboration.jobs.set('saved', { id: 'saved', owner: 'parent', agent: 'pi', childId: 'child', status: 'running', task: 'continue', workspace, teamId: 'team', memberId: 'member', teamTaskId: 'team-task' });
   rt.collaboration.jobs.set('finished', { id: 'finished', owner: 'parent', agent: 'pi', childId: 'done', status: 'completed', result: 'kept' });
+  rt.collaboration.teams.set('team', { id: 'team', owner: 'parent', name: 'Recovery team', goal: 'Resume safely', status: 'active', members: [{ id: 'member', name: 'Builder', role: 'Continue work', agent: 'pi', status: 'working', childId: 'child' }], tasks: [{ id: 'team-task', title: 'Continue', description: 'Resume after restart', assignee: 'member', dependsOn: [], status: 'in_progress' }], messages: [], updatedAt: Date.now() });
   await rt.collaboration.save();
+  await rt.collaboration.saveTeams();
   const restarted = new Collaboration(rt); await restarted.initialize();
   assert.equal(restarted.jobs.get('saved').status, 'interrupted');
   assert.equal(restarted.jobs.get('saved').childId, 'child');
   assert.equal(restarted.jobs.get('saved').workspace.cwd, workspace.cwd);
   assert.equal(restarted.jobs.get('finished').result, 'kept');
+  assert.equal(restarted.teams.get('team').members[0].status, 'interrupted');
+  assert.equal(restarted.teams.get('team').tasks[0].status, 'interrupted');
   assert.equal(restarted.keys.size, 0, 'No session authorization keys persisted');
   // Resume must reuse the durable child identity, rather than spawn a replacement.
   const parent = { id: 'parent', cwd: repo, title: 'Lead' }, child = { id: 'child', parentThreadId: 'parent', cwd: workspace.cwd };
@@ -78,10 +82,15 @@ async function main() {
     async createThread() { throw new Error('Duplicate child created'); }, async cancel() {} };
   restarted.runtime = fake;
   await restarted.call('parent', 'resume_delegation', { task_id: 'saved' });
+  assert.equal(restarted.teams.get('team').members[0].status, 'working');
+  assert.equal(restarted.teams.get('team').tasks[0].status, 'in_progress');
   await restarted.jobs.get('saved').done;
   assert.match(received, /do not repeat completed side effects/);
   assert.equal(restarted.jobs.get('saved').result, 'resumed');
   assert.equal(restarted.jobs.get('saved').childId, 'child');
+  assert.equal(restarted.teams.get('team').members[0].status, 'ready');
+  assert.equal(restarted.teams.get('team').tasks[0].status, 'completed');
+  assert.equal(restarted.teams.get('team').status, 'completed');
   const nativeReview = await restarted.call('parent', 'review_delegation_changes', { task_id: 'saved' });
   assert.equal(nativeReview.digest, review.digest); assert.match(nativeReview.patch, /worker/);
   rt.collaboration.jobs.clear();
@@ -92,7 +101,7 @@ async function main() {
     async readNative() { calls.push('read'); return [{ id: 'u', role: 'user', text: 'old question', at: 1 }, { id: 'a', role: 'assistant', text: 'old answer', at: 2 }]; },
   });
   const protocol = new NativeProtocol(rt, () => {});
-  const rows = await protocol.request('codexhost/harness/session-import/list', { harnessId: 'all-harnesses', query: 'Native' });
+  const rows = await protocol.request('harnessmix/harness/session-import/list', { harnessId: 'all-harnesses', query: 'Native' });
   assert.equal(rows.total, 1);
   const params = { harnessId: 'all-harnesses', nativeSessionId: rows.candidates[0].nativeSessionId };
   const context = await rt.history.context(params);

package/scripts/collaboration-test.cjs

@@ -2,7 +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 { mentionedAgents } = require('../src/main/host/collaboration');
+const { mentionedAgents, teamTaskDepths, teamPhase, teamProgress } = require('../src/main/host/collaboration');
 const { JsonlProcess } = require('../src/main/host/jsonl');
 const wait = async fn => { for (let i = 0; i < 300; i++) { if (fn()) return; await new Promise(r => setTimeout(r, 10)); } throw new Error('Timed out'); };
 
@@ -10,42 +10,61 @@ async function main() {
   const root = await fs.mkdtemp(path.resolve('output/collaboration-'));
   const rt = new HostRuntime({ dataDirectory: path.join(root, 'data') });
   await rt.store.load();
-  let connection, active = 0, maximum = 0;
+  let connection, teamConnection, active = 0, maximum = 0;
   const pending = new Map();
   let leadPrompt = '';
   const lead = { manifest: { id: 'lead', name: 'Lead', capabilities: { collaborationTools: true } },
     async open(input) { connection = input.collaboration; return { emit: input.emit, collaborationEnabled: true }; },
     async send(s, text) { leadPrompt = text; }, async cancel() {}, async close() {} };
-  const worker = { manifest: { id: 'worker', name: 'Worker', aliases: ['w'], capabilities: {} },
-    async open(input) { assert.equal(input.collaboration, undefined); return { id: input.thread.id, emit: input.emit }; },
+  const worker = { manifest: { id: 'worker', name: 'Worker', aliases: ['w'], capabilities: { collaborationTools: true } },
+    async open(input) {
+      if (input.collaboration) teamConnection = input.collaboration;
+      else assert.equal(input.collaboration, undefined);
+      return { id: input.thread.id, emit: input.emit, collaborationEnabled: !!input.collaboration };
+    },
     async send(s, text) { active++; maximum = Math.max(maximum, active); pending.set(s.id, { s, text }); },
     async cancel(s) { if (pending.delete(s.id)) active--; }, async close() {} };
+  const reviewer = { ...worker, manifest: { id: 'reviewer', name: 'Reviewer', capabilities: { collaborationTools: true } } };
   rt.adapters.set('lead', lead); rt.status.lead = { available: true };
   rt.adapters.set('worker', worker); rt.status.worker = { available: true };
-  const parent = await rt.createThread({ harnessId: 'lead', cwd: root });
-  rt.collaboration.jobs.set('interrupted-fixture', { id: 'interrupted-fixture', owner: parent.id, agent: 'worker', childId: 'old-child', status: 'interrupted' });
+  rt.adapters.set('reviewer', reviewer); rt.status.reviewer = { available: true };
+  const parent = await rt.createThread({ harnessId: 'lead', cwd: root });
+  rt.collaboration.jobs.set('interrupted-fixture', { id: 'interrupted-fixture', owner: parent.id, agent: 'worker', childId: 'old-child', status: 'interrupted' });
   const ownerConnection = connection;
   const transport = new JsonlProcess(connection.command, connection.args, { env: { ...process.env, ...connection.env } }, {});
   const call = (name, args) => rt.collaboration.call(parent.id, name, args);
   const finish = (id, answer) => { const { s } = pending.get(id); pending.delete(id); active--; s.emit({ kind: 'text-delta', text: answer }); s.emit({ kind: 'completed', finalAnswer: true }); };
   try {
-    assert.deepEqual(mentionedAgents('ask #w and [Worker](harness-mix://agent/worker) `#lead` issue#lead #worker/foo', rt), ['worker']);
-    assert.deepEqual(mentionedAgents('leave @w to native Codex mentions', rt), []);
+    assert.deepEqual(mentionedAgents('ask #w and [Worker](harness-mix://agent/worker) `#lead` issue#lead #worker/foo', rt), ['worker']);
+    assert.deepEqual(mentionedAgents('leave @w to native Codex mentions', rt), []);
+    assert.deepEqual(mentionedAgents('创建 Agent Team：Worker 负责开发，Reviewer 负责审查。', rt), ['worker', 'reviewer'], '纯文本 Harness 名称可在明确团队语境中授权');
+    assert.deepEqual(mentionedAgents('讨论 Worker 和 Reviewer 的界面显示', rt), [], '普通产品讨论不得误启动跨 Harness 协作');
+    assert.deepEqual(mentionedAgents('组建团队，但不要从 `Worker` 或 ```Reviewer``` 调度', rt), [], '代码区域中的名称不得作为授权');
+    assert.deepEqual(mentionedAgents('让 issue-worker 参与团队', rt), [], '较长标识符内的 Harness 子串不得误匹配');
+    const depthFixture = [{ id: 'a', dependsOn: [] }, { id: 'b', dependsOn: ['a'] }, { id: 'c', dependsOn: ['b', 'missing'] }];
+    assert.equal(teamTaskDepths(depthFixture).get('c'), 2, 'Depth follows the longest dependency chain and ignores unknown ids');
+    assert.equal(teamTaskDepths(depthFixture).get('a'), 0);
+    const cyclic = teamTaskDepths([{ id: 'x', dependsOn: ['y'] }, { id: 'y', dependsOn: ['x'] }]);
+    assert.ok(Number.isFinite(cyclic.get('x')) && Number.isFinite(cyclic.get('y')), 'Cyclic graphs terminate');
+    assert.equal(teamPhase({ tasks: [] }), 'forming');
+    assert.equal(teamProgress([{ status: 'completed' }, { status: 'blocked' }]).percent, 50);
     await assert.rejects(call('list_agents', {}), /no longer active/);
     rt.history.context = async ({ nativeSessionId }) => { assert.equal(nativeSessionId, 'c2Vzc2lvbg'); return { harnessId: 'pi', title: 'Old session', cwd: root, transcript: 'User: prior question\nAssistant: prior answer' }; };
-    await rt.send(parent.id, '#worker review files #[Old session](harness-mix://session/c2Vzc2lvbg)');
-    assert.ok(rt.execution.isRunning(parent.id));
-    assert.match(leadPrompt, /untrusted historical data[\s\S]*prior answer/);
-    assert.match(leadPrompt, /Recovery checkpoint:[\s\S]*interrupted-fixture \(worker\)[\s\S]*call list_delegations now/);
-    assert.equal(rt.collaboration.jobs.get('interrupted-fixture').status, 'interrupted', 'Prompt injection never auto-resumes interrupted work');
-    rt.collaboration.jobs.delete('interrupted-fixture');
+    await rt.send(parent.id, '#worker #reviewer review files #[Old session](harness-mix://session/c2Vzc2lvbg)');
+    assert.ok(rt.execution.isRunning(parent.id));
+    assert.match(leadPrompt, /untrusted historical data[\s\S]*prior answer/);
+    assert.match(leadPrompt, /Recovery checkpoint:[\s\S]*interrupted-fixture \(worker\)[\s\S]*call list_delegations now/);
+    assert.equal(rt.collaboration.jobs.get('interrupted-fixture').status, 'interrupted', 'Prompt injection never auto-resumes interrupted work');
+    rt.collaboration.jobs.delete('interrupted-fixture');
     assert.ok(!JSON.stringify(rt.core.getItemsForTurn(rt.execution.lastTurn(parent.id).id)).includes('[Harness Mix collaboration]'), 'Routing guidance stays out of displayed user text');
     const init = await transport.request('initialize', { protocolVersion: '2024-11-05', capabilities: {}, clientInfo: { name: 'test', version: '1' } });
     assert.ok(init.capabilities.tools);
     const catalog = await transport.request('tools/list', {});
-    assert.equal(catalog.tools.length, 10);
+    assert.equal(catalog.tools.length, 15);
     assert.ok(catalog.tools.some(tool => tool.name === 'review_delegation_changes'));
     assert.ok(catalog.tools.some(tool => tool.name === 'apply_delegation_changes'));
+    assert.ok(catalog.tools.some(tool => tool.name === 'create_agent_team'));
+    assert.equal(catalog.tools.find(tool => tool.name === 'create_agent_team').inputSchema.properties.members.maxItems, 6, 'A Team supports six specialist members plus its Lead');
     await call('update_agent_plan', { steps: [{ text: 'Develop then review', status: 'in_progress' }] });
     assert.ok(rt.core.getItemsForTurn(rt.execution.lastTurn(parent.id).id).some(item => item.type === 'plan' && item.entries[0].text === 'Develop then review'));
     const first = JSON.parse((await transport.request('tools/call', { name: 'delegate_to_agent', arguments: { agent_type: 'worker', task: 'one' } })).content[0].text);
@@ -87,22 +106,90 @@ async function main() {
     await wait(() => pending.size === 1);
     finish(jobs[0].childId, 'follow-up-result');
     assert.equal((await call('get_delegation_status', { task_ids: [first.task_id], wait_ms: 3000 }))[0].result, 'follow-up-result');
+    const team = await call('create_agent_team', { name: 'Release team', goal: 'Ship a verified change', members: [{ name: 'Builder', role: 'Implement and coordinate', agent_type: 'worker' }, { name: 'Reviewer', role: 'Independently verify', agent_type: 'reviewer' }, { name: 'Frontend', role: 'Integrate the native UI', agent_type: 'worker' }, { name: 'QA', role: 'Run the regression matrix', agent_type: 'reviewer' }, { name: 'Docs', role: 'Document the delivery', agent_type: 'worker' }, { name: 'Release', role: 'Verify Git and final Diff', agent_type: 'reviewer' }] });
+    assert.equal(team.lead.agent, 'lead');
+    assert.match(team.lead.role, /Lead/);
+    assert.equal(team.members.length, 6);
+    const teamTask = (await call('assign_team_task', { team_id: team.team_id, title: 'Build', description: 'Implement the change', assignee: team.members[0].id })).task;
+    const dependentAssign = await call('assign_team_task', { team_id: team.team_id, title: 'Verify', description: 'Verify the result', assignee: team.members[1].id, depends_on: [teamTask.id] });
+    const dependent = dependentAssign.task;
+    assert.equal(dependent.status, 'blocked');
+    assert.equal(dependentAssign.team.phase, 'waiting', 'Assigned work with nothing in flight reads as waiting');
+    assert.deepEqual(dependentAssign.team.progress, { total: 2, pending: 1, blocked: 1, in_progress: 0, completed: 0, failed: 0, interrupted: 0, percent: 0 });
+    assert.equal(dependentAssign.team.tasks.find(entry => entry.id === dependent.id).depth, 1, 'Dependent task sits one dependency lane deep');
+    assert.equal(dependentAssign.team.tasks.find(entry => entry.id === teamTask.id).depth, 0);
+    const teamJob = await call('delegate_to_agent', { agent_type: 'worker', task: 'Implement as Builder', team_id: team.team_id, member_id: team.members[0].id, team_task_id: teamTask.id, isolation: 'shared' });
+    await wait(() => pending.size === 1 && teamConnection);
+    const teammateTransport = new JsonlProcess(teamConnection.command, teamConnection.args, { env: { ...process.env, ...teamConnection.env } }, {});
+    await teammateTransport.request('initialize', { protocolVersion: '2024-11-05', capabilities: {}, clientInfo: { name: 'teammate-test', version: '1' } });
+    const teammateState = JSON.parse((await teammateTransport.request('tools/call', { name: 'get_team_state', arguments: { team_id: team.team_id } })).content[0].text);
+    assert.equal(teammateState.members[0].display_status, 'working');
+    assert.equal(teammateState.phase, 'running', 'In-flight work reads as running');
+    assert.equal(teammateState.progress.in_progress, 1);
+    await teammateTransport.request('tools/call', { name: 'send_team_message', arguments: { team_id: team.team_id, to: 'lead', task_id: teamTask.id, kind: 'review-request', message: 'Implementation is ready for verification.' } });
+    await assert.rejects(rt.collaboration.call(parent.id, 'send_team_message', { team_id: team.team_id, to: 'lead', message: 'bad kind', kind: 'bogus' }), /invalid_value|Invalid/, 'Message kind is a closed enum');
+    const teamChild = rt.collaboration.jobs.get(teamJob.task_id).childId;
+    await assert.rejects(rt.collaboration.call(teamChild, 'assign_team_task', { team_id: team.team_id, title: 'Escalate', description: 'Must be lead-owned', assignee: team.members[0].id }), /Only the Team Lead/);
+    await assert.rejects(rt.collaboration.call(teamChild, 'delegate_to_agent', { agent_type: 'worker', task: 'recursive' }), /Only lead/);
+    finish(teamChild, 'team-result');
+    await wait(() => rt.collaboration.jobs.get(teamJob.task_id).status === 'completed');
+    const settledTeam = await call('get_team_state', { team_id: team.team_id });
+    assert.equal(settledTeam.tasks.find(entry => entry.id === teamTask.id).status, 'completed');
+    assert.equal(settledTeam.tasks.find(entry => entry.id === dependent.id).status, 'pending');
+    assert.equal(settledTeam.messages[0].fromName, 'Builder');
+    assert.equal(settledTeam.messages[0].kind, 'review-request', 'Mailbox messages keep their typed kind');
+    assert.equal(settledTeam.phase, 'waiting', 'Build settled but dependent review is not delegated yet');
+    assert.equal(settledTeam.progress.completed, 1);
+    assert.equal(settledTeam.members[0].child_thread_id ?? settledTeam.members[0].childId, teamChild);
+    const verifyJob = await call('delegate_to_agent', { agent_type: 'reviewer', task: 'Verify independently as Reviewer', team_id: team.team_id, member_id: team.members[1].id, team_task_id: dependent.id, isolation: 'shared' });
+    await wait(() => rt.collaboration.jobs.get(verifyJob.task_id).childId && pending.has(rt.collaboration.jobs.get(verifyJob.task_id).childId));
+    const reviewerChild = rt.collaboration.jobs.get(verifyJob.task_id).childId;
+    assert.notEqual(reviewerChild, teamChild, 'Different Harness teammates own different native sessions');
+    finish(reviewerChild, 'verification-result');
+    await wait(() => rt.collaboration.jobs.get(verifyJob.task_id).status === 'completed');
+    const polish = (await call('assign_team_task', { team_id: team.team_id, title: 'Polish', description: 'Address final details', assignee: team.members[0].id, depends_on: [dependent.id] })).task;
+    const polishJob = await call('delegate_to_agent', { agent_type: 'worker', task: 'Polish in the persistent Builder session', team_id: team.team_id, member_id: team.members[0].id, team_task_id: polish.id, isolation: 'worktree' });
+    assert.equal(polishJob.child_thread_id, teamChild, 'A teammate keeps one native session across team tasks');
+    assert.equal(polishJob.workspace.cwd, rt.collaboration.jobs.get(teamJob.task_id).workspace.cwd, 'A teammate keeps its existing workspace across team tasks');
+    await wait(() => pending.has(teamChild));
+    finish(teamChild, 'polish-result');
+    await wait(() => rt.collaboration.jobs.get(polishJob.task_id).status === 'completed');
+    const inspectedTeam = await rt.collaboration.inspectTeam(parent.id, team.team_id);
+    assert.equal(inspectedTeam.team.team_id, team.team_id);
+    assert.equal(inspectedTeam.team.phase, 'completed', 'All team tasks settled');
+    assert.equal(inspectedTeam.team.progress.percent, 100);
+    assert.ok(inspectedTeam.snapshots.length >= 8, 'Team lifecycle is preserved as replayable snapshots');
+    assert.ok(inspectedTeam.snapshots.some(entry => entry.action === 'member_session_ready'));
+    assert.ok(inspectedTeam.snapshots.some(entry => entry.action === 'task_settled'));
+    assert.equal((await rt.collaboration.inspectTeam(teamChild, team.team_id)).team.team_id, team.team_id, 'Members may inspect their own shared team state');
+    const { NativeProtocol } = require('../src/main/native/protocol');
+    const protocolTeam = await new NativeProtocol(rt, () => {}).request('harnessmix/thread/team/inspect', { threadId: parent.id, teamId: team.team_id });
+    assert.equal(protocolTeam.snapshots.at(-1).team.team_id, team.team_id, 'Renderer protocol exposes the persisted Team timeline');
+    await rt.collaboration.saveTeams();
+    const persistedTeams = JSON.parse(await fs.readFile(path.join(root, 'data', 'collaboration', 'teams.json'), 'utf8'));
+    assert.equal(persistedTeams[0].id, team.team_id);
+    assert.equal(persistedTeams[0].history.length, inspectedTeam.snapshots.length);
+    teammateTransport.stop();
     await assert.rejects(call('get_delegation_status', { task_ids: ['foreign-task'] }), /Unknown task/);
     await assert.rejects(rt.collaboration.call(jobs[0].childId, 'delegate_to_agent', { agent_type: 'worker', task: 'recursive' }), /Only lead/);
-    await assert.rejects(call('delegate_to_agent', { agent_type: 'worker', task: 'x', unexpected: true }));
-    const savedMentions = parent.activeMentions;
-    delete parent.activeMentions;
-    await assert.rejects(call('delegate_to_agent', { agent_type: 'worker', task: 'unauthorized' }), /用户本轮未显式委派/);
+    await assert.rejects(call('delegate_to_agent', { agent_type: 'worker', task: 'x', unexpected: true }));
+    const savedMentions = parent.activeMentions;
+    delete parent.activeMentions;
+    await assert.rejects(call('delegate_to_agent', { agent_type: 'worker', task: 'unauthorized' }), /用户本轮未显式委派/);
     parent.activeMentions = savedMentions;
     const denied = await fetch(ownerConnection.env.HARNESS_MIX_COLLAB_URL, { method: 'POST', headers: { Authorization: 'Bearer invalid' }, body: '{}' });
-    assert.equal(denied.status, 403);
-    const outsider = await rt.createThread({ harnessId: 'worker', cwd: root });
-    await rt.send(outsider.id, 'unrelated');
-    assert.equal(outsider.messages.at(-1).concurrent, true, 'Independent same-workspace turns are marked concurrent');
-    await rt.cancel(outsider.id); await wait(() => !pending.has(outsider.id));
-    for (let i = 0; i < 4; i++) await call('delegate_to_agent', { agent_type: 'worker', task: 'cancel me', isolation: 'shared' });
-    await wait(() => pending.size === 4);
-    await assert.rejects(call('delegate_to_agent', { agent_type: 'worker', task: 'too many' }), /four concurrent/);
+    assert.equal(denied.status, 403);
+    const outsider = await rt.createThread({ harnessId: 'worker', cwd: root });
+    await assert.rejects(rt.collaboration.inspectTeam(outsider.id, team.team_id), /not a team participant/);
+    const noTeam = await rt.collaboration.inspectTeam(outsider.id);
+    assert.equal(noTeam.team, null, 'Inspecting a non-team thread without a teamId answers benignly');
+    assert.deepEqual(noTeam.snapshots, []);
+    await rt.send(outsider.id, 'unrelated');
+    assert.equal(outsider.messages.at(-1).concurrent, true, 'Independent same-workspace turns are marked concurrent');
+    await rt.cancel(outsider.id); await wait(() => !pending.has(outsider.id));
+    for (let i = 0; i < 6; i++) await call('delegate_to_agent', { agent_type: 'worker', task: 'cancel me', isolation: 'shared' });
+    await wait(() => pending.size === 6);
+    await assert.rejects(call('delegate_to_agent', { agent_type: 'worker', task: 'too many' }), /six concurrent/);
     await rt.cancel(parent.id);
     await wait(() => !pending.size);
     assert.equal(rt.execution.lastTurn(parent.id).status, 'cancelled');

package/scripts/collaboration-ui-smoke.cjs

@@ -4,14 +4,17 @@ const fs = require('node:fs/promises');
 const path = require('node:path');
 app.disableHardwareAcceleration();
 app.whenReady().then(async () => {
-  const bundle = await require('esbuild').build({ stdin: { contents: `export * from './src/native-ui/renderer-extension/src/renderer-harness-mentions.ts';`, resolveDir: process.cwd() }, bundle: true, platform: 'browser', format: 'iife', globalName: 'Mentions', write: false });
-  const win = new BrowserWindow({ show: false, width: 900, height: 650, webPreferences: { sandbox: true, contextIsolation: true, offscreen: true, backgroundThrottling: false } });
+  const bundle = await require('esbuild').build({ stdin: { contents: `export * from './src/native-ui/renderer-extension/src/renderer-harness-mentions.ts'; export * from './src/native-ui/renderer-extension/src/renderer-team-cards.ts';`, resolveDir: process.cwd() }, bundle: true, platform: 'browser', format: 'iife', globalName: 'Mentions', write: false });
+  const win = new BrowserWindow({ show: false, width: 1024, height: 716, webPreferences: { sandbox: true, contextIsolation: true, offscreen: true, backgroundThrottling: false } });
   try {
-    await win.loadURL('data:text/html;charset=utf-8,' + encodeURIComponent('<body style="font:16px system-ui;padding:32px"><h2>Harness Mix · 多 Agent 协作</h2><p>主任务负责分工、收集结果与验证。</p><div data-codex-composer-root data-composer-draft-id="textarea-smoke" style="position:absolute;left:40px;bottom:50px;width:750px;box-sizing:border-box;padding:14px;border:2px solid #aaa;border-radius:16px"><textarea style="width:100%;height:90px;border:0;outline:0;resize:none;font:16px system-ui" placeholder="输入 # 选择协作 Harness"></textarea></div><div data-codex-composer-root data-composer-draft-id="rich-smoke" style="position:fixed;left:-1200px;width:400px"><div contenteditable="true" style="border:1px solid gray;padding:16px">你负责后端，</div></div></body>'));
+    await win.loadURL('data:text/html;charset=utf-8,' + encodeURIComponent('<body style="font:16px system-ui;padding:32px"><h2>Harness Mix · 多 Agent 协作</h2><p>主任务负责分工、收集结果与验证。</p><div id="thread-content-anchor"></div><div data-codex-composer-root data-composer-draft-id="textarea-smoke" style="position:absolute;left:40px;bottom:50px;width:750px;box-sizing:border-box;padding:14px;border:2px solid #aaa;border-radius:16px"><textarea style="width:100%;height:90px;border:0;outline:0;resize:none;font:16px system-ui" placeholder="输入 # 选择协作 Harness"></textarea></div><div data-codex-composer-root data-composer-draft-id="rich-smoke" style="position:fixed;left:-1200px;width:400px"><div contenteditable="true" style="border:1px solid gray;padding:16px">你负责后端，</div></div></body>'));
     await win.webContents.executeJavaScript(`globalThis.__HARNESS_MIX_ICONS__ = ${JSON.stringify(require('../src/main/native/icons').getAllIconsDictionary())}`);
     await win.webContents.executeJavaScript(bundle.outputFiles[0].text);
-    const result = await win.webContents.executeJavaScript(`(async () => {
+    const result = await win.webContents.executeJavaScript(`(async () => {
       const api = Mentions.installHarnessMentions(async () => ({agents:[{id:'pi',name:'Pi',available:true,lead:true},{id:'claude',name:'Claude Code',available:true,lead:true},{id:'dsh',name:'DeepSeek Harness',available:false,lead:false}],sessions:[{id:'c2Vzc2lvbg',title:'旧版登录审查',harnessId:'claude',cwd:'E:/project',running:false}]}));
+      const teamState = {action:'message_sent',team_id:'team-1',lead_thread_id:'lead-thread',name:'Release Team',goal:'实现并验证 Agent Team',status:'active',updated_at:2,lead:{id:'lead',name:'Team Lead',role:'Codex · 协调与验收',agent:'codex',display_status:'working'},members:[{id:'member-1',name:'Backend',role:'后端架构与 Host Runtime',agent:'pi',childId:'builder-thread',display_status:'working'},{id:'member-2',name:'Reviewer',role:'独立代码审查与质量验收',agent:'claude',display_status:'ready'},{id:'member-3',name:'Frontend',role:'Codex 原生界面集成',agent:'codex',display_status:'working'},{id:'member-4',name:'QA',role:'测试矩阵与回归验证',agent:'dsh',display_status:'ready'},{id:'member-5',name:'Docs',role:'文档与交付说明',agent:'opencode',display_status:'ready'},{id:'member-6',name:'Release',role:'Git、Diff 与最终发布检查',agent:'antigravity',display_status:'blocked'}],tasks:[{id:'task-1',title:'实现 Team Runtime',assignee:'member-1',dependsOn:[],status:'in_progress'},{id:'task-2',title:'独立验证实现',assignee:'member-2',dependsOn:['task-1'],status:'blocked'},{id:'task-3',title:'实现内嵌团队页面',assignee:'member-3',dependsOn:[],status:'in_progress'},{id:'task-4',title:'执行完整回归',assignee:'member-4',dependsOn:['task-1','task-3'],status:'blocked'},{id:'task-5',title:'更新协作文档',assignee:'member-5',dependsOn:[],status:'completed'},{id:'task-6',title:'核对最终 Diff',assignee:'member-6',dependsOn:['task-2','task-4'],status:'blocked'}],messages:[{id:'message-1',from:'member-1',fromName:'Backend',to:'member-2',body:'Runtime 已就绪，请准备审查。',at:1}]};
+      globalThis.openedTeamThread = null;
+      const teamApi = Mentions.installTeamCards({inspectTeam:async () => ({team:teamState,snapshots:[{id:'snapshot-1',action:'team_created',at:1,team:{...teamState,tasks:[],messages:[]}},{id:'snapshot-2',action:'message_sent',at:2,team:teamState}]}),openThread:async id => { globalThis.openedTeamThread=id; },activeThread:() => ({threadId:'lead-thread',anchor:document.querySelector('#thread-content-anchor')})});
       const editor = document.querySelector('textarea');
       editor.focus(); editor.value = '@cl'; editor.setSelectionRange(editor.value.length,editor.value.length); editor.dispatchEvent(new Event('input',{bubbles:true}));
       await new Promise(r=>setTimeout(r,30));
@@ -47,7 +50,14 @@ app.whenReady().then(async () => {
       const sessionBadge=[...document.querySelectorAll('[data-harness-mix-selected-mentions] [data-harness-mix-mention-badge]')].some(b=>b.title.startsWith('移除历史会话'));
       editor.value='请分别实现并审查这个任务。'; editor.setSelectionRange(editor.value.length,editor.value.length); editor.dispatchEvent(new Event('input',{bubbles:true}));
       globalThis.mentionSmokeEditor = editor;
-      return {atTriggerStayedNative,filtered,text,richText,badge,badgeLabel:badgeButton?.getAttribute('aria-label'),inline,selectedAgentCount,icons,disabled,sessionBadge};
+      const teamPanel = document.querySelector('.harness-mix-team-panel');
+      const compact = {name:teamPanel?.querySelector('.harness-mix-team-name')?.textContent,panels:document.querySelectorAll('.harness-mix-team-panel').length,button:teamPanel?.querySelector('.harness-mix-team-open')?.textContent,icons:teamPanel?.querySelectorAll('img').length,topMounted:teamPanel?.nextElementSibling?.id === 'thread-content-anchor'};
+      teamPanel.querySelector('.harness-mix-team-open').click(); await new Promise(r=>setTimeout(r,30));
+      const workbench=document.querySelector('.harness-mix-team-workbench');
+      const builder=workbench.querySelector('[data-agent="pi"]'); builder.click(); await new Promise(r=>setTimeout(r,0));
+      const teamResult = {compact,name:workbench?.querySelector('.harness-mix-team-name')?.textContent,workbenches:document.querySelectorAll('.harness-mix-team-workbench').length,position:getComputedStyle(workbench).position,bodyOverflow:document.body.style.overflow,icons:workbench?.querySelectorAll('img').length,roles:[...workbench?.querySelectorAll('[data-agent]') ?? []].map(node=>node.getAttribute('data-agent')),lanes:workbench?.querySelectorAll('.harness-mix-team-lanes > div').length,hasTask:workbench?.textContent.includes('实现 Team Runtime'),hasRole:workbench?.textContent.includes('后端架构与 Host Runtime')&&workbench?.textContent.includes('独立代码审查与质量验收'),hasLeader:workbench?.textContent.includes('主导者'),hasMessage:workbench?.textContent.includes('Runtime 已就绪'),timeline:workbench?.querySelector('.harness-mix-team-timeline input')?.max,opened:globalThis.openedTeamThread};
+      globalThis.teamSmoke = teamApi;
+      return {atTriggerStayedNative,filtered,text,richText,badge,badgeLabel:badgeButton?.getAttribute('aria-label'),inline,selectedAgentCount,icons,disabled,sessionBadge,teamResult};
     })()`);
     assert.equal(result.atTriggerStayedNative, true);
     assert.equal(result.filtered, 1);
@@ -58,13 +68,40 @@ app.whenReady().then(async () => {
     assert.equal(result.inline, true);
     assert.equal(result.selectedAgentCount, 2);
     assert.equal(result.sessionBadge, true);
+    assert.equal(result.teamResult.name, 'Release Team');
+    assert.equal(result.teamResult.compact.panels, 1);
+    assert.equal(result.teamResult.compact.button, '展开详情');
+    assert.equal(result.teamResult.compact.topMounted, true, 'Agent Team launcher mounts before the native conversation content');
+    assert.equal(result.teamResult.workbenches, 0, 'Opening a member native session closes the workbench');
+    assert.notEqual(result.teamResult.position, 'fixed', 'Team details stay embedded in the Codex conversation layout');
+    assert.equal(result.teamResult.bodyOverflow, '', 'Opening Team details must not lock or cover the native Codex UI');
+    assert.equal(result.teamResult.opened, 'builder-thread');
+    assert.ok(result.teamResult.icons >= 5, 'Lead/member/task/message routes use real Harness icons');
+    assert.deepEqual(result.teamResult.roles, ['codex', 'pi', 'claude', 'codex', 'dsh', 'opencode', 'antigravity']);
+    assert.equal(result.teamResult.lanes, 6);
+    assert.equal(result.teamResult.hasTask, true);
+    assert.equal(result.teamResult.hasRole, true);
+    assert.equal(result.teamResult.hasLeader, true);
+    assert.equal(result.teamResult.hasMessage, true);
+    assert.equal(result.teamResult.timeline, '1');
     const out = path.resolve('output/collaboration-ui'); await fs.mkdir(out, { recursive: true });
+    await win.webContents.executeJavaScript('window.scrollTo(0,0)');
+    await fs.writeFile(path.join(out, 'team-inline-compact.png'), (await win.webContents.capturePage()).toPNG());
+    const compactBounds = await win.webContents.executeJavaScript(`(() => { const r=document.querySelector('.harness-mix-team-panel').getBoundingClientRect(); return {x:Math.max(0,Math.floor(r.x)-8),y:Math.max(0,Math.floor(r.y)-8),width:Math.ceil(r.width)+16,height:Math.ceil(r.height)+16}; })()`);
+    await fs.writeFile(path.join(out, 'team-inline-compact-focus.png'), (await win.webContents.capturePage(compactBounds)).toPNG());
+    await win.webContents.executeJavaScript(`document.querySelector('.harness-mix-team-open').click()`);
     await new Promise(r => setTimeout(r,100));
-    await fs.writeFile(path.join(out, 'mentions.png'), (await win.webContents.capturePage()).toPNG());
-    const submittedText = await win.webContents.executeJavaScript(`(() => { const root=mentionSmokeEditor.closest('[data-codex-composer-root]'); root.dispatchEvent(new Event('submit',{bubbles:true})); return mentionSmokeEditor.value; })()`);
+    const expanded = (await win.webContents.capturePage()).toPNG();
+    await fs.writeFile(path.join(out, 'team-inline-expanded.png'), expanded);
+    await fs.writeFile(path.join(out, 'mentions.png'), expanded);
+    const expandedBounds = await win.webContents.executeJavaScript(`(() => { const a=document.querySelector('.harness-mix-team-panel').getBoundingClientRect(), b=document.querySelector('.harness-mix-team-workbench').getBoundingClientRect(), left=Math.min(a.left,b.left), top=Math.min(a.top,b.top), right=Math.max(a.right,b.right), bottom=Math.max(a.bottom,b.bottom); return {x:Math.max(0,Math.floor(left)-8),y:Math.max(0,Math.floor(top)-8),width:Math.ceil(right-left)+16,height:Math.ceil(bottom-top)+16}; })()`);
+    await win.webContents.executeJavaScript(`document.querySelector('[data-composer-draft-id="textarea-smoke"]').style.visibility='hidden'`);
+    await fs.writeFile(path.join(out, 'team-inline-expanded-focus.png'), (await win.webContents.capturePage(expandedBounds)).toPNG());
+    await win.webContents.executeJavaScript(`document.querySelector('[data-composer-draft-id="textarea-smoke"]').style.visibility=''`);
+    const submittedText = await win.webContents.executeJavaScript(`(() => { const root=mentionSmokeEditor.closest('[data-codex-composer-root]'); mentionSmoke.prepareSubmission(root); return mentionSmokeEditor.value; })()`);
     assert.match(submittedText, /#claude/);
     assert.match(submittedText, /#pi/);
-    await win.webContents.executeJavaScript('mentionSmoke.dispose()');
+    await win.webContents.executeJavaScript('mentionSmoke.dispose(); teamSmoke.dispose()');
     assert.equal(await win.webContents.executeJavaScript('document.querySelectorAll("[data-harness-mix-mentions]").length'), 0);
     console.log('PASS: Electron native composer # Harness/session icons, badges, keyboard selection, textarea/rich text and cleanup');
   } finally { win.destroy(); app.quit(); }

package/scripts/concurrency-layers-test.cjs

@@ -124,6 +124,11 @@ const until = async (predicate, timeoutMs = 4000) => {
   // Test 2: 第三层 —— 基于 Git Worktree 的物理隔离 (Worktree Isolation)
   // -------------------------------------------------------------
   console.log('--- Testing Layer 3: Git Worktree Physical Isolation ---');
+  await assert.rejects(
+    rt.createThread({ harnessId: 'mock-worker', cwd: sharedDir, worktree: true }),
+    /无法建立隔离工作区|not a git repository/i,
+    'An explicit Worktree request must never silently fall back to the shared directory'
+  );
   const gitRepo = path.join(tmpDir, 'git-project');
   await fs.mkdir(gitRepo);
   await git(gitRepo, ['init']);

package/scripts/diagnostics.cjs

@@ -29,7 +29,7 @@ const tail = (file, lines = 200) => {
 const write = (name, content) => fs.writeFileSync(path.join(stage, name), String(content));
 
 const env = nativeEnvironment();
-const data = env.CODEXHOST_DATA_DIR;
+const data = env.HARNESSMIX_DATA_DIR;
 write('versions.json', JSON.stringify({
   'harness-mix': pkg.version,
   node: process.version,

package/scripts/e2e-native-host.cjs

@@ -12,12 +12,12 @@ async function main() {
   assert.ok(stock && fs.existsSync(stock), 'Official Codex executable must exist');
   const directory = path.resolve('output/native-host', `run-${Date.now()}`);
   fs.mkdirSync(directory, { recursive: true });
-  const env = nativeEnvironment({ ...process.env, CODEXHOST_DATA_DIR: path.join(directory, 'data') });
+  const env = nativeEnvironment({ ...process.env, HARNESSMIX_DATA_DIR: path.join(directory, 'data') });
   Object.assign(env, {
-    CODEXHOST_STOCK_CODEX_PATH: stock,
-    CODEXHOST_HOST_NODE_PATH: process.execPath,
-    CODEXHOST_HOST_RUNTIME_PATH: paths.wrapper,
-    CODEXHOST_DEFAULT_AGENT: 'codex',
+    HARNESSMIX_STOCK_CODEX_PATH: stock,
+    HARNESSMIX_HOST_NODE_PATH: process.execPath,
+    HARNESSMIX_HOST_RUNTIME_PATH: paths.wrapper,
+    HARNESSMIX_DEFAULT_AGENT: 'codex',
   });
   const events = [];
   const diagnostics = [];
@@ -44,11 +44,11 @@ async function main() {
     assert.deepEqual(ownership.codex, { mode: 'official-passthrough', managedRoute: 'codex-harness' });
     report.checks.push('Harness Mix HostRuntime and ProtocolCore own external execution');
     report.checks.push('official Codex route is separate from the managed Codex worker');
-    const plugins = await request('codexhost/harness/plugins/list', {});
+    const plugins = await request('harnessmix/harness/plugins/list', {});
     assert.ok(plugins.plugins.some(plugin => (plugin.id || plugin.manifest?.id) === 'pi'), 'Pi plugin registered');
     report.checks.push('external harness plugins registered');
     for (const harnessId of ['pi', 'claude-code', 'deepseek-harness']) {
-      const inspection = await request('codexhost/harness/inspect', { harnessId, cwd: directory });
+      const inspection = await request('harnessmix/harness/inspect', { harnessId, cwd: directory });
       report[harnessId] = inspection;
       console.log(`${harnessId}: ${inspection.status}; models=${inspection.catalog?.models?.length || 0}${inspection.error ? `; ${inspection.error.message}` : ''}`);
       assert.equal(inspection.status, 'ready', `${harnessId} must be ready`);
@@ -56,12 +56,12 @@ async function main() {
     const officialModels = await request('model/list', {});
     assert.ok(Array.isArray(officialModels.data), 'Official model/list passes through');
     report.checks.push('official model/list passthrough');
-    const codexAccounts = await request('codexhost/account/refresh', {});
+    const codexAccounts = await request('harnessmix/account/refresh', {});
     const officialAccount = codexAccounts.accounts?.find(account => account.management === 'native');
     assert.ok(officialAccount, 'Official Codex account is projected into Account management');
     assert.equal(officialAccount.authenticated, true, 'Current official Codex login is detected');
     assert.ok(officialAccount.email, 'Current ChatGPT account identity is available from account/read');
-    const officialAccountUsage = await request('codexhost/account/usage/inspect', { accountId: officialAccount.accountId });
+    const officialAccountUsage = await request('harnessmix/account/usage/inspect', { accountId: officialAccount.accountId });
     assert.ok(officialAccountUsage.accountCredits, 'Official Codex rate limits are projected');
     report.account = {
       authenticated: officialAccount.authenticated,
@@ -94,7 +94,7 @@ async function main() {
       report.checks.push('real official Codex thread/turn passthrough');
     }
     // Real Host + stock-server section catalog, with test threads isolated in output/.
-    const sidebarThread = await request('thread/start', { cwd: directory, model: 'codexhost/pi-native' });
+    const sidebarThread = await request('thread/start', { cwd: directory, model: 'harnessmix/pi-native' });
     const sidebarId = sidebarThread.thread.id;
     assert.equal(sidebarThread.thread.sessionId, sidebarId);
     const descendants = await request('thread/list', { ancestorThreadId: sidebarId, sourceKinds: ['subAgentThreadSpawn'] });
@@ -109,14 +109,14 @@ async function main() {
     await request('thread/section/move', { threadId: sidebarId, sectionId: null });
     assert.equal((await inSection()).length, 0, 'Unpin stays removed on the next list query');
     const resumed = await request('thread/resume', { threadId: sidebarId });
-    assert.equal(resumed.model, 'codexhost/pi-native');
-    const inspected = await request('codexhost/thread/inspect', { threadId: sidebarId });
+    assert.equal(resumed.model, 'harnessmix/pi-native');
+    const inspected = await request('harnessmix/thread/inspect', { threadId: sidebarId });
     assert.equal(inspected.harnessId, 'pi');
     assert.equal(inspected.transportModelId, resumed.model);
     report.checks.push('external identity, no self-descendants, pin/unpin and resume ownership');
     if (process.argv.includes('--live')) {
       const harnessId = process.argv.find(arg => arg.startsWith('--harness='))?.split('=')[1] || 'pi';
-      const started = await request('thread/start', { cwd: directory, model: `codexhost/${harnessId}-native` });
+      const started = await request('thread/start', { cwd: directory, model: `harnessmix/${harnessId}-native` });
       assert.ok(started.thread?.id, 'Native external thread created');
       const threadId = started.thread.id;
       const turn = await request('turn/start', {

package/scripts/error-kind-test.cjs

@@ -90,15 +90,15 @@ function main() {
   const noInfo = protocol.turn({ id: 'turn_10', status: 'error', error: 'boom' });
   assert.equal(noInfo.error.codexErrorInfo, null);
   return (async () => {
-    const state = await protocol.request('codexhost/harness/turn-error', { threadId: 'thread_3' });
+    const state = await protocol.request('harnessmix/harness/turn-error', { threadId: 'thread_3' });
     assert.equal(state.errorKind, 'auth');
     assert.equal(state.error, 'Invalid API key');
     assert.deepEqual(state.actions, ['login', 'newSession']); // claude-code 有 loginCommand
     fakeRuntime.threads[0].errorKind = null;
-    const cleared = await protocol.request('codexhost/harness/turn-error', { threadId: 'thread_3' });
+    const cleared = await protocol.request('harnessmix/harness/turn-error', { threadId: 'thread_3' });
     assert.equal(cleared.errorKind, null);
     assert.deepEqual(cleared.actions, []);
-    await assert.rejects(protocol.request('codexhost/harness/turn-error', { threadId: 'nope' }), /Unknown thread/);
+    await assert.rejects(protocol.request('harnessmix/harness/turn-error', { threadId: 'nope' }), /Unknown thread/);
     protocol.close?.();
     console.log('PASS: error classification (explicit/codexErrorInfo/status/pattern/unknown), actions, normalizer/core/thread projection, turn-error query');
   })();