carthagent 1.0.7 → 1.1.0-beta.1

package/tests/opencode-session-controls.test.mjs

@@ -94,6 +94,21 @@ test('persisted per-session launcher settings control framing without affecting
   assert.notEqual(event.prompt.text, 'Implement a parser');
 });
 
+test('explicit framing RPC override wins over persisted launch guide setting for only that session', async () => {
+  const f = fixture({}, {
+    a: { metadata: { 'carthagent.options': { guide: true } } },
+    b: { metadata: { 'carthagent.options': { guide: true } } },
+  });
+  await registerSessionControls(f.ctx);
+  await f.handlers.framing({ sessionID: 'a', enabled: false }, call());
+  const a = { sessionID: 'a', prompt: { text: 'Implement a parser' } };
+  const b = { sessionID: 'b', prompt: { text: 'Implement a parser' } };
+  await f.hooks.prompt(a);
+  await f.hooks.prompt(b);
+  assert.equal(a.prompt.text, 'Implement a parser');
+  assert.notEqual(b.prompt.text, 'Implement a parser');
+});
+
 test('queued controls recheck ownership after a session moves', async () => {
   const f = fixture();
   let releaseWrite;

package/tests/opencode-ship-rpc.test.mjs

@@ -0,0 +1,71 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+const jiti = (await import('jiti')).createJiti(import.meta.url);
+const { createShipRpcHandlers: createHandlers } = await jiti.import('../plugins/carthagent/src/server/ship-rpc.ts');
+const { CloudClient } = await import('../lib/cloud/client.mjs');
+
+test('profile Ship RPC uses resolved native OAuth and loopback account, billing, and revoke endpoints', async () => {
+  const requests = [];
+  const server = await import('node:http').then(({ createServer }) => createServer(async (request, response) => {
+    let body = '';
+    for await (const chunk of request) body += chunk;
+    requests.push({ method: request.method, url: request.url, authorization: request.headers.authorization, body: body ? JSON.parse(body) : undefined });
+    const payload = request.url === '/v1/account' ? { account: { id: 'acct-loopback' }, grants: [], sessions: [] }
+      : request.url === '/v1/account/usage?limit=25' ? { data: [{ alias: 'loopback-model', inputTokens: 5, outputTokens: 3 }] }
+      : request.url === '/v1/billing/checkout' ? { url: 'https://billing.test/checkout' }
+        : request.url === '/v1/billing/portal' ? { url: 'https://billing.test/portal' }
+          : {};
+    response.writeHead(200, { 'content-type': 'application/json' });
+    response.end(JSON.stringify(payload));
+  }));
+  server.listen(0, '127.0.0.1');
+  await new Promise(resolve => server.once('listening', resolve));
+  try {
+    const baseUrl = `http://127.0.0.1:${server.address().port}`;
+    const removed = [];
+    const ctx = { integration: { connection: {
+      active: async id => { assert.equal(id, 'experiential-labs'); return { type: 'credential', method: 'oauth', id: 'cred-profile' }; },
+      resolve: async () => ({ type: 'oauth', methodID: 'carthagent-device', access: 'loopback-token' }),
+    }, transform: async fn => fn({ remove: id => removed.push(id) }) } };
+    const handlers = createHandlers(ctx, { baseUrl, cloudUrl: baseUrl, cloudClient: new CloudClient({ baseUrl }) });
+    const signal = new AbortController().signal;
+    assert.deepEqual(await handlers.shipAccount({}, { signal }), { account: { account: { id: 'acct-loopback' }, grants: [], sessions: [] } });
+    assert.deepEqual(await handlers.shipUsage({ limit: 25 }, { signal }), { usage: { data: [{ alias: 'loopback-model', inputTokens: 5, outputTokens: 3 }] } });
+    assert.deepEqual(await handlers.shipBilling({ action: 'checkout' }, { signal }), { url: 'https://billing.test/checkout' });
+    assert.deepEqual(await handlers.shipBilling({ action: 'portal' }, { signal }), { url: 'https://billing.test/portal' });
+    assert.deepEqual(await handlers.shipLogout({ session: 'session-target' }, { signal }), { revoked: true });
+    assert.deepEqual(await handlers.shipLogout({}, { signal }), { revoked: true, credentialID: 'cred-profile' });
+    assert.deepEqual(requests.map(item => [item.method, item.url]), [
+      ['GET', '/v1/account'], ['GET', '/v1/account/usage?limit=25'], ['POST', '/v1/billing/checkout'], ['POST', '/v1/billing/portal'],
+      ['DELETE', '/v1/account/sessions/session-target'], ['POST', '/v1/token/revoke'],
+    ]);
+    assert.ok(requests.every(item => item.authorization === 'Bearer loopback-token'));
+    assert.deepEqual(requests[2].body, { successUrl: `${baseUrl}/account`, cancelUrl: `${baseUrl}/account` });
+    assert.deepEqual(requests[3].body, { returnUrl: `${baseUrl}/account` });
+    assert.deepEqual(removed, ['cred-profile']);
+  } finally {
+    server.closeAllConnections();
+    await new Promise(resolve => server.close(resolve));
+  }
+});
+
+test('profile Ship RPC rejects BYOK, absent auth, and pre-aborted operations without network calls', async () => {
+  let requests = 0;
+  const cloudClient = { async account() { requests++; }, async checkout() { requests++; }, async portal() { requests++; }, async revokeCurrent() { requests++; }, async revokeSession() { requests++; } };
+  const rpcCall = signal => ({
+    signal,
+    error: (code, message, data) => { throw Object.assign(new Error(message), { type: `ship.${code}`, data }); },
+  });
+  for (const connection of [undefined, { type: 'credential', method: 'key', id: 'key' }]) {
+    const handlers = createHandlers({ integration: { connection: {
+      active: async () => connection,
+      resolve: async () => connection ? { type: 'key', key: 'byok' } : undefined,
+    } } }, { cloudClient });
+    await assert.rejects(handlers.shipAccount({}, rpcCall(new AbortController().signal)), /active Carthagent Ship OAuth/);
+  }
+  const handlers = createHandlers({ integration: { connection: { active: async () => undefined, resolve: async () => undefined } } }, { cloudClient });
+  const controller = new AbortController();
+  controller.abort(new Error('cancelled before request'));
+  await assert.rejects(handlers.shipAccount({}, rpcCall(controller.signal)), /cancelled before request/);
+  assert.equal(requests, 0);
+});

package/tests/opencode-update.test.mjs

@@ -0,0 +1,475 @@
+import { test } from 'node:test';
+import assert from 'node:assert/strict';
+import { execFileSync, spawn } from 'node:child_process';
+import { mkdtempSync, mkdirSync, readFileSync, rmSync, writeFileSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { createServer } from 'node:http';
+import { once } from 'node:events';
+import { fileURLToPath } from 'node:url';
+import { readUpdateChannel, writeUpdateChannel } from '../lib/update-channel.mjs';
+import { npmUpdateArgv, runNativeUpdate } from '../lib/opencode/update.mjs';
+
+const release = { version: '1.2.0', tag: 'v1.2.0', installSpec: 'github:B-icy/Carthagent#v1.2.0', minNode: '22.19.0' };
+const noopIo = { log() {}, error() {} };
+
+function tempDir(fn) {
+  const dir = mkdtempSync(join(tmpdir(), 'ctg-native-update-'));
+  return Promise.resolve().then(() => fn(dir)).finally(() => rmSync(dir, { recursive: true, force: true }));
+}
+
+function git(args, cwd) {
+  return execFileSync('git', args, { cwd, encoding: 'utf8', stdio: ['ignore', 'pipe', 'pipe'] }).trim();
+}
+
+test('check-only resolves availability but does not inspect or install anything', async () => {
+  let commands = 0;
+  const result = await runNativeUpdate({
+    args: ['--check'], io: noopIo, root: '/does/not/matter', currentVersion: '1.0.0',
+    fetchLatestRelease: async () => ({ release }),
+    detectInstallMethod: () => { throw new Error('should not inspect install'); },
+    runCommand: async () => { commands++; },
+  });
+  assert.equal(result.status, 'available');
+  assert.equal(commands, 0);
+});
+
+test('rejects an invalid canonical tag before invoking an installer', async () => {
+  let calls = 0;
+  await assert.rejects(runNativeUpdate({
+    io: noopIo, currentVersion: '1.0.0', fetchLatestRelease: async () => ({ release: { ...release, tag: 'v1.2.0; npm evil' } }),
+    detectInstallMethod: () => 'npm', runCommand: async () => { calls++; },
+  }), /invalid or mismatched/);
+  assert.equal(calls, 0);
+});
+
+test('force remains bound to the validated version and command', async () => {
+  const calls = [];
+  await runNativeUpdate({
+    args: ['--force'], io: noopIo, currentVersion: '1.3.0',
+    fetchLatestRelease: async () => ({ release }), detectInstallMethod: () => 'npm',
+    platform: 'linux',
+    runCommand: async (argv, options) => { calls.push({ argv, options }); return { code: 0, output: '' }; },
+  });
+  assert.deepEqual(calls.map(call => call.argv), [
+    ['npm', 'view', `carthagent@${release.version}`, 'version', '--json'],
+    ['npm', 'install', '-g', '--install-links=true', `carthagent@${release.version}`],
+  ]);
+});
+
+test('npm update falls back to the validated GitHub spec when npm view fails', async () => {
+  const calls = [];
+  await runNativeUpdate({
+    io: noopIo, currentVersion: '1.0.0', fetchLatestRelease: async () => ({ release }),
+    detectInstallMethod: () => 'npm', platform: 'linux',
+    runCommand: async (argv, options) => {
+      calls.push({ argv, options });
+      return argv[1] === 'view' ? { code: 1, output: 'E404' } : { code: 0, output: '' };
+    },
+  });
+  assert.deepEqual(calls.map(call => call.argv), [
+    ['npm', 'view', `carthagent@${release.version}`, 'version', '--json'],
+    ['npm', 'install', '-g', '--install-links=true', release.installSpec],
+  ]);
+  assert.equal(calls[0].options.timeoutSeconds, 10);
+});
+
+test('clone update does not query the registry', async () => {
+  const calls = [];
+  await runNativeUpdate({
+    io: noopIo, currentVersion: '1.0.0', fetchLatestRelease: async () => ({ release }),
+    detectInstallMethod: () => 'clone', platform: 'linux',
+    runCommand: async argv => {
+      calls.push(argv);
+      if (argv[1] === 'status') return { code: 0, output: '' };
+      if (argv[1] === 'fetch') return { code: 0, output: '' };
+      if (argv[1] === 'rev-parse') return { code: 0, output: `${'a'.repeat(40)}\n` };
+      if (argv[1] === 'checkout') return { code: 0, output: '' };
+      if (argv[0] === 'npm') return { code: 0, output: '' };
+      throw new Error(`unexpected command ${argv.join(' ')}`);
+    },
+  });
+  assert.equal(calls.some(argv => argv[0] === 'npm' && argv[1] === 'view'), false);
+});
+
+test('clone update refuses dirty changes and preserves the dirty file', () => tempDir(async base => {
+  const remote = join(base, 'remote.git');
+  const seed = join(base, 'seed');
+  const clone = join(base, 'clone');
+  mkdirSync(seed);
+  git(['init', '--bare', remote], base);
+  git(['init', '-b', 'main'], seed);
+  git(['config', 'user.email', 'test@example.invalid'], seed);
+  git(['config', 'user.name', 'Test'], seed);
+  writeFileSync(join(seed, 'tracked.txt'), 'base\n');
+  git(['add', 'tracked.txt'], seed);
+  git(['commit', '-m', 'base'], seed);
+  git(['tag', 'v1.2.0'], seed);
+  git(['remote', 'add', 'origin', remote], seed);
+  git(['push', 'origin', 'main', '--tags'], seed);
+  git(['symbolic-ref', 'HEAD', 'refs/heads/main'], remote);
+  git(['clone', remote, clone], base);
+  git(['config', 'user.email', 'test@example.invalid'], clone);
+  git(['config', 'user.name', 'Test'], clone);
+  writeFileSync(join(clone, 'tracked.txt'), 'user modification\n');
+  writeFileSync(join(clone, 'untracked-user-data.txt'), 'user data\n');
+  let commands = 0;
+  await assert.rejects(runNativeUpdate({
+    io: noopIo, root: clone, currentVersion: '1.0.0', fetchLatestRelease: async () => ({ release }),
+    detectInstallMethod: () => 'clone', runCommand: async (...args) => { commands++; return (await import('../lib/opencode/update.mjs')).runUpdateCommand(...args); },
+  }), /uncommitted changes/);
+  assert.equal(commands, 1);
+  assert.equal(readFileSync(join(clone, 'tracked.txt'), 'utf8'), 'user modification\n');
+  assert.equal(readFileSync(join(clone, 'untracked-user-data.txt'), 'utf8'), 'user data\n');
+}));
+
+test('clone update fetches without force and checks out the exact release tag', () => tempDir(async base => {
+  const remote = join(base, 'remote.git');
+  const seed = join(base, 'seed');
+  const clone = join(base, 'clone');
+  mkdirSync(seed);
+  git(['init', '--bare', remote], base);
+  git(['init', '-b', 'main'], seed);
+  git(['config', 'user.email', 'test@example.invalid'], seed);
+  git(['config', 'user.name', 'Test'], seed);
+  writeFileSync(join(seed, 'tracked.txt'), 'base\n');
+  git(['add', 'tracked.txt'], seed);
+  git(['commit', '-m', 'base'], seed);
+  git(['tag', 'v1.2.0'], seed);
+  git(['remote', 'add', 'origin', remote], seed);
+  git(['push', 'origin', 'main', '--tags'], seed);
+  git(['clone', remote, clone], base);
+  const commands = [];
+  const result = await runNativeUpdate({
+    io: noopIo, root: clone, currentVersion: '1.0.0', fetchLatestRelease: async () => ({ release }),
+    detectInstallMethod: () => 'clone', runCommand: async (argv, options) => {
+      commands.push(argv);
+      if (argv[0] === 'git') return (await import('../lib/opencode/update.mjs')).runUpdateCommand(argv, options);
+      return { code: 0, output: '' };
+    },
+  });
+  assert.equal(result.status, 'updated');
+  assert.deepEqual(commands[0], ['git', 'status', '--porcelain']);
+  assert.deepEqual(commands[1].slice(0, 4), ['git', 'fetch', '--no-tags', 'origin']);
+  assert.equal(commands[1][4].startsWith('refs/tags/v1.2.0:'), true);
+  assert.deepEqual(commands[2].slice(0, 3), ['git', 'rev-parse', '--verify']);
+  assert.deepEqual(commands[3].slice(0, 3), ['git', 'checkout', '--detach']);
+  assert.equal(git(['describe', '--tags', '--exact-match'], clone), 'v1.2.0');
+  assert.equal(git(['status', '--porcelain'], clone), '');
+}));
+
+test('clone update uses the origin tag commit when a conflicting local tag exists and preserves that tag', () => tempDir(async base => {
+  const remote = join(base, 'remote.git');
+  const seed = join(base, 'seed');
+  const clone = join(base, 'clone');
+  mkdirSync(seed);
+  git(['init', '--bare', remote], base);
+  git(['init', '-b', 'main'], seed);
+  git(['config', 'user.email', 'test@example.invalid'], seed);
+  git(['config', 'user.name', 'Test'], seed);
+  writeFileSync(join(seed, 'tracked.txt'), 'remote release\n');
+  git(['add', 'tracked.txt'], seed);
+  git(['commit', '-m', 'release'], seed);
+  const remoteCommit = git(['rev-parse', 'HEAD'], seed);
+  git(['tag', 'v1.2.0'], seed);
+  git(['remote', 'add', 'origin', remote], seed);
+  git(['push', 'origin', 'main', '--tags'], seed);
+  git(['symbolic-ref', 'HEAD', 'refs/heads/main'], remote);
+  git(['clone', remote, clone], base);
+  git(['config', 'user.email', 'test@example.invalid'], clone);
+  git(['config', 'user.name', 'Test'], clone);
+  writeFileSync(join(clone, 'other.txt'), 'local tag target\n');
+  git(['add', 'other.txt'], clone);
+  git(['commit', '-m', 'local tag target'], clone);
+  const localTagCommit = git(['rev-parse', 'HEAD'], clone);
+  git(['tag', '-f', 'v1.2.0', localTagCommit], clone);
+  const calls = [];
+  await runNativeUpdate({
+    io: noopIo, root: clone, currentVersion: '1.0.0', fetchLatestRelease: async () => ({ release }),
+    detectInstallMethod: () => 'clone', runCommand: async (argv, options) => {
+      calls.push(argv);
+      return argv[0] === 'git' ? (await import('../lib/opencode/update.mjs')).runUpdateCommand(argv, options) : { code: 0, output: '' };
+    },
+  });
+  assert.equal(git(['rev-parse', 'HEAD'], clone), remoteCommit);
+  assert.equal(git(['rev-parse', 'refs/tags/v1.2.0^{commit}'], clone), localTagCommit);
+  assert.equal(calls.some(argv => argv[0] === 'git' && argv[1] === 'fetch' && argv.includes('--force')), false);
+  assert.equal(calls.some(argv => argv[0] === 'git' && argv.some(arg => arg.startsWith('refs/tags/v1.2.0:'))), true);
+}));
+
+test('clone update rejects an origin-missing release tag without checking out a local tag', () => tempDir(async base => {
+  const remote = join(base, 'remote.git');
+  const seed = join(base, 'seed');
+  const clone = join(base, 'clone');
+  mkdirSync(seed);
+  git(['init', '--bare', remote], base);
+  git(['init', '-b', 'main'], seed);
+  git(['config', 'user.email', 'test@example.invalid'], seed);
+  git(['config', 'user.name', 'Test'], seed);
+  writeFileSync(join(seed, 'tracked.txt'), 'remote main\n');
+  git(['add', 'tracked.txt'], seed);
+  git(['commit', '-m', 'main'], seed);
+  git(['remote', 'add', 'origin', remote], seed);
+  git(['push', 'origin', 'main'], seed);
+  git(['symbolic-ref', 'HEAD', 'refs/heads/main'], remote);
+  git(['clone', remote, clone], base);
+  git(['tag', 'v1.2.0'], clone);
+  const head = git(['rev-parse', 'HEAD'], clone);
+  const calls = [];
+  await assert.rejects(runNativeUpdate({
+    io: noopIo, root: clone, currentVersion: '1.0.0', fetchLatestRelease: async () => ({ release }),
+    detectInstallMethod: () => 'clone', runCommand: async (argv, options) => {
+      calls.push(argv);
+      return argv[0] === 'git' ? (await import('../lib/opencode/update.mjs')).runUpdateCommand(argv, options) : { code: 0, output: '' };
+    },
+  }), /git fetch v1\.2\.0 failed/);
+  assert.equal(git(['rev-parse', 'HEAD'], clone), head);
+  assert.equal(calls.every(argv => argv[0] === 'git'), true);
+}));
+
+test('clone update still removes its private ref after fetch cancellation', async () => {
+  const controller = new AbortController();
+  const calls = [];
+  await assert.rejects(runNativeUpdate({
+    io: noopIo, root: '/fixture/clone', currentVersion: '1.0.0', signal: controller.signal,
+    fetchLatestRelease: async () => ({ release }), detectInstallMethod: () => 'clone',
+    runCommand: async (argv, options) => {
+      calls.push({ argv, options });
+      if (argv[1] === 'fetch') {
+        controller.abort(new Error('cancelled during fetch'));
+        return { code: 1, output: '', cancelled: true };
+      }
+      if (argv[1] === 'status') return { code: 0, output: '' };
+      if (argv[1] === 'update-ref') return { code: 0, output: '' };
+      throw new Error(`unexpected command ${argv.join(' ')}`);
+    },
+  }), /git fetch v1\.2\.0 failed \(cancelled\)/);
+  const cleanup = calls.find(call => call.argv[1] === 'update-ref');
+  assert.ok(cleanup, 'best-effort cleanup is attempted after cancelled fetch');
+  assert.equal(cleanup.options.signal, undefined, 'cleanup is not suppressed by the aborted lifecycle signal');
+
+  await assert.rejects(runNativeUpdate({
+    io: noopIo, root: '/fixture/clone', currentVersion: '1.0.0',
+    fetchLatestRelease: async () => ({ release }), detectInstallMethod: () => 'clone',
+    runCommand: async argv => {
+      if (argv[1] === 'status') return { code: 0, output: '' };
+      if (argv[1] === 'fetch') throw new Error('fetch fixture failure');
+      if (argv[1] === 'update-ref') throw new Error('cleanup fixture failure');
+      throw new Error(`unexpected command ${argv.join(' ')}`);
+    },
+  }), /fetch fixture failure/);
+});
+
+test('clone update removes a real fetched private ref after cancellation', () => tempDir(async base => {
+  const remote = join(base, 'remote.git');
+  const seed = join(base, 'seed');
+  const clone = join(base, 'clone');
+  mkdirSync(seed);
+  git(['init', '--bare', remote], base);
+  git(['init', '-b', 'main'], seed);
+  git(['config', 'user.email', 'test@example.invalid'], seed);
+  git(['config', 'user.name', 'Test'], seed);
+  writeFileSync(join(seed, 'tracked.txt'), 'release\n');
+  git(['add', 'tracked.txt'], seed);
+  git(['commit', '-m', 'release'], seed);
+  git(['tag', 'v1.2.0'], seed);
+  git(['remote', 'add', 'origin', remote], seed);
+  git(['push', 'origin', 'main', '--tags'], seed);
+  git(['symbolic-ref', 'HEAD', 'refs/heads/main'], remote);
+  git(['clone', remote, clone], base);
+
+  const controller = new AbortController();
+  const commands = [];
+  await assert.rejects(runNativeUpdate({
+    io: noopIo, root: clone, currentVersion: '1.0.0', signal: controller.signal,
+    fetchLatestRelease: async () => ({ release }), detectInstallMethod: () => 'clone',
+    runCommand: async (argv, options) => {
+      commands.push({ argv, options });
+      const result = await (await import('../lib/opencode/update.mjs')).runUpdateCommand(argv, options);
+      if (argv[1] === 'fetch') {
+        assert.equal(result.code, 0, result.output);
+        assert.match(argv[4], /^refs\/tags\/v1\.2\.0:refs\/opencode-update\/[a-f0-9-]+$/);
+        controller.abort(new Error('cancelled immediately after fetch'));
+        return { ...result, code: 1, cancelled: true };
+      }
+      return result;
+    },
+  }), /git fetch v1\.2\.0 failed \(cancelled\)/);
+
+  const fetch = commands.find(command => command.argv[1] === 'fetch');
+  const cleanup = commands.find(command => command.argv[1] === 'update-ref');
+  assert.ok(fetch);
+  assert.ok(cleanup);
+  assert.equal(cleanup.options.signal, undefined);
+  assert.equal(cleanup.options.timeoutSeconds, 30);
+  assert.equal(cleanup.argv[2], '-d');
+  assert.equal(cleanup.argv[3], fetch.argv[4].split(':')[1]);
+  assert.equal(git(['for-each-ref', '--format=%(refname)', 'refs/opencode-update/'], clone), '');
+}));
+
+test('failed update command stops later steps and includes bounded failure output', async () => {
+  const calls = [];
+  await assert.rejects(runNativeUpdate({
+    io: noopIo, currentVersion: '1.0.0', fetchLatestRelease: async () => ({ release }),
+    detectInstallMethod: () => 'npm', platform: 'linux', runCommand: async argv => {
+      calls.push(argv);
+      return argv[1] === 'view' ? { code: 0, output: '"1.2.0"' } : { code: 2, output: 'npm failure' };
+    },
+  }), /npm install .* failed:\nnpm failure/);
+  assert.equal(calls.length, 2);
+  assert.deepEqual(calls[1], ['npm', 'install', '-g', '--install-links=true', 'carthagent@1.2.0']);
+});
+
+test('runUpdateCommand strips runtime download tokens from child env case-insensitively without mutating caller env', async () => {
+  const env = {
+    ...process.env,
+    CTG_RUNTIME_GITHUB_TOKEN: 'fake-uppercase-token',
+    ctg_runtime_github_token: 'fake-lowercase-token',
+    Ctg_Runtime_Github_Token: 'fake-mixedcase-token',
+    CTG_RUNTIME_OTHER: 'preserve-this-value',
+  };
+  const result = await (await import('../lib/opencode/update.mjs')).runUpdateCommand(
+    [process.execPath, '-e', 'process.stdout.write(JSON.stringify({env: process.env.CTG_RUNTIME_OTHER, tokenKeys: Object.keys(process.env).filter(key => key.toUpperCase() === "CTG_RUNTIME_GITHUB_TOKEN")}))'],
+    { cwd: process.cwd(), env, timeoutSeconds: 10 },
+  );
+  assert.equal(result.code, 0);
+  assert.deepEqual(JSON.parse(result.output), { env: 'preserve-this-value', tokenKeys: [] });
+  assert.equal(env.ctg_runtime_github_token, 'fake-lowercase-token');
+});
+
+test('Windows cancellation sanitizes taskkill environment and handles taskkill spawn errors', async () => {
+  const { EventEmitter } = await import('node:events');
+  const controller = new AbortController();
+  const calls = [];
+  const env = {
+    PATH: process.env.PATH,
+    CTG_RUNTIME_GITHUB_TOKEN: 'fake-uppercase-token',
+    ctg_runtime_github_token: 'fake-lowercase-token',
+    Ctg_Runtime_Github_Token: 'fake-mixedcase-token',
+    CTG_RUNTIME_OTHER: 'preserve-this-value',
+  };
+  const spawnImpl = (command, args, options) => {
+    calls.push({ command, args, options });
+    const child = new EventEmitter();
+    child.stdout = new EventEmitter();
+    child.stderr = new EventEmitter();
+    child.pid = command === 'taskkill' ? 9999 : 4242;
+    child.kill = () => { if (command !== 'taskkill') queueMicrotask(() => child.emit('close', 1)); };
+    child.unref = () => {};
+    if (command === 'taskkill') queueMicrotask(() => child.emit('error', new Error('taskkill unavailable')));
+    return child;
+  };
+  const pending = (await import('../lib/opencode/update.mjs')).runUpdateCommand(
+    ['fixture-updater'], { cwd: process.cwd(), env, signal: controller.signal, platform: 'win32', spawnImpl, timeoutSeconds: 10 },
+  );
+  controller.abort(new Error('cancel test'));
+  const result = await pending;
+  await new Promise(resolve => setImmediate(resolve));
+  assert.equal(result.cancelled, true);
+  assert.deepEqual(calls.map(call => call.command), ['fixture-updater', 'taskkill']);
+  assert.equal(calls[0].options.detached, false);
+  assert.equal(calls[1].options.env.CTG_RUNTIME_GITHUB_TOKEN, undefined);
+  assert.equal(calls[1].options.env.ctg_runtime_github_token, undefined);
+  assert.equal(calls[1].options.env.Ctg_Runtime_Github_Token, undefined);
+  assert.equal(calls[1].options.env.CTG_RUNTIME_OTHER, 'preserve-this-value');
+  assert.equal(env.Ctg_Runtime_Github_Token, 'fake-mixedcase-token');
+});
+
+test('zero exit code with timeout or cancellation is failure and prevents later steps', async () => {
+  for (const result of [{ code: 0, output: '', timedOut: true }, { code: 0, output: '', cancelled: true }]) {
+    const calls = [];
+    await assert.rejects(runNativeUpdate({
+      io: noopIo, currentVersion: '1.0.0', fetchLatestRelease: async () => ({ release }),
+      detectInstallMethod: () => 'npm', platform: 'linux', runCommand: async argv => {
+        calls.push(argv);
+        return argv[1] === 'view' ? { code: 0, output: '"1.2.0"' } : result;
+      },
+    }), result.timedOut ? /timed out/ : /cancelled/);
+    assert.equal(calls.length, 2);
+    assert.equal(calls[1][1], 'install');
+  }
+});
+
+test('an already-aborted lifecycle never checks releases or starts an installer', async () => {
+  const controller = new AbortController();
+  controller.abort(new Error('plugin disposed'));
+  let fetched = false;
+  let installed = false;
+  await assert.rejects(runNativeUpdate({
+    signal: controller.signal,
+    fetchLatestRelease: async () => { fetched = true; return { release }; },
+    detectInstallMethod: () => 'npm',
+    runCommand: async () => { installed = true; return { code: 0, output: '' }; },
+  }), /plugin disposed/);
+  assert.equal(fetched, false);
+  assert.equal(installed, false);
+});
+
+test('runUpdateCommand kills the updater process tree when its host lifecycle aborts', async () => {
+  const controller = new AbortController();
+  const pending = (await import('../lib/opencode/update.mjs')).runUpdateCommand(
+    [process.execPath, '-e', 'setTimeout(() => {}, 30000)'],
+    { cwd: process.cwd(), timeoutSeconds: 60, signal: controller.signal },
+  );
+  setTimeout(() => controller.abort(new Error('plugin disposed')), 40).unref?.();
+  const result = await pending;
+  assert.equal(result.cancelled, true);
+  assert.notEqual(result.code, 0);
+});
+
+test('a successful code with a timed-out global-install retry remains a failure', async () => {
+  const calls = [];
+  let attempt = 0;
+  await assert.rejects(runNativeUpdate({
+    io: noopIo, currentVersion: '1.0.0', fetchLatestRelease: async () => ({ release }),
+    detectInstallMethod: () => 'npm', cleanStaleInstall: () => ['/temporary/stale'],
+    platform: 'linux',
+    runCommand: async argv => {
+      calls.push(argv);
+      if (argv[0] === 'npm' && argv[1] === 'install') return ++attempt === 1
+        ? { code: 1, output: 'EEXIST' }
+        : { code: 0, output: '', timedOut: true };
+      return { code: 0, output: '/global/node_modules' };
+    },
+  }), /timed out/);
+  assert.equal(attempt, 2);
+});
+
+test('Windows npm command uses cmd.exe argv without a shell string', () => {
+  assert.deepEqual(npmUpdateArgv(['install', '-g', 'github:B-icy/Carthagent#v1.2.0'], 'win32'), [
+    'cmd.exe', '/d', '/s', '/c', 'npm', 'install', '-g', 'github:B-icy/Carthagent#v1.2.0',
+  ]);
+});
+
+test('runNativeUpdate passes npm operations through the Windows cmd shim', async () => {
+  const calls = [];
+  await runNativeUpdate({
+    io: noopIo, currentVersion: '1.0.0', fetchLatestRelease: async () => ({ release }),
+    detectInstallMethod: () => 'npm', platform: 'win32',
+    runCommand: async (argv, options) => { calls.push({ argv, options }); return { code: 0, output: '' }; },
+  });
+  assert.deepEqual(calls.map(call => call.argv), [
+    ['cmd.exe', '/d', '/s', '/c', 'npm', 'view', `carthagent@${release.version}`, 'version', '--json'],
+    ['cmd.exe', '/d', '/s', '/c', 'npm', 'install', '-g', '--install-links=true', `carthagent@${release.version}`],
+  ]);
+});
+
+
+test('explicit native command previews stable rollback without acquiring a runtime or saving a preference', () => tempDir(async dir => {
+  const env = { ...process.env, CARTHAGENT_UPDATE_CHANNEL_FILE: join(dir, 'channel.json'), CARTHAGENT_CODING_AGENT_DIR: join(dir, 'agent'), CTG_OPENCODE_HOME: join(dir, 'native') };
+  delete env.CTG_NATIVE;
+  writeUpdateChannel('experimental', env);
+  const server = createServer((_req, res) => { res.writeHead(200, { 'content-type': 'application/json' }); res.end(JSON.stringify({ version: '1.0.7', tag: 'v1.0.7' })); });
+  server.listen(0, '127.0.0.1');
+  await once(server, 'listening');
+  try {
+    env.CARTHAGENT_CLOUD_URL = `http://127.0.0.1:${server.address().port}`;
+    const child = spawn(process.execPath, [fileURLToPath(new URL('../bin/ctg.mjs', import.meta.url)), 'native', 'update', '--channel', 'stable', '--check'], { env, cwd: dir, stdio: ['ignore', 'pipe', 'pipe'] });
+    let output = ''; child.stdout.on('data', data => output += data); child.stderr.on('data', data => output += data);
+    const [code] = await once(child, 'close');
+    assert.equal(code, 0, output);
+    assert.match(output, /1\.0\.7.*available/);
+    assert.match(output, /--channel stable/);
+    assert.equal(readUpdateChannel(env), 'experimental');
+  } finally { server.closeAllConnections(); await new Promise(resolve => server.close(resolve)); }
+}));

package/tests/opencode-workspace.test.mjs

@@ -6,10 +6,55 @@ import { tmpdir } from 'node:os';
 import { join } from 'node:path';
 import { createTask, listNativeSessions, listNativeWorktrees, listTasks, reconcileTasks } from '../lib/opencode/workspace.mjs';
 import { listLegacyArchive, searchLegacyArchive, readLegacyTranscript, exportLegacyTranscript } from '../lib/opencode/archive.mjs';
-import { startReview, startPullRequestReview, verifyPullRequestHeads } from '../lib/opencode/review.mjs';
+import { localReviewSnapshot, startReview, startPullRequestReview, verifyPullRequestHeads } from '../lib/opencode/review.mjs';
 
 function git(cwd, ...args) { return execFileSync('git', args, { cwd, encoding: 'utf8', stdio: ['ignore', 'pipe', 'pipe'] }).trim(); }
 
+test('local review git children strip every runtime token spelling and preserve unrelated environment', { skip: process.platform === 'win32' }, t => {
+  const root = mkdtempSync(join(tmpdir(), 'ctg-review-git-env-'));
+  t.after(() => rmSync(root, { recursive: true, force: true }));
+  git(root, 'init', '-q');
+  git(root, 'config', 'user.email', 'test@example.invalid');
+  git(root, 'config', 'user.name', 'Test');
+  writeFileSync(join(root, 'source.txt'), 'review me\n');
+  git(root, 'add', 'source.txt');
+  git(root, 'commit', '-qm', 'fixture');
+
+  const bin = join(root, 'bin');
+  mkdirSync(bin);
+  const realGit = execFileSync('which', ['git'], { encoding: 'utf8' }).trim();
+  const capturePath = join(root, 'git-child-env.jsonl');
+  const wrapper = join(bin, 'git');
+  writeFileSync(wrapper, `#!/usr/bin/env node\nimport { appendFileSync } from 'node:fs';\nimport { spawnSync } from 'node:child_process';\nappendFileSync(process.env.CTG_REVIEW_GIT_CAPTURE, JSON.stringify({ tokenKeys: Object.keys(process.env).filter(key => key.toUpperCase() === 'CTG_RUNTIME_GITHUB_TOKEN'), unrelated: process.env.CTG_RUNTIME_OTHER }) + '\\n');\nconst result = spawnSync(${JSON.stringify(realGit)}, process.argv.slice(2), { stdio: 'inherit', env: process.env });\nprocess.exit(result.status ?? 1);\n`);
+  chmodSync(wrapper, 0o755);
+
+  const envKeys = ['PATH', 'CTG_RUNTIME_GITHUB_TOKEN', 'ctg_runtime_github_token', 'Ctg_Runtime_Github_Token', 'CTG_RUNTIME_OTHER', 'CTG_REVIEW_GIT_CAPTURE'];
+  const previous = Object.fromEntries(envKeys.map(key => [key, process.env[key]]));
+  Object.assign(process.env, {
+    PATH: `${bin}${process.platform === 'win32' ? ';' : ':'}${previous.PATH || ''}`,
+    CTG_RUNTIME_GITHUB_TOKEN: 'sentinel-uppercase-secret',
+    ctg_runtime_github_token: 'sentinel-lowercase-secret',
+    Ctg_Runtime_Github_Token: 'sentinel-mixedcase-secret',
+    CTG_RUNTIME_OTHER: 'preserve-review-env',
+    CTG_REVIEW_GIT_CAPTURE: capturePath,
+  });
+  try {
+    assert.match(localReviewSnapshot(root).head, /^[a-f0-9]{40,64}$/i);
+    const childEnvironments = readFileSync(capturePath, 'utf8').trim().split('\n').map(line => JSON.parse(line));
+    assert.ok(childEnvironments.length >= 3, 'snapshot runs multiple real git children');
+    for (const childEnv of childEnvironments) {
+      assert.deepEqual(childEnv.tokenKeys, []);
+      assert.equal(childEnv.unrelated, 'preserve-review-env');
+    }
+    assert.equal(process.env.CTG_RUNTIME_GITHUB_TOKEN, 'sentinel-uppercase-secret', 'credential remains in the parent process');
+  } finally {
+    for (const [key, value] of Object.entries(previous)) {
+      if (value === undefined) delete process.env[key];
+      else process.env[key] = value;
+    }
+  }
+});
+
 test('creates native worktree and explicit independent session; recovery is not blindly replayed', async t => {
   const root = mkdtempSync(join(tmpdir(), 'ctg-native ')); t.after(() => rmSync(root, { recursive: true, force: true }));
   const repo = join(root, 'repo'); mkdirSync(repo); git(repo, 'init', '-q'); git(repo, 'config', 'user.email', 'test@example.invalid'); git(repo, 'config', 'user.name', 'Test');
@@ -275,7 +320,11 @@ test('PR review rejects GitHub metadata that does not match fetched real branch
   process.env.PATH = `${bin}${process.platform === 'win32' ? ';' : ':'}${priorPath ?? ''}`;
   const ctx = { agent: { async list() { return { data: [{ id: 'build' }] }; } }, session: { async create() { reviewerCreated = true; return { id: 'no' }; } } };
   try {
-    await assert.rejects(startPullRequestReview({ ctx, cwd: root, repository: 'owner/fixture', prNumber: 9 }), /Fetched GitHub branch refs do not match/);
+    await assert.rejects(startPullRequestReview({ ctx, cwd: root, repository: 'owner/fixture', prNumber: 9 }), error => {
+      assert.match(error.message, /Fetched GitHub branch refs do not match/);
+      assert.equal(error.exitCode, 2);
+      return true;
+    });
     assert.equal(reviewerCreated, false);
   } finally { process.env.PATH = priorPath; }
 });