carthagent 1.0.7 → 1.1.0-preview.12

package/tools/test-native-default-cli.mjs

@@ -0,0 +1,106 @@
+#!/usr/bin/env node
+import assert from 'node:assert/strict';
+import { execFileSync, spawn } from 'node:child_process';
+import { mkdir, readFile, writeFile } from 'node:fs/promises';
+import { dirname, join, resolve } from 'node:path';
+import { once } from 'node:events';
+import { nativeFixture, streamText } from './native-fixture.mjs';
+import { stopService } from '../lib/opencode/service.mjs';
+
+const root = resolve(import.meta.dirname, '..');
+let verdict = 'APPROVE';
+let reviews = 0;
+let mutateSource = false;
+const host = await nativeFixture({ respond(body, response) {
+  const text = JSON.stringify(body.messages);
+  const snapshot = text.match(/Snapshot(?: SHA-256)?: ([a-f0-9]+)/)?.[1];
+  const head = text.match(/HEAD: ([a-f0-9]+)/)?.[1];
+  if (!snapshot || !head || !text.includes('REVIEW_JSON:')) return streamText(response, 'NATIVE_DEFAULT_EXECUTABLE_OK');
+  reviews++;
+  if (mutateSource) execFileSync(process.execPath, ['-e', 'require("node:fs").writeFileSync("mutated.txt", "changed during review")'], { cwd: mutationWorkspace });
+  const findings = verdict === 'CHANGES-REQUESTED' ? [{ file: 'fixture.txt', line: 1, severity: 'blocking', issue: 'Fixture content needs repair.', fix: 'Repair fixture content.' }] : [];
+  return streamText(response, verdict === 'MISSING' ? 'No verdict was supplied.' : `Native reviewer fixture.\nREVIEW_JSON: ${JSON.stringify({ version: 1, snapshot, head, findings })}\nVERDICT: ${verdict}`);
+} });
+const profileRoot = join(host.temp, 'cli-profile');
+const mutationWorkspace = join(host.temp, 'mutation-workspace');
+const env = Object.fromEntries(['PATH', 'SystemRoot', 'WINDIR', 'COMSPEC', 'PATHEXT', 'LANG', 'LC_ALL'].filter(key => process.env[key]).map(key => [key, process.env[key]]));
+Object.assign(env, {
+  HOME: join(host.temp, 'cli-home'), USERPROFILE: join(host.temp, 'cli-home'),
+  CTG_OPENCODE_HOME: profileRoot,
+  CARTHAGENT_CONFIG: join(host.temp, 'carthagent-config.json'),
+});
+if (host.runtimeIdentity.kind === 'ctg-owned') env.CTG_OWNED_OPENCODE_RUNTIME = dirname(dirname(dirname(host.runtimeIdentity.binary)));
+else env.CTG_OPENCODE_BIN = host.runtimeIdentity.binary;
+async function cli(args, cwd = host.cwd) {
+  const child = spawn(process.execPath, [join(root, 'bin/ctg.mjs'), ...args], { cwd, env, stdio: ['ignore', 'pipe', 'pipe'] });
+  let output = '';
+  child.stdout.on('data', chunk => { output += chunk; });
+  child.stderr.on('data', chunk => { output += chunk; });
+  const timer = setTimeout(() => child.kill('SIGTERM'), 45_000);
+  try { const [code] = await once(child, 'close'); return { code, output }; }
+  finally { clearTimeout(timer); }
+}
+function git(cwd, ...args) { return execFileSync('git', args, { cwd, encoding: 'utf8', stdio: ['ignore', 'pipe', 'pipe'] }); }
+async function baseline(cwd) {
+  await mkdir(cwd, { recursive: true });
+  git(cwd, 'init', '--initial-branch=main');
+  await writeFile(join(cwd, 'fixture.txt'), 'baseline\n');
+  await writeFile(join(cwd, 'task.txt'), 'Review the exact fixture content.\n');
+  git(cwd, 'add', 'fixture.txt', 'task.txt');
+  git(cwd, '-c', 'user.name=openhands', '-c', 'user.email=openhands@all-hands.dev', 'commit', '-m', 'Native executable fixture\n\nCo-authored-by: openhands <openhands@all-hands.dev>');
+}
+try {
+  await mkdir(join(profileRoot, 'config/opencode'), { recursive: true });
+  const config = JSON.parse(await readFile(join(host.temp, 'config/opencode/opencode.json'), 'utf8'));
+  config.providers.lattice = { ...config.providers['ctg-fixture'], models: { 'gpt-6-luna': config.providers['ctg-fixture'].models.fixture } };
+  await writeFile(join(profileRoot, 'config/opencode/opencode.json'), JSON.stringify(config));
+  const result = await cli(['-p', '--no-guide', '--no-delivery', '--model', 'ctg-fixture/fixture', 'Native default executable fixture']);
+  assert.equal(result.code, 0, result.output);
+  assert.match(result.output, /NATIVE_DEFAULT_EXECUTABLE_OK/);
+  const models = await cli(['--list-models', 'ctg-fixture']);
+  assert.equal(models.code, 0, models.output);
+  assert.match(models.output, /fixture/);
+  const account = await cli(['account']);
+  assert.equal(account.code, 1, account.output);
+  assert.match(account.output, /not signed in|connect|login/i);
+  await baseline(host.cwd);
+  const reviewArgs = ['review', 'workspace', '--request-file', 'task.txt', '--timeout', '20'];
+  const approved = await cli(reviewArgs);
+  assert.equal(approved.code, 0, approved.output);
+  assert.match(approved.output, /VERDICT: APPROVE/);
+  const calls = reviews;
+  const duplicate = await cli(reviewArgs);
+  assert.equal(duplicate.code, 2, duplicate.output);
+  assert.match(duplicate.output, /already approved/i);
+  assert.equal(reviews, calls);
+  await writeFile(join(host.cwd, 'fixture.txt'), 'changed source\n');
+  verdict = 'CHANGES-REQUESTED';
+  const changed = await cli(reviewArgs);
+  assert.equal(changed.code, 1, changed.output);
+  assert.match(changed.output, /VERDICT: CHANGES-REQUESTED/);
+  await writeFile(join(host.cwd, 'fixture.txt'), 'third source\n');
+  verdict = 'MISSING';
+  const missing = await cli(reviewArgs);
+  assert.equal(missing.code, 2, missing.output);
+  assert.match(missing.output, /VERDICT|structured/i);
+  const beforeLimit = reviews;
+  const limited = await cli(reviewArgs);
+  assert.equal(limited.code, 2, limited.output);
+  assert.match(limited.output, /round limit/i);
+  assert.equal(reviews, beforeLimit);
+  await baseline(mutationWorkspace);
+  verdict = 'APPROVE';
+  mutateSource = true;
+  const mutated = await cli(reviewArgs, mutationWorkspace);
+  assert.equal(mutated.code, 2, mutated.output);
+  assert.match(mutated.output, /source.*(?:changed|moved)|snapshot changed/i);
+  const stopped = await cli(['service', 'stop']);
+  assert.equal(stopped.code, 0, stopped.output);
+  const restarted = await cli(['native', '-p', '--no-guide', '--no-delivery', '--model', 'ctg-fixture/fixture', 'Native alias after service restart']);
+  assert.equal(restarted.code, 0, restarted.output);
+  assert.match(restarted.output, /NATIVE_DEFAULT_EXECUTABLE_OK/);
+  console.log(JSON.stringify({ runtime: host.runtimeIdentity.runtimeVersion, executable: 'default ctg without opt-in', headless: 'passed', modelDiscovery: 'passed', accountFailClosed: 'passed', reviewApprovalChangesAndMalformedVerdict: 'passed', persistedReviewAdmission: 'passed', reviewSourceMutationRejected: 'passed', explicitServiceStopAndRestart: 'passed', reviewRequests: reviews }));
+} finally {
+  await stopService({ root: profileRoot }).catch(() => {});
+  await host.close();
+}

package/tools/test-native-delivery-host.mjs

@@ -2,19 +2,37 @@
 /** 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 { spawn } from 'node:child_process';
 import { once } from 'node:events';
 import { randomBytes } from 'node:crypto';
 import { OpenCode } from '@opencode/client';
+import { resolveOpenCode, runtimeIdentity as getRuntimeIdentity } from '../lib/opencode/runtime.mjs';
 import { createNativeFixture, toolCall, assistantText } from './native-fixture.mjs';
+import { loadNativeTestRuntime, preflightNativeTestRuntimeArtifact } from './native-runtime-identity.mjs';
+import { waitForPluginActive } from './native-plugin-readiness.mjs';
 
 const root = resolve(import.meta.dirname, '..');
 const plugin = resolve(process.argv[2] ?? join(root, 'plugins/carthagent'));
 const productionPlugin = plugin.endsWith('/.ctg-production-plugin') ? resolve(plugin, '../plugins/carthagent/src/index.ts') : plugin.endsWith('/plugins/carthagent') ? resolve(plugin, 'src/index.ts') : plugin;
 const archiveFixture = resolve(root, 'tests/fixtures/archive-plugin');
-const binary = process.env.CTG_OPENCODE_BIN ?? join(root, 'node_modules/@opencode/cli/bin/opencode.exe');
+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 temp = await mkdtemp(join(tmpdir(), 'ctg-host-smoke-'));
 const password = randomBytes(24).toString('hex');
 let child;
@@ -44,7 +62,7 @@ const Observer = { id: 'carthagent-delivery-observer', methods: { state: {
 } }, events: {} };
 export default { id: 'carthagent', async setup(context) {
   const monitored = { ...context,
-    tool: { ...context.tool, hook: async (name, callback) => context.tool.hook(name, async event => { if (name === 'execute.before') { const entry = { hook: name, sessionID: event.sessionID, tool: event.tool, id: event.id, messageID: event.messageID }; if (invocations.some(previous => previous.sessionID === entry.sessionID && previous.tool === entry.tool && previous.id === entry.id && previous.messageID === entry.messageID)) duplicateInvocations.push(entry); invocations.push(entry); } await callback(event); }) },
+    tool: { ...context.tool, hook: async (name, callback) => context.tool.hook(name, async event => { if (name === 'execute.before') { const entry = { hook: name, sessionID: event.sessionID, tool: event.tool, agent: event.agent, id: event.id, messageID: event.messageID }; if (invocations.some(previous => previous.sessionID === entry.sessionID && previous.tool === entry.tool && previous.id === entry.id && previous.messageID === entry.messageID)) duplicateInvocations.push(entry); invocations.push(entry); } await callback(event); }) },
     shell: { ...context.shell, hook: async (name, callback) => context.shell.hook(name, async event => { if (name === 'create.before') invocations.push({ hook: 'shell.' + name, command: event.command }); await callback(event); }) },
     session: { ...context.session, interrupt: async input => { interrupts.push(input); return context.session.interrupt(input); } },
   };
@@ -74,6 +92,8 @@ export default { id: 'carthagent', async setup(context) {
     } else if (JSON.stringify(latestUser).includes('MIXED_DISABLED')) {
       if (tools.includes('shell') && toolResults === 0) toolCall(response, { name: 'shell', arguments: { command: "printf disabled-session > mixed-disabled.txt" } });
       else assistantText(response, 'DISABLED_SESSION_SHELL_OK');
+    } else if (JSON.stringify(latestUser).includes('MODE_SHIP_PARITY')) {
+      assistantText(response, 'MODE_SHIP_GUIDANCE_OK');
     } else if (scenario === 'budget' && toolResults >= 6) {
       toolCall(response, { name: 'execute', arguments: { code: 'return await tools.carthagent["delivery_status"]({})' } });
     } else if (tools.includes('execute') && toolResults === 0) {
@@ -148,26 +168,20 @@ export default { id: 'carthagent', async setup(context) {
   // multi-turn offline workflow; give each host call its own bounded signal.
   const request = { signal: AbortSignal.timeout(120_000) };
   const info = await client.server.info(request);
-  assert.equal(info.version, '2.0.32');
+  assert.equal(info.version, runtimeIdentity.runtimeVersion);
   const unauthorized = await fetch(`${endpoint}/api/info`, { signal: request.signal });
   assert.equal(unauthorized.status, 401);
   await client.session.create({ location: { directory: cwd }, title: 'CTG host smoke' }, request);
-  let plugins;
-  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;
-    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');
-  assert.equal(nativePlugin.state.status, 'active');
-  assert.equal(archivePlugin?.state.status, 'active', 'archive registration fixture must become visible');
+  const location = { directory: cwd };
+  const listPlugins = async (timeoutMs) => client.plugin.list({ location }, { signal: AbortSignal.timeout(timeoutMs) });
+  const readinessOptions = { listPlugins, timeoutMs: 15_000, hostOutput: () => output };
+  const nativePlugin = await waitForPluginActive('carthagent', readinessOptions);
+  await waitForPluginActive('ctg-archive-fixture', readinessOptions);
   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);
   await assert.rejects(client.rpc.call({
@@ -290,7 +304,75 @@ export default { id: 'carthagent', async setup(context) {
     assert.ok(disabledDiagnostics.output.budget.limits.tools === 10);
   }
   }
-  console.log('Native plugin and validated RPC passed against OpenCode 2.0.32.');
+  if (scenario === 'standard') {
+    const agents = (await client.agent.list({ location: { directory: cwd } }, request)).data;
+    assert.ok(agents.some(agent => agent.id === 'ship' && agent.name === 'Ship' && agent.mode === 'primary'));
+    assert.ok(agents.some(agent => agent.id === 'lite' && agent.name === 'Lite' && agent.mode === 'primary'));
+    const modeSession = await client.session.create({ location: { directory: cwd }, title: 'Native mode parity', agent: 'lite' }, request);
+    await client.session.switchModel({ sessionID: modeSession.id, model: { providerID: 'fixture', id: 'fixture' } }, request);
+    const first = observed.length;
+    await client.session.prompt({ sessionID: modeSession.id, text: 'MIXED_DISABLED native mode parity: execute directly.' }, request);
+    await client.session.wait({ sessionID: modeSession.id }, { signal: AbortSignal.timeout(45_000) });
+    assert.equal(observed.slice(first).some(call => JSON.stringify(call.messages).includes('Standard delivery:')), false, 'Lite has no delivery guidance');
+    const liteHistory = await client.message.list({ sessionID: modeSession.id }, request);
+    assert.match(JSON.stringify(liteHistory.data), /DISABLED_SESSION_SHELL_OK/);
+    await client.session.switchAgent({ sessionID: modeSession.id, agent: 'ship' }, request);
+    const second = observed.length;
+    await client.session.prompt({ sessionID: modeSession.id, text: 'MODE_SHIP_PARITY inspect the workspace.' }, request);
+    await client.session.wait({ sessionID: modeSession.id }, { signal: AbortSignal.timeout(45_000) });
+    assert.ok(observed.slice(second).some(call => JSON.stringify(call.messages).includes('Standard delivery:')), 'switching to Ship enables the harness on the next request');
+    await client.session.switchAgent({ sessionID: modeSession.id, agent: 'lite' }, request);
+    assert.equal((await client.session.get({ sessionID: modeSession.id }, request)).agent, 'lite');
+    const beforeCommands = fixture.calls;
+    await client.session.command({ sessionID: modeSession.id, name: 'delivery-budget-status', text: '' }, request);
+    await client.session.command({ sessionID: modeSession.id, name: 'delivery-budget-reset', text: '' }, request);
+    assert.equal(fixture.calls, beforeCommands, 'budget commands must not dispatch provider requests');
+    const planHistory = await client.message.list({ sessionID: session.id }, request);
+    const snapshots = planHistory.data.flatMap(message => message.type === 'assistant' ? message.content.filter(part => part.type === 'tool' && part.state.status === 'completed' && part.state.metadata?.deliveryPlan) : []);
+    assert.ok(snapshots.length > 0, 'real Code Mode results persist delivery plan snapshots for the graph');
+    if (process.env.CTG_NATIVE_PLAN_PTY === '1') {
+      assert.ok(ownedRoot, 'graph rendering acceptance requires a verified owned runtime');
+      const probe = spawn(process.env.PYTHON ?? 'python3', ['-c', `
+import importlib.util, json, os, sys
+from pathlib import Path
+root, binary = sys.argv[1:]
+spec = importlib.util.spec_from_file_location('slash_probe', Path(root) / 'tools/test-native-slash-commands.py')
+module = importlib.util.module_from_spec(spec)
+spec.loader.exec_module(module)
+fixture = json.load(sys.stdin)
+home = Path(fixture['temp']) / 'graph-tui-home'
+env = module.fixture_environment(os.environ, home, '', '')
+env = {key: value for key, value in env.items() if key in module.TUI_ENV_KEYS}
+env['OPENCODE_SERVER_PASSWORD'] = fixture['password']
+env['OPENCODE_SERVER_USERNAME'] = 'opencode'
+tui = module.Tui(binary, fixture, fixture['sessionID'], env)
+try:
+    tui.wait_for(lambda: '┃' in tui.screen.visible(), 'session composer')
+    if 'getting started' in tui.screen.visible().lower():
+        os.write(tui.master, b'\x1b')
+        tui.drain(.3)
+    tui.submit_slash('/graph', marker='SHIP PLAN')
+    tui.wait_for(lambda: 'Create fixture file' in tui.screen.visible(), 'authoritative delivery step in plan graph')
+    print(json.dumps({'graph': 'passed', 'source': 'actual Code Mode delivery snapshot', 'step': 'Create fixture file'}))
+finally:
+    tui.stop()
+`, root, binary], {
+        cwd: root,
+        env: Object.fromEntries(['PATH', 'LANG', 'LC_ALL', 'SystemRoot', 'WINDIR', 'COMSPEC', 'PATHEXT'].filter(key => process.env[key]).map(key => [key, process.env[key]])),
+        stdio: ['pipe', 'pipe', 'pipe'],
+      });
+      let probeOutput = '';
+      probe.stdout.on('data', chunk => { probeOutput += chunk; });
+      probe.stderr.on('data', chunk => { probeOutput += chunk; });
+      probe.stdin.end(JSON.stringify({ temp, cwd, baseUrl: endpoint, password, sessionID: session.id }));
+      const timer = setTimeout(() => probe.kill('SIGTERM'), 45_000);
+      const [code] = await once(probe, 'exit');
+      clearTimeout(timer);
+      assert.equal(code, 0, probeOutput.replaceAll(password, '[redacted]'));
+      console.log(probeOutput.trim());
+    }
+  }
+  console.log(`Native plugin and validated RPC passed against OpenCode ${runtimeIdentity.runtimeVersion} (compatibility ${runtimeIdentity.compatibilityVersion}).`);
 } catch (error) {
   console.error(output.replaceAll(password, '[redacted]'));
   throw error;

package/tools/test-native-evaluation.mjs

@@ -19,6 +19,10 @@ try {
   await host.outcome(unrelated.id);
   const result = await runNativeEvaluation({ client, directory, prompt:'Run bounded fixture task.', provider:model.providerID, model:model.id, timeoutSeconds:30, maxTurns:4, maxCost:1 });
   assert.equal(result.runtime,'opencode-2');
+  const hostInfo = await client.server.info(request());
+  assert.equal(result.compatibilityVersion,'2.0.32');
+  assert.equal(result.runtimeVersion,hostInfo.version,'evaluation records the actual connected server version');
+  assert.equal(result.opencodeVersion,hostInfo.version,'legacy version field is not normalized to the compatibility version');
   assert.equal(result.exitCode,0,JSON.stringify(result));
   assert.equal(result.outcome,'succeeded');
   assert.equal(result.turns,1,JSON.stringify(result));
@@ -36,11 +40,11 @@ try {
   assert.equal(failed.turns,1,JSON.stringify(failed));
   assert.equal(failed.productiveTurns,0,JSON.stringify(failed));
   assert.ok(failed.providerErrors >= 1,JSON.stringify(failed));
-  assert.equal(host.requests.length,2);
+  assert.equal(host.requests.length,3,'an unrelated native session is outside the evaluation-only budget guard');
   const mismatched = await runNativeEvaluation({client,directory,prompt:'This must fail the budget handshake.',provider:model.providerID,model:model.id,timeoutSeconds:30,maxTurns:5,maxCost:1});
   assert.equal(mismatched.exitCode,1,JSON.stringify(mismatched));
   assert.equal(mismatched.outcome,'failed',JSON.stringify(mismatched));
   assert.ok(mismatched.errors.some(error=>/budget handshake/i.test(error)),JSON.stringify(mismatched));
-  assert.equal(host.requests.length,2,'mismatched turn limit must be rejected before provider admission');
-  console.log(JSON.stringify({host:'2.0.32',outcome:result.outcome,failureOutcome:failed.outcome,turns:result.turns,cost:result.cost,isolatedFromConcurrentSession:true}));
+  assert.equal(host.requests.length,3,'mismatched turn limit must be rejected before provider admission');
+  console.log(JSON.stringify({host:{compatibilityVersion:result.compatibilityVersion,runtimeVersion:result.runtimeVersion},outcome:result.outcome,failureOutcome:failed.outcome,turns:result.turns,cost:result.cost,isolatedFromConcurrentSession:true}));
 } finally { await host.close(); }

package/tools/test-native-glyph-pty.mjs

@@ -0,0 +1,94 @@
+#!/usr/bin/env node
+/** Strictly identified owned-runtime paired glyph rendering proof. */
+import assert from 'node:assert/strict';
+import { createHash } from 'node:crypto';
+import { mkdtemp, readFile, rm } from 'node:fs/promises';
+import { spawnSync } from 'node:child_process';
+import { existsSync } from 'node:fs';
+import { dirname, join, resolve } from 'node:path';
+import { tmpdir } from 'node:os';
+import { fileURLToPath } from 'node:url';
+import { resolveOpenCode, runtimeIdentity } from '../lib/opencode/runtime.mjs';
+import { loadNativeTestRuntime, preflightNativeTestRuntimeArtifact } from './native-runtime-identity.mjs';
+
+const root = resolve(dirname(fileURLToPath(import.meta.url)), '..');
+const installedDefault = process.argv.includes('--installed-default');
+assert.ok(!installedDefault || !process.env.CTG_TEST_RUNTIME_ARTIFACT_ROOT,
+  'installed acceptance must use the package default runtime resolver, not CTG_TEST_RUNTIME_ARTIFACT_ROOT');
+assert.ok(!installedDefault || !process.env.CTG_TEST_RUNTIME_RELEASE_MANIFEST,
+  'installed acceptance must use its packaged trusted release manifest');
+assert.ok(!installedDefault || !process.env.CTG_OWNED_OPENCODE_RUNTIME,
+  'installed acceptance must not select a developer-owned runtime artifact');
+const ownedRoot = process.env.CTG_TEST_RUNTIME_ARTIFACT_ROOT ?? process.env.CTG_OWNED_OPENCODE_RUNTIME;
+const trustedManifestPath = process.env.CTG_TEST_RUNTIME_RELEASE_MANIFEST ?? join(root, 'lib/opencode/runtime-release.json');
+assert.ok(!process.env.CTG_OPENCODE_BIN, 'Unset CTG_OPENCODE_BIN; this proof uses the production owned-runtime resolver');
+assert.ok(!process.env.CTG_TEST_RUNTIME_SHA256, 'Do not override trusted executable digest in glyph acceptance');
+if (process.env.CTG_TEST_RUNTIME_ARTIFACT_ROOT) {
+  assert.ok(process.env.CTG_TEST_RUNTIME_RELEASE_MANIFEST,
+    'Explicit test artifact requires a trusted CTG_TEST_RUNTIME_RELEASE_MANIFEST');
+}
+
+let preflight;
+let runtimeOptions = { runtimeReleaseManifestPath: trustedManifestPath };
+if (ownedRoot) {
+  preflight = await preflightNativeTestRuntimeArtifact({ ownedRoot, expectedManifestPath: trustedManifestPath });
+  runtimeOptions = { ...runtimeOptions, ownedRuntime: ownedRoot };
+} else {
+  // Packaged/default owned-runtime selection is made by the normal resolver.
+}
+
+const binary = await resolveOpenCode(runtimeOptions);
+const productIdentity = await runtimeIdentity(binary, runtimeOptions);
+assert.equal(productIdentity.kind, 'ctg-owned', 'glyph acceptance requires the production resolver to select CTG-owned runtime');
+const resolvedOwnedRoot = ownedRoot ?? dirname(dirname(dirname(binary)));
+const identity = await loadNativeTestRuntime({
+  binary,
+  ownedRoot: resolvedOwnedRoot,
+  expectedManifest: preflight?.expectedManifest ?? JSON.parse(await readFile(trustedManifestPath, 'utf8')),
+});
+assert.equal(resolve(identity.binary), resolve(binary));
+if (installedDefault) {
+  assert.equal(productIdentity.kind, 'ctg-owned', 'installed glyph acceptance requires the default resolver to select CTG-owned runtime');
+  assert.equal(identity.binarySha256, productIdentity.binarySha256, 'independent identity must match default resolver byte identity');
+}
+if (preflight) {
+  assert.equal(identity.binarySha256, preflight.identity.binarySha256);
+  assert.equal(productIdentity.binarySha256, preflight.identity.binarySha256);
+}
+
+const artifact = process.env.CTG_GLYPH_ARTIFACT;
+const scratch = await mkdtemp(join(tmpdir(), 'ctg-glyph-proof-'));
+const ptyArtifact = join(scratch, 'pty.json');
+const pythonCandidates = [process.env.PYTHON,
+  join(root, '.venv', process.platform === 'win32' ? 'Scripts/python.exe' : 'bin/python'),
+  process.platform === 'win32' ? 'python.exe' : 'python3', 'python'].filter(Boolean);
+const findExecutable = candidate => {
+  if (existsSync(candidate)) return candidate;
+  return (process.env.PATH || '').split(process.platform === 'win32' ? ';' : ':')
+    .map(directory => join(directory, candidate)).find(existsSync) ?? null;
+};
+const python = pythonCandidates.map(findExecutable).find(Boolean);
+if (!python) throw new Error('Python was not found; set PYTHON to an interpreter path');
+const args = [join(root, 'tools/native-glyph-pty.py'), '--binary', binary];
+args.push('--artifact', ptyArtifact);
+const probeEnv = Object.fromEntries(['PATH', 'LANG', 'LC_ALL'].filter(key => process.env[key])
+  .map(key => [key, process.env[key]]));
+const probe = spawnSync(python, args, { cwd: root, encoding: 'utf8', timeout: 120_000, env: probeEnv });
+if (probe.stderr) process.stderr.write(probe.stderr);
+if (probe.status !== 0) {
+  if (probe.stdout) process.stderr.write(probe.stdout);
+  await rm(scratch, { recursive: true, force: true });
+  assert.equal(probe.status, 0, `PTY glyph probe failed with status ${probe.status}`);
+}
+const binaryHash = createHash('sha256').update(await readFile(binary)).digest('hex');
+const proof = {
+  runtime: { binary, binarySha256: binaryHash, compatibilityVersion: identity.compatibilityVersion,
+    runtimeVersion: identity.runtimeVersion, sourceRevision: identity.sourceRevision,
+    patchSha256: identity.patchSha256, lockSha256: identity.lockSha256,
+    productResolverKind: productIdentity.kind, productResolverVersion: productIdentity.version },
+  glyphProof: JSON.parse(await readFile(ptyArtifact, 'utf8')),
+};
+const rendered = JSON.stringify(proof, null, 2) + '\n';
+process.stdout.write(rendered);
+if (artifact) await (await import('node:fs/promises')).writeFile(resolve(artifact), rendered, 'utf8');
+await rm(scratch, { recursive: true, force: true });