@harness-mix/cli 0.1.3

package/scripts/cdp-eval.cjs

@@ -0,0 +1,40 @@
+// CDP driver: evaluate JS and/or send raw CDP commands against the live Codex Desktop.
+// usage: node scripts/cdp-eval.cjs <port> <expression>          -> Runtime.evaluate
+//        node scripts/cdp-eval.cjs <port> --cmd <method> <json> -> raw command
+const http = require('node:http');
+
+function getJson(url) {
+  return new Promise((resolve, reject) => {
+    http.get(url, res => {
+      let data = '';
+      res.on('data', c => (data += c));
+      res.on('end', () => { try { resolve(JSON.parse(data)); } catch (e) { reject(e); } });
+    }).on('error', reject);
+  });
+}
+
+async function main() {
+  const port = process.argv[2];
+  const targets = await getJson(`http://127.0.0.1:${port}/json/list`);
+  const page = targets.find(t => t.type === 'page' && t.url === 'app://-/index.html');
+  if (!page) throw new Error('main page not found');
+  const ws = new WebSocket(page.webSocketDebuggerUrl);
+  await new Promise((res, rej) => { ws.onopen = res; ws.onerror = rej; });
+  let id = 0;
+  const pending = new Map();
+  ws.onmessage = ev => {
+    const msg = JSON.parse(ev.data);
+    if (msg.id && pending.has(msg.id)) { pending.get(msg.id)(msg); pending.delete(msg.id); }
+  };
+  const send = (method, params) => new Promise(res => { const i = ++id; pending.set(i, res); ws.send(JSON.stringify({ id: i, method, params })); });
+  if (process.argv[3] === '--cmd') {
+    const result = await send(process.argv[4], JSON.parse(process.argv[5] || '{}'));
+    console.log(JSON.stringify(result.result ?? result.error ?? null));
+  } else {
+    const result = await send('Runtime.evaluate', { expression: process.argv[3], returnByValue: true, awaitPromise: true });
+    if (result.result?.exceptionDetails) console.error('EX:', JSON.stringify(result.result.exceptionDetails).slice(0, 400));
+    else console.log(JSON.stringify(result.result?.result?.value ?? result, null, 2));
+  }
+  ws.close();
+}
+main().catch(e => { console.error(e.message); process.exit(1); });

package/scripts/cdp-watch.cjs

@@ -0,0 +1,36 @@
+// Watch renderer console/log for N milliseconds.
+const http = require('node:http');
+function getJson(url) {
+  return new Promise((resolve, reject) => {
+    http.get(url, res => { let d = ''; res.on('data', c => (d += c)); res.on('end', () => { try { resolve(JSON.parse(d)); } catch (e) { reject(e); } }); }).on('error', reject);
+  });
+}
+async function main() {
+  const port = process.argv[2];
+  const seconds = Number(process.argv[3] || 60);
+  const filter = process.argv[4] ? new RegExp(process.argv[4], 'i') : null;
+  const targets = await getJson(`http://127.0.0.1:${port}/json/list`);
+  const page = targets.find(t => t.type === 'page' && t.url === 'app://-/index.html');
+  const ws = new WebSocket(page.webSocketDebuggerUrl);
+  await new Promise((res, rej) => { ws.onopen = res; ws.onerror = rej; });
+  let id = 0;
+  const send = (method, params) => { ws.send(JSON.stringify({ id: ++id, method, params })); };
+  send('Runtime.enable');
+  send('Log.enable');
+  ws.onmessage = ev => {
+    const msg = JSON.parse(ev.data);
+    let line = null;
+    if (msg.method === 'Runtime.consoleAPICalled') {
+      line = 'console.' + msg.params.type + ': ' + msg.params.args.map(a => a.value ?? a.description ?? JSON.stringify(a)).join(' ').slice(0, 500);
+    } else if (msg.method === 'Log.entryAdded') {
+      const e = msg.params.entry;
+      line = `log.${e.level}: ${(e.text || '').slice(0, 500)}`;
+    } else if (msg.method === 'Runtime.exceptionThrown') {
+      line = 'EXCEPTION: ' + JSON.stringify(msg.params.exceptionDetails).slice(0, 500);
+    }
+    if (line && (!filter || filter.test(line))) console.log(new Date().toLocaleTimeString(), line);
+  };
+  console.log('watching for', seconds, 's');
+  setTimeout(() => { ws.close(); process.exit(0); }, seconds * 1000);
+}
+main().catch(e => { console.error(e.message); process.exit(1); });

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/codebuddy-migration-test.cjs

@@ -0,0 +1,47 @@
+const assert = require('node:assert/strict');
+const fs = require('node:fs/promises');
+const path = require('node:path');
+const registry = require('../src/main/adapters');
+const codebuddy = require('../src/main/adapters/codebuddy');
+const savedBuilder = registry.buildAdapters;
+registry.buildAdapters = () => [{ manifest: codebuddy.manifest, inspect: async () => ({ available: true }) }];
+const { HostRuntime } = require('../src/main/host/runtime');
+registry.buildAdapters = savedBuilder;
+
+(async () => {
+  const directory = path.resolve('output', 'codebuddy-migration-' + Date.now());
+  await fs.mkdir(directory, { recursive: true });
+  const thread = { id: 'old-thread', harnessId: 'workbuddy', nativeSessionId: 'native-unchanged', cwd: directory, title: 'Keep my title',
+    messages: [], tools: [], status: 'ready', createdAt: 1,
+    harnessChain: [{ harnessId: 'workbuddy', nativeSessionId: 'previous-native', options: { model: { id: 'native-model' } } }],
+    pendingHandoff: { fromHarnessId: 'workbuddy' } };
+  await fs.writeFile(path.join(directory, 'threads.json'), JSON.stringify([thread]));
+  const runtime = new HostRuntime({ dataDirectory: directory });
+  await runtime.initialize();
+  const restored = runtime.threads[0];
+  assert.equal(restored.harnessId, 'codebuddy');
+  assert.equal(restored.nativeSessionId, 'native-unchanged');
+  assert.equal(restored.title, thread.title);
+  assert.equal(restored.harnessChain[0].harnessId, 'codebuddy');
+  assert.equal(restored.harnessChain[0].nativeSessionId, 'previous-native');
+  assert.equal(restored.pendingHandoff.fromHarnessId, 'codebuddy');
+  assert.equal(runtime.resolveHarnessId('Workbuddy'), 'codebuddy');
+  assert.equal(JSON.parse(await fs.readFile(path.join(directory, 'threads.json'), 'utf8'))[0].harnessId, 'codebuddy');
+  const history = require('../src/main/adapters/codebuddy-history');
+  const savedRoot = process.env.CODEBUDDY_CONFIG_DIR;
+  process.env.CODEBUDDY_CONFIG_DIR = path.join(directory, 'native-config');
+  try {
+    const projects = path.join(process.env.CODEBUDDY_CONFIG_DIR, 'projects', 'workspace');
+    await fs.mkdir(projects, { recursive: true });
+    const file = path.join(projects, 'session.jsonl');
+    const rows = [{ type: 'message', id: 'u', role: 'user', content: 'Hello', cwd: directory, sessionId: 'session' },
+      { type: 'message', id: 'a', parentId: 'u', role: 'assistant', content: 'Reply', cwd: directory, sessionId: 'session' }];
+    await fs.writeFile(file, rows.map(r => JSON.stringify(r)).join('\n') + '\n');
+    assert.equal(history.messages(await history.readCodeBuddyHistory(directory, 'session')).length, 2);
+    await assert.rejects(history.readCodeBuddyHistory(process.cwd(), 'session'), /another workspace/);
+    await assert.rejects(history.readCodeBuddyHistory(directory, '../escape'), /Invalid/);
+    await fs.appendFile(file, '{broken');
+    await assert.rejects(history.readCodeBuddyHistory(directory, 'session'));
+  } finally { if (savedRoot === undefined) delete process.env.CODEBUDDY_CONFIG_DIR; else process.env.CODEBUDDY_CONFIG_DIR = savedRoot; }
+  console.log('CodeBuddy migration: old name, persisted identity, switch history and title preserved PASS');
+})().catch(error => { console.error(error); process.exitCode = 1; });

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,111 @@
+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, discardWorkspace, pushWorkspace, 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');
+  const conflictRev = await reviewWorkspace(workspace);
+  assert.equal(conflictRev.hasConflict, true);
+  assert.deepEqual(conflictRev.conflictingFiles, ['file.txt']);
+  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 workspace2 = await createWorkspace(repo, randomUUID());
+  await fs.writeFile(path.join(workspace2.cwd, 'file2.txt'), 'w2 content\n');
+  const review2 = await reviewWorkspace(workspace2);
+  assert.equal(review2.hasConflict, false);
+  const remoteBare = path.join(root, 'remote-bare.git');
+  await git(repo, ['init', '--bare', remoteBare]);
+  await git(repo, ['remote', 'add', 'origin', remoteBare]);
+  const pushRes = await pushWorkspace(workspace2, 'origin');
+  assert.equal(pushRes.pushed, true);
+  assert.equal(pushRes.remote, 'origin');
+  assert.equal(pushRes.branch, workspace2.branch);
+  const discardRes = await discardWorkspace(workspace2);
+  assert.equal(discardRes.discarded, true);
+  assert.equal(discardRes.branch, workspace2.branch);
+  assert.equal(await fs.stat(workspace2.root).catch(() => null), null, 'Worktree directory cleaned');
+
+  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,108 @@
+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 });
+  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` 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.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.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 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/);
+    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,57 @@
+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('历史会话'));
+      const root = editor.closest('[data-codex-composer-root]');
+      root.dispatchEvent(new Event('submit', { bubbles: true }));
+      const submittedText = editor.value;
+      return {filtered,text,submittedText,richText,badge,icons,disabled,sessionText:editor.value,sessionBadge};
+    })()`);
+    assert.equal(result.filtered, 1);
+    assert.equal(result.text, '你负责后端， ');
+    assert.match(result.submittedText, /@claude/);
+    assert.equal(result.disabled, 1);
+    assert.equal(result.badge, 'harnesses/claude'); assert.equal(result.icons, 3);
+    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); });