@harness-mix/cli 0.1.3

package/scripts/antigravity-adapter-test.cjs

@@ -0,0 +1,529 @@
+const assert = require('node:assert/strict');
+const { EventEmitter } = require('node:events');
+const fs = require('node:fs');
+const os = require('node:os');
+const path = require('node:path');
+const { PassThrough } = require('node:stream');
+const antigravity = require('../src/main/adapters/antigravity');
+
+(async () => {
+  const { manifest, create, parseModelsOutput, parseUsage, formatPrompt, prepareImageAttachments, formatAntigravityResultError, modelSupportsEffort, ANTIGRAVITY_PERMISSION_MODES } = antigravity;
+
+  // 1. Manifest
+  assert.equal(manifest.id, 'antigravity');
+  assert.equal(manifest.name, 'Antigravity');
+  assert.equal(manifest.icon, 'antigravity-color.svg');
+  assert.equal(manifest.capabilities.streaming, true);
+  assert.equal(manifest.capabilities.thinking, true);
+  assert.equal(manifest.capabilities.tools, true);
+  assert.equal(manifest.capabilities.approvals, true);
+  assert.equal(manifest.capabilities.questions, true);
+  assert.equal(manifest.capabilities.models, true);
+  assert.equal(manifest.capabilities.thinkingLevels, true);
+  assert.equal(manifest.capabilities.permissionModes, true);
+  assert.equal(manifest.capabilities.resume, true);
+  assert.equal(manifest.capabilities.fork, true);
+  assert.equal(manifest.capabilities.forkFromMessage, true);
+  assert.equal(manifest.capabilities.attachments, true);
+
+  // 2. parseModelsOutput
+  const sampleModelsOutput = `
+Fetching available models...
+gemini-3.8-flash-high\tGemini 3.8 Flash (High)
+gemini-3.8-flash-medium\tGemini 3.8 Flash (Medium)
+gemini-3.8-flash-low\tGemini 3.8 Flash (Low)
+gemini-3.1-pro-high\tGemini 3.1 Pro (High)
+gemini-3.1-pro-low\tGemini 3.1 Pro (Low)
+claude-sonnet-4-6\tClaude Sonnet 4.6 (Thinking)
+gpt-oss-120b-medium\tGPT-OSS 120B (Medium)
+`;
+  const models = parseModelsOutput(sampleModelsOutput);
+  assert.ok(models.length >= 4);
+
+  const flash = models.find(m => m.id === 'gemini-3.8-flash');
+  assert.ok(flash);
+  assert.equal(flash.name, 'Gemini 3.8 Flash');
+  assert.equal(flash.provider, 'google');
+  assert.equal(flash.efforts.length, 3);
+  assert.equal(flash.efforts[0].id, 'low');
+  assert.equal(flash.efforts[2].id, 'high');
+  assert.equal(flash.defaultEffort, 'high');
+  assert.equal(flash.contextWindow, 1_048_576);
+  assert.equal(modelSupportsEffort(flash), true);
+
+  const claude = models.find(m => m.id === 'claude-sonnet-4-6');
+  assert.ok(claude);
+  assert.equal(claude.provider, 'anthropic');
+  assert.equal(claude.contextWindow, 200_000);
+  assert.equal(modelSupportsEffort(claude), false);
+  assert.equal(modelSupportsEffort({ id: 'claude-sonnet-4-6' }), false);
+
+  // 3. parseUsage
+  const usage = parseUsage({
+    input_tokens: 1200,
+    output_tokens: 300,
+    thinking_tokens: 150,
+    total_tokens: 1650,
+    context_used_tokens: 25000,
+  }, 'gemini-3.8-flash');
+  assert.equal(usage.inputTokens, 1200);
+  assert.equal(usage.outputTokens, 300);
+  assert.equal(usage.reasoningOutputTokens, 150);
+  assert.equal(usage.contextWindow, 1_048_576);
+  assert.equal(usage.tokens, 25000);
+  assert.ok(usage.contextPercent > 2.3 && usage.contextPercent < 2.5);
+
+  // 4. formatPrompt
+  const rawPrompt = '帮我修改 app.js';
+  const formatted = formatPrompt(rawPrompt);
+  assert.ok(formatted.includes('write_to_file'));
+  assert.ok(formatted.includes('replace_file_content'));
+  assert.ok(formatted.includes(rawPrompt));
+
+  // Slash commands / already instruction formatted should not duplicate
+  assert.equal(formatPrompt('/usage'), '/usage');
+  assert.equal(formatPrompt(formatted), formatted);
+
+  // 5. Adapter lifecycle and Session
+  const adapter = create(() => {});
+  assert.equal(typeof adapter.open, 'function');
+  assert.equal(typeof adapter.send, 'function');
+  assert.equal(typeof adapter.cancel, 'function');
+  assert.equal(typeof adapter.close, 'function');
+  assert.equal(typeof adapter.respond, 'function');
+  assert.equal(typeof adapter.fork, 'function');
+  assert.equal(typeof adapter.listModelsFor, 'function');
+  assert.equal(typeof adapter.setModel, 'function');
+  assert.equal(typeof adapter.setThinkingLevel, 'function');
+  assert.equal(typeof adapter.setPermissionMode, 'function');
+
+  // 6. Inspect
+  const inspection = await adapter.inspect();
+  assert.ok(typeof inspection.available === 'boolean');
+  assert.ok(typeof inspection.detail === 'string');
+
+  // 7. Open session
+  const openEvents = [];
+  const session = await adapter.open({
+    thread: {
+      id: 'thread-1',
+      nativeSessionId: 'conv-12345',
+      cwd: 'E:\\harness-mix',
+      restore: true,
+      options: {
+        model: { id: 'gemini-3.8-flash', name: 'Gemini 3.8 Flash' },
+        thinking: 'medium',
+        permissionMode: 'desktop',
+      },
+    },
+    emit: (event) => openEvents.push(event),
+    diagnostic: () => {},
+  });
+  assert.equal(session.nativeSessionId, 'conv-12345');
+  assert.equal(session.thinkingLevel, 'medium');
+  assert.equal(session.permissionMode, 'desktop');
+  assert.ok(openEvents.some(e => e.kind === 'session' && e.nativeSessionId === 'conv-12345'));
+
+  // 8. setModel, setThinkingLevel, setPermissionMode
+  await adapter.setModel(session, { id: 'gemini-3.1-pro', name: 'Gemini 3.1 Pro' });
+  assert.equal(session.model.id, 'gemini-3.1-pro');
+  await adapter.setThinkingLevel(session, 'high');
+  assert.equal(session.thinkingLevel, 'high');
+  await adapter.setPermissionMode(session, 'skip');
+  assert.equal(session.permissionMode, 'skip');
+
+  // 9. Describe
+  const desc = await adapter.describe();
+  assert.ok(Array.isArray(desc.models));
+  assert.equal(desc.thinkingLevels.length, 3);
+  assert.equal(desc.permissionModes.length, 3);
+
+  // 10. Fork session
+  const forkEvents = [];
+  const forked = await adapter.fork({
+    id: 'thread-1',
+    nativeSessionId: 'conv-12345',
+    cwd: 'E:\\harness-mix',
+    model: { id: 'gemini-3.8-flash', name: 'Gemini 3.8 Flash' },
+    options: { thinking: 'high', permissionMode: 'default' },
+  }, {
+    emit: (e) => forkEvents.push(e),
+    diagnostic: () => {},
+  });
+  assert.ok(forked.nativeSessionId);
+  assert.notEqual(forked.nativeSessionId, 'conv-12345');
+  assert.equal(forked.session.nativeSessionId, forked.nativeSessionId);
+  assert.ok(forkEvents.some(e => e.kind === 'session' && e.nativeSessionId === forked.nativeSessionId));
+
+  // 11. Image attachments
+  const tmpRoot = path.join(os.tmpdir(), `agy-attach-test-${Date.now()}`);
+  await fs.promises.mkdir(tmpRoot, { recursive: true });
+  const localImg = path.join(tmpRoot, 'test.png');
+  await fs.promises.writeFile(localImg, Buffer.from('iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAQAAAC1HAwCAAAAC0lEQVR42mP8/x8AAwMCAO+jRZkAAAAASUVORK5CYII=', 'base64'));
+  const prepared = await prepareImageAttachments([
+    { name: 'test.png', path: localImg },
+    { name: 'inline.png', mime: 'image/png', data: 'iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAQAAAC1HAwCAAAAC0lEQVR42mP8/x8AAwMCAO+jRZkAAAAASUVORK5CYII=' },
+  ], tmpRoot);
+  assert.equal(prepared.imageEntries.length, 2);
+  assert.equal(prepared.imageEntries[0].name, 'test.png');
+  assert.notEqual(prepared.imageEntries[0].path, localImg.replace(/\\/g, '/'));
+  assert.match(prepared.imageEntries[0].path, /[\\/]\.gemini[\\/]attachments[\\/]/);
+  assert.equal(fs.readFileSync(prepared.imageEntries[0].path).toString('base64'), 'iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAQAAAC1HAwCAAAAC0lEQVR42mP8/x8AAwMCAO+jRZkAAAAASUVORK5CYII=');
+  assert.ok(fs.existsSync(prepared.imageEntries[1].path));
+  await fs.promises.unlink(localImg);
+  assert.ok(fs.existsSync(prepared.imageEntries[0].path));
+  const legacyPath = path.join(os.tmpdir(), `codex-clipboard-legacy-${Date.now()}.png`);
+  await fs.promises.rm(legacyPath, { force: true }).catch(() => {});
+  const legacySession = await adapter.open({
+    thread: {
+      id: 'legacy-image-thread',
+      nativeSessionId: 'legacy-image-session',
+      cwd: tmpRoot,
+      messages: [{ role: 'user', attachments: [{ kind: 'image', path: legacyPath, data: 'iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAQAAAC1HAwCAAAAC0lEQVR42mP8/x8AAwMCAO+jRZkAAAAASUVORK5CYII=' }] }],
+      options: {},
+    },
+    emit: () => {},
+    diagnostic: () => {},
+  });
+  assert.equal(fs.readFileSync(legacyPath).toString('base64'), 'iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAQAAAC1HAwCAAAAC0lEQVR42mP8/x8AAwMCAO+jRZkAAAAASUVORK5CYII=');
+  await adapter.close(legacySession);
+  await fs.promises.unlink(legacyPath).catch(() => {});
+  await fs.promises.rm(tmpRoot, { recursive: true, force: true }).catch(() => {});
+
+  // 12. mergePendingStep
+  const { mergePendingStep, cloneDatabase } = antigravity;
+  const activeStep = {
+    step_index: 2,
+    state: 'ACTIVE',
+    step_type: 'tool',
+    tool_name: 'write_to_file',
+    tool_info: {
+      name: 'write_to_file',
+      parameters: { TargetFile: 'test.txt', Description: 'create file' },
+    },
+  };
+  const doneStep = {
+    step_index: 2,
+    state: 'DONE',
+    step_type: 'tool',
+    tool_info: {
+      output: 'File written successfully',
+    },
+  };
+  const merged = mergePendingStep(activeStep, doneStep);
+  assert.equal(merged.state, 'DONE');
+  assert.equal(merged.tool_name, 'write_to_file');
+  assert.equal(merged.tool_info.name, 'write_to_file');
+  assert.equal(merged.tool_info.parameters.TargetFile, 'test.txt');
+  assert.equal(merged.tool_info.output, 'File written successfully');
+
+  // 13. cloneDatabase with message turn pruning and summaries.db
+  const mockHome = path.join(os.tmpdir(), `agy-mock-home-${Date.now()}`);
+  const convDir = path.join(mockHome, '.gemini', 'antigravity-cli', 'conversations');
+  await fs.promises.mkdir(convDir, { recursive: true });
+  const { DatabaseSync } = require('node:sqlite');
+  const sourceDbPath = path.join(convDir, 'source-conv.db');
+  const db = new DatabaseSync(sourceDbPath);
+  db.exec(`
+    CREATE TABLE trajectory_meta (cascade_id TEXT);
+    INSERT INTO trajectory_meta VALUES ('source-conv');
+    CREATE TABLE steps (idx INTEGER PRIMARY KEY, step_type INTEGER);
+    INSERT INTO steps VALUES (1, 14), (2, 1), (3, 14), (4, 1);
+    CREATE TABLE gen_metadata (idx INTEGER PRIMARY KEY);
+    INSERT INTO gen_metadata VALUES (0), (1);
+    CREATE TABLE executor_metadata (idx INTEGER PRIMARY KEY);
+    INSERT INTO executor_metadata VALUES (0), (1);
+    CREATE TABLE parent_references (idx INTEGER PRIMARY KEY);
+    INSERT INTO parent_references VALUES (0), (1);
+    CREATE TABLE battle_mode_infos (idx INTEGER PRIMARY KEY);
+    INSERT INTO battle_mode_infos VALUES (0), (1);
+  `);
+  db.close();
+
+  const sumDbPath = path.join(mockHome, '.gemini', 'antigravity-cli', 'conversation_summaries.db');
+  const sumDb = new DatabaseSync(sumDbPath);
+  sumDb.exec(`
+    CREATE TABLE conversation_summaries (conversation_id TEXT PRIMARY KEY, title TEXT, step_count INTEGER, last_modified_time TEXT);
+    INSERT INTO conversation_summaries VALUES ('source-conv', 'Test Session', 4, '2026-09-01T00:00:00.000Z');
+  `);
+  sumDb.close();
+
+  const clonedOk = await cloneDatabase('source-conv', 'derived-conv', 1, mockHome);
+  assert.equal(clonedOk, true);
+
+  const derivedDb = new DatabaseSync(path.join(convDir, 'derived-conv.db'));
+  const meta = derivedDb.prepare('SELECT cascade_id FROM trajectory_meta').get();
+  assert.equal(meta.cascade_id, 'derived-conv');
+  const remainingSteps = derivedDb.prepare('SELECT count(*) as c FROM steps').get();
+  assert.equal(remainingSteps.c, 2); // only first turn retained
+  derivedDb.close();
+
+  const sumDbCheck = new DatabaseSync(sumDbPath);
+  const sumRow = sumDbCheck.prepare('SELECT * FROM conversation_summaries WHERE conversation_id = ?').get('derived-conv');
+  assert.ok(sumRow);
+  assert.equal(sumRow.title, 'Test Session');
+  assert.equal(sumRow.step_count, 2);
+  sumDbCheck.close();
+
+  await fs.promises.rm(mockHome, { recursive: true, force: true }).catch(() => {});
+
+  // 14. Quota and Credits parsing
+  const mockUsageCommand = {
+    name: 'usage',
+    data: {
+      groups: [
+        {
+          name: 'Gemini Models',
+          buckets: [
+            { id: 'gemini-weekly', name: 'Weekly Limit', window: 'weekly', remaining_fraction: 0.45, reset_time: '2026-09-16T01:12:46Z' },
+            { id: 'gemini-5h', name: '5-Hour Limit', window: '5h', remaining_fraction: 0.80, reset_time: '2026-09-12T14:45:59Z' },
+          ],
+        },
+      ],
+    },
+  };
+  const { parseAntigravityUsageCommand } = antigravity;
+  const quotaSnapshot = parseAntigravityUsageCommand(mockUsageCommand);
+  assert.ok(quotaSnapshot);
+  assert.equal(quotaSnapshot.periodType, 'weekly');
+  assert.equal(quotaSnapshot.usedPercent, 55); // (1 - 0.45) * 100
+  assert.equal(quotaSnapshot.resetsAt, '2026-09-16T01:12:46Z');
+  assert.ok(Array.isArray(quotaSnapshot.productUsage));
+  assert.equal(quotaSnapshot.productUsage[0].usagePercent, 20); // (1 - 0.8) * 100
+
+  // 15. Native result failures must be visible instead of becoming an empty
+  // successful turn. This is the real error returned by agy 1.2.2 for an
+  // unsupported API location.
+  const locationError = formatAntigravityResultError({
+    status: 'ERROR',
+    error: { code: 'FAILED_PRECONDITION', message: 'User location is not supported for the API use.' },
+  });
+  assert.equal(locationError, 'Antigravity 回合失败：FAILED_PRECONDITION: User location is not supported for the API use.');
+
+  const errorChild = new EventEmitter();
+  errorChild.stdin = new PassThrough();
+  errorChild.stdout = new PassThrough();
+  errorChild.stderr = new PassThrough();
+  let errorCommandArgs = [];
+  let errorClosed = false;
+  const closeErrorChild = () => {
+    if (errorClosed) return;
+    errorClosed = true;
+    errorChild.stdout.end();
+    errorChild.stderr.end();
+    errorChild.emit('close', 0);
+  };
+  errorChild.stdin.once('data', () => setTimeout(() => {
+    if (!errorClosed) errorChild.stdout.write(`${JSON.stringify({
+      event: 'result',
+      result: {
+        conversation_id: 'fake-location-error',
+        status: 'ERROR',
+        error: { code: 'FAILED_PRECONDITION', message: 'User location is not supported for the API use.' },
+      },
+    })}\n`);
+  }, 1));
+  errorChild.stdin.once('finish', () => setTimeout(closeErrorChild, 0));
+  errorChild.kill = closeErrorChild;
+  const errorAdapter = create(() => {}, { spawnProcess: (_bin, args) => { errorCommandArgs = args; return errorChild; }, resultDrainMs: 10, resultDrainMaxMs: 30 });
+  const errorSession = await errorAdapter.open({
+    thread: { id: 'fake-error-thread', cwd: os.tmpdir(), options: { model: { id: 'claude-sonnet-4-6' }, thinking: 'high', permissionMode: 'skip' } },
+    emit: () => {},
+    diagnostic: () => {},
+  });
+  const errorEvents = [];
+  await assert.rejects(
+    errorAdapter.send(errorSession, 'return an error', { emit: event => errorEvents.push(event) }),
+    /User location is not supported for the API use/,
+  );
+  const errorEvent = errorEvents.find(event => event.kind === 'error');
+  assert.equal(errorEvent?.message, locationError);
+  assert.equal(errorCommandArgs.includes('--effort'), false);
+  assert.equal(errorEvents.some(event => event.kind === 'completed'), false);
+  assert.equal(errorSession.activeTurn, null);
+  await errorAdapter.close(errorSession);
+
+  // 16. A clean process exit without any result is also a protocol failure.
+  const noResultChild = new EventEmitter();
+  noResultChild.stdin = new PassThrough();
+  noResultChild.stdout = new PassThrough();
+  noResultChild.stderr = new PassThrough();
+  let noResultClosed = false;
+  const closeNoResultChild = () => {
+    if (noResultClosed) return;
+    noResultClosed = true;
+    noResultChild.stdout.end();
+    noResultChild.stderr.end();
+    noResultChild.emit('close', 0);
+  };
+  noResultChild.stdin.once('data', () => setTimeout(closeNoResultChild, 1));
+  noResultChild.kill = closeNoResultChild;
+  const noResultAdapter = create(() => {}, { spawnProcess: () => noResultChild });
+  const noResultSession = await noResultAdapter.open({
+    thread: { id: 'fake-no-result-thread', cwd: os.tmpdir(), options: { permissionMode: 'skip' } },
+    emit: () => {},
+    diagnostic: () => {},
+  });
+  const noResultEvents = [];
+  await assert.rejects(
+    noResultAdapter.send(noResultSession, 'return nothing', { emit: event => noResultEvents.push(event) }),
+    /未返回 result/,
+  );
+  assert.match(noResultEvents.find(event => event.kind === 'error')?.message || '', /未返回 result/);
+  assert.equal(noResultEvents.some(event => event.kind === 'completed'), false);
+  assert.equal(noResultSession.activeTurn, null);
+  await noResultAdapter.close(noResultSession);
+
+  // 17. A SUCCESS result with no assistant text must not be reported as a
+  // successful empty turn.
+  const emptySuccessChild = new EventEmitter();
+  emptySuccessChild.stdin = new PassThrough();
+  emptySuccessChild.stdout = new PassThrough();
+  emptySuccessChild.stderr = new PassThrough();
+  let emptySuccessClosed = false;
+  const closeEmptySuccessChild = () => {
+    if (emptySuccessClosed) return;
+    emptySuccessClosed = true;
+    emptySuccessChild.stdout.end();
+    emptySuccessChild.stderr.end();
+    emptySuccessChild.emit('close', 0);
+  };
+  emptySuccessChild.stdin.once('data', () => setTimeout(() => {
+    if (!emptySuccessClosed) emptySuccessChild.stdout.write(`${JSON.stringify({
+      event: 'result',
+      result: { conversation_id: 'fake-empty-success', status: 'SUCCESS', response: '' },
+    })}\n`);
+  }, 1));
+  emptySuccessChild.stdin.once('finish', () => setTimeout(closeEmptySuccessChild, 0));
+  emptySuccessChild.kill = closeEmptySuccessChild;
+  const emptySuccessAdapter = create(() => {}, { spawnProcess: () => emptySuccessChild, resultDrainMaxMs: 20 });
+  const emptySuccessSession = await emptySuccessAdapter.open({
+    thread: { id: 'fake-empty-success-thread', cwd: os.tmpdir(), options: { permissionMode: 'skip' } },
+    emit: () => {},
+    diagnostic: () => {},
+  });
+  const emptySuccessEvents = [];
+  await assert.rejects(
+    emptySuccessAdapter.send(emptySuccessSession, 'return an empty success', { emit: event => emptySuccessEvents.push(event) }),
+    /没有 assistant 文本/,
+  );
+  assert.match(emptySuccessEvents.find(event => event.kind === 'error')?.message || '', /没有 assistant 文本/);
+  assert.equal(emptySuccessEvents.some(event => event.kind === 'completed'), false);
+  assert.equal(emptySuccessSession.activeTurn, null);
+  await emptySuccessAdapter.close(emptySuccessSession);
+
+  // 18. An empty view_file result must not close the Core turn before a late
+  // assistant response. This is the stream shape produced for image files by
+  // agy: the terminal tool step has no tool_info.output field.
+  const fakeChild = new EventEmitter();
+  fakeChild.stdin = new PassThrough();
+  fakeChild.stdout = new PassThrough();
+  fakeChild.stderr = new PassThrough();
+  let fakePrompt = '';
+  let fakeClosed = false;
+  const closeFakeChild = () => {
+    if (fakeClosed) return;
+    fakeClosed = true;
+    fakeChild.stdout.end();
+    fakeChild.stderr.end();
+    fakeChild.emit('close', 0);
+  };
+  fakeChild.stdin.once('data', (chunk) => {
+    fakePrompt = JSON.parse(String(chunk).trim()).message?.content || '';
+    const emit = (event, delay = 0) => setTimeout(() => {
+      if (!fakeClosed) fakeChild.stdout.write(`${JSON.stringify(event)}\n`);
+    }, delay);
+    emit({ event: 'init', conversation_id: 'fake-empty-view-file' });
+    emit({
+      event: 'step_update',
+      step_update: {
+        conversation_id: 'fake-empty-view-file',
+        step_index: 0,
+        state: 'DONE',
+        step_type: 'agent_response',
+        text_delta: 'checking image... ',
+      },
+    }, 1);
+    emit({
+      event: 'step_update',
+      step_update: {
+        conversation_id: 'fake-empty-view-file',
+        step_index: 1,
+        state: 'ACTIVE',
+        step_type: 'tool',
+        tool_name: 'view_file',
+        tool_info: { name: 'view_file', parameters: { AbsolutePath: 'image.png' } },
+      },
+    }, 5);
+    emit({
+      event: 'step_update',
+      step_update: {
+        conversation_id: 'fake-empty-view-file',
+        step_index: 1,
+        state: 'DONE',
+        step_type: 'tool',
+        tool_name: 'view_file',
+        tool_info: { name: 'view_file', parameters: { AbsolutePath: 'image.png' } },
+      },
+    }, 10);
+    emit({
+      event: 'result',
+      result: {
+        conversation_id: 'fake-empty-view-file',
+        status: 'SUCCESS',
+        num_turns: 1,
+        response: '',
+      },
+    }, 15);
+    emit({
+      event: 'step_update',
+      step_update: {
+        conversation_id: 'fake-empty-view-file',
+        step_index: 2,
+        state: 'DONE',
+        step_type: 'agent_response',
+        text_delta: 'late answer',
+      },
+    }, 70);
+  });
+  fakeChild.stdin.once('finish', () => setTimeout(closeFakeChild, 0));
+  fakeChild.kill = closeFakeChild;
+  const fakeAdapter = create(() => {}, {
+    spawnProcess: () => fakeChild,
+    resultDrainMs: 20,
+    resultDrainMaxMs: 250,
+  });
+  const fakeCwd = path.join(os.tmpdir(), `agy-empty-view-file-${Date.now()}`);
+  const fakeImagePath = path.join(fakeCwd, 'codex-clipboard-stale.png');
+  const tinyPng = 'iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAQAAAC1HAwCAAAAC0lEQVR42mP8/x8AAwMCAO+jRZkAAAAASUVORK5CYII=';
+  await fs.promises.mkdir(fakeCwd, { recursive: true });
+  await fs.promises.writeFile(fakeImagePath, Buffer.from(tinyPng, 'base64'));
+  const fakeSession = await fakeAdapter.open({
+    thread: { id: 'fake-thread', cwd: fakeCwd, options: { permissionMode: 'skip' } },
+    emit: () => {},
+    diagnostic: () => {},
+  });
+  const fakeEvents = [];
+  await fakeAdapter.send(fakeSession, 'inspect image', { emit: event => fakeEvents.push(event) }, {
+    images: [{ name: 'codex-clipboard-stale.png', path: fakeImagePath, data: tinyPng }],
+  });
+  assert.match(fakePrompt, /[\\/]\.gemini[\\/]attachments[\\/]/);
+  assert.ok(!fakePrompt.includes(fakeImagePath.replace(/\\/g, '/')));
+  await fs.promises.unlink(fakeImagePath);
+  const fakeTool = fakeEvents.filter(event => event.kind === 'tool').at(-1);
+  assert.equal(fakeTool?.title, 'view_file');
+  assert.equal(fakeTool?.state, 'done');
+  assert.equal(fakeTool?.output, undefined);
+  assert.equal(fakeEvents.filter(event => event.kind === 'text-delta').map(event => event.text).join(''), 'checking image... late answer');
+  assert.ok(fakeEvents.findIndex(event => event.kind === 'text-delta') < fakeEvents.findIndex(event => event.kind === 'completed'));
+  await fakeAdapter.close(fakeSession);
+  await fs.promises.rm(fakeCwd, { recursive: true, force: true }).catch(() => {});
+
+  // 19. Close session
+  await adapter.close(session);
+
+  console.log('antigravity adapter: manifest, models catalog, usage projection, quota/credits, prompt formatting, image attachments, session lifecycle, model switching, describe, fork, step merging, and turn pruning passed');
+})().catch((err) => {
+  console.error(err);
+  process.exitCode = 1;
+});

package/scripts/architecture-test.cjs

@@ -0,0 +1,62 @@
+// P0-10 / §55：Architecture Guard —— 静态检查 Core 边界，防止 Harness 泄漏。
+// 规则：
+//   1. protocol-core/ 与 shared-contracts/ 不得 import adapters/*
+//   2. 上述目录不得出现 'pi' / 'claude' / 'dsh' 字面量（Harness 名称分支）
+//   3. harness-adapter/event-normalizer 同样保持 Harness 名称零感知
+const { readdirSync, statSync, readFileSync } = require('node:fs');
+const { join, relative } = require('node:path');
+
+const GUARDED_DIRS = ['src/main/protocol-core', 'src/main/shared-contracts', 'src/main/harness-adapter'];
+const FORBIDDEN_PATTERNS = [
+  { re: /require\(['"`][^'"`]*adapters[/-]/, label: 'import from adapters/*' },
+  { re: /require\(['"`][^'"`]*renderer[/-]/, label: 'import from renderer/*' },
+  { re: /(['"`])(pi|claude|dsh)\1/, label: 'harness name literal' },
+];
+
+function* walk(dir) {
+  for (const entry of readdirSync(dir)) {
+    const full = join(dir, entry);
+    if (statSync(full).isDirectory()) yield* walk(full);
+    else if (/\.js$/.test(entry)) yield full;
+  }
+}
+
+let violations = 0;
+for (const dir of GUARDED_DIRS) {
+  for (const file of walk(dir)) {
+    const source = readFileSync(file, 'utf8');
+    for (const { re, label } of FORBIDDEN_PATTERNS) {
+      const match = source.match(re);
+      if (match) {
+        violations++;
+        console.error(`VIOLATION ${relative('.', file)}: ${label} (${match[0]})`);
+      }
+    }
+  }
+}
+
+for (const file of walk('src/main/adapters')) {
+  if (/require\(['"`][^'"`]*renderer[/-]/.test(readFileSync(file, 'utf8'))) {
+    violations++; console.error(`VIOLATION ${file}: adapter imports Renderer`);
+  }
+}
+for (const file of walk('src')) {
+  if (/require\(['"`][^'"`]*(?:legacy[-/]|scripts\/support)/.test(readFileSync(file, 'utf8'))) {
+    violations++; console.error(`VIOLATION ${file}: production imports legacy test oracle`);
+  }
+}
+for (const file of ['src/main/host/runtime.js']) {
+  if (/(['"`])(pi|claude|dsh)\1/.test(readFileSync(file, 'utf8'))) {
+    violations++; console.error(`VIOLATION ${file}: execution branches on harness name`);
+  }
+}
+if (/PROTOCOL_CORE_(SHADOW|RENDERER)|finishMessage|ensureAssistantMessage/.test(readFileSync('src/main/host/runtime.js', 'utf8'))) {
+  violations++; console.error('VIOLATION Runtime retains legacy execution path');
+}
+
+if (violations) {
+  console.error(`architecture: ${violations} violation(s)`);
+  process.exitCode = 1;
+} else {
+  console.log(`architecture: core boundaries clean (${GUARDED_DIRS.join(', ')})`);
+}

package/scripts/build-native.cjs

@@ -0,0 +1,56 @@
+const fs = require('node:fs');
+const path = require('node:path');
+const { execFileSync } = require('node:child_process');
+const esbuild = require('esbuild');
+const os = require('node:os');
+const { executableName } = require('../src/main/native/platform');
+const { getAllIconsDictionary, MODEL_FAMILIES } = require('../src/main/native/icons');
+const root = path.resolve(__dirname, '..');
+const out = path.join(root, 'output/native-build');
+
+function cargoCommand() {
+  const candidates = ['cargo', path.join(os.homedir(), '.cargo/bin', executableName('cargo'))];
+  for (const candidate of candidates) {
+    try {
+      execFileSync(candidate, ['--version'], { stdio: 'ignore', windowsHide: true });
+      return candidate;
+    } catch { /* try the next candidate */ }
+  }
+  throw new Error('Rust toolchain (cargo) not found; install via https://rustup.rs (use the x86_64-pc-windows-gnu host when Visual Studio Build Tools are absent)');
+}
+
+async function main() {
+  fs.mkdirSync(out, { recursive: true });
+  const alias = { '@codexhost/shared-contracts': path.join(root, 'src/native-ui/shared-contracts/src/index.ts') };
+  const common = { bundle: true, alias, logLevel: 'warning', target: 'es2024' };
+  const icons = getAllIconsDictionary();
+  icons.harnesses['claude-code'] = icons.harnesses.claude;
+  icons.harnesses['deepseek-harness'] = icons.harnesses.dsh;
+  await esbuild.build({ ...common, entryPoints: ['src/native-ui/renderer-extension/src/production-entry.ts'],
+    platform: 'browser', format: 'iife', outfile: path.join(out, 'renderer-extension.js'),
+    loader: { '.svg': 'dataurl', '.png': 'dataurl', '.css': 'text' },
+    banner: { js: `globalThis.__HARNESS_MIX_ICONS__=${JSON.stringify(icons)};globalThis.__HARNESS_MIX_MODEL_FAMILIES__=${JSON.stringify(MODEL_FAMILIES.map(f => ({ id: f.id, pattern: f.regex.source })))};` } });
+  await esbuild.build({ ...common, entryPoints: ['src/native-ui/desktop-control/src/release-main.ts'],
+    platform: 'node', format: 'esm', outfile: path.join(out, 'desktop-controller.mjs') });
+  execFileSync(cargoCommand(), ['build', '--release', '--manifest-path', path.join(root, 'src/main/native/rs/Cargo.toml'),
+    ...(process.platform === 'win32' ? [] : ['--package', 'harness-mix-shim'])], { stdio: 'inherit', windowsHide: true });
+  const target = path.join(root, 'src/main/native/rs/target/release');
+  for (const exe of process.platform === 'win32' ? ['harness-mix-shim.exe', 'harness-mix-appx.exe', 'harness-mix-secret.exe'] : ['harness-mix-shim']) {
+    const source = path.join(target, exe);
+    const destination = path.join(out, exe);
+    // An unchanged executable may be running while UI-only fixes are built.
+    try {
+      fs.copyFileSync(source, destination);
+      if (process.platform !== 'win32') fs.chmodSync(destination, 0o755);
+    } catch (err) {
+      if (err && err.code === 'EBUSY') {
+        console.warn(`[build:native] Notice: ${exe} is in use, keeping existing binary.`);
+      } else {
+        throw err;
+      }
+    }
+  }
+  fs.writeFileSync(path.join(out, 'node-path.txt'), process.execPath);
+  console.log('Harness Mix local Renderer, Desktop Controller and Shim built.');
+}
+main().catch(error => { console.error(error); process.exitCode = 1; });

package/scripts/catalog-test.cjs

@@ -0,0 +1,25 @@
+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');
+(async () => {
+  const dir = await fs.mkdtemp(path.join(os.tmpdir(), 'hm-catalog-'));
+  const rt = new HostRuntime({ dataDirectory: dir });
+  try {
+    await rt.initialize();
+    for (const harnessId of ['pi', 'dsh']) {
+      const thread = await rt.createThread({ harnessId, cwd: dir });
+      const session = rt.sessions.get(thread.id);
+      const catalog = await rt.describe(harnessId);
+      assert.ok(catalog.models.length, harnessId + ' live model catalog');
+      assert.equal(rt.sessions.get(thread.id), session);
+      assert.equal(await rt.describe(harnessId), catalog, 'cached catalog reused');
+      await session.adapter.close(session); rt.sessions.delete(thread.id);
+      const commands = await rt.listCommands({ threadId: thread.id });
+      assert.equal(rt.sessions.has(thread.id), false, 'menu never restores session');
+      if (harnessId === 'pi') assert.ok(commands.some(c => c.id === 'compact'));
+    }
+    console.log('native Pi/DSH catalogs reused; command menu does not restore sessions');
+  } finally { await rt.close(); }
+})().catch(error => { console.error(error); process.exitCode = 1; });