carthagent 1.0.7 → 1.1.0-beta.2

package/tools/test-native-host.mjs

@@ -2,7 +2,7 @@
 /** Offline real-host test. Uses a disposable HOME and never discovers the user's service. */
 import assert from 'node:assert/strict';
 import { mkdtemp, mkdir, writeFile, rm, readFile } from 'node:fs/promises';
-import { join, resolve } from 'node:path';
+import { dirname, join, resolve } from 'node:path';
 import { tmpdir } from 'node:os';
 import { execFile, spawn } from 'node:child_process';
 import { createServer } from 'node:http';
@@ -10,14 +10,29 @@ import { once } from 'node:events';
 import { randomBytes } from 'node:crypto';
 import { promisify } from 'node:util';
 import { OpenCode } from '@opencode/client';
-import { resolveOpenCode } from '../lib/opencode/runtime.mjs';
+import { resolveOpenCode, runtimeIdentity as getRuntimeIdentity } from '../lib/opencode/runtime.mjs';
+import { loadNativeTestRuntime, preflightNativeTestRuntimeArtifact } from './native-runtime-identity.mjs';
 import { cancelSession } from '../lib/opencode/service.mjs';
 import { runHeadless } from '../lib/opencode/headless.mjs';
 
 const root = resolve(import.meta.dirname, '..');
 const plugin = resolve(process.argv[2] ?? join(root, 'plugins/carthagent'));
-const archiveFixture = resolve(root, 'tests/fixtures/archive-plugin');
-const binary = await resolveOpenCode();
+const runtimeOptions = {};
+if (process.env.CTG_TEST_RUNTIME_RELEASE_MANIFEST) {
+  runtimeOptions.runtimeReleaseManifestPath = process.env.CTG_TEST_RUNTIME_RELEASE_MANIFEST;
+}
+if (process.env.CTG_TEST_RUNTIME_ARTIFACT_ROOT) {
+  await preflightNativeTestRuntimeArtifact({
+    ownedRoot: process.env.CTG_TEST_RUNTIME_ARTIFACT_ROOT,
+    expectedManifestPath: process.env.CTG_TEST_RUNTIME_RELEASE_MANIFEST,
+  });
+  runtimeOptions.acquireOwnedRuntime = async () => process.env.CTG_TEST_RUNTIME_ARTIFACT_ROOT;
+}
+const binary = await resolveOpenCode(runtimeOptions);
+const productionIdentity = await getRuntimeIdentity(binary, runtimeOptions);
+const ownedRoot = productionIdentity.kind === 'ctg-owned' ? dirname(dirname(dirname(binary))) : undefined;
+const expectedManifest = ownedRoot ? JSON.parse(await readFile(process.env.CTG_TEST_RUNTIME_RELEASE_MANIFEST ?? join(root, 'lib/opencode/runtime-release.json'), 'utf8')) : undefined;
+const runtimeIdentity = await loadNativeTestRuntime({ binary, ownedRoot, expectedManifest });
 const execFileAsync = promisify(execFile);
 const temp = await mkdtemp(join(tmpdir(), 'ctg-host-smoke-'));
 const password = randomBytes(24).toString('hex');
@@ -25,35 +40,6 @@ const providerKey = `sentinel-${randomBytes(24).toString('hex')}`;
 let child;
 let childClosed = false;
 let output = '';
-let deviceAuthorizationBody;
-const gatewayAuth = [];
-const gatewayServer = createServer((request, response) => {
-  gatewayAuth.push({ authorization: request.headers.authorization, url: request.url });
-  response.writeHead(200, { 'content-type': 'application/json' });
-  response.end(JSON.stringify(request.url?.endsWith('/models')
-    ? { data: [{ id: 'sentinel-model' }] }
-    : { id: 'chatcmpl-sentinel', object: 'chat.completion', choices: [{ index: 0, message: { role: 'assistant', content: 'ok' }, finish_reason: 'stop' }], usage: { prompt_tokens: 1, completion_tokens: 1, total_tokens: 2 } }));
-});
-await new Promise((resolveListen, reject) => gatewayServer.listen(0, '127.0.0.1', resolveListen).once('error', reject));
-const gatewayAddress = gatewayServer.address();
-const authServer = createServer((request, response) => {
-  let body = '';
-  request.setEncoding('utf8').on('data', (chunk) => { body += chunk; });
-  request.on('end', () => {
-  if (request.url === '/v1/device/authorizations') {
-    deviceAuthorizationBody = JSON.parse(body);
-    response.writeHead(201, { 'content-type': 'application/json' });
-    response.end(JSON.stringify({ deviceCode: 'offline-device-code', userCode: 'OFFLINE', verificationUri: 'http://127.0.0.1/verify', expiresIn: 120, interval: 1 }));
-  } else if (request.url === '/v1/device/token') {
-    response.writeHead(400, { 'content-type': 'application/json' });
-    response.end(JSON.stringify({ error: 'authorization_pending' }));
-  } else {
-    response.writeHead(404).end();
-  }
-  });
-});
-await new Promise((resolveListen, reject) => authServer.listen(0, '127.0.0.1', resolveListen).once('error', reject));
-const authAddress = authServer.address();
 let fixtureRequests = 0;
 const fixture = createServer(async (req, res) => {
   fixtureRequests += 1;
@@ -93,27 +79,66 @@ const fixture = createServer(async (req, res) => {
   res.end('data: [DONE]\n\n');
 });
 await new Promise((resolveListen, reject) => fixture.once('error', reject).listen(0, '127.0.0.1', resolveListen));
+let deviceAuthorizationBody;
+const gatewayAuth = [];
+const gatewayServer = createServer((request, response) => {
+  gatewayAuth.push({ authorization: request.headers.authorization, url: request.url });
+  response.writeHead(200, { 'content-type': 'application/json' });
+  response.end(JSON.stringify(request.url?.endsWith('/models')
+    ? { data: [{ id: 'sentinel-model' }] }
+    : { id: 'chatcmpl-sentinel', object: 'chat.completion', choices: [{ index: 0, message: { role: 'assistant', content: 'ok' }, finish_reason: 'stop' }], usage: { prompt_tokens: 1, completion_tokens: 1, total_tokens: 2 } }));
+});
+await new Promise((resolveListen, reject) => gatewayServer.listen(0, '127.0.0.1', resolveListen).once('error', reject));
+const gatewayAddress = gatewayServer.address();
+const authServer = createServer((request, response) => {
+  let body = '';
+  request.setEncoding('utf8').on('data', (chunk) => { body += chunk; });
+  request.on('end', () => {
+  if (request.url === '/v1/device/authorizations') {
+    deviceAuthorizationBody = JSON.parse(body);
+    response.writeHead(201, { 'content-type': 'application/json' });
+    response.end(JSON.stringify({ deviceCode: 'offline-device-code', userCode: 'OFFLINE', verificationUri: 'http://127.0.0.1/verify', expiresIn: 120, interval: 1 }));
+  } else if (request.url === '/v1/device/token') {
+    response.writeHead(400, { 'content-type': 'application/json' });
+    response.end(JSON.stringify({ error: 'authorization_pending' }));
+  } else {
+    response.writeHead(404).end();
+  }
+  });
+});
+await new Promise((resolveListen, reject) => authServer.listen(0, '127.0.0.1', resolveListen).once('error', reject));
+const authAddress = authServer.address();
 try {
   const cwd = join(temp, 'project');
   const config = join(temp, 'config/opencode');
-  const homeConfig = join(temp, 'home/.config/opencode');
   const legacy = join(temp, 'home/.carthagent/agent/sessions');
+  const homeConfig = join(temp, 'home/.config/opencode');
+  const ancestorConfig = join(temp, '.opencode');
   await Promise.all([
-    mkdir(cwd), mkdir(config, { recursive: true }), mkdir(homeConfig, { recursive: true }), mkdir(legacy, { recursive: true }),
-    mkdir(join(temp, 'appdata'), { recursive: true }), mkdir(join(temp, 'localappdata'), { recursive: true }),
+    mkdir(cwd),
+    mkdir(config, { recursive: true }),
+    mkdir(legacy, { recursive: true }),
+    mkdir(join(temp, 'appdata'), { recursive: true }),
+    mkdir(join(temp, 'localappdata'), { recursive: true }),
+    mkdir(homeConfig, { recursive: true }),
+    mkdir(ancestorConfig, { recursive: true }),
   ]);
+  await writeFile(join(legacy, 'legacy.jsonl'), '{"type":"session","id":"legacy-fixture"}\n{"type":"message","message":{"role":"user","content":"fixture needle"}}\nmalformed\n');
   await writeFile(join(homeConfig, 'opencode.json'), JSON.stringify({ model: 'home-poison/model', plugins: ['home-poison-plugin'] }));
   await writeFile(join(cwd, 'opencode.json'), JSON.stringify({ model: 'project-poison/model', plugins: ['project-poison-plugin'] }));
-  await writeFile(join(legacy, 'legacy.jsonl'), '{"type":"session","id":"legacy-fixture"}\n{"type":"message","message":{"role":"user","content":"fixture needle"}}\nmalformed\n');
+  await writeFile(join(temp, 'opencode.json'), JSON.stringify({ model: 'ancestor-poison/model', plugins: ['ancestor-poison-plugin'] }));
+  await writeFile(join(ancestorConfig, 'opencode.json'), JSON.stringify({ model: 'hidden-ancestor-poison/model', plugins: ['hidden-ancestor-poison-plugin'] }));
   await writeFile(join(config, 'opencode.json'), JSON.stringify({
-    plugins: [plugin, archiveFixture], update: 'disable',
+    plugins: [plugin], update: 'disable',
     model: 'ctgfixture/fixture',
     providers: {
       ctgfixture: {
         name: 'CTG local prompt fixture',
         package: '@opencode/ai/providers/openai-compatible',
         settings: { baseURL: `http://127.0.0.1:${fixture.address().port}/v1` },
-        models: { fixture: { name: 'Fixture', limit: { context: 8192, output: 1024 } } },
+        // This fixture tests host attachment, not compaction; leave room for the
+        // production tool catalog and the preceding multi-turn wrapper checks.
+        models: { fixture: { name: 'Fixture', limit: { context: 32768, output: 1024 } } },
       },
     },
   }));
@@ -160,12 +185,12 @@ try {
   });
   const request = { signal: AbortSignal.timeout(90_000) };
   const info = await client.server.info(request);
-  assert.equal(info.version, '2.0.32');
+  assert.equal(info.version, runtimeIdentity.runtimeVersion);
   const isolationFetch = async (url, init) => {
     const response = await fetch(url, init);
     if (new URL(url).pathname === '/api/config') {
       const entries = await response.clone().json();
-      assert.ok(!entries.some((entry) => entry.type === 'document' && [join(homeConfig, 'opencode.json'), join(cwd, 'opencode.json')].includes(entry.path)), `home and workspace config must not be discovered: ${JSON.stringify(entries)}`);
+      assert.ok(!entries.some((entry) => entry.type === 'document' && [homeConfig, cwd, temp, ancestorConfig].map(directory => join(directory, 'opencode.json')).includes(entry.path)), `home, workspace and ancestor config must not be discovered: ${JSON.stringify(entries)}`);
       assert.ok(!JSON.stringify(entries).includes('poison'), `foreign config/plugin discovery must not leak into the CTG profile: ${JSON.stringify(entries)}`);
     }
     return response;
@@ -189,14 +214,14 @@ try {
   const deadline = Date.now() + 15_000;
   do {
     plugins = await client.plugin.list({ location: { directory: cwd } }, request);
-    if (plugins.data.some((entry) => entry.id === 'carthagent')) break;
+    const current = plugins.data.find((entry) => entry.id === 'carthagent');
+    if (current?.state.status === 'active') break;
+    if (current?.state.status === 'error') throw new Error(`Carthagent plugin setup failed: ${JSON.stringify(current)}`);
     await new Promise((done) => setTimeout(done, 200));
   } while (Date.now() < deadline);
   const nativePlugin = plugins.data.find((entry) => entry.id === 'carthagent');
-  const archivePlugin = plugins.data.find((entry) => entry.id === 'ctg-archive-fixture');
   assert.ok(nativePlugin, `Carthagent plugin must become visible: ${JSON.stringify(plugins.data)}`);
   assert.equal(nativePlugin.state.status, 'active');
-  assert.equal(archivePlugin?.state.status, 'active', 'archive registration fixture must become visible');
   const providers = await client.provider.list({ location: { directory: cwd } }, request);
   assert.ok(providers.data.some((provider) => provider.id === 'experiential-labs'),
     'plugin setup must register the Ship provider with the real host');
@@ -205,8 +230,10 @@ try {
   assert.ok(ship, 'the native provider catalog must supply a real Ship integration record');
   assert.ok(ship.methods.some(({ type, id }) => type === 'oauth' && id === 'carthagent-device'),
     'plugin integration transform must register the Ship device-OAuth method');
-  assert.ok(ship.methods.some(({ type }) => type === 'key'),
-    'plugin integration transform must register the Ship API-key method');
+  assert.equal(ship.methods.some(({ type }) => type === 'key'), false,
+    'fresh Cloud sign-in must hide the advanced API-key method');
+  assert.equal(ship.methods.find(({ type, id }) => type === 'oauth' && id === 'carthagent-device').form?.length ?? 0, 0,
+    'fresh Cloud sign-in must not prompt for legacy import');
   assert.ok(ship.methods.some(({ type, names }) => type === 'env' && names?.includes('EXPLABS_API_KEY')),
     'the native integration catalog resolves BYOK from the named environment credential');
   const models = await client.model.list({ location: { directory: cwd } }, request);
@@ -231,19 +258,10 @@ try {
   const health = await client.rpc.call({
     rpcID: 'carthagent', method: 'health', input: {}, location: { directory: cwd },
   }, request);
-  console.log(JSON.stringify({ version: info.version, plugin: nativePlugin, health }, null, 2));
+  assert.equal(health.output.hostVersion, runtimeIdentity.runtimeVersion);
+  console.log(JSON.stringify({ version: info.version, compatibilityVersion: runtimeIdentity.compatibilityVersion, plugin: nativePlugin, health }, null, 2));
   assert.equal(health.output.directory, cwd);
   assert.equal(health.output.protocol, 1);
-  const auth = await client.rpc.call({
-    rpcID: 'carthagent', method: 'authStart', input: {}, location: { directory: cwd },
-  }, request);
-  assert.equal(auth.output.userCode, 'OFFLINE');
-  assert.match(auth.output.flowId, /^[0-9a-f-]{36}$/);
-  assert.match(deviceAuthorizationBody.installId, /^[0-9a-f-]{36}$/);
-  assert.equal((await client.rpc.call({
-    rpcID: 'carthagent', method: 'authCancel', input: { flowId: auth.output.flowId }, location: { directory: cwd },
-  }, request)).output.cancelled, true);
-  console.log('Device authorization start/cancel RPC passed against offline OpenCode host.');
   const echo = await client.rpc.call({
     rpcID: 'carthagent', method: 'echo', input: { text: 'native RPC fixture' }, location: { directory: cwd },
   }, request);
@@ -303,7 +321,7 @@ try {
     attached.once('close', (code, signal) => {
       clearTimeout(timer);
       if (code === 0) resolveRun(stdout);
-      else reject(new Error(`Attached native CLI exited ${code ?? signal}: ${stderr}`));
+      else reject(new Error(`Attached native CLI exited ${code ?? signal}: ${stderr}\n${stdout}`));
     });
   });
   assert.match(attachedRun, /CTG_FIXTURE_OK/, 'the packaged CLI should attach to and prompt the ensured service');
@@ -327,6 +345,16 @@ try {
   } while (Date.now() < ptyDeadline);
   assert.equal(ptyState.data.status, 'running', 'native TUI should attach and remain active in the service-owned PTY');
   await client.pty.remove({ ptyID, location: { directory: cwd } }, request);
+  const auth = await client.rpc.call({
+    rpcID: 'carthagent', method: 'authStart', input: {}, location: { directory: cwd },
+  }, request);
+  assert.equal(auth.output.userCode, 'OFFLINE');
+  assert.match(auth.output.flowId, /^[0-9a-f-]{36}$/);
+  assert.match(deviceAuthorizationBody.installId, /^[0-9a-f-]{36}$/);
+  assert.equal((await client.rpc.call({
+    rpcID: 'carthagent', method: 'authCancel', input: { flowId: auth.output.flowId }, location: { directory: cwd },
+  }, request)).output.cancelled, true);
+  console.log('Device authorization start/cancel RPC passed against offline OpenCode host.');
   await assert.rejects(client.rpc.call({
     rpcID: 'carthagent', method: 'health', input: { unexpected: true }, location: { directory: cwd },
   }, request));
@@ -350,14 +378,14 @@ try {
   await assert.rejects(archiveCall('search', { query: '   ' }), (error) => error.type === 'archive_error');
   await assert.rejects(archiveCall('list', { limit: 101 }), (error) => error.type === 'rpc.invalid_input');
   assert.equal(await readFile(join(legacy, 'legacy.jsonl'), 'utf8'), '{"type":"session","id":"legacy-fixture"}\n{"type":"message","message":{"role":"user","content":"fixture needle"}}\nmalformed\n');
-  console.log('Native plugin, archive RPC methods, output schemas, and declared failures passed against OpenCode 2.0.32.');
+  console.log(`Native plugin, archive RPC methods, output schemas, and declared failures passed against OpenCode ${runtimeIdentity.runtimeVersion} (compatibility ${runtimeIdentity.compatibilityVersion}).`);
 } catch (error) {
   console.error(JSON.stringify({ fixtureRequests }));
   console.error(output.replaceAll(password, '[redacted]'));
   throw error;
 } finally {
   if (child) {
-    const closed = childClosed ? Promise.resolve() : once(child, 'close').then(() => { childClosed = true; });
+    const closed = childClosed ? Promise.resolve() : once(child, 'close');
     if (child.exitCode === null && child.signalCode === null) {
       if (process.platform === 'win32') {
         // This PID is the exact host process spawned above; /T is needed to
@@ -376,10 +404,8 @@ try {
       await closed;
     }
   }
-  await Promise.all([
-    new Promise((resolveClose) => authServer.close(resolveClose)),
-    new Promise((resolveClose) => gatewayServer.close(resolveClose)),
-    new Promise((resolveClose) => fixture.close(resolveClose)),
-  ]);
+  await new Promise((resolveClose) => fixture.close(resolveClose));
+  await new Promise((resolveClose) => authServer.close(resolveClose));
+  await new Promise((resolveClose) => gatewayServer.close(resolveClose));
   await rm(temp, { recursive: true, force: true, maxRetries: 12, retryDelay: 250 });
 }

package/tools/test-native-outcomes.mjs

@@ -21,6 +21,7 @@ const host = await nativeFixture({
     } else streamText(res);
   },
 });
+const identity = host.runtimeIdentity;
 
 async function bounded(promise, message) {
   let timer;
@@ -63,7 +64,8 @@ try {
   assert.ok(history.some(message => message.type === 'idle' && message.outcome === 'interrupted'));
   assert.equal(history.at(-1).outcome, 'succeeded');
   assert.deepEqual(host.providerErrors, []);
-  console.log(JSON.stringify({ host: '2.0.32', failure: 'passed', cancellation: 'passed',
+  console.log(JSON.stringify({ host: identity.runtimeVersion, compatibilityVersion: identity.compatibilityVersion,
+    ...(identity.binarySha256 ? { binarySha256: identity.binarySha256 } : {}), failure: 'passed', cancellation: 'passed',
     concurrentIsolation: 'passed', recovery: 'passed', queuedInterruption: 'passed', cancellationMs }));
 } catch (error) {
   console.error(host.output);

package/tools/test-native-package.mjs

@@ -1,70 +1,238 @@
 #!/usr/bin/env node
 /** Build and install the published artifact in isolation, then exercise its owned host. */
 import assert from 'node:assert/strict';
+import { createRequire } from 'node:module';
 import { spawnSync } from 'node:child_process';
-import { mkdir, mkdtemp, readFile, rm, stat, writeFile } from 'node:fs/promises';
+import { dirname, join as joinPath } from 'node:path';
+import { mkdir, mkdtemp, readFile, rm, stat } from 'node:fs/promises';
 import { tmpdir } from 'node:os';
 import { join, resolve } from 'node:path';
 import { fileURLToPath } from 'node:url';
+import { withoutRuntimeGithubToken } from './runtime-token-env.mjs';
 
 const root = resolve(fileURLToPath(new URL('..', import.meta.url)));
 const temp = await mkdtemp(join(tmpdir(), 'ctg-native-package-'));
+const focused = process.env.CTG_NATIVE_PACKAGE_TEST;
+const requireOwnedRuntime = process.argv.includes('--require-owned') || process.env.CTG_REQUIRE_OWNED_RUNTIME === '1';
+assert.ok(!requireOwnedRuntime || !focused, 'owned-runtime release acceptance cannot be narrowed to a focused probe');
 const run = (command, args, options = {}) => {
-  const result = spawnSync(command, args, { cwd: root, encoding: 'utf8', ...options });
+  const result = spawnSync(command, args, { cwd: root, encoding: 'utf8', timeout: 300_000, ...options });
+  if (result.error) throw new Error(`${command} ${args.join(' ')} failed: ${result.error.message}`, { cause: result.error });
   if (result.status !== 0) throw new Error(`${command} ${args.join(' ')} failed:\n${result.stdout}\n${result.stderr}`);
   return result.stdout;
 };
 
+// A package gate must exercise the normal installed-product acquisition path,
+// not a developer's binary, cache, profile, or running service. Keep every
+// OpenCode data location under this invocation's temporary directory.
+const env = { ...process.env };
+for (const key of Object.keys(env)) {
+  if (/^(?:CTG_OPENCODE_|CTG_OWNED_OPENCODE_RUNTIME$|CTG_RUNTIME_(?!GITHUB_TOKEN$)|CTG_TEST_|OPENCODE_|CARTHAGENT_(?:AGENT_DIR|CODING_AGENT_DIR|CONFIG|CLI)|PI_CODING_AGENT_DIR$)/i.test(key)) delete env[key];
+}
+const isolatedHome = join(temp, 'runtime-home');
+Object.assign(env, {
+  HOME: isolatedHome,
+  USERPROFILE: isolatedHome,
+  APPDATA: join(temp, 'appdata'),
+  LOCALAPPDATA: join(temp, 'localappdata'),
+  XDG_CONFIG_HOME: join(temp, 'config'),
+  XDG_DATA_HOME: join(temp, 'data'),
+  XDG_STATE_HOME: join(temp, 'state'),
+  XDG_CACHE_HOME: join(temp, 'cache'),
+  CTG_OPENCODE_HOME: join(temp, 'ctg-runtime'),
+  CARTHAGENT_AGENT_DIR: join(temp, 'agent'),
+  CARTHAGENT_CODING_AGENT_DIR: join(temp, 'agent'),
+  PI_CODING_AGENT_DIR: join(temp, 'agent'),
+  CARTHAGENT_CONFIG: join(temp, 'carthagent-config.json'),
+  npm_config_cache: join(temp, 'npm-cache'),
+});
+
 try {
-  const packed = JSON.parse(run('npm', ['pack', '--json', '--pack-destination', temp]));
+  await mkdir(isolatedHome, { recursive: true });
+  const npmEnv = withoutRuntimeGithubToken(env);
+  const packed = JSON.parse(run('npm', ['pack', '--json', '--pack-destination', temp], { env: npmEnv }));
   const tarball = join(temp, packed[0].filename);
   const paths = packed[0].files.map((file) => file.path);
   assert.ok(paths.includes('plugins/carthagent/index.ts'), 'pack must include plugin server entrypoint');
   assert.ok(paths.includes('plugins/carthagent/tui.ts'), 'pack must include plugin TUI entrypoint');
+  assert.ok(paths.includes('tests/native-cli-host-smoke.mjs'), 'pack must include the production-backed native CLI smoke');
+  assert.ok(paths.includes('tools/test-native-refresh-reentry.mjs'), 'pack must include the expired native OAuth refresh regression');
+  assert.ok(paths.includes('tests/fixtures/native-discovery-plugin/server.ts'), 'pack must include the exact project-discovery fixture required by the native CLI smoke');
+  assert.ok(paths.includes('tests/fixtures/archive-plugin/index.ts'), 'pack must retain the separately allowlisted archive fixture');
+  assert.ok(!paths.includes('tests/fixtures/plan-advisor-corpus.json'), 'pack must not broaden fixture inclusion beyond explicitly required package fixtures');
   assert.ok(!paths.some((path) => /(^|\/)node_modules(\/|$)/.test(path)), 'pack must not include node_modules');
   assert.ok(packed[0].size < 30_000_000, `unexpectedly large package tarball: ${packed[0].size} bytes`);
 
   const install = join(temp, 'install');
-  await import('node:fs/promises').then(({ mkdir }) => mkdir(install));
-  run('npm', ['install', '--prefix', install, '--omit=dev', '--no-audit', '--no-fund', tarball]);
+  await mkdir(install);
+  run('npm', ['install', '--prefix', install, '--omit=dev', '--no-audit', '--no-fund', tarball], { env: npmEnv });
   const manifest = JSON.parse(await readFile(join(install, 'node_modules/carthagent/package.json'), 'utf8'));
-  assert.equal(manifest.dependencies['@opencode/cli'], '2.0.32');
-  const binary = join(install, 'node_modules/@opencode/cli/bin/opencode.exe');
-  assert.ok((await stat(binary)).size > 100_000_000, 'native host binary must be materialized by postinstall');
-  const version = run(binary, ['--version'], { cwd: install }).trim();
-  assert.equal(version, 'opencode v2.0.32');
-
-  const env = {
-    ...process.env,
-    CTG_OPENCODE_BIN: binary,
-    CTG_EVALUATION_MAX_TURNS: '8',
-    CTG_EVALUATION_MAX_COST: '1',
-    HOME: join(temp, 'home'),
-    XDG_CONFIG_HOME: join(temp, 'config'),
-    XDG_DATA_HOME: join(temp, 'data'),
-    XDG_STATE_HOME: join(temp, 'state'),
-    XDG_CACHE_HOME: join(temp, 'cache'),
-  };
   const installed = join(install, 'node_modules/carthagent');
-  // The product entrypoint is intentionally parent-composed. Build a disposable
-  // host entrypoint that composes the package's exported native integration.
-  const installedPlugin = join(installed, '.ctg-production-plugin');
-  await mkdir(installedPlugin);
-  await writeFile(join(installedPlugin, 'index.ts'), `import { Plugin } from '@opencode/plugin';\nimport { setupCarthagent } from '../plugins/carthagent/src/index';\nexport default Plugin.define({ id: 'carthagent', setup: context => setupCarthagent(context, { delivery: true }) });\n`);
+  const installedPlugin = join(installed, 'plugins/carthagent');
+  assert.equal(manifest.devDependencies['@opencode/cli'], '2.0.32');
+  assert.equal(Object.hasOwn(manifest.dependencies, '@opencode/cli'), false, '@opencode/cli must not ship as a runtime dependency');
+  assert.equal(manifest.dependencies['@opencode/theme'], '2.0.32');
+  assert.equal(manifest.dependencies['@opentui/core'], '0.5.17');
+  assert.equal(manifest.dependencies['@opentui/solid'], '0.5.17');
+  assert.equal(manifest.dependencies['solid-js'], '1.9.12');
+  assert.equal(manifest.dependencies['web-tree-sitter'], '0.25.10');
+  assert.equal(manifest.dependencies['web-tree-sitter-legacy'], 'npm:web-tree-sitter@0.22.6');
+  const sharedRuntime = ['@opentui/core', '@opentui/solid', 'solid-js'];
+  for (const name of sharedRuntime) {
+    const hostResolution = createRequire(join(installed, 'package.json')).resolve(name);
+    const pluginResolution = createRequire(join(installedPlugin, 'package.json')).resolve(name);
+    assert.equal(pluginResolution, hostResolution, `${name} must resolve to the same host and plugin runtime instance`);
+  }
+  const packageVersion = async (from, name) => {
+    const entry = createRequire(from).resolve(name);
+    let directory = dirname(entry);
+    while (directory !== dirname(directory)) {
+      try {
+        const manifest = JSON.parse(await readFile(joinPath(directory, 'package.json'), 'utf8'));
+        if (manifest.name === name) return manifest.version;
+      } catch {}
+      directory = dirname(directory);
+    }
+    throw new Error(`Could not locate ${name} package manifest from ${entry}`);
+  };
+  assert.equal(await packageVersion(join(install, 'node_modules/@opentui/core/package.json'), 'web-tree-sitter'), '0.25.10');
+  assert.equal(await packageVersion(join(installed, 'package.json'), 'web-tree-sitter'), '0.25.10');
+  assert.equal(JSON.parse(await readFile(join(install, 'node_modules/web-tree-sitter-legacy/package.json'), 'utf8')).version, '0.22.6');
+  const releaseManifestPath = join(installed, 'lib/opencode/runtime-release.json');
+  let releaseManifest;
+  try { releaseManifest = JSON.parse(await readFile(releaseManifestPath, 'utf8')); }
+  catch (error) { if (error.code !== 'ENOENT') throw error; }
+
+  // Ask the installed package's *default* resolver and identity reporter.
+  // The JSON explicitly distinguishes preview upstream-compatible packages
+  // from packages whose resolver acquired the pinned CTG-owned runtime.
+  const resolution = JSON.parse(run(process.execPath, ['--input-type=module', '-e', `
+    import { pathToFileURL } from 'node:url';
+    const runtime = await import(pathToFileURL(process.argv[1]).href);
+    const { loadNativeTestRuntime } = await import(pathToFileURL(process.argv[2]).href);
+    const options = {};
+    const binary = await runtime.resolveOpenCode(options);
+    const identity = await runtime.runtimeIdentity(binary, options);
+    const expectedManifest = JSON.parse(await (await import('node:fs/promises')).readFile(process.argv[3], 'utf8').catch(error => error.code === 'ENOENT' ? 'null' : Promise.reject(error)));
+    const { dirname, isAbsolute, relative, resolve, sep } = await import('node:path');
+    const ownedRoot = identity.kind === 'ctg-owned' ? resolve(dirname(dirname(dirname(binary)))) : undefined;
+    if (identity.kind === 'ctg-owned') {
+      const executableName = process.platform === 'win32' ? 'opencode.exe' : 'opencode';
+      const expectedBinary = resolve(ownedRoot, 'cli-' + identity.platform, 'bin', executableName);
+      if (binary !== expectedBinary) throw new Error('Selected owned runtime executable is outside its canonical artifact layout: expected ' + expectedBinary + ', got ' + binary);
+    }
+    const isolatedHome = process.env.HOME ?? process.env.USERPROFILE;
+    const cacheRelative = ownedRoot && relative(isolatedHome, ownedRoot);
+    if (ownedRoot && (!cacheRelative || cacheRelative === '..' || cacheRelative.startsWith('..' + sep) || isAbsolute(cacheRelative))) {
+      throw new Error('Default owned runtime cache escaped the isolated HOME: ' + ownedRoot);
+    }
+    const verified = await loadNativeTestRuntime({ binary, ownedRoot, expectedManifest });
+    console.log(JSON.stringify({ binary, ownedRoot: ownedRoot ?? null, identity, verified, cacheIsolated: Boolean(ownedRoot) }));
+  `, join(installed, 'lib/opencode/runtime.mjs'), join(installed, 'tools/native-runtime-identity.mjs'), releaseManifestPath], { cwd: install, env }).trim());
+  const binary = resolve(resolution.binary);
+  assert.ok((await stat(binary)).isFile(), 'default resolver must select a materialized runtime executable');
+  assert.ok(resolution.identity && typeof resolution.identity.kind === 'string', 'default resolver must report runtime identity');
+  if (resolution.identity.kind === 'ctg-owned') {
+    assert.ok(releaseManifest, 'owned runtime identity requires a package-pinned release manifest');
+    assert.ok(resolution.ownedRoot, 'owned runtime identity must report the acquired runtime root');
+    assert.equal(resolution.identity.version, releaseManifest.runtimeVersion, 'owned runtime version must match the package-pinned release');
+    assert.equal(resolution.identity.binaryPath && resolve(resolution.identity.binaryPath), binary, 'reported owned identity must name the selected executable');
+    assert.equal(resolution.verified.binary, binary, 'independent verifier must select the exact default-resolved executable');
+    assert.equal(resolution.verified.binarySha256, releaseManifest.assets[resolution.identity.platform].executableSha256,
+      'independent verifier must match executable bytes against the installed trusted release manifest');
+    assert.equal(resolution.verified.sourceRevision, releaseManifest.sourceRevision, 'independent verifier must check runtime source provenance');
+    assert.equal(resolution.verified.patchSha256, releaseManifest.patchSha256, 'independent verifier must check runtime patch provenance');
+    assert.equal(resolution.verified.lockSha256, releaseManifest.lockSha256, 'independent verifier must check runtime lock provenance');
+    assert.equal(resolution.cacheIsolated, true, 'default acquisition cache must remain inside this test\'s isolated HOME');
+  } else {
+    assert.equal(resolution.identity.kind, 'upstream-compatible', 'unknown runtime identity cannot satisfy installed package acceptance');
+    assert.equal(resolution.identity.version, '2.0.32', 'preview upstream runtime must match the explicitly supported compatibility version');
+    assert.equal(resolution.verified.runtimeVersion, '2.0.32', 'independent verifier must validate upstream compatibility exactly');
+    assert.ok(!releaseManifest && !requireOwnedRuntime,
+      'a release package manifest or --require-owned requires the default resolver to acquire its package-pinned CTG runtime; upstream-compatible mode is preview-only');
+  }
+
+  assert.throws(
+    () => createRequire(join(installed, 'package.json')).resolve('@opencode/cli/package.json'),
+    { code: 'MODULE_NOT_FOUND' },
+    'installed package must not include the 203 MB OpenCode CLI fallback',
+  );
   // Run the acceptance harness from the installed artifact itself so its
   // imports (including @opencode/client) resolve only through that install.
-  const composedPlugin = installedPlugin;
-  for (const test of ['test-native-host.mjs', 'test-native-controls.mjs', 'test-native-outcomes.mjs', 'test-native-evaluation.mjs', 'test-native-swe.mjs']) {
-    run(process.execPath, [join(installed, 'tools', test), composedPlugin], { cwd: install, env });
-  }
-  run(process.execPath, [join(installed, 'tools', 'test-native-swe-host.mjs'), join(installed, 'plugins/carthagent')], { cwd: install, env });
-  for (const scenario of ['standard', 'strict', 'raw', 'budget', 'mixed', 'concurrent']) {
-    run(process.execPath, [join(installed, 'tools', 'test-native-delivery-host.mjs'), composedPlugin], {
-      cwd: install, env: { ...env, CTG_NATIVE_SCENARIO: scenario },
-    });
+  const probes = [];
+  const acceptanceTests = [
+    'test-native-ship-walkthrough.mjs', 'test-native-default-cli.mjs',
+    'test-owned-host-controls.mjs', 'test-native-glyph-pty.mjs',
+    'test-native-terminal-semantics-installed.mjs', 'test-native-visual-clear-installed.mjs',
+    'test-native-host.mjs', 'test-native-ship-models.mjs', 'test-native-refresh-reentry.mjs',
+    'test-native-controls.mjs', 'test-native-outcomes.mjs',
+    'test-native-product.mjs', 'test-native-runtime.mjs', 'test-native-tasks.mjs',
+    'test-native-review.mjs', 'test-native-swe-host.mjs', 'test-native-pty.mjs',
+    'test-native-evaluation.mjs', 'test-native-swe.mjs',
+    'test-native-report.mjs',
+    'test-native-delivery-host.mjs',
+    '../tests/codegraph.test.mjs',
+    '../tests/native-cli-host-smoke.mjs',
+  ];
+  assert.ok(!focused || acceptanceTests.includes(focused), `Unknown installed acceptance probe: ${focused}`);
+  const tests = focused ? [focused] : acceptanceTests;
+  const cases = tests.flatMap(test => test === 'test-native-delivery-host.mjs'
+    ? ['standard', 'strict', 'budget', 'raw', 'mixed', 'concurrent'].map(scenario => ({ test, scenario }))
+    : [{ test }]);
+  for (const { test, scenario } of cases) {
+    const identity = { test, ...(scenario ? { scenario } : {}), runtime: resolution.identity };
+    const ownedProbe = ['test-owned-host-controls.mjs', 'test-native-glyph-pty.mjs',
+      'test-native-terminal-semantics-installed.mjs', 'test-native-visual-clear-installed.mjs'].includes(test);
+    if (ownedProbe && resolution.identity.kind !== 'ctg-owned') {
+      const result = { ...identity, status: 'skipped', reason: 'owned-runtime probe is outside upstream-compatible preview scope' };
+      probes.push(result);
+      console.log(JSON.stringify(result));
+      continue;
+    }
+    if (ownedProbe && process.platform !== 'linux') {
+      assert.ok(!requireOwnedRuntime, `--require-owned cannot skip ${test} on ${process.platform}`);
+      const result = { ...identity, status: 'skipped', reason: 'owned installed acceptance probes currently require Linux PTY' };
+      probes.push(result);
+      console.log(JSON.stringify(result));
+      continue;
+    }
+    if (test === 'test-native-pty.mjs' && process.platform === 'win32') {
+      const result = { ...identity, status: 'skipped', reason: 'Unix-only Python PTY harness' };
+      probes.push(result);
+      console.log(JSON.stringify(result));
+      continue;
+    }
+    const started = performance.now();
+    console.log(JSON.stringify({ ...identity, status: 'started' }));
+    try {
+      const probePath = join(installed, 'tools', test);
+      // Parser/WASM behavior must resolve from the packed installation too.
+      const args = test.endsWith('.test.mjs') ? ['--test', probePath] : [probePath, installedPlugin];
+      if (test === 'test-owned-host-controls.mjs' || test === 'test-native-glyph-pty.mjs') args.push('--installed-default');
+      run(process.execPath, args, {
+        // The trusted harness may need to reacquire a missing default runtime.
+        // Runtime identity/version, host, PTY, workspace, and npm children
+        // independently strip the optional transport credential.
+        env: { ...env, CTG_NATIVE_SCENARIO: scenario ?? '', CTG_NATIVE_PLAN_PTY: scenario === 'standard' && resolution.identity.kind === 'ctg-owned' && process.platform === 'linux' ? '1' : '' },
+        cwd: install,
+      });
+    } catch (error) {
+      console.error(JSON.stringify({ ...identity, status: 'failed', elapsedMs: Math.round(performance.now() - started), completed: probes }));
+      throw error;
+    }
+    const result = { ...identity, status: 'passed', elapsedMs: Math.round(performance.now() - started) };
+    probes.push(result);
+    console.log(JSON.stringify(result));
   }
-  run(process.execPath, [join(installed, 'tools', 'test-native-report.mjs'), join(installed, 'tools', 'native-report-plugin')], { cwd: install, env });
-  console.log(JSON.stringify({ tarball: packed[0].filename, unpackedSize: packed[0].unpackedSize, binary, version }, null, 2));
+  console.log(JSON.stringify({
+    scope: focused ? 'focused' : 'full',
+    acceptance: resolution.identity.kind === 'ctg-owned' ? 'owned-runtime' : 'preview-upstream-compatible',
+    tarball: packed[0].filename,
+    unpackedSize: packed[0].unpackedSize,
+    runtime: resolution.identity,
+    binary,
+    probes,
+  }, null, 2));
 } finally {
   await rm(temp, { recursive: true, force: true });
 }

package/tools/test-native-performance.mjs

@@ -0,0 +1,26 @@
+#!/usr/bin/env node
+/** Cached workspace RPC latency on the installed native host; not UI latency. */
+import assert from 'node:assert/strict';
+import { performance } from 'node:perf_hooks';
+import { nativeFixture } from './native-fixture.mjs';
+
+const host = await nativeFixture({ plugin: process.argv[2] });
+try {
+  await host.active();
+  const snapshot = () => host.client.rpc.call({ rpcID: 'carthagent.workspace', method: 'snapshot',
+    input: {}, location: host.location }, host.request());
+  await snapshot();
+  const latencies = [];
+  for (let sample = 0; sample < 30; sample++) {
+    const started = performance.now();
+    const response = await snapshot();
+    latencies.push(performance.now() - started);
+    assert.equal(response.output.projects[0].directory, host.cwd);
+  }
+  const sorted = latencies.toSorted((a, b) => a - b);
+  const p95 = sorted[Math.ceil(sorted.length * 0.95) - 1];
+  assert.ok(p95 <= 300, `Cached workspace RPC p95 ${p95.toFixed(1)} ms exceeds 300 ms`);
+  console.log(JSON.stringify({ host: '2.0.32', samples: sorted.length,
+    cachedWorkspaceRpcP95Ms: Math.round(p95 * 10) / 10, maximumMs: Math.round(sorted.at(-1) * 10) / 10,
+    inputLatency: 'not measured by this probe', warmSwitchLatency: 'not measured by this probe' }));
+} finally { await host.close(); }