harness-mix 0.1.0

package/scripts/check.cjs

@@ -0,0 +1,23 @@
+// 递归对 src/ 与 scripts/ 下所有 JS 做语法检查
+const { execFileSync } = require('node:child_process');
+const { readdirSync, statSync } = require('node:fs');
+const { join } = require('node:path');
+
+function* walk(dir) {
+  for (const entry of readdirSync(dir)) {
+    if (entry === 'node_modules') continue;
+    const full = join(dir, entry);
+    if (statSync(full).isDirectory()) yield* walk(full);
+    else if (/\.(js|cjs)$/.test(entry)) yield full;
+  }
+}
+
+let count = 0;
+for (const root of ['src', 'scripts']) {
+  for (const file of walk(root)) {
+    execFileSync(process.execPath, ['--check', file], { stdio: 'pipe' });
+    count++;
+    console.log('ok', file);
+  }
+}
+console.log(`${count} files passed syntax check`);

package/scripts/codex-adapter-test.cjs

@@ -0,0 +1,83 @@
+const assert = require('node:assert/strict');
+const { projectNotification, queueRequest, usageView, modelView } = require('../src/main/adapters/codex');
+
+function fakeSession() {
+  return {
+    nativeSessionId: 'thread-native',
+    pendingApprovals: new Map(),
+    state: {
+      turn: null, compaction: null, nativeTurnId: null, usage: undefined,
+      itemText: new Map(), reasoningItems: new Set(), toolOutput: new Map(),
+    },
+  };
+}
+
+(async () => {
+  const session = fakeSession();
+  const events = [];
+  const emit = event => events.push(event);
+  projectNotification({ method: 'turn/started', params: { threadId: 'thread-native', turn: { id: 'turn-1' } } }, session, emit);
+  projectNotification({ method: 'item/agentMessage/delta', params: { threadId: 'thread-native', turnId: 'turn-1', itemId: 'answer-1', delta: '你好' } }, session, emit);
+  projectNotification({ method: 'item/reasoning/summaryTextDelta', params: { threadId: 'thread-native', turnId: 'turn-1', itemId: 'reason-1', delta: '分析' } }, session, emit);
+  projectNotification({ method: 'item/started', params: { threadId: 'thread-native', turnId: 'turn-1', item: { type: 'commandExecution', id: 'tool-1', command: 'git status', status: 'inProgress' } } }, session, emit);
+  projectNotification({ method: 'item/commandExecution/outputDelta', params: { threadId: 'thread-native', turnId: 'turn-1', itemId: 'tool-1', delta: 'clean' } }, session, emit);
+  projectNotification({ method: 'item/completed', params: { threadId: 'thread-native', turnId: 'turn-1', item: { type: 'commandExecution', id: 'tool-1', command: 'git status', status: 'completed', aggregatedOutput: 'clean' } } }, session, emit);
+  projectNotification({ method: 'thread/tokenUsage/updated', params: { threadId: 'thread-native', turnId: 'turn-1', tokenUsage: { last: { totalTokens: 250 }, total: { inputTokens: 200, outputTokens: 50, cachedInputTokens: 25 }, modelContextWindow: 1000 } } }, session, emit);
+  projectNotification({ method: 'turn/completed', params: { threadId: 'thread-native', turn: { id: 'turn-1', status: 'completed' } } }, session, emit);
+
+  assert.ok(events.some(event => event.kind === 'text-delta' && event.text === '你好'));
+  assert.ok(events.some(event => event.kind === 'thinking-delta' && event.text === '分析'));
+  assert.ok(events.some(event => event.kind === 'tool' && event.toolCallId === 'tool-1' && event.state === 'done' && event.title === 'exec_command' && event.input === 'git status'));
+  assert.ok(events.some(event => event.kind === 'usage' && event.usage.contextPercent === 25));
+  assert.ok(events.some(event => event.kind === 'completed' && event.nativeRef.checkpointId === 'turn-1'));
+
+  const questionSession = fakeSession();
+  const questions = [];
+  const answer = queueRequest({ id: 7, method: 'item/tool/requestUserInput', params: {
+    threadId: 'thread-native', turnId: 'turn-1', itemId: 'question-1', isBlocking: true,
+    questions: [
+      { id: 'framework', header: '框架', question: '选择框架', options: [{ label: 'React' }, { label: 'Vue' }] },
+      { id: 'name', header: '名称', question: '输入名称', options: null },
+    ],
+  } }, questionSession, event => questions.push(event));
+  assert.equal(questions.length, 2);
+  const adapter = require('../src/main/adapters/codex').create();
+  await adapter.respond(questionSession, 'codex-7-framework', { optionId: 'React' });
+  await adapter.respond(questionSession, 'codex-7-name', { value: 'Harness Mix' });
+  assert.deepEqual(await answer, { answers: { framework: { answers: ['React'] }, name: { answers: ['Harness Mix'] } } });
+
+  const approvalSession = fakeSession();
+  const approval = queueRequest({ id: 8, method: 'item/commandExecution/requestApproval', params: {
+    threadId: 'thread-native', turnId: 'turn-1', itemId: 'tool-2', command: 'npm test', availableDecisions: ['accept', 'decline'],
+  } }, approvalSession, () => {});
+  await adapter.respond(approvalSession, 'codex-8', { optionId: 'accept' });
+  assert.deepEqual(await approval, { decision: 'accept' });
+  const mcpSession = fakeSession();
+  const mcpEvents = [];
+  const mcpApproval = queueRequest({ id: 9, method: 'mcpServer/elicitation/request', params: {
+    threadId: 'thread-native', serverName: 'harness-mix', mode: 'form', message: 'Allow tool?',
+    requestedSchema: { type: 'object', properties: {}, additionalProperties: false },
+  } }, mcpSession, event => mcpEvents.push(event));
+  assert.equal(mcpEvents[0].kind, 'approval');
+  assert.equal(mcpSession.pendingApprovals.size, 1, 'MCP requests await a native user response');
+  await adapter.respond(mcpSession, 'codex-9', { optionId: 'decline' });
+  assert.deepEqual(await mcpApproval, { action: 'decline', content: null });
+
+  const compactSession = fakeSession();
+  const compactEvents = [];
+  compactSession.host = { async request(method) {
+    assert.equal(method, 'thread/compact/start');
+    projectNotification({ method: 'turn/started', params: { threadId: 'thread-native', turn: { id: 'compact-turn' } } }, compactSession, event => compactEvents.push(event));
+    projectNotification({ method: 'item/completed', params: { threadId: 'thread-native', turnId: 'compact-turn', item: { type: 'contextCompaction', id: 'compact-item' } } }, compactSession, event => compactEvents.push(event));
+    projectNotification({ method: 'turn/completed', params: { threadId: 'thread-native', turn: { id: 'compact-turn', status: 'completed' } } }, compactSession, event => compactEvents.push(event));
+    return {};
+  } };
+  await adapter.executeCommand(compactSession, 'compact', { emit: event => compactEvents.push(event) });
+  const compactDone = compactEvents.find(event => event.kind === 'completed');
+  assert.equal(compactDone.nativeRef.checkpointId, 'compact-turn');
+  assert.ok(compactEvents.some(event => event.kind === 'text-delta' && /Codex 压缩/.test(event.text)));
+
+  assert.equal(usageView({ last: { totalTokens: 50 }, total: {}, modelContextWindow: 200 }).contextPercent, 25);
+  assert.deepEqual(modelView({ model: 'gpt-x', displayName: 'GPT X', supportedReasoningEfforts: [], isDefault: true }).id, 'gpt-x');
+  console.log('codex adapter: native notifications, usage, multi-question and approvals passed');
+})().catch(error => { console.error(error); process.exitCode = 1; });

package/scripts/collaboration-recovery-test.cjs

@@ -0,0 +1,91 @@
+const assert = require('node:assert/strict');
+const fs = require('node:fs/promises');
+const path = require('node:path');
+const { randomUUID } = require('node:crypto');
+const { createWorkspace, reviewWorkspace, applyWorkspace, git } = require('../src/main/host/collaboration-worktree');
+const { Collaboration } = require('../src/main/host/collaboration');
+const { HostRuntime } = require('../src/main/host/runtime');
+const { SessionHistory } = require('../src/main/host/session-history');
+const { NativeProtocol } = require('../src/main/native/protocol');
+
+async function main() {
+  const root = await fs.mkdtemp(path.resolve('output/collab-recovery-'));
+  const repo = path.join(root, 'repo'); await fs.mkdir(repo);
+  await git(repo, ['init']); await git(repo, ['config', 'core.autocrlf', 'false']); await fs.writeFile(path.join(repo, 'file.txt'), 'initial\n');
+  await git(repo, ['add', '.']); await git(repo, ['-c', 'user.name=Test', '-c', 'user.email=test@example.invalid', 'commit', '-m', 'initial']);
+  await fs.writeFile(path.join(repo, 'file.txt'), 'staged\n'); await git(repo, ['add', 'file.txt']);
+  await fs.writeFile(path.join(repo, 'file.txt'), 'unstaged\n'); await fs.writeFile(path.join(repo, 'untracked.txt'), 'keep\n');
+  const staged = await git(repo, ['diff', '--cached', '--binary']);
+  const workspace = await createWorkspace(repo, randomUUID());
+  assert.equal(workspace.mode, 'worktree');
+  assert.equal(await fs.readFile(path.join(workspace.cwd, 'file.txt'), 'utf8'), 'unstaged\n');
+  assert.equal(await fs.readFile(path.join(workspace.cwd, 'untracked.txt'), 'utf8'), 'keep\n');
+  assert.equal(await git(repo, ['diff', '--cached', '--binary']), staged, 'Source index preserved');
+  assert.equal((await reviewWorkspace(workspace)).patch, '', 'Seed changes are not worker changes');
+  await fs.writeFile(path.join(workspace.cwd, 'file.txt'), 'worker\n');
+  await fs.writeFile(path.join(workspace.cwd, 'new.txt'), 'worker new\n');
+  const review = await reviewWorkspace(workspace);
+  assert.match(review.patch, /worker/);
+  assert.doesNotMatch(review.patch, /untracked.txt/);
+  await assert.rejects(applyWorkspace(workspace, 'stale'), /重新审查/);
+  await fs.writeFile(path.join(repo, 'file.txt'), 'conflicting edit\n');
+  await assert.rejects(applyWorkspace(workspace, review.digest));
+  assert.equal(await fs.readFile(path.join(repo, 'file.txt'), 'utf8'), 'conflicting edit\n');
+  assert.equal(await fs.stat(path.join(repo, 'new.txt')).catch(() => null), null, 'Conflict applies no partial patch');
+  await fs.writeFile(path.join(repo, 'file.txt'), 'unstaged\n');
+  await applyWorkspace(workspace, review.digest);
+  assert.equal(await fs.readFile(path.join(repo, 'file.txt'), 'utf8'), 'worker\n');
+  assert.equal(await git(repo, ['diff', '--cached', '--binary']), staged);
+
+  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('finished', { id: 'finished', owner: 'parent', agent: 'pi', childId: 'done', status: 'completed', result: 'kept' });
+  await rt.collaboration.save();
+  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.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 };
+  let received, active = false;
+  const fake = { store: rt.store, threads: [parent, child], adapters: new Map([['pi', { manifest: { name: 'Pi' } }]]),
+    execution: { isRunning: id => id === 'parent' || active, lastTurn: () => ({ id: 'turn', status: 'completed' }) },
+    core: { getItemsForTurn: () => [{ type: 'agent_message', phase: 'final', content: 'resumed' }] },
+    emitCollaboration() {}, async send(id, task) { assert.equal(id, 'child'); received = task; },
+    async createThread() { throw new Error('Duplicate child created'); }, async cancel() {} };
+  restarted.runtime = fake;
+  await restarted.call('parent', 'resume_delegation', { task_id: 'saved' });
+  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');
+  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();
+  const calls = [];
+  rt.adapters.set('pi', { manifest: { id: 'pi', name: 'Pi', capabilities: {} } }); rt.status.pi = { available: true };
+  rt.history = new SessionHistory(rt, {
+    async listNative() { calls.push('list'); return [{ nativeSessionId: 'native-id', title: 'Native history', cwd: repo, updatedAt: 10, running: null }]; },
+    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' });
+  assert.equal(rows.total, 1);
+  const params = { harnessId: 'all-harnesses', nativeSessionId: rows.candidates[0].nativeSessionId };
+  const context = await rt.history.context(params);
+  assert.equal(context.harnessId, 'pi'); assert.match(context.transcript, /User: old question[\s\S]*Assistant: old answer/);
+  assert.equal(rt.sessions.size, 0, 'Referencing history does not launch or import a model session');
+  const [one, two] = await Promise.all([rt.history.import(params), rt.history.import(params)]);
+  assert.equal(one.threadId, two.threadId); assert.equal(calls.filter(c => c === 'read').length, 2);
+  assert.equal(rt.sessions.size, 0, 'Browsing/importing history does not launch model sessions');
+  const imported = rt.threads.find(t => t.id === one.threadId);
+  assert.equal(imported.nativeSessionId, 'native-id'); assert.equal(imported.restore, true);
+  assert.match(JSON.stringify(rt.core.getItemsForTurn(rt.execution.lastTurn(imported.id).id)), /old answer/);
+  await assert.rejects(rt.history.import({ harnessId: 'pi', nativeSessionId: '../outside' }), /no longer exists/);
+  protocol.close(); await restarted.close(); await rt.close();
+  console.log('PASS: dirty worktree isolation, source index preservation, digest/conflict-safe apply, durable recovery identity, unified history search/import/dedup and lazy native resume');
+}
+main().catch(error => { console.error(error); process.exitCode = 1; });

package/scripts/collaboration-test.cjs

@@ -0,0 +1,102 @@
+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 { 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'); };
+
+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;
+  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 }; },
+    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() {} };
+  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 });
+  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` mail@lead.com @worker/foo', rt), ['worker']);
+    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.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.ok(catalog.tools.some(tool => tool.name === 'review_delegation_changes'));
+    assert.ok(catalog.tools.some(tool => tool.name === 'apply_delegation_changes'));
+    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);
+    const second = await call('delegate_to_agent', { agent_type: 'worker', task: 'two', isolation: 'shared' });
+    await wait(() => pending.size === 2);
+    assert.equal(maximum, 2, 'Workers execute concurrently');
+    const jobs = [...rt.collaboration.jobs.values()];
+    for (const job of jobs) {
+      const child = rt.threads.find(t => t.id === job.childId);
+      assert.equal(child.parentThreadId, parent.id);
+      assert.equal(child.cwd, root, 'Default worker shares the lead workspace');
+      const assistant = child.messages.find(m => m.role === 'assistant');
+      assert.equal(assistant.reviewId, undefined);
+      assert.equal(assistant.reviewOwnerThreadId, parent.id);
+    }
+    const waitingChild = rt.threads.find(t => t.id === jobs[0].childId);
+    waitingChild && pending.get(waitingChild.id).s.emit({ kind: 'approval', requestId: 'native-approval', method: 'confirm', title: 'Allow test?' });
+    assert.equal(rt.collaboration.view(jobs[0]).display_status, 'waiting_approval');
+    await wait(() => String(rt.core.getItemsForTurn(rt.execution.lastTurn(parent.id).id).find(item => item.type === 'tool_call')?.output).includes('waiting_approval'));
+    pending.get(jobs[0].childId).s.emit({ kind: 'interaction-responded', requestId: 'native-approval' });
+    finish(jobs[0].childId, 'first-result');
+    await wait(() => jobs[0].status === 'completed');
+    const before = Date.now();
+    const partial = await call('get_delegation_status', { task_ids: [first.task_id, second.task_id], wait_ms: 3000 });
+    assert.equal(partial[1].status, 'running');
+    assert.ok(Date.now() - before < 1000, 'Fan-out collection returns when any result is ready');
+    finish(jobs[1].childId, 'second-result');
+    await wait(() => jobs[1].status === 'completed');
+    const results = await call('get_delegation_status', { task_ids: [first.task_id, second.task_id], wait_ms: 3000 });
+    assert.deepEqual(results.map(r => r.status), ['completed', 'completed']);
+    assert.deepEqual(results.map(r => r.result), ['first-result', 'second-result']);
+    const cards = rt.core.getItemsForTurn(rt.execution.lastTurn(parent.id).id).filter(item => item.collaboration);
+    const { projectItem } = require('../src/main/native/protocol');
+    assert.equal(projectItem(cards[0]).type, 'collabAgentToolCall');
+    assert.deepEqual(projectItem(cards[0]).receiverThreadIds, [jobs[0].childId]);
+    assert.equal(projectItem(cards[0]).agentsStates[jobs[0].childId].message, 'first-result');
+    assert.ok(rt.execution.isRunning(parent.id), 'Tool results do not end the native lead turn');
+    await call('message_agent', { task_id: first.task_id, task: 'follow-up' });
+    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');
+    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 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 assert.rejects(rt.send(outsider.id, 'unrelated'), /同一项目/);
+    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/);
+    await rt.cancel(parent.id);
+    await wait(() => !pending.size);
+    assert.equal(rt.execution.lastTurn(parent.id).status, 'cancelled');
+    await assert.rejects(call('list_agents', {}), /no longer active/);
+    console.log('PASS: real MCP stdio → authenticated Host → parallel native-session adapters → results/follow-up/cancellation, ownership and shared review');
+  } finally { transport.stop(); await rt.close(); }
+}
+main().catch(error => { console.error(error); process.exitCode = 1; });

package/scripts/collaboration-ui-smoke.cjs

@@ -0,0 +1,52 @@
+const { app, BrowserWindow } = require('electron');
+const assert = require('node:assert/strict');
+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 } });
+  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 style="position:absolute;bottom:50px;width:750px"><textarea style="width:100%;height:90px;font:16px system-ui" placeholder="输入 @ 选择协作 Harness"></textarea><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 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 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));
+      const filtered = document.querySelectorAll('[data-harness-mix-mentions] [role="option"]').length;
+      editor.dispatchEvent(new KeyboardEvent('keydown',{key:'Enter',bubbles:true,cancelable:true}));
+      const text = editor.value;
+      const badge = document.querySelector('[data-harness-mix-selected-mentions] img')?.dataset.harnessMixIcon;
+      const rich = document.querySelector('[contenteditable]'); rich.focus();
+      const selection = getSelection(), range = document.createRange(); range.selectNodeContents(rich); range.collapse(false); selection.removeAllRanges(); selection.addRange(range);
+      document.execCommand('insertText',false,' @pi');
+      await new Promise(r=>setTimeout(r,30));
+      rich.textContent = rich.textContent; // Native editor redraw replaces the original Range nodes.
+      document.querySelector('[data-harness-mix-mentions] [role="option"]').click();
+      const richText = rich.textContent;
+      editor.focus(); editor.value='@'; editor.setSelectionRange(1,1); editor.dispatchEvent(new Event('input',{bubbles:true}));
+      await new Promise(r=>setTimeout(r,30));
+      globalThis.mentionSmoke = api;
+      const tabs = document.querySelectorAll('[data-harness-mix-mentions] [role=tab]').length;
+      if (tabs !== 2) throw new Error('Missing Agents/session tabs');
+      const icons = document.querySelectorAll('[data-harness-mix-mentions] img').length;
+      const disabled = document.querySelectorAll('[data-harness-mix-mentions] [role="option"]:disabled').length;
+      editor.value='@旧';editor.setSelectionRange(2,2);editor.dispatchEvent(new Event('input',{bubbles:true}));await new Promise(r=>setTimeout(r,30));
+      document.querySelector('[data-harness-mix-mentions] [role="option"]').click();
+      const sessionBadge=[...document.querySelectorAll('[data-harness-mix-selected-mentions] span')].some(b=>b.title.startsWith('历史会话'));
+      return {filtered,text,richText,badge,icons,disabled,sessionText:editor.value,sessionBadge};
+    })()`);
+    assert.equal(result.filtered, 1); assert.equal(result.text, '你负责后端， @claude ');
+    assert.match(result.richText, /^你负责后端， @pi\s$/); assert.equal(result.disabled, 1);
+    assert.equal(result.badge, 'harnesses/claude'); assert.equal(result.icons, 3); assert.equal(result.disabled, 1);
+    assert.match(result.sessionText, /harness-mix:\/\/session\/c2Vzc2lvbg/); assert.equal(result.sessionBadge, true);
+    const out = path.resolve('output/collaboration-ui'); await fs.mkdir(out, { recursive: true });
+    await new Promise(r => setTimeout(r,100));
+    await fs.writeFile(path.join(out, 'mentions.png'), (await win.webContents.capturePage()).toPNG());
+    await win.webContents.executeJavaScript('mentionSmoke.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(); }
+}).catch(error => { console.error(error); app.exit(1); });

package/scripts/concurrency-layers-test.cjs

@@ -0,0 +1,179 @@
+const assert = require('node:assert/strict');
+const fs = require('node:fs/promises');
+const os = require('node:os');
+const path = require('node:path');
+const { HostRuntime } = require('../src/main/host/runtime');
+const { git } = require('../src/main/host/collaboration-worktree');
+
+const until = async (predicate, timeoutMs = 4000) => {
+  const start = Date.now();
+  while (!predicate()) {
+    if (Date.now() - start > timeoutMs) throw new Error('Timed out waiting for condition');
+    await new Promise(r => setTimeout(r, 20));
+  }
+};
+
+(async () => {
+  const tmpDir = await fs.mkdtemp(path.join(os.tmpdir(), 'hm-layers-test-'));
+  const rt = new HostRuntime({ dataDirectory: path.join(tmpDir, 'data') });
+  await rt.store.load();
+
+  // -------------------------------------------------------------
+  // Test 1: 第二层 —— 原生 Codex 协议直通 (Native Patch Passthrough)
+  // -------------------------------------------------------------
+  console.log('--- Testing Layer 2: Native Codex Protocol Passthrough ---');
+  const sharedDir = path.join(tmpDir, 'shared-repo');
+  await fs.mkdir(sharedDir);
+
+  const codexEmits = new Map();
+  const workerEmits = new Map();
+
+  const codexAdapter = {
+    manifest: {
+      id: 'mock-codex',
+      name: 'Mock Codex',
+      capabilities: { nativeDiff: true, nativePatch: true },
+    },
+    async open({ thread, emit }) {
+      codexEmits.set(thread.id, emit);
+      return {};
+    },
+    async send() {},
+    async close() {},
+  };
+
+  const workerAdapter = {
+    manifest: {
+      id: 'mock-worker',
+      name: 'Mock Worker',
+      capabilities: {},
+    },
+    async open({ thread, emit }) {
+      workerEmits.set(thread.id, emit);
+      return {};
+    },
+    async send() {},
+    async close() {},
+  };
+
+  rt.adapters.set('mock-codex', codexAdapter);
+  rt.status['mock-codex'] = { available: true };
+  rt.adapters.set('mock-worker', workerAdapter);
+  rt.status['mock-worker'] = { available: true };
+
+  const codexThread = await rt.createThread({ harnessId: 'mock-codex', cwd: sharedDir });
+  const workerThread = await rt.createThread({ harnessId: 'mock-worker', cwd: sharedDir });
+
+  // 1.1 并发执行：Worker 修改 worker.txt，Codex 修改 codex.txt
+  await rt.send(codexThread.id, 'codex edit turn');
+  await rt.send(workerThread.id, 'worker edit turn');
+
+  const codexMsg1 = codexThread.messages.at(-1);
+  const workerMsg1 = workerThread.messages.at(-1);
+
+  // Worker 在磁盘写入 worker.txt
+  await fs.writeFile(path.join(sharedDir, 'worker.txt'), 'from worker\n');
+  const workerEmit1 = workerEmits.get(workerThread.id);
+  workerEmit1({ kind: 'text-delta', text: 'worker done' });
+  workerEmit1({ kind: 'completed', finalAnswer: true });
+  await until(() => workerThread.status === 'ready' && !workerThread.reviewPending);
+
+  // Codex 原生通过 fileChange 汇报修改 codex.txt
+  await fs.writeFile(path.join(sharedDir, 'codex.txt'), 'from codex\n');
+  const codexEmit1 = codexEmits.get(codexThread.id);
+  codexEmit1({
+    kind: 'file-change',
+    source: 'native',
+    changes: [{
+      path: path.join(sharedDir, 'codex.txt'),
+      patch: '@@ -0,0 +1,1 @@\n+from codex',
+      complete: true,
+    }],
+  });
+  codexEmit1({ kind: 'text-delta', text: 'codex done' });
+  codexEmit1({ kind: 'completed', finalAnswer: true });
+  await until(() => codexThread.status === 'ready' && !codexThread.reviewPending);
+
+  // 核心断言：由于原生协议直通生效，Codex 的审查记录中 ONLY 包含 codex.txt，绝不混入并发的 worker.txt！
+  const codexReview1 = await rt.readReview(codexThread, codexMsg1);
+  assert.equal(codexReview1.files.length, 1, 'Codex review should only contain its own file');
+  assert.equal(codexReview1.files[0].path, 'codex.txt');
+  assert.equal(codexReview1.files.some(f => f.path === 'worker.txt'), false, 'Worker file must NOT leak into Codex review');
+
+  // 1.2 并发执行：Worker 修改其他文件，Codex 仅纯问答（0 原生变更）
+  await rt.send(codexThread.id, 'codex question turn');
+  await rt.send(workerThread.id, 'worker second turn');
+
+  const codexMsg2 = codexThread.messages.at(-1);
+  await fs.writeFile(path.join(sharedDir, 'worker2.txt'), 'another worker edit\n');
+  const workerEmit2 = workerEmits.get(workerThread.id);
+  workerEmit2({ kind: 'completed', finalAnswer: true });
+  await until(() => workerThread.status === 'ready' && !workerThread.reviewPending);
+
+  const codexEmit2 = codexEmits.get(codexThread.id);
+  codexEmit2({ kind: 'text-delta', text: 'just an answer, no files modified' });
+  codexEmit2({ kind: 'completed', finalAnswer: true });
+  await until(() => codexThread.status === 'ready' && !codexThread.reviewPending);
+
+  const codexReview2 = await rt.readReview(codexThread, codexMsg2);
+  assert.equal(codexReview2.files.length, 0, 'Pure question in Codex must have exactly 0 files despite concurrent edits');
+
+  console.log('Layer 2 (Native Codex Protocol Passthrough) passed successfully!');
+
+  // -------------------------------------------------------------
+  // Test 2: 第三层 —— 基于 Git Worktree 的物理隔离 (Worktree Isolation)
+  // -------------------------------------------------------------
+  console.log('--- Testing Layer 3: Git Worktree Physical Isolation ---');
+  const gitRepo = path.join(tmpDir, 'git-project');
+  await fs.mkdir(gitRepo);
+  await git(gitRepo, ['init']);
+  await git(gitRepo, ['config', 'core.autocrlf', 'false']);
+  await fs.writeFile(path.join(gitRepo, 'main-code.txt'), 'initial main code\n');
+  await git(gitRepo, ['add', '.']);
+  await git(gitRepo, ['-c', 'user.name=Test', '-c', 'user.email=test@example.com', 'commit', '-m', 'initial commit']);
+
+  // 新建启用 Worktree 隔离的任务
+  const wtThread = await rt.createThread({
+    harnessId: 'mock-worker',
+    cwd: gitRepo,
+    worktree: true,
+  });
+
+  assert.equal(wtThread.isolation, 'worktree', 'Thread should have worktree isolation');
+  assert.ok(wtThread.workspace, 'Thread should hold a workspace object');
+  assert.equal(wtThread.workspace.mode, 'worktree');
+  assert.notEqual(wtThread.cwd, gitRepo, 'Worktree cwd must be physically different from gitRepo');
+  assert.equal(wtThread.originalCwd, gitRepo);
+
+  // 在主仓库和隔离分支同时并发写入同名或不同文件
+  await fs.writeFile(path.join(gitRepo, 'main-code.txt'), 'main modified\n');
+  await fs.writeFile(path.join(wtThread.cwd, 'worktree-feature.txt'), 'new feature in branch\n');
+
+  // 物理隔离验证：主仓库绝对看不到工作树创建的文件
+  await assert.rejects(fs.access(path.join(gitRepo, 'worktree-feature.txt')), 'Main repo must not see isolated worktree files');
+
+  // 审查隔离工作区改动
+  const wtReview = await rt.reviewThreadWorkspace(wtThread.id);
+  assert.match(wtReview.patch, /worktree-feature\.txt/);
+
+  // 将隔离分支改动合入主项目
+  await rt.applyThreadWorkspace(wtThread.id, wtReview.digest);
+  assert.equal(
+    await fs.readFile(path.join(gitRepo, 'worktree-feature.txt'), 'utf8'),
+    'new feature in branch\n',
+    'Main repo should now have the applied file after applyThreadWorkspace'
+  );
+
+  // 删除线程时自动清理 Worktree 分支与临时目录
+  const wtRoot = wtThread.workspace.root;
+  await rt.removeThread(wtThread.id);
+  await assert.rejects(fs.access(wtRoot), 'Worktree directory should be cleaned up on removeThread');
+
+  console.log('Layer 3 (Git Worktree Physical Isolation) passed successfully!');
+
+  await rt.close();
+  console.log('ALL CONCURRENCY LAYERS TESTS PASSED!');
+})().catch(error => {
+  console.error(error);
+  process.exitCode = 1;
+});