carthagent 1.0.7 → 1.1.0-beta.1

package/tests/cli.test.mjs

@@ -1,8 +1,8 @@
 import { test } from 'node:test';
 import assert from 'node:assert/strict';
-import { mkdtempSync, rmSync, writeFileSync, readFileSync, mkdirSync, chmodSync, copyFileSync } from 'node:fs';
+import { mkdtempSync, rmSync, writeFileSync, readFileSync, mkdirSync } from 'node:fs';
 import { tmpdir } from 'node:os';
-import { dirname, join, resolve, delimiter } from 'node:path';
+import { dirname, join, resolve } from 'node:path';
 import { fileURLToPath, pathToFileURL } from 'node:url';
 import { spawnSync } from 'node:child_process';
 import { approveFixture } from './helpers/tested-design.mjs';
@@ -23,6 +23,31 @@ function run(cwd, ...args) {
   return spawnSync(process.execPath, [cli, ...args], { cwd, encoding: 'utf8' });
 }
 
+test('default CLI and its native alias always use the native console, even with the old opt-out variable', t => {
+  const cwd = fixture(t);
+  for (const prefix of [[], ['native']]) {
+    const result = spawnSync(process.execPath, [cli, ...prefix, '--help'], { cwd, encoding: 'utf8', env: { ...process.env, CTG_NATIVE: '0' } });
+    assert.equal(result.status, 0, result.stderr);
+    assert.match(result.stdout, /Launch the native Carthagent delivery console/);
+    assert.doesNotMatch(result.stdout, /split-terminal|opt-in native|live plan\.d2 side panel/);
+    assert.match(result.stdout, /ctg service stop/);
+  }
+});
+
+test('native runtime selection never falls back to a legacy engine override', t => {
+  const cwd = fixture(t);
+  const missing = join(cwd, 'missing-native-runtime');
+  const fallback = join(cwd, 'legacy.mjs');
+  const marker = join(cwd, 'legacy-started');
+  writeFileSync(fallback, `import { writeFileSync } from 'node:fs'; writeFileSync(${JSON.stringify(marker)}, 'unexpected');`);
+  const result = spawnSync(process.execPath, [cli, '-p', '--engine-cli', missing, '--no-delivery', '--max-tools', '1', 'Task'], {
+    cwd, encoding: 'utf8', timeout: 10000, env: { ...process.env, CTG_NATIVE: '0', CARTHAGENT_CLI: fallback },
+  });
+  assert.equal(result.status, 1, result.stderr);
+  assert.match(result.stderr, /missing-native-runtime/);
+  assert.throws(() => readFileSync(marker), { code: 'ENOENT' });
+});
+
 test('status reads the newest persisted extension report', t => {
   const cwd = fixture(t);
   createReport(cwd, {
@@ -86,13 +111,17 @@ test('guidance routing is not a user-facing command and Ship account commands ar
   assert.match(result.stdout, /logout-cloud/);
 });
 
-test('Cloud account commands fail closed when no browser session is stored', t => {
+test('native account commands fail closed instead of consuming legacy engine credentials', t => {
   const cwd = fixture(t);
-  const env = { ...process.env, CARTHAGENT_CODING_AGENT_DIR: join(cwd, 'agent'), PI_CODING_AGENT_DIR: join(cwd, 'agent') };
+  const agent = join(cwd, 'legacy-agent');
+  mkdirSync(agent);
+  writeFileSync(join(agent, 'auth.json'), JSON.stringify({ 'experiential-labs': { type: 'api_key', key: 'legacy-fixture-credential' } }));
+  const env = { ...process.env, CTG_OPENCODE_BIN: join(cwd, 'missing-native-runtime'), CARTHAGENT_CODING_AGENT_DIR: agent, PI_CODING_AGENT_DIR: agent };
   for (const args of [['account'], ['billing'], ['logout-cloud']]) {
     const result = spawnSync(process.execPath, [cli, ...args], { cwd, env, encoding: 'utf8' });
     assert.equal(result.status, 1, result.stderr);
-    assert.match(result.stderr, /not signed in/);
+    assert.match(result.stderr, /missing-native-runtime/);
+    assert.doesNotMatch(result.stdout + result.stderr, /legacy-fixture-credential/);
   }
 });
 
@@ -107,69 +136,12 @@ test('review shows and persists the self-review default', t => {
   assert.equal(runEnv('review', 'bogus').status, 2);
 });
 
-/** Fake `gh` + fake engine CLI so `ctg review <pr>` runs end-to-end offline. */
-function reviewFixture(t, verdictLine) {
+test('native review rejects invalid targets and bounds before resolving a host', t => {
   const cwd = fixture(t);
-  const bin = join(cwd, 'bin');
-  mkdirSync(join(cwd, 'bin'), { recursive: true });
-  const gh = join(bin, 'gh');
-  writeFileSync(gh, `#!/bin/sh
-if [ "$1" = "pr" ] && [ "$2" = "view" ]; then echo '{"title":"Fixture PR","url":"https://example.test/pr/14","headRefName":"feat","baseRefName":"main","headRefOid":"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"}'; exit 0; fi
-exit 0
-`);
-  chmodSync(gh, 0o755);
-  // Native executable fixture: Windows cannot execute a POSIX shebang shim.
-  if (process.platform === 'win32') {
-    copyFileSync(process.execPath, join(bin, 'gh.exe'));
-    writeFileSync(join(cwd, 'gh-preload.cjs'), `if (require('node:path').basename(process.execPath).toLowerCase() === 'gh.exe') { console.log(JSON.stringify({title:'Fixture PR',url:'https://example.test/pr/14',headRefName:'feat',baseRefName:'main',headRefOid:'aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa'})); process.exit(0); }`);
-  }
-  const reviewer = join(cwd, 'reviewer.mjs');
-  writeFileSync(reviewer, `const prompt = process.argv.at(-1); const snapshot = /snapshot:"([a-f0-9]+)"/.exec(prompt)?.[1]; const head = /head:"([a-f0-9]+)"/.exec(prompt)?.[1]; console.log('fixture findings'); console.log('REVIEW_JSON: ' + JSON.stringify({version:1,snapshot,head,findings:${JSON.stringify(verdictLine.includes('CHANGES-REQUESTED') ? [{file:'app.mjs',line:1,severity:'blocking',issue:'fixture issue',fix:'fixture fix'}] : [])}})); console.log('${verdictLine}');\n`);
-  const env = { ...process.env, CARTHAGENT_CONFIG: join(cwd, 'config.json'), CARTHAGENT_CLI: reviewer, PATH: `${bin}${delimiter}${process.env.PATH}` };
-  if (process.platform === 'win32') env.NODE_OPTIONS = `${env.NODE_OPTIONS || ''} --require ${JSON.stringify(join(cwd, 'gh-preload.cjs'))}`;
-  return { cwd, env };
-}
-
-test('ctg review <pr> exits 0 when the fresh reviewer approves', t => {
-  const { cwd, env } = reviewFixture(t, 'VERDICT: APPROVE');
-  const result = spawnSync(process.execPath, [cli, 'review', '14'], { cwd, env, encoding: 'utf8' });
-  assert.equal(result.status, 0, result.stderr);
-  assert.match(result.stdout, /fixture findings/);
-  assert.match(result.stdout, /VERDICT: APPROVE/);
-});
-
-test('ctg review <pr> exits 1 on requested changes and 2 without a verdict', t => {
-  const { cwd, env } = reviewFixture(t, 'VERDICT: CHANGES-REQUESTED');
-  const result = spawnSync(process.execPath, [cli, 'review', '14'], { cwd, env, encoding: 'utf8' });
-  assert.equal(result.status, 1, result.stderr);
-  const silent = reviewFixture(t, 'analysis but no verdict line');
-  const bad = spawnSync(process.execPath, [cli, 'review', '14'], { cwd: silent.cwd, env: silent.env, encoding: 'utf8' });
-  assert.equal(bad.status, 2);
-  assert.match(bad.stderr, /no VERDICT/);
-});
-
-test('review persists admission limits across fresh CLI processes', t => {
-  const { cwd, env } = reviewFixture(t, 'VERDICT: CHANGES-REQUESTED');
-  for (let i = 0; i < 3; i++) {
-    const result = spawnSync(process.execPath, [cli, 'review', '14'], { cwd, env, encoding: 'utf8' });
-    assert.equal(result.status, 1, result.stderr);
-  }
-  const exhausted = spawnSync(process.execPath, [cli, 'review', '14'], { cwd, env, encoding: 'utf8' });
-  assert.equal(exhausted.status, 2);
-  assert.match(exhausted.stderr, /round limit/);
-  assert.doesNotMatch(exhausted.stdout, /fixture findings/);
-});
-
-test('review rejects source mutation and invalid execution bounds', t => {
-  const { cwd, env } = reviewFixture(t, 'VERDICT: APPROVE');
-  writeFileSync(join(cwd, 'reviewer.mjs'), `import {writeFileSync} from 'node:fs'; writeFileSync('changed.txt', 'café'); console.log('VERDICT: APPROVE');`);
-  const changed = spawnSync(process.execPath, [cli, 'review', '14'], { cwd, env, encoding: 'utf8' });
-  assert.equal(changed.status, 2);
-  assert.match(changed.stderr, /snapshot changed/);
-  for (const value of ['0', '301', 'Infinity', 'invalid']) {
-    const invalid = spawnSync(process.execPath, [cli, 'review', '14', '--timeout', value], { cwd, env, encoding: 'utf8' });
-    assert.equal(invalid.status, 2);
-    assert.match(invalid.stderr, /integer from 1 to 300/);
+  for (const args of [['review', 'bogus'], ['review', '14', '--timeout', '0'], ['review', '14', '--timeout', '301'], ['review', '14', '--timeout', 'Infinity'], ['review', '14', '--timeout', 'invalid']]) {
+    const result = run(cwd, ...args);
+    assert.equal(result.status, 2, result.stderr);
+    assert.match(result.stderr, /Invalid review target|integer from 1 to 300/);
   }
 });
 
@@ -194,33 +166,17 @@ test('review modes launch the real bundled engine without unknown flags', t => {
   }
 });
 
-test('ctg --list-models renders stored identity-only Cloud metadata as unknown', t => {
+test('native model listing cannot silently fall back to legacy cached model metadata', t => {
   const cwd = fixture(t);
-  const agentDir = join(cwd, 'agent');
-  mkdirSync(agentDir, { recursive: true });
-  writeFileSync(join(agentDir, 'auth.json'), JSON.stringify({
-    'experiential-labs': { type: 'api_key', key: 'fixture-credential' },
-  }));
-  writeFileSync(join(agentDir, 'models-store.json'), JSON.stringify({
-    'experiential-labs': {
-      models: [{ id: 'carthagent-code', name: 'carthagent-code' }],
-      checkedAt: 1,
-    },
-  }));
-  const result = spawnSync(process.execPath, [cli, '--list-models', 'Carthagent Ship'], {
-    cwd,
-    encoding: 'utf8',
-    env: {
-      ...process.env,
-      PI_OFFLINE: '1',
-      CARTHAGENT_CODING_AGENT_DIR: agentDir,
-      PI_CODING_AGENT_DIR: agentDir,
-    },
-  });
-  assert.equal(result.status, 0, result.stderr);
-  assert.match(result.stdout, /Carthagent Ship\s+carthagent-code\s+\?\s+\?\s+\?\s+\?/);
-  assert.doesNotMatch(result.stdout, /experiential/i);
-  assert.doesNotMatch(result.stderr, /Cannot read properties|Failed to load extension/);
+  const agent = join(cwd, 'legacy-agent');
+  mkdirSync(agent);
+  writeFileSync(join(agent, 'models-store.json'), JSON.stringify({ 'experiential-labs': { models: [{ id: 'legacy-only-model' }], checkedAt: 1 } }));
+  const result = spawnSync(process.execPath, [cli, '--list-models'], { cwd, encoding: 'utf8', env: {
+    ...process.env, CTG_OPENCODE_BIN: join(cwd, 'missing-native-runtime'), CARTHAGENT_CODING_AGENT_DIR: agent, PI_CODING_AGENT_DIR: agent,
+  } });
+  assert.equal(result.status, 1, result.stderr);
+  assert.match(result.stderr, /missing-native-runtime/);
+  assert.doesNotMatch(result.stdout, /legacy-only-model/);
 });
 
 test('vendored agent engine is bundled and loads ModelRuntime cleanly', async () => {
@@ -235,11 +191,11 @@ test('vendored agent engine is bundled and loads ModelRuntime cleanly', async ()
   assert.ok(providers.size >= 35);
 });
 
-test('CLI rejects invalid, missing and disabled-extension budget options', t => {
+test('native CLI rejects invalid and missing budget options', t => {
   const cwd = fixture(t);
-  for (const args of [['--max-tools'], ['--max-seconds', 'NaN', 'task'], ['--no-delivery', '--max-tools', '1', 'task']]) {
+  for (const args of [['--max-tools'], ['--max-seconds', 'NaN', 'task'], ['--no-delivery', '--max-tools', '-1', 'task']]) {
     const result = spawnSync(process.execPath, [cli, '-p', ...args], { cwd, encoding: 'utf8', timeout: 10000 });
     assert.equal(result.status, 1, result.stderr);
-    assert.match(result.stderr, /Missing value|must be an integer|require the delivery/);
+    assert.match(result.stderr, /Missing value|must be an integer|non-negative/);
   }
 });

package/tests/daily-evidence.test.mjs

@@ -0,0 +1,62 @@
+import { test } from 'node:test';
+import assert from 'node:assert/strict';
+import { canonicalDailyEvidence, dailyRequest } from '../plugins/carthagent/src/daily-evidence.mjs';
+
+const ID = 'ABCDEF01-2345-6789-ABCD-EF0123456789';
+const REV = 'A'.repeat(40);
+const evidence = () => ({ projectId: ID, outcomeId: ID, runId: ID, revision: REV, goal: '  A goal\r\nline  ', change: 'A change', checks: [{ name: 'test', before: 'failed', after: 'passed', revision: REV, result: 'Observed passing check' }], findings: [{ issue: 'Issue', evidence: 'Observation', resolution: 'Resolved' }] });
+const invalid = value => assert.throws(() => canonicalDailyEvidence(value), { message: 'invalid_daily_evidence' });
+test('canonical evidence has backend field ordering, lowercase identifiers, LF and trim; preserves astral pairs', () => {
+  const e = evidence(); e.change = '\r valid \u{1f680} \r';
+  const c = canonicalDailyEvidence(e);
+  assert.equal(c.goal, 'A goal\nline'); assert.equal(c.change, 'valid \u{1f680}');
+  assert.equal(c.projectId, ID.toLowerCase()); assert.equal(c.revision, REV.toLowerCase());
+  assert.deepEqual(Object.keys(c), ['projectId', 'outcomeId', 'runId', 'revision', 'goal', 'change', 'checks', 'findings']);
+  assert.deepEqual(canonicalDailyEvidence(c), c);
+  assert.deepEqual(dailyRequest(ID, e), { id: ID.toLowerCase(), consent: true, evidence: c });
+  assert.throws(() => dailyRequest('bad-id', e), { message: 'invalid_daily_evidence' });
+});
+test('exact fields, plain data records, dense arrays, limits and enums fail closed', () => {
+  for (const mutate of [
+    e => { e.extra = true; }, e => { delete e.runId; }, e => { e.checks[0].extra = true; }, e => { delete e.findings[0].issue; },
+    e => { e.projectId = 'not-a-uuid'; }, e => { e.revision = 'a'.repeat(41); }, e => { e.checks[0].after = 'ok'; },
+    e => { e.checks[0].before = 'passed'; }, e => { e.checks[0].revision = 'b'.repeat(40); },
+    e => { e.checks = Array(1); }, e => { e.findings = Array(1); }, e => { e.checks.extra = true; },
+    e => { e.checks = Array.from({ length: 13 }, () => e.checks[0]); }, e => { e.findings = Array.from({ length: 6 }, () => e.findings[0]); },
+    e => { Object.defineProperty(e, 'goal', { get() { throw new Error('must not read getter'); }, enumerable: true }); },
+    e => { e.checks = [Object.create(e.checks[0])]; }, e => { e[Symbol('extra')] = true; },
+  ]) { const e = evidence(); mutate(e); invalid(e); }
+  const e = evidence(); e.checks[0].after = 'failed'; e.checks[0].revision = 'b'.repeat(64);
+  assert.equal(canonicalDailyEvidence(e).checks[0].revision.length, 64);
+});
+test('rejects controls and lone surrogates before normalization and bounds UTF8, not character count', () => {
+  for (const value of ['\u0000', '\u000b', '\u001f', '\u007f', '\u0085', '\ud800', '\udfff', 'x\ud800y']) {
+    const e = evidence(); e.goal = value; invalid(e);
+  }
+  for (const [field, limit] of [['goal', 1024], ['change', 3072]]) {
+    const e = evidence(); e[field] = ' '.repeat(limit + 1); invalid(e);
+    e[field] = 'é'.repeat(limit / 2); assert.equal(canonicalDailyEvidence(e)[field], e[field]);
+    e[field] += 'a'; invalid(e);
+  }
+  for (const [collection, index, field, limit] of [['checks', 0, 'name', 160], ['checks', 0, 'result', 1024], ['findings', 0, 'issue', 768], ['findings', 0, 'evidence', 1536], ['findings', 0, 'resolution', 1024]]) {
+    const e = evidence(); e[collection][index][field] = ' '.repeat(limit + 1); invalid(e);
+  }
+});
+test('canonical aggregate evidence limit is exact, includes escaping, request is bounded', () => {
+  const e = evidence(); e.goal = 'g'.repeat(1024); e.change = 'c'.repeat(3072);
+  e.checks = Array.from({ length: 7 }, () => ({ name: 'n', before: 'failed', after: 'passed', revision: REV, result: 'r'.repeat(1024) }));
+  e.findings = [];
+  while (Buffer.byteLength(JSON.stringify(canonicalDailyEvidence({ ...e, checks: e.checks.slice(0, -1) }))) > 12288) e.checks.pop();
+  const base = { ...e, checks: e.checks.slice(0, -1) };
+  let last = canonicalDailyEvidence(base);
+  // Fill another bounded field to find the precise canonical edge.
+  base.findings = [{ issue: '', evidence: '', resolution: '' }];
+  for (let n = 0; n <= 1536; n++) {
+    base.findings[0].evidence = 'x'.repeat(n);
+    try { last = canonicalDailyEvidence(base); } catch {
+      assert.equal(Buffer.byteLength(JSON.stringify(last)), 12288); invalid(base);
+      assert.ok(Buffer.byteLength(JSON.stringify(dailyRequest(ID, last))) <= 16384); return;
+    }
+  }
+  assert.fail('fixture must reach evidence byte boundary');
+});

package/tests/delivery-review.test.mjs

@@ -115,7 +115,7 @@ test('review rejects modified receipts, stale coverage, and cancellation', async
   await assert.rejects(captureDeliveryReview(state, cwd, dir, AbortSignal.abort()), /cancelled/);
 });
 
-test('review accepts filesystem aliases of the Git root but rejects ancestor repositories', async t => {
+test('review accepts filesystem aliases of the Git root and nested workspaces', async t => {
   const { cwd, state } = fixture(t);
   const parent = mkdtempSync(join(tmpdir(), 'review-alias-'));
   t.after(() => rmSync(parent, { recursive: true, force: true }));
@@ -126,7 +126,51 @@ test('review accepts filesystem aliases of the Git root but rejects ancestor rep
   assert.match(capture.diff, /diff --git/);
   const child = join(cwd, 'nested');
   mkdirSync(child);
-  await assert.rejects(captureDeliveryReview(state, child, join(child, '.harness')), /workspace Git root/);
+  writeFileSync(join(child, 'new.txt'), 'nested source');
+  const nested = await captureDeliveryReview(state, child, join(child, '.harness'));
+  assert.match(nested.diff, /nested source/);
+  assert.doesNotMatch(nested.diff, /export const amount|export const result/);
+});
+
+test('nested review scopes tracked, staged, deleted and new files and retains freshness', async t => {
+  const { cwd: root, state, params } = fixture(t);
+  const cwd = join(root, 'app café [one]');
+  mkdirSync(cwd);
+  const git = args => execFileSync('git', args, { cwd: root, stdio: 'pipe' });
+  for (const name of ['changed.txt', 'deleted.txt', 'moved.txt']) writeFileSync(join(cwd, name), 'baseline\n');
+  git(['add', '.']);
+  git(['-c', 'user.name=Test', '-c', 'user.email=test@localhost', 'commit', '-qm', 'Nested baseline']);
+  writeFileSync(join(root, 'app.mjs'), 'OUTSIDE_TRACKED_SECRET');
+  writeFileSync(join(root, 'outside.txt'), 'OUTSIDE_NEW_SECRET');
+  writeFileSync(join(cwd, 'changed.txt'), 'inside staged change\n');
+  git(['add', '.']);
+  git(['mv', 'app café [one]/moved.txt', 'outside-moved.txt']);
+  rmSync(join(cwd, 'deleted.txt'));
+  writeFileSync(join(cwd, 'new café.txt'), 'inside new source');
+  for (const name of ['node_modules', '.harness', 'artifacts']) {
+    mkdirSync(join(cwd, name), { recursive: true });
+    writeFileSync(join(cwd, name, 'noise.txt'), 'EXCLUDED_SECRET');
+  }
+  const capture = await captureDeliveryReview(state, cwd, join(cwd, '.harness', 'review'));
+  assert.match(capture.diff, /inside staged change/);
+  assert.match(capture.diff, /deleted file mode/);
+  assert.match(capture.diff, /inside new source/);
+  assert.match(capture.diff, /a\/moved.txt/);
+  assert.doesNotMatch(capture.diff, /OUTSIDE_|outside-moved|EXCLUDED_SECRET/);
+  state.evidence.unit.fingerprint = fingerprint(cwd, ['.']);
+  recordDeliveryReview(state, cwd, params(capture.id));
+  writeFileSync(join(root, 'outside.txt'), 'outside changes do not stale app review');
+  recordDeliveryReview(state, cwd, params(capture.id));
+  writeFileSync(join(cwd, 'new café.txt'), 'changed after review');
+  assert.throws(() => recordDeliveryReview(state, cwd, params(capture.id)), /stale/);
+});
+
+test('nested review rejects untracked symlinks escaping the workspace', async t => {
+  const { cwd: root, state } = fixture(t);
+  const cwd = join(root, 'nested');
+  mkdirSync(cwd);
+  symlinkSync(join(root, 'app.mjs'), join(cwd, 'escape.mjs'));
+  await assert.rejects(captureDeliveryReview(state, cwd, join(cwd, '.harness')), /outside|escape|symlink/i);
 });
 
 test('large diffs retain full receipt instead of silently using output tail', async t => {
@@ -137,3 +181,14 @@ test('large diffs retain full receipt instead of silently using output tail', as
   assert.ok(readFileSync(capture.path, 'utf8').length > 12000);
   assert.match(capture.diff, /diff --git/);
 });
+
+test('review accepts assertion aliases and names missing requirements', async t => {
+  const { cwd, state, params, dir } = fixture(t);
+  const capture = await captureDeliveryReview(state, cwd, dir);
+  assert.throws(() => recordDeliveryReview(state, cwd, { ...params(capture.id), coverage: [{ requirement: 'Other', assertions: 'x' }] }), /Missing: \["Correct amount"\]/);
+  recordDeliveryReview(state, cwd, { ...params(capture.id), coverage: [{ requirement: 'Correct amount', assertion: 'app amount equals 2' }] });
+  assert.equal(state.reviewEvidence.coverage[0].assertions, 'app amount equals 2');
+  const again = await captureDeliveryReview(state, cwd, dir);
+  recordDeliveryReview(state, cwd, { ...params(again.id), coverage: [{ requirement: 'Correct amount', assertions: ['amount is 2', 'new result is 2'] }] });
+  assert.equal(state.reviewEvidence.coverage[0].assertions, 'amount is 2; new result is 2');
+});

package/tests/delivery.test.mjs

@@ -79,6 +79,28 @@ test('argv execution captures output without shell expansion, including spaces',
   assert.equal(result.code, 0); assert.match(result.output, /literal \$HOME ; echo bad/);
   assert.match(readFileSync(logPath, 'utf8'), /literal/);
 });
+test('runCommand strips runtime transport tokens case-insensitively without mutating parent env', async t => {
+  const cwd = fixture(t);
+  const tokenKeys = ['CTG_RUNTIME_GITHUB_TOKEN', 'ctg_runtime_github_token', 'CtG_RuNtImE_GiThUb_ToKeN'];
+  const original = new Map(tokenKeys.map(key => [key, process.env[key]]));
+  const preservedOriginal = process.env.DELIVERY_ENV_PRESERVED;
+  process.env.DELIVERY_ENV_PRESERVED = 'yes';
+  for (const key of tokenKeys) process.env[key] = 'test-only-marker';
+  t.after(() => {
+    if (preservedOriginal === undefined) delete process.env.DELIVERY_ENV_PRESERVED;
+    else process.env.DELIVERY_ENV_PRESERVED = preservedOriginal;
+    for (const [key, value] of original) {
+      if (value === undefined) delete process.env[key];
+      else process.env[key] = value;
+    }
+  });
+
+  const script = `const keys = Object.keys(process.env); console.log(JSON.stringify({ tokensAbsent: !keys.some(key => key.toUpperCase() === 'CTG_RUNTIME_GITHUB_TOKEN'), preserved: process.env.DELIVERY_ENV_PRESERVED === 'yes' }));`;
+  const result = await runCommand([process.execPath, '-e', script], { cwd });
+  assert.equal(result.code, 0);
+  assert.deepEqual(JSON.parse(result.output.trim()), { tokensAbsent: true, preserved: true });
+  assert.deepEqual(tokenKeys.map(key => process.env[key]), tokenKeys.map(key => 'test-only-marker'));
+});
 test('nonzero exit and missing executable cannot be successful', async t => {
   const cwd = fixture(t);
   const fail = await runCommand([process.execPath, '-e', 'process.exit(7)'], { cwd, logPath: join(cwd, 'fail.log') });
@@ -340,4 +362,3 @@ test('guidance, prompt template and README document the classification', () => {
   assert.match(readme, /Informational vs delivery asks/);
   assert.match(readme, /advisory/);
 });
-

package/tests/fixtures/native-discovery-plugin/server.ts

@@ -0,0 +1,15 @@
+import { Plugin } from '@opencode/plugin';
+
+export default Plugin.define({
+  id: 'ctg-project-discovery-fixture',
+  setup: async ctx => {
+    const registration = await ctx.command.transform(editor => {
+      editor.add({
+        name: 'fixture-project-plugin-marker',
+        description: 'Proves project-local plugin discovery is active.',
+        execute: async () => { throw new Error('fixture marker command is not intended to execute'); },
+      });
+    });
+    return () => registration.dispose();
+  },
+});