harness-mix 0.1.0

package/scripts/native-images-test.cjs

@@ -0,0 +1,56 @@
+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 { NativeProtocol, routeModel } = require('../src/main/native/protocol');
+const { prepareInput } = require('../src/main/native/input');
+
+async function main() {
+  const root = path.resolve('output/native-images', String(Date.now()));
+  await fs.mkdir(root, { recursive: true });
+  const data = 'iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAQAAAC1HAwCAAAAC0lEQVR42mP8/x8AAwMCAO+jRZkAAAAASUVORK5CYII=';
+  const imagePath = path.join(root, '图片.png');
+  await fs.writeFile(imagePath, Buffer.from(data, 'base64'));
+  const local = { type: 'localImage', path: imagePath };
+  const inline = { type: 'image', url: `data:image/png;base64,${data}` };
+  assert.equal((await prepareInput([local], root)).attachments[0].data, data);
+  await assert.rejects(prepareInput([{ type: 'localImage', path: path.join(root, 'missing.png') }]), /ENOENT/);
+  await assert.rejects(prepareInput([{ type: 'image', url: 'bad' }]), /base64/);
+  await assert.rejects(prepareInput(Array(7).fill(inline)), /6/);
+  await assert.rejects(prepareInput([{ type: 'file' }]), /Unsupported/);
+  const runtime = new HostRuntime({ dataDirectory: path.join(root, 'data') });
+  await runtime.store.load();
+  const events = [], received = [];
+  const bridge = new NativeProtocol(runtime, event => events.push(event));
+  try {
+    for (const id of ['pi', 'claude', 'dsh']) {
+      runtime.status[id] = { available: true };
+      runtime.adapters.set(id, {
+        manifest: { id, name: id, capabilities: { attachments: true } },
+        async open({ emit }) { return { emit }; }, async close() {},
+        async describe() { return { models: [] }; },
+        async send(session, text, hooks, attachments) {
+          received.push({ id, text, attachments });
+          hooks.emit({ kind: 'completed', finalAnswer: true });
+        },
+      });
+      const { thread } = await bridge.request('thread/start', { cwd: root, model: routeModel(id === 'claude' ? 'claude-code' : id === 'dsh' ? 'deepseek-harness' : id) });
+      const { turn } = await bridge.request('turn/start', { threadId: thread.id, input: id === 'pi' ? [local] : [{ type: 'text', text: 'describe' }, inline] });
+      for (let n = 0; n < 200 && (runtime.execution.isRunning(thread.id) || runtime.threads.find(t => t.id === thread.id).reviewPending); n++) await new Promise(r => setTimeout(r, 20));
+      assert.equal(received.at(-1).attachments.images[0].data, data);
+      assert.equal(received.at(-1).text, id === 'pi' ? '' : 'describe');
+      const history = await bridge.request('thread/read', { threadId: thread.id });
+      assert.equal(history.thread.turns[0].items[0].content[1].url, inline.url);
+      assert.ok(events.some(e => e.method === 'item/completed' && e.params.turnId === turn.id && e.params.item.content?.[1]?.url === inline.url));
+    }
+    const stored = await runtime.store.load();
+    const restored = new HostRuntime({ dataDirectory: path.join(root, 'data') });
+    restored.threads = stored;
+    for (const thread of stored) restored.execution.threadCreated(thread);
+    const replay = new NativeProtocol(restored, () => {});
+    assert.equal(replay.projectThread(stored[0]).turns[0].items[0].content[1].url, inline.url);
+    replay.unsubscribe();
+    console.log('PASS: local/inline images, image-only turns, three adapter dispatches, notifications and persisted history; invalid inputs rejected');
+  } finally { bridge.unsubscribe(); }
+}
+main().catch(error => { console.error(error); process.exitCode = 1; });

package/scripts/native-protocol-test.cjs

@@ -0,0 +1,233 @@
+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 { NativeProtocol, decodeRoute, routeModel } = require('../src/main/native/protocol');
+const wait = async fn => { for (let i = 0; i < 200; i++) { if (fn()) return; await new Promise(r => setTimeout(r, 20)); } throw new Error('Timed out'); };
+
+async function main() {
+  const root = path.resolve('output/native-protocol', String(Date.now()));
+  await fs.mkdir(root, { recursive: true });
+  const runtime = new HostRuntime({ dataDirectory: path.join(root, 'data') });
+  await runtime.store.load();
+  let emit;
+  const emits = [];
+  const answers = [];
+  const adapter = { manifest: { id: 'pi', name: 'Pi', capabilities: { streaming: true, models: true, approvals: true, questions: true, resume: true } },
+    async open(input) { emits.push(input.emit); emit = input.emit; return {}; },
+    async describe() { return { models: [{ id: 'demo', name: 'Demo', provider: 'test' }], thinkingLevels: [{ id: 'high', label: 'High', default: true }, { id: 'low', label: 'Low' }], permissionModes: [] }; },
+    async send() {}, async cancel() {}, async close() {},
+    async respond(session, id, answer) { answers.push({ id, answer }); } };
+  runtime.adapters.set('pi', adapter); runtime.status.pi = { available: true };
+  const events = [];
+  const section = { id: 'test-pinned-section', name: 'Pinned', appearance: null };
+  const bridge = new NativeProtocol(runtime, event => events.push(event), async method => {
+    assert.equal(method, 'threadSection/list');
+    return { data: [section], nextCursor: null };
+  });
+  try {
+    const catalogModels = [{ id: 'shared', provider: 'a' }, { id: 'shared', provider: 'b' }, { id: 'unique', provider: 'a' }];
+    runtime.catalogs.set('pi', { models: catalogModels, thinkingLevels: [{ id: 'high', label: 'High', default: true }, { id: 'low', label: 'Low' }] });
+    const ref = model => ({ id: Buffer.from(JSON.stringify({ id: model.id, provider: model.provider })).toString('base64url') });
+    assert.deepEqual(bridge.configuration({ harnessId: 'pi', model: { id: 'unique' } }).effectiveModel, ref(catalogModels[2]), 'Recover provider from an unambiguous old Pi record');
+    assert.deepEqual(bridge.configuration({ harnessId: 'pi', model: { id: 'shared' }, options: { model: catalogModels[1] } }).effectiveModel, ref(catalogModels[1]), 'Preserve provider identity for duplicate model names');
+    assert.deepEqual(bridge.configuration({ harnessId: 'pi', model: { id: 'shared' } }).effectiveModel, ref({ id: 'shared' }), 'Do not guess an ambiguous provider');
+    // 思考档位：adapter 声明默认档后才下发可选集合，且生效档位必须属于其中
+    const thinkingConf = bridge.configuration({ harnessId: 'pi', model: { id: 'unique' }, options: { thinking: 'low' } });
+    assert.deepEqual(thinkingConf.availableThinkingOptions, [{ id: 'high', label: 'High' }, { id: 'low', label: 'Low' }], 'Declared default thinking level unlocks the selectable set');
+    assert.equal(thinkingConf.effectiveThinkingOptionId, 'low');
+    assert.equal(bridge.configuration({ harnessId: 'pi', model: { id: 'unique' }, options: { thinking: 'obsolete' } }).effectiveThinkingOptionId, undefined, 'Stale thinking level outside the catalog is dropped');
+    runtime.catalogs.set('claude', { models: [{ id: 'opus', name: 'Native resolved model' }], thinkingLevels: [{ id: 'high', label: 'high' }] });
+    const claudeConf = bridge.configuration({ harnessId: 'claude', model: { id: 'opus' }, options: { thinking: 'high' } });
+    assert.deepEqual(claudeConf.availableThinkingOptions, [{ id: 'high', label: 'high' }], 'Thinking options flow without a declared default');
+    assert.equal(claudeConf.effectiveThinkingOptionId, 'high');
+    // 模型声明了 efforts（含空数组）以模型为准：声明空集的模型不适用全局档位
+    runtime.catalogs.set('claude', { models: [{ id: 'opus', name: 'Native resolved model', efforts: [] }], thinkingLevels: [{ id: 'high', label: 'high' }] });
+    assert.equal(bridge.configuration({ harnessId: 'claude', model: { id: 'opus' }, options: { thinking: 'high' } }).availableThinkingOptions, undefined, 'Model with declared empty efforts exposes no thinking options');
+    runtime.catalogs.set('claude', { models: [{ id: 'opus', name: 'Native resolved model' }] });
+    assert.deepEqual(bridge.configuration({ harnessId: 'claude', model: { id: 'resolved-model[1M]' }, options: { model: { id: 'opus' } } }).effectiveModel, ref({ id: 'opus' }), 'Keep the native selectable alias after runtime initialization');
+    runtime.catalogs.delete('pi');
+    const esbuild = require('esbuild');
+    const schemaPath = path.join(root, 'schemas.cjs');
+    await esbuild.build({ entryPoints: ['src/native-ui/shared-contracts/src/index.ts'], outfile: schemaPath, bundle: true, platform: 'node', format: 'cjs', logLevel: 'silent' });
+    const schemas = require(schemaPath);
+    const inspection = await bridge.inspect('pi');
+    schemas.harnessInspectionSchema.parse(inspection);
+    assert.equal(inspection.catalog.defaultThinkingOptionId, 'high', 'Declared default thinking level projects to the catalog');
+    assert.ok(inspection.catalog.models.every(m => m.supportedThinkingOptionIds?.join(',') === 'high,low'), 'Every catalog model carries the selectable thinking set');
+    schemas.harnessPluginListResultSchema.parse(await bridge.request('codexhost/harness/plugins/list'));
+    const started = await bridge.request('thread/start', { cwd: root, model: routeModel('pi') });
+    const threadId = started.thread.id;
+    assert.equal(started.thread.sessionId, threadId, 'Desktop session identity is the host thread, not a native session id');
+    assert.equal(started.thread.model, 'codexhost/pi-native');
+    const { includesThread } = require('../src/main/native/thread-list');
+    const storedThread = runtime.threads.find(t => t.id === threadId);
+    assert.equal(includesThread(storedThread, { sectionId: section.id }), false);
+    await bridge.request('thread/section/move', { threadId, sectionId: section.id });
+    assert.deepEqual((await bridge.request('thread/read', { threadId })).thread.section, section);
+    assert.equal(includesThread(storedThread, { sectionId: section.id }), true);
+    assert.equal((await runtime.store.load()).find(t => t.id === threadId).section.id, section.id);
+    await bridge.request('thread/section/move', { threadId, sectionId: null });
+    assert.equal(includesThread(storedThread, { sectionId: section.id }), false);
+    assert.equal((await runtime.store.load()).find(t => t.id === threadId).section, null);
+    await assert.rejects(bridge.request('thread/section/move', { threadId, sectionId: 'missing' }), /Unknown thread section/);
+    // Desktop draft prewarm: ephemeral threads project as ephemeral and stay out of the sidebar;
+    // the first real turn materializes them.
+    const prewarmed = await bridge.request('thread/start', { cwd: root, model: routeModel('pi'), ephemeral: true });
+    assert.equal(prewarmed.thread.ephemeral, true, 'Prewarm thread projects as ephemeral');
+    await bridge.request('turn/start', { threadId: prewarmed.thread.id, input: [{ type: 'text', text: 'real input' }] });
+    assert.equal(runtime.threads.find(t => t.id === prewarmed.thread.id).ephemeral, undefined, 'First real input materializes the thread');
+    const materialized = await bridge.request('thread/read', { threadId: prewarmed.thread.id });
+    assert.equal(materialized.thread.ephemeral, false, 'Materialized thread projects as persistent');
+    await bridge.request('turn/interrupt', { threadId: prewarmed.thread.id });
+    await wait(() => !runtime.threads.find(t => t.id === prewarmed.thread.id).reviewPending);
+    emit = emits[0]; // 恢复主线程的事件源（open 顺序：主线程序，预热线程后）
+    schemas.threadInspectionSchema.parse(await bridge.request('codexhost/thread/inspect', { threadId }));
+    const turn = await bridge.request('turn/start', { threadId, input: [{ type: 'text', text: 'test' }] });
+    assert.ok(runtime.core.getTurn(turn.turn.id), 'Native turn IDs come from the existing ProtocolCore');
+    emit({ kind: 'thinking-delta', text: 'reason' });
+    emit({ kind: 'text-delta', text: 'hello' });
+    emit({ kind: 'text-delta', text: ' world' });
+    emit({ kind: 'tool', toolCallId: 't', title: 'Read', state: 'running', input: '{}' });
+    emit({ kind: 'tool', toolCallId: 't', title: 'Read', state: 'completed', output: 'done' });
+    emit({ kind: 'approval', requestId: 'permission', method: 'confirm', title: 'Allow?' });
+    const approval = events.find(e => e.id?.startsWith('harness-mix:approval:'));
+    assert.equal(answers.length, 0, 'Approval is not fabricated');
+    await bridge.respond({ id: approval.id, result: { decision: 'decline' } });
+    assert.deepEqual(answers[0], { id: 'permission', answer: { confirmed: false } });
+    emit({ kind: 'approval', requestId: 'question', method: 'input', title: 'Name?' });
+    const question = events.find(e => e.method === 'item/tool/requestUserInput');
+    await bridge.respond({ id: question.id, result: { answers: { question: { answers: ['Alice'] } } } });
+    assert.equal(answers[1].answer.value, 'Alice');
+    emit({ kind: 'file-change', changes: [{ path: 'a.txt', changeType: 'added', before: '', after: 'hello', complete: true }] });
+    emit({ kind: 'completed', finalAnswer: true });
+    await wait(() => !runtime.threads.find(t => t.id === threadId).reviewPending);
+    assert.equal(events.filter(e => e.method === 'item/agentMessage/delta').map(e => e.params.delta).join(''), 'hello world');
+    assert.ok(events.some(e => e.method === 'item/completed' && e.params.item.type === 'mcpToolCall'));
+    // Desktop 以 `diff --git a/x b/x` 切分文件并提取路径，且只在 @@ hunk 头之后计数增删行
+    const turnDiff = events.filter(e => e.method === 'turn/diff/updated').at(-1).params.diff;
+    assert.ok(turnDiff.includes('diff --git a/a.txt b/a.txt'), 'turn diff carries git-style file headers');
+    assert.ok(turnDiff.includes('--- /dev/null') && turnDiff.includes('+++ b/a.txt'), 'added file uses /dev/null header');
+    assert.ok(turnDiff.includes('@@ -0,0 +1,1 @@') && turnDiff.includes('+hello'), 'turn diff carries a countable hunk');
+    assert.ok(events.some(e => e.method === 'turn/diff/updated' && e.params.diff.includes('a.txt')));
+    assert.equal(events.filter(e => e.method === 'turn/completed' && e.params.threadId === threadId).length, 1);
+    const history = await bridge.request('thread/read', { threadId });
+    assert.equal(history.thread.turns[0].status, 'completed');
+    const projectedChange = history.thread.turns[0].items.find(i => i.type === 'fileChange')?.changes?.[0];
+    assert.equal(projectedChange?.kind.type, 'add', 'fileChange item projects the added kind');
+    assert.ok(projectedChange?.diff.includes('diff --git a/a.txt b/a.txt') && projectedChange.diff.includes('@@ -0,0 +1,1 @@'), 'fileChange item carries a full unified diff');
+    await bridge.request('thread/name/set', { threadId, name: 'Local Core' });
+    await bridge.request('thread/archive', { threadId });
+    assert.equal(runtime.threads.find(t => t.id === threadId).archived, true);
+    await bridge.request('thread/unarchive', { threadId });
+    await bridge.request('turn/start', { threadId, input: [{ type: 'text', text: 'cancel' }] });
+    await bridge.request('turn/interrupt', { threadId });
+    await wait(() => !runtime.threads.find(t => t.id === threadId).reviewPending);
+    assert.equal(events.filter(e => e.method === 'turn/completed').at(-1).params.turn.status, 'interrupted');
+    // External steering: cancel the active Turn, settle, then start a real new Turn.
+    const stale = await bridge.request('turn/start', { threadId, input: [{ type: 'text', text: 'first' }] });
+    await assert.rejects(bridge.request('turn/steer', { threadId, expectedTurnId: stale.turn.id, input: [] }), /non-empty text/, 'Invalid input is rejected before cancelling');
+    assert.ok(runtime.execution.isRunning(threadId), 'Rejected steering leaves the active Turn running');
+    const steered = await bridge.request('turn/steer', { threadId, expectedTurnId: stale.turn.id, clientUserMessageId: 'msg-1', input: [{ type: 'text', text: 'redirect' }] });
+    assert.ok(steered.turnId && steered.turnId !== stale.turn.id, 'Steering allocates a real new Turn identity');
+    assert.equal(runtime.core.getTurn(stale.turn.id).status, 'cancelled', 'Old Turn was cancelled');
+    const replay = await bridge.request('turn/steer', { threadId, expectedTurnId: stale.turn.id, clientUserMessageId: 'msg-1', input: [{ type: 'text', text: 'redirect' }] });
+    assert.equal(replay.turnId, steered.turnId, 'Identical retry returns the delivery receipt');
+    await assert.rejects(bridge.request('turn/steer', { threadId, expectedTurnId: 'other', clientUserMessageId: 'msg-1', input: [{ type: 'text', text: 'changed' }] }), /Conflicting/, 'Same message ID with different payload is rejected');
+    emit({ kind: 'completed', finalAnswer: true });
+    await wait(() => !runtime.threads.find(t => t.id === threadId).reviewPending);
+    await bridge.request('turn/start', { threadId, input: [{ type: 'text', text: 'second' }] });
+    const current = runtime.threads.find(t => t.id === threadId).currentTurn.id;
+    await assert.rejects(bridge.request('turn/steer', { threadId, expectedTurnId: 'wrong-turn', input: [{ type: 'text', text: 'x' }] }), /no longer matches/, 'Stale target is not guessed');
+    assert.ok(runtime.execution.isRunning(threadId) && runtime.threads.find(t => t.id === threadId).currentTurn.id === current, 'Stale steering never cancels the running Turn');
+    emit({ kind: 'completed', finalAnswer: true });
+    await wait(() => !runtime.threads.find(t => t.id === threadId).reviewPending);
+    assert.equal(await bridge.request('thread/start', { model: 'official-model' }), undefined, 'Official Codex requests pass through');
+    adapter.listCommands = async () => [{ id: 'compact', action: 'execute', label: 'Compact' }];
+    let compactCalls = 0;
+    adapter.executeCommand = async (_session, id, hooks) => {
+      assert.equal(id, 'compact'); compactCalls++;
+      hooks.emit({ kind: 'usage', usage: { input: 20, output: 5, cacheRead: 10, tokens: 30, contextWindow: 100, cost: 0.01 } });
+      hooks.emit({ kind: 'completed', finalAnswer: true });
+    };
+    const command = await bridge.request('codexhost/thread/command/execute', { threadId, commandId: 'compact' });
+    schemas.threadCommandExecuteResultSchema.parse(command);
+    await wait(() => compactCalls === 1 && !runtime.threads.find(t => t.id === threadId).reviewPending);
+    const usage = await bridge.request('codexhost/thread/usage/inspect', { threadId });
+    schemas.threadUsageInspectionSchema.parse(usage);
+    assert.equal(usage.usage.inputTokens, 20);
+    assert.equal(usage.usage.contextUsagePercent, 30);
+    assert.ok(events.some(e => e.method === 'codexhost/thread/usage/updated' && e.params.usage?.cachedInputTokens === 10));
+    await assert.rejects(bridge.request('codexhost/thread/command/execute', { threadId, commandId: 'missing' }), /不支持此指令/);
+    // ===== 新 Harness 路由：omp / opencode / grok 的 legacy 传输串解码与投影 =====
+    assert.equal(routeModel('omp'), 'codexhost/omp-native');
+    assert.equal(routeModel('opencode'), 'codexhost/opencode-native');
+    assert.equal(routeModel('grok'), 'codexhost/grok-native');
+    assert.deepEqual(decodeRoute('codexhost/omp-native'), { harnessId: 'omp' });
+    assert.deepEqual(decodeRoute('codexhost/omp-native@model-x@high'), { harnessId: 'omp', model: { id: 'model-x' }, thinkingOptionId: 'high' }, 'OMP 两段式 = model@thinking');
+    assert.deepEqual(decodeRoute('codexhost/omp-native@model-x@approve@high'), { harnessId: 'omp', model: { id: 'model-x' }, permissionModeId: 'approve', thinkingOptionId: 'high' }, 'OMP 三段式 = model@permission@thinking');
+    assert.deepEqual(decodeRoute('codexhost/opencode-native@m@perm'), { harnessId: 'opencode', model: { id: 'm' }, permissionModeId: 'perm' });
+    assert.deepEqual(decodeRoute('codexhost/grok-native@m@@think'), { harnessId: 'grok', model: { id: 'm' }, thinkingOptionId: 'think' });
+    assert.throws(() => decodeRoute('codexhost/omp-native@a@b@c@d'), /Invalid native Harness route/);
+    // ===== 跨 Harness 协作：委派 → 消息 → 等待 → 级联取消 =====
+    const childEmits = [];
+    let childSend;
+    const childAdapter = { manifest: { id: 'claude', name: 'Claude Code', aliases: ['claude', 'claude-code'], capabilities: { streaming: true, models: true, resume: true } },
+      async open(input) { childEmits.push(input.emit); return {}; },
+      async describe() { return { models: [], thinkingLevels: [], permissionModes: [] }; },
+      sendCalls: [], cancelCalls: 0,
+      async send(session, text, hooks) { this.sendCalls.push(text); await (childSend ?? (() => {}))(hooks); },
+      async cancel() { this.cancelCalls++; },
+      async close() {} };
+    runtime.adapters.set('claude', childAdapter); runtime.status.claude = { available: true };
+    // Host 级 /delegate 指令出现在命令目录中（insert 型，填入输入框）
+    const commandList = await bridge.request('codexhost/thread/commands/inspect', { threadId });
+    assert.ok(commandList.commands.some(c => c.invocation === '/delegate' && c.argumentMode === 'text'), 'Host 级 /delegate 指令应出现在命令目录');
+    // 委派：协议入口创建子任务线程并挂起父线程协作 Turn
+    childSend = hooks => { hooks.emit({ kind: 'text-delta', text: '子任务结论' }); hooks.emit({ kind: 'completed', finalAnswer: true }); };
+    const delegated = await bridge.request('codexhost/thread/delegate', { threadId, harnessId: 'claude-code', task: '审查代码' });
+    schemas.threadDelegationResultSchema.parse(delegated);
+    assert.equal(delegated.turn.status, 'inProgress', '委派后父线程协作 Turn 保持活动');
+    assert.ok(delegated.turn?.id, 'Delegation starts a parent collaboration Turn');
+    const childId = delegated.childThreadId;
+    const childThread = runtime.threads.find(t => t.id === childId);
+    assert.equal(childThread.parentThreadId, threadId, '子任务记录父任务归属');
+    assert.ok(events.some(e => e.method === 'thread/started' && e.params.thread.id === childId), 'Desktop 收到协作子任务的 thread/started');
+    assert.equal((await bridge.request('thread/read', { threadId: childId })).thread.parentThreadId, threadId, '子任务投影 parentThreadId');
+    assert.equal(includesThread(childThread, { parentThreadId: threadId }, runtime.threads), true, '父子归属查询匹配子任务');
+    assert.equal(includesThread(childThread, { ancestorThreadId: threadId }, runtime.threads), true, '祖先查询沿 parentThreadId 链匹配');
+    assert.equal(includesThread(storedThread, { parentThreadId: threadId }, runtime.threads), false, '普通线程不出现在子任务查询');
+    await wait(() => !runtime.execution.isRunning(threadId));
+    assert.deepEqual(childAdapter.sendCalls, ['审查代码'], '子任务收到委派任务');
+    const parentTurn = runtime.core.getItemsForTurn(delegated.turn.id);
+    const delegateTool = parentTurn.find(i => i.type === 'tool_call');
+    assert.equal(delegateTool.title, 'Agent 协作 · Claude Code');
+    assert.equal(delegateTool.status, 'completed', '子任务结算后协作工具项完成');
+    assert.ok(String(delegateTool.output).includes('子任务结论'), '协作工具项携带子任务最终答复');
+    // 消息链：向同一子任务跟进（复用既有子线程）
+    const followUp = await bridge.request('codexhost/thread/message', { threadId, childThreadId: childId, text: '再检查一遍' });
+    schemas.threadDelegationResultSchema.parse(followUp);
+    await wait(() => !runtime.execution.isRunning(threadId));
+    assert.deepEqual(childAdapter.sendCalls, ['审查代码', '再检查一遍'], '跟进消息进入同一子任务');
+    assert.equal(followUp.childThreadId, childId);
+    // 循环防护：子任务不能继续委派
+    await assert.rejects(bridge.request('codexhost/thread/delegate', { threadId: childId, harnessId: 'pi', task: 'x' }), /暂不支持继续委派/);
+    // 斜杠通道：/delegate 文本走同一委派链路
+    childSend = hooks => { hooks.emit({ kind: 'text-delta', text: '斜杠委派完成' }); hooks.emit({ kind: 'completed', finalAnswer: true }); };
+    const slashTurn = await bridge.request('turn/start', { threadId, input: [{ type: 'text', text: '/delegate claude 用斜杠通道' }] });
+    await wait(() => !runtime.execution.isRunning(threadId));
+    assert.deepEqual(childAdapter.sendCalls.at(-1), '用斜杠通道', '斜杠指令进入委派链路');
+    assert.equal(runtime.core.getItemsForTurn(slashTurn.turn.id).find(i => i.type === 'tool_call')?.status, 'completed');
+    await assert.rejects(bridge.request('turn/start', { threadId, input: [{ type: 'text', text: '/delegate' }] }), /用法：\/delegate/);
+    // 级联取消：中断父线程协作 Turn ⇒ 子任务被取消
+    childSend = () => new Promise(() => {}); // 子任务永不自行结算
+    const stuck = await bridge.request('codexhost/thread/delegate', { threadId, harnessId: 'claude', task: '长跑任务' });
+    assert.ok(runtime.execution.isRunning(threadId), '父线程协作 Turn 等待子任务');
+    await bridge.request('turn/interrupt', { threadId });
+    await wait(() => !runtime.execution.isRunning(threadId) && !runtime.execution.isRunning(stuck.childThreadId));
+    assert.equal(childAdapter.cancelCalls, 1, '中断父线程级联取消子任务');
+    assert.equal(runtime.core.getTurn(stuck.turn.id).status, 'cancelled');
+    console.log('PASS: native protocol, external steering, command execution and Usage projection');
+  } finally { bridge.close(); await runtime.close(); }
+}
+main().catch(error => { console.error(error); process.exitCode = 1; });

package/scripts/native-rollback-test.cjs

@@ -0,0 +1,46 @@
+const assert = require('node:assert/strict');
+const path = require('node:path');
+const { HostRuntime } = require('../src/main/host/runtime');
+const { NativeProtocol } = require('../src/main/native/protocol');
+const wait = async fn => { for (let n = 0; n < 400; n++) { if (fn()) return; await new Promise(r => setTimeout(r, 25)); } throw new Error('Timed out'); };
+
+(async () => {
+  const root = path.resolve('output/rollback-test', String(Date.now()));
+  await require('node:fs/promises').mkdir(root, { recursive: true });
+  const runtime = new HostRuntime({ dataDirectory: path.join(root, 'data') });
+  await runtime.store.load();
+  let forks = 0;
+  const adapter = {
+    manifest: { id: 'pi', name: 'Pi', capabilities: { fork: true, forkFromMessage: true } },
+    async open({ thread }) { return { nativeSessionId: thread.nativeSessionId }; },
+    async close() {}, async describe() { return { models: [] }; },
+    async send(_session, text, hooks) { hooks.emit({ kind: 'text-delta', text }); hooks.emit({ kind: 'completed', finalAnswer: true }); },
+    async fork(_thread, { message }) { assert.equal(message.text, 'kept'); forks++; return { session: { nativeSessionId: 'forked-native' } }; },
+  };
+  runtime.adapters.set('pi', adapter); runtime.status.pi = { available: true };
+  const bridge = new NativeProtocol(runtime, () => {});
+  try {
+    const { thread } = await bridge.request('thread/start', { cwd: root, model: 'codexhost/pi-native' });
+    for (const text of ['kept', 'removed']) {
+      await bridge.request('turn/start', { threadId: thread.id, input: [{ type: 'text', text }] });
+      await wait(() => !runtime.execution.isRunning(thread.id) && !runtime.threads[0].reviewPending);
+    }
+    await assert.rejects(bridge.request('thread/rollback', { threadId: thread.id, numTurns: 3 }), /回退轮数/);
+    const rollback = await bridge.request('thread/rollback', { threadId: thread.id, numTurns: 1 });
+    assert.equal(forks, 1);
+    assert.equal(rollback.thread.turns.length, 1);
+    assert.equal(runtime.threads[0].nativeSessionId, 'forked-native');
+    assert.equal(runtime.threads[0].messages.length, 2);
+    assert.ok(!rollback.thread.turns.flatMap(t => t.items).some(i => i.type === 'agentMessage' && i.text === 'removed'));
+    const empty = await bridge.request('thread/rollback', { threadId: thread.id, numTurns: 1 });
+    assert.equal(empty.thread.turns.length, 0);
+    assert.notEqual(runtime.threads[0].nativeSessionId, 'forked-native');
+    await bridge.request('turn/start', { threadId: thread.id, input: [{ type: 'text', text: 'replacement' }] });
+    await wait(() => !runtime.execution.isRunning(thread.id) && !runtime.threads[0].reviewPending);
+    assert.equal(bridge.projectThread(runtime.threads[0]).turns.length, 1);
+    const stored = await runtime.store.load();
+    assert.equal(stored[0].coreState.turns.length, 1);
+    assert.equal(stored[0].rewindHistory.length, 2);
+    console.log('PASS: native fork boundary, empty-session rewind, resend, persistence and invalid counts');
+  } finally { bridge.close(); await runtime.close(); }
+})().catch(error => { console.error(error); process.exitCode = 1; });

package/scripts/native-sidebar-test.cjs

@@ -0,0 +1,88 @@
+const assert = require('node:assert/strict');
+const fs = require('node:fs');
+const path = require('node:path');
+const { includesThread, mergeThreadPage } = require('../src/main/native/thread-list');
+const { cacheCodexRuntime } = require('../src/main/native/launcher');
+
+const thread = { id: 'external', title: 'Pi session', cwd: 'E:/project', createdAt: 10 };
+for (const query of [
+  { sectionId: 'pinned' }, { ancestorThreadId: 'external' }, { parentThreadId: 'external' },
+  { sourceKinds: ['subAgentThreadSpawn'] }, { modelProviders: ['openai'] },
+  { cwd: ['E:/other'] }, { archived: true }, { searchTerm: 'missing' }, { projectId: 'other' },
+]) assert.equal(includesThread(thread, query), false, JSON.stringify(query));
+for (const query of [{}, { sectionId: null }, { cwd: ['E:/project'] }, { searchTerm: 'PI' }, { modelProviders: [] }]) {
+  assert.equal(includesThread(thread, query), true, JSON.stringify(query));
+}
+assert.equal(includesThread({ ...thread, ephemeral: true }, {}), false);
+assert.equal(includesThread({ ...thread, section: { id: 'pinned' } }, { sectionId: 'pinned' }), true);
+const page = { data: [{ id: 'official', createdAt: 20 }, thread], nextCursor: 'next' };
+const merged = mergeThreadPage(page, [thread], {}, t => t);
+assert.deepEqual(merged.data.map(t => t.id), ['official', 'external']);
+assert.equal(merged.nextCursor, 'next');
+assert.equal(mergeThreadPage(page, [thread], { cursor: 'next' }, t => t), page);
+
+const root = fs.mkdtempSync(path.resolve('output/native-runtime-cache-test-'));
+const resources = path.join(root, 'resources');
+const cache = path.join(root, 'cache');
+fs.mkdirSync(resources); fs.mkdirSync(cache);
+for (const name of ['codex.exe', 'codex-code-mode-host.exe', 'codex-command-runner.exe', 'codex-windows-sandbox-setup.exe', 'rg.exe']) {
+  fs.writeFileSync(path.join(resources, name), `fixture:${name}`);
+}
+fs.writeFileSync(path.join(resources, 'unrelated.exe'), 'unrelated');
+fs.copyFileSync(path.join(resources, 'codex.exe'), path.join(cache, 'codex.exe'));
+cacheCodexRuntime(resources, cache);
+assert.equal(fs.existsSync(path.join(cache, 'unrelated.exe')), false);
+assert.equal(fs.readFileSync(path.join(cache, 'codex-code-mode-host.exe'), 'utf8'), 'fixture:codex-code-mode-host.exe');
+fs.truncateSync(path.join(cache, 'codex-code-mode-host.exe'), 0);
+cacheCodexRuntime(resources, cache);
+assert.ok(fs.statSync(path.join(cache, 'codex-code-mode-host.exe')).size > 0);
+console.log('PASS: section/tree filters, deduplication, and incomplete Codex runtime cache repair');
+
+async function testPrewarm() {
+  const file = path.join(root, 'prewarm.cjs');
+  await require('esbuild').build({ entryPoints: ['src/native-ui/desktop-control/src/renderer-draft-prewarm-runtime.ts'], outfile: file, bundle: true, platform: 'node', format: 'cjs', logLevel: 'silent' });
+  const { installDraftPrewarmPolicyBridge } = require(file);
+  const sent = [];
+  const prewarmed = [];
+  const bridge = { sendRequest: (method, params) => sent.push({ method, params }), prewarmThreadStart: params => prewarmed.push(params) };
+  const manager = { onNotification() {}, onRequest() {}, dispatchAppServerResponse() {} };
+  const target = {};
+  installDraftPrewarmPolicyBridge(manager, bridge, 'local', target, { discardAllPrewarmedThreads() {} });
+  const policy = target.__codexhostDraftPrewarmPolicyV1;
+  for (const harness of ['pi', 'claude-code', 'deepseek-harness', 'antigravity']) {
+    policy.select(`codexhost/${harness}-native`);
+    bridge.prewarmThreadStart({ cwd: 'E:/project', model: 'gpt-test' });
+    bridge.sendRequest('thread/start', { cwd: 'E:/project', model: 'gpt-test' });
+    assert.equal(prewarmed.at(-1).ephemeral, true);
+    assert.equal(prewarmed.at(-1).model, `codexhost/${harness}-native`);
+    assert.equal(sent.at(-1).params.ephemeral, undefined);
+  }
+  bridge.prewarmThreadStart({ ephemeral: true, model: 'gpt-title' });
+  assert.equal(prewarmed.at(-1).model, 'gpt-title', 'Internal ephemeral Codex tasks retain their own model');
+  policy.select(null);
+  bridge.prewarmThreadStart({ model: 'gpt-test' });
+  assert.deepEqual(prewarmed.at(-1), { model: 'gpt-test' });
+  policy.dispose();
+  console.log('PASS: all four external prewarm routes stay ephemeral; actual starts and Codex internal tasks are preserved');
+  const sidebarFile = path.join(root, 'sidebar.cjs');
+  await require('esbuild').build({ entryPoints: ['src/native-ui/renderer-extension/src/renderer-sidebar-agent-icons.ts'], outfile: sidebarFile, bundle: true, platform: 'node', format: 'cjs', alias: { '@codexhost/shared-contracts': path.resolve('src/native-ui/shared-contracts/src/index.ts') }, loader: { '.png': 'dataurl', '.svg': 'dataurl' }, logLevel: 'silent' });
+  const { installRendererSidebarAgentIcons } = require(sidebarFile);
+  let cleared = 0;
+  let agent = null;
+  let resolveOwnership;
+  const row = { isConnected: () => true, hostId: () => 'local', threadId: () => 'test', draftId: () => null, render: value => { agent = value; }, clear: () => { agent = null; cleared++; } };
+  const control = installRendererSidebarAgentIcons({ dom: { rows: () => [row], observe: () => () => {}, clear() {} }, getClient: () => ({ listThreadOwnership: () => new Promise(resolve => { resolveOwnership = resolve; }) }) });
+  const settle = () => new Promise(resolve => setImmediate(resolve));
+  await settle(); resolveOwnership({ threads: [{ threadId: 'test', owner: 'codex' }] }); await settle();
+  assert.equal(agent, 'codex');
+  const clearsBeforeRefresh = cleared;
+  control.refresh(); await settle();
+  assert.equal(agent, 'codex');
+  assert.equal(cleared, clearsBeforeRefresh, 'Retain the visible icon while background ownership is unresolved');
+  resolveOwnership({ threads: [{ threadId: 'test', owner: 'external', harnessId: 'pi' }] }); await settle();
+  assert.equal(agent, 'pi');
+  assert.equal(cleared, clearsBeforeRefresh, 'Replace identity without an empty frame');
+  control.dispose();
+  console.log('PASS: sidebar revalidation preserves icons until authoritative ownership arrives');
+}
+testPrewarm().catch(error => { console.error(error); process.exitCode = 1; });

package/scripts/native-ui-smoke.cjs

@@ -0,0 +1,94 @@
+const { app, BrowserWindow } = require('electron');
+const fs = require('node:fs');
+const path = require('node:path');
+const assert = require('node:assert/strict');
+const esbuild = require('esbuild');
+const { getAllIconsDictionary, MODEL_FAMILIES } = require('../src/main/native/icons');
+app.disableHardwareAcceleration();
+
+app.whenReady().then(async () => {
+  const out = path.resolve('output/native-ui-smoke');
+  fs.mkdirSync(out, { recursive: true });
+  const icons = getAllIconsDictionary();
+  icons.harnesses['claude-code'] = icons.harnesses.claude;
+  icons.harnesses['deepseek-harness'] = icons.harnesses.dsh;
+  const bundle = await esbuild.build({ stdin: { contents: `export { createRendererAgentIcon } from './src/native-ui/renderer-extension/src/renderer-agent-icon.ts'; export { mountRendererModelPicker, renderRendererModelPicker } from './src/native-ui/renderer-extension/src/renderer-model-picker.ts'; export { restoredThreadOwnership } from './src/native-ui/renderer-extension/src/renderer-binding-probe.ts'; export { installRendererSidebarAgentIcons } from './src/native-ui/renderer-extension/src/renderer-sidebar-agent-icons.ts';`, resolveDir: process.cwd() }, bundle: true, alias: { '@codexhost/shared-contracts': path.resolve('src/native-ui/shared-contracts/src/index.ts') }, platform: 'browser', format: 'iife', globalName: 'NativeUI', write: false, loader: { '.svg': 'dataurl', '.png': 'dataurl', '.css': 'text' }, logLevel: 'silent' });
+  const win = new BrowserWindow({ show: false, width: 900, height: 650, webPreferences: { contextIsolation: true, sandbox: true, offscreen: true, backgroundThrottling: false } });
+  await win.loadURL('data:text/html,<html><head><style>body{background:%2317191d;color:white;font:16px Arial;padding:40px}button{background:%23272a30;color:white;border:0;padding:12px}img{vertical-align:middle}main{display:flex;gap:25px;margin-bottom:40px}</style></head><body><h2>Harness Mix native components</h2><main></main></body></html>');
+  await win.webContents.executeJavaScript(`globalThis.__HARNESS_MIX_ICONS__=${JSON.stringify(icons)};globalThis.__HARNESS_MIX_MODEL_FAMILIES__=${JSON.stringify(MODEL_FAMILIES.map(f => ({ id: f.id, pattern: f.regex.source })))};${bundle.outputFiles[0].text}`);
+  const { NativeProtocol } = require('../src/main/native/protocol');
+  const nativeThreads = ['pi', 'claude', 'dsh', 'antigravity'].map((harnessId, index) => ({ id: 'sidebar-' + index, harnessId, model: { id: 'model-' + index, provider: 'native' }, options: {} }));
+  const protocol = new NativeProtocol({ threads: nativeThreads, subscribe: () => () => {}, core: { subscribe: () => () => {} }, describe: async () => ({}), getCapabilities: () => ({}) }, () => {});
+  const inspections = await Promise.all(nativeThreads.map(thread => protocol.request('codexhost/thread/inspect', { threadId: thread.id })));
+  await win.webContents.executeJavaScript(`globalThis.testInspections=${JSON.stringify(inspections)}`);
+  const result = await win.webContents.executeJavaScript(`(async () => {
+    const agents = ['codex','pi','claude-code','deepseek-harness','antigravity','omp','opencode','grok'];
+    const restored = testInspections.map(inspection => NativeUI.restoredThreadOwnership(inspection));
+    const sidebar = document.createElement('aside'); document.body.append(sidebar);
+    sidebar.style.cssText = 'margin:24px 0;padding:16px;border:1px solid #555;line-height:30px';
+    for (const [index, agent] of agents.entries()) {
+      const row = document.createElement('div');
+      const attrs = { 'data-app-action-sidebar-thread-row': 'true', 'data-app-action-sidebar-thread-id': 'local:row-' + index, 'data-app-action-sidebar-thread-host-id': 'local' };
+      for (const [key, value] of Object.entries(attrs)) row.setAttribute(key, value);
+      row.innerHTML = '<span data-thread-title-trigger><span data-thread-title>' + agent + ' session</span></span>';
+      row.__reactFiber$test = { memoizedProps: { conversationId: 'row-' + index, dataAttributes: attrs } };
+      sidebar.append(row);
+    }
+    const decoration = NativeUI.installRendererSidebarAgentIcons({ getClient: () => ({ listThreadOwnership: async ({threadIds}) => ({threads: threadIds.map(threadId => { const agent = agents[Number(threadId.slice(4))]; return agent === 'codex' ? {threadId, owner:'codex'} : {threadId, owner:'external', harnessId:agent}; })}) }) });
+    await new Promise(resolve => setTimeout(resolve, 50));
+    const sidebarIcons = [...sidebar.querySelectorAll('[data-codexhost-sidebar-agent-icon]')].map(icon => icon.getAttribute('data-codexhost-sidebar-agent-icon'));
+    // Rescan a React-updated row: no duplicate icon and no loss of ownership.
+    decoration.refresh(); await new Promise(resolve => setTimeout(resolve, 50));
+    const sidebarIconCount = sidebar.querySelectorAll('[data-codexhost-sidebar-agent-icon]').length;
+    globalThis.testSidebarDecoration = decoration;
+    for(const agent of agents) { const el=document.createElement('div'); el.append(NativeUI.createRendererAgentIcon(agent,28),document.createTextNode(' '+agent));document.querySelector('main').append(el); }
+    let selected;
+    const picker=NativeUI.mountRendererModelPicker('test',id=>selected=id,()=>{});
+    globalThis.testModelPicker = picker;
+    document.body.append(picker.root);
+    NativeUI.renderRendererModelPicker(picker,{status:'ready',selected:{id:'a'},catalog:{models:[{ref:{id:'a'},label:'Claude Sonnet'},{ref:{id:'b'},label:'DeepSeek'},{ref:{id:'c'},label:'Gemini'}],thinkingOptions:[]}},true);
+    picker.trigger.click();
+    const option=picker.options.get('b').button;
+    option.click();
+    picker.close(); picker.trigger.click();
+    const levels = [{id:'low',label:'Low'},{id:'high',label:'High'}];
+    const view = {status:'ready',selected:{id:'a'},catalog:{models:[{ref:{id:'a'},label:'Claude Sonnet'}, {ref:{id:'b'},label:'DeepSeek',supportedThinkingOptionIds:['low','high']}],thinkingOptions:levels}};
+    let thinking;
+    const flow=NativeUI.mountRendererModelPicker('flow', id=>{ view.selected={id}; NativeUI.renderRendererModelPicker(flow,view,true); },id=>{thinking=id;view.selectedThinkingOptionId=id;NativeUI.renderRendererModelPicker(flow,view,true);});
+    document.body.append(flow.root);
+    NativeUI.renderRendererModelPicker(flow,view,true);
+    flow.trigger.click();
+    const modelFirst = flow.menu.dataset.twoColumn === 'false';
+    flow.options.get('b').button.click();
+    const stayedOpen = flow.menu.matches(':popover-open');
+    const modelRect = flow.options.get('b').button.getBoundingClientRect();
+    const thinkingRect = flow.thinkingOptions.get('high').button.getBoundingClientRect();
+    const thinkingOnRight = thinkingRect.left >= modelRect.right;
+    flow.thinkingOptions.get('high').button.click();
+    const confirmed = flow.thinkingOptions.get('high').button.getAttribute('aria-checked') === 'true';
+    const closedAfterThinking = !flow.menu.matches(':popover-open');
+    flow.trigger.click();
+    const reopenedModelFirst = flow.menu.dataset.twoColumn === 'false';
+    flow.dispose();
+    await Promise.all([...document.images].map(i=>i.decode()));
+    return {selected,modelFirst,stayedOpen,thinkingOnRight,thinking,confirmed,closedAfterThinking,reopenedModelFirst,restored,sidebarIcons,sidebarIconCount,icons:[...document.images].map(i=>i.dataset.harnessMixIcon),loaded:[...document.images].every(i=>i.naturalWidth>0)};
+  })()`);
+  assert.equal(result.selected, 'b');
+  for (const key of ['modelFirst','stayedOpen','thinkingOnRight','confirmed','closedAfterThinking','reopenedModelFirst']) assert.equal(result[key], true, key);
+  assert.equal(result.thinking, 'high');
+  assert.equal(result.loaded, true);
+  assert.deepEqual(result.sidebarIcons, ['codex','pi','claude-code','deepseek-harness','antigravity','omp','opencode','grok']);
+  assert.equal(result.sidebarIconCount, 8);
+  assert.deepEqual(result.restored.map(item => item.agent), ['pi','claude-code','deepseek-harness','antigravity']);
+  assert.deepEqual(result.restored.map(item => item.model), inspections.map(item => item.effectiveModel));
+  for (const id of ['harnesses/codex','harnesses/pi','harnesses/claude-code','harnesses/deepseek-harness','harnesses/antigravity','models/claude','models/deepseek','models/gemini']) assert.ok(result.icons.includes(id), id);
+  await win.webContents.executeJavaScript('testModelPicker.trigger.click();document.querySelector("main").style.flexWrap="wrap"');
+  await new Promise(resolve => setTimeout(resolve, 300));
+  fs.writeFileSync(path.join(out, 'native-components.png'), (await win.webContents.capturePage()).toPNG());
+  await win.webContents.executeJavaScript(`document.body.style.background='#fff';document.body.style.color='#17191d';document.querySelector('main').style.flexWrap='wrap'`);
+  await new Promise(resolve => setTimeout(resolve, 100));
+  fs.writeFileSync(path.join(out, 'native-components-light.png'), (await win.webContents.capturePage()).toPNG());
+  win.destroy();
+  console.log('PASS: real Electron native picker selection and all project Harness/model SVGs load');
+  app.quit();
+}).catch(error => { console.error(error); app.exit(1); });