carthagent 1.0.7 → 1.1.0-preview.13

package/tools/test-native-review.mjs

@@ -0,0 +1,75 @@
+#!/usr/bin/env node
+/** Real-host independent review receipts must bind to exact Git source. */
+import assert from 'node:assert/strict';
+import { execFileSync } from 'node:child_process';
+import { writeFile, readFile, readdir } from 'node:fs/promises';
+import { join } from 'node:path';
+import { nativeFixture, streamText } from './native-fixture.mjs';
+
+let reviewRequests = 0;
+const host = await nativeFixture({
+  plugin: process.argv[2],
+  pluginOptions: { reviewModel: { providerID: 'ctg-fixture', id: 'fixture' } },
+  respond(body, res) {
+    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(res);
+    reviewRequests++;
+    streamText(res, `Fixture source review complete.\nREVIEW_JSON: ${JSON.stringify({ version: 1, snapshot, head, findings: [] })}\nVERDICT: APPROVE`);
+  },
+});
+const identity = host.runtimeIdentity;
+try {
+  const git = (...args) => execFileSync('git', args, { cwd: host.cwd, encoding: 'utf8' });
+  git('init', '--initial-branch=main');
+  await writeFile(join(host.cwd, 'fixture.txt'), 'review baseline\n');
+  git('add', 'fixture.txt');
+  git('-c', 'user.name=CTG Fixture', '-c', 'user.email=fixture@example.invalid', 'commit', '-m', 'Review fixture');
+  await host.active();
+  const worker = await host.client.session.create({ location: host.location, model: host.model, title: 'Implementation session' }, host.request());
+  const rpc = async method => (await host.client.rpc.call({ rpcID: 'carthagent.workspace', method,
+    input: { sessionID: worker.id }, location: host.location }, host.request())).output;
+  const before = await rpc('review');
+  assert.equal(before.status, 'unreviewed');
+  const result = await rpc('startReview');
+  assert.equal(result.status, 'approved');
+  assert.notEqual(result.sessionID, worker.id);
+  const reviewer = await host.client.session.get({ sessionID: result.sessionID }, host.request());
+  assert.equal(reviewer.parentID, undefined);
+  assert.equal(reviewer.location.directory, host.cwd);
+  assert.equal((await rpc('review')).status, 'approved');
+  const count = reviewRequests;
+  await assert.rejects(rpc('startReview'));
+  assert.equal(reviewRequests, count, 'Already approved source must not launch another review');
+  await host.stop();
+  await host.start();
+  await host.active();
+  assert.equal((await rpc('review')).status, 'approved', 'Review receipt survives service restart');
+  await writeFile(join(host.cwd, 'fixture.txt'), 'changed source\n');
+  assert.equal((await rpc('review')).status, 'stale', 'Any source change invalidates approval');
+  assert.equal((await rpc('startReview')).status, 'approved');
+  await writeFile(join(host.cwd, 'fixture.txt'), 'third source revision\n');
+  assert.equal((await rpc('startReview')).status, 'approved');
+  await host.stop();
+  await host.start();
+  await host.active();
+  await writeFile(join(host.cwd, 'fixture.txt'), 'fourth source revision\n');
+  const admissions = reviewRequests;
+  await assert.rejects(rpc('startReview'), error => error.type === 'reviewFailed' && /round limit/i.test(error.message));
+  assert.equal(reviewRequests, admissions, 'Restart and changed source must not bypass the three-review admission limit');
+  console.log(JSON.stringify({ host: identity.runtimeVersion, compatibilityVersion: identity.compatibilityVersion,
+    ...(identity.binarySha256 ? { binarySha256: identity.binarySha256 } : {}),
+    independentReview: 'passed', persistedReceipt: 'passed', staleInvalidation: 'passed', persistentAdmissionLimit: 'passed' }));
+} catch (error) {
+  console.error(host.output);
+  const reviews = join(host.cwd, '.harness/reviews');
+  for (const entry of await readdir(reviews).catch(() => [])) {
+    if (entry.endsWith('.json')) console.error(await readFile(join(reviews, entry), 'utf8'));
+  }
+  const inventory = await host.client.session.list({ location: host.location }, host.request());
+  for (const session of inventory.data ?? []) console.error(JSON.stringify({ title: session.title, messages: await host.client.session.context({ sessionID: session.id }, host.request()) }));
+  throw error;
+} finally {
+  await host.close();
+}

package/tools/test-native-runtime.mjs

@@ -0,0 +1,120 @@
+#!/usr/bin/env node
+/** Exercise CTG's wrappers, including resumed failures, against the real host. */
+import assert from 'node:assert/strict';
+import { readFile, writeFile } from 'node:fs/promises';
+import { join } from 'node:path';
+import { ensureService, stopService } from '../lib/opencode/service.mjs';
+import { runHeadless } from '../lib/opencode/headless.mjs';
+import { nativeFixture, streamText } from './native-fixture.mjs';
+
+let stallStarted;
+const stalled = new Promise(resolve => { stallStarted = resolve; });
+const host = await nativeFixture({
+  plugin: process.argv[2],
+  respond(body, res) {
+    const text = JSON.stringify([...body.messages].reverse().find(message => message.role === 'user'));
+    if (text.includes('WRAPPER_STALL')) {
+      res.writeHead(200, { 'content-type': 'text/event-stream' });
+      res.flushHeaders();
+      stallStarted();
+      return;
+    }
+    if (text.includes('WRAPPER_TOOL') && !body.messages.some(message => message.role === 'tool')) {
+      assert.ok(body.tools.some(tool => tool.function?.name === 'read'), 'Native host must advertise the requested read tool');
+      const chunk = (delta, finish_reason = null) => `data: ${JSON.stringify({
+        id: 'runtime-tool', object: 'chat.completion.chunk', created: 1, model: 'fixture',
+        choices: [{ index: 0, delta, finish_reason }],
+      })}\n\n`;
+      res.writeHead(200, { 'content-type': 'text/event-stream' });
+      res.end(`${chunk({ role: 'assistant', tool_calls: [{ index: 0, id: 'wrapper-read', type: 'function',
+        function: { name: 'read', arguments: JSON.stringify({ path: join(host.cwd, 'wrapper-tool.txt') }) } }] })}${chunk({}, 'tool_calls')}data: [DONE]\n\n`);
+      return;
+    }
+    if (text.includes('WRAPPER_FAILURE')) {
+      res.writeHead(400, { 'content-type': 'application/json' });
+      res.end(JSON.stringify({ error: { message: 'Offline wrapper rejection', type: 'invalid_request_error' } }));
+    } else streamText(res, text.includes('WRAPPER_TOOL') ? 'FINAL_AFTER_TOOL' : text.includes('WRAPPER_SECOND') ? 'SECOND_TURN' : 'FIRST_TURN');
+  },
+});
+const identity = host.runtimeIdentity;
+const options = { root: join(host.temp, 'runtime'), pluginPath: process.argv[2] ?? join(import.meta.dirname, '../plugins/carthagent') };
+try {
+  options.profile = JSON.parse(await readFile(join(host.temp, 'config/opencode/opencode.json'), 'utf8'));
+  const service = await ensureService(options);
+  assert.equal(service.info.version, identity.runtimeVersion, 'Owned service must run the fixture-identified native binary');
+  const reused = await ensureService(options);
+  assert.equal(reused.info.pid, service.info.pid);
+  assert.equal(reused.url, service.url);
+  const common = { timeout: 30_000, env: { PATH: process.env.PATH }, session: {
+    model: host.model, metadata: { 'carthagent.options': { guide: false } },
+  } };
+  const first = await runHeadless(service, host.cwd, 'WRAPPER_FIRST', common);
+  assert.equal(first.result?.text, 'FIRST_TURN');
+  assert.equal(first.outcome, 'succeeded');
+  assert.equal(first.terminal, true);
+  assert.equal(first.budgetReason, undefined, 'A successful terminal outcome has no budget failure reason');
+  const second = await runHeadless(service, host.cwd, 'WRAPPER_SECOND', { ...common, sessionID: first.session.id });
+  assert.equal(second.result?.text, 'SECOND_TURN', 'Resume must return the current turn');
+  await writeFile(join(host.cwd, 'wrapper-tool.txt'), 'Read this through the native tool.\n');
+  const toolTurn = await runHeadless(service, host.cwd, 'WRAPPER_TOOL', common);
+  assert.equal(toolTurn.outcome, 'succeeded');
+  const readTool = toolTurn.messages.flatMap(message => message.content ?? []).find(part => part.type === 'tool' && part.name === 'read');
+  assert.equal(readTool?.state.status, 'completed', 'The native read tool must really complete before the final answer');
+  assert.ok(readTool.state.content.some(part => part.type === 'text' && part.text.includes('Read this through the native tool.')));
+  assert.equal(toolTurn.result?.text, 'FINAL_AFTER_TOOL', 'Return the final assistant after tools, not the initial tool-call message');
+  let failure;
+  try { failure = await runHeadless(service, host.cwd, 'WRAPPER_FAILURE', { ...common, sessionID: first.session.id }); }
+  catch (error) { failure = { error }; }
+  assert.ok(failure.error || failure.result?.error || failure.result?.status === 'error' || failure.outcome === 'failed',
+    `Provider failure must not return a previous successful assistant: ${JSON.stringify(failure)}`);
+  const recovered = await runHeadless(service, host.cwd, 'WRAPPER_SECOND', { ...common, sessionID: first.session.id });
+  assert.equal(recovered.result?.text, 'SECOND_TURN');
+  const cancel = new AbortController();
+  const interrupted = runHeadless(service, host.cwd, 'WRAPPER_STALL', { ...common, sessionID: first.session.id, signal: cancel.signal });
+  let admissionTimer;
+  try {
+    await Promise.race([stalled, new Promise((_, reject) => {
+      admissionTimer = setTimeout(() => reject(Error('Wrapper cancellation fixture did not reach provider')), 10_000);
+    })]);
+    const neighbor = await runHeadless(service, host.cwd, 'WRAPPER_SECOND', common);
+    assert.equal(neighbor.result?.text, 'SECOND_TURN', 'A stalled session must not block its neighbor');
+  } finally {
+    clearTimeout(admissionTimer);
+    cancel.abort(Error('Offline wrapper cancellation'));
+  }
+  const cancelled = await interrupted;
+  assert.equal(cancelled.reason, 'aborted');
+  assert.equal(cancelled.outcome, 'interrupted');
+  assert.notEqual(cancelled.result?.text, 'SECOND_TURN', 'An interrupted resumed turn must not reuse a prior answer');
+  const afterCancel = await runHeadless(service, host.cwd, 'WRAPPER_SECOND', { ...common, sessionID: first.session.id });
+  assert.equal(afterCancel.result?.text, 'SECOND_TURN');
+  let preAborted;
+  try {
+    preAborted = await runHeadless(service, host.cwd, 'MUST_NOT_BE_ADMITTED', {
+      ...common, sessionID: first.session.id, signal: AbortSignal.abort(Error('Already cancelled')),
+    });
+  } catch (error) { preAborted = { error }; }
+  assert.ok(preAborted.error || preAborted.outcome === 'interrupted', 'A pre-aborted invocation cannot inherit an earlier successful outcome');
+  assert.equal(preAborted.result, undefined, 'A pre-aborted invocation has no current-turn assistant response');
+  let unroutable;
+  try {
+    unroutable = await runHeadless(service, host.cwd, 'UNAVAILABLE_MODEL', {
+      ...common, session: { model: { providerID: 'absent-fixture', id: 'missing' } },
+    });
+  } catch (error) { unroutable = { error }; }
+  assert.ok(unroutable.error || unroutable.outcome === 'failed' || unroutable.session?.outcome === 'failed',
+    `A failure without an assistant must expose a failed terminal outcome: ${JSON.stringify(unroutable)}`);
+  assert.equal(await stopService(options), true);
+  const restarted = await ensureService(options);
+  assert.notEqual(restarted.info.id, service.info.id, 'Restart registers a fresh owned service identity');
+  const resumed = await runHeadless(restarted, host.cwd, 'WRAPPER_SECOND', { ...common, sessionID: first.session.id });
+  assert.equal(resumed.session.id, first.session.id);
+  assert.equal(resumed.result?.text, 'SECOND_TURN', 'Session state remains usable after the owned service restarts');
+  assert.equal(await stopService(options), true);
+  console.log(JSON.stringify({ host: identity.runtimeVersion, compatibilityVersion: identity.compatibilityVersion,
+    ...(identity.binarySha256 ? { binarySha256: identity.binarySha256 } : {}),
+    serviceReuse: 'passed', repeatedTurns: 'passed', finalAnswerAfterTool: 'passed', successMetadata: 'passed', failure: 'passed', recovery: 'passed', cancellation: 'passed', neighboringSession: 'passed', preAbortedInvocation: 'passed', serviceRestart: 'passed' }));
+} finally {
+  try { await stopService(options); }
+  finally { await host.close(); }
+}

package/tools/test-native-ship-models.mjs

@@ -0,0 +1,176 @@
+#!/usr/bin/env node
+import assert from 'node:assert/strict';
+import { execFile, spawn } from 'node:child_process';
+import { once } from 'node:events';
+import { access, mkdir, mkdtemp, readFile, rm, writeFile } from 'node:fs/promises';
+import { createServer } from 'node:http';
+import { tmpdir } from 'node:os';
+import { join, resolve } from 'node:path';
+import { randomBytes } from 'node:crypto';
+import { promisify } from 'node:util';
+import { OpenCode } from '@opencode/client';
+import { provisionRuntime, resolveOpenCode, runtimePaths } from '../lib/opencode/runtime.mjs';
+import { preflightNativeTestRuntimeArtifact } from './native-runtime-identity.mjs';
+import { stopFixtureBrowser } from './native-fixture-browser-cleanup.mjs';
+import { fixtureStopDiagnostics } from './native-fixture-stop-diagnostics.mjs';
+
+const root = resolve(import.meta.dirname, '..');
+const runtimeOptions = { runtimeCacheRoot: process.env.CTG_RUNTIME_TEST_CACHE };
+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 temp = await mkdtemp(join(tmpdir(), 'ctg-ship-models-'));
+const cwd = join(temp, 'project');
+const config = join(temp, 'config/opencode');
+const password = randomBytes(24).toString('hex');
+const token = `fixture.${Buffer.from(JSON.stringify({ sub: 'offline-user', sid: 'offline-session', scope: 'gateway:invoke', exp: Math.floor(Date.now() / 1000) + 3600 })).toString('base64url')}.fixture`;
+let modelRequests = 0;
+let verificationUri;
+const cloud = createServer((req, res) => {
+  req.resume();
+  req.on('end', () => {
+    let status = 200, body;
+    if (req.url === '/v1/device/authorizations') {
+      body = { deviceCode: 'offline-device', userCode: 'OFFLINE', verificationUri, expiresIn: 120, interval: 1 };
+    } else if (req.url === '/v1/device/token') {
+      body = { accessToken: token, refreshToken: 'offline-refresh', expiresIn: 3600 };
+    } else if (req.url === '/v1/models' && req.headers.authorization === `Bearer ${token}`) {
+      modelRequests++;
+      body = { data: [{ id: 'ctg-ship-fixture' }] };
+    } else { status = 404; body = {}; }
+    res.writeHead(status, { 'content-type': 'application/json' });
+    res.end(JSON.stringify(body));
+  });
+});
+let child;
+let output = '';
+try {
+  cloud.listen(0, '127.0.0.1');
+  await once(cloud, 'listening');
+  verificationUri = `http://127.0.0.1:${cloud.address().port}/verify-${randomBytes(16).toString('hex')}`;
+  await mkdir(cwd);
+  await mkdir(config, { recursive: true });
+  await writeFile(join(config, 'opencode.json'), JSON.stringify({ plugins: [
+    join(temp, 'deleted-pr-checkout/plugins/carthagent'),
+    { package: join(temp, 'deleted-install/plugins/carthagent'), options: {} },
+  ], update: 'disable' }));
+  await provisionRuntime({ root: temp, pluginPath: join(root, 'plugins/carthagent') });
+  const env = Object.fromEntries(['PATH', 'SystemRoot', 'WINDIR', 'ComSpec', 'PATHEXT'].filter(key => process.env[key]).map(key => [key, process.env[key]]));
+  Object.assign(env, {
+    HOME: join(temp, 'home'), USERPROFILE: join(temp, 'home'),
+    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'),
+    OPENCODE_CONFIG_DIR: config, OPENCODE_CONFIG: join(config, 'opencode.json'),
+    OPENCODE_CONFIG_PROJECT_DISABLE: 'true', OPENCODE_DB: join(temp, 'database.sqlite'),
+    OPENCODE_SERVER_PASSWORD: password, CARTHAGENT_CLOUD_URL: `http://127.0.0.1:${cloud.address().port}`,
+  });
+  async function startHost() {
+    output = '';
+    child = spawn(binary, ['serve', '--hostname', '127.0.0.1', '--port', '0', '--print-logs'], { cwd, env, stdio: ['ignore', 'pipe', 'pipe'] });
+    const endpoint = await new Promise((resolveEndpoint, reject) => {
+      const timer = setTimeout(() => reject(Error('Native Ship fixture host startup timed out')), 30_000);
+      const collect = chunk => {
+        output = (output + String(chunk)).slice(-16384);
+        const found = output.match(/http:\/\/127\.0\.0\.1:\d+/)?.[0];
+        if (found) { clearTimeout(timer); resolveEndpoint(found); }
+      };
+      child.stdout.on('data', collect); child.stderr.on('data', collect);
+      child.once('error', error => { clearTimeout(timer); reject(error); });
+      child.once('exit', code => { clearTimeout(timer); reject(Error(`Native Ship fixture exited ${code}`)); });
+    });
+    const client = OpenCode.make({ baseUrl: endpoint, headers: { authorization: `Basic ${Buffer.from(`opencode:${password}`).toString('base64')}` } });
+    return { client, endpoint };
+  }
+  const { client, endpoint } = await startHost();
+  const location = { directory: cwd };
+  const request = { signal: AbortSignal.timeout(30_000) };
+  const startedAt = Date.now();
+  while (true) {
+    const plugins = await client.plugin.list({ location }, request);
+    const plugin = plugins.data.find(item => item.id === 'carthagent');
+    if (plugin?.state.status === 'active') {
+      assert.equal(plugins.data.filter(item => item.id === 'carthagent').length, 1, 'Migrated profile must load exactly one Carthagent plugin');
+      assert.ok(!plugins.data.some(item => item.state.status === 'failed' || item.state.status === 'error'), 'Migrated profile must not leave stale or duplicate plugin failures');
+      break;
+    }
+    assert.notEqual(plugin?.state.status, 'error', 'Carthagent plugin setup failed');
+    assert.ok(Date.now() - startedAt < 15000, 'Carthagent plugin did not become active');
+    await new Promise(resolve => setTimeout(resolve, 100));
+  }
+  const integrations = await client.integration.list({ location }, request);
+  console.log(JSON.stringify({ supportedIntegrations: integrations.data.filter(item => /anthropic|openai|codex|chatgpt|xai|google|gemini|experiential/.test(item.id)).map(item => ({ id: item.id, name: item.name, methods: item.methods.map(method => ({ type: method.type, id: method.id, label: method.label })) })) }));
+  const ship = integrations.data.find(item => item.id === 'experiential-labs');
+  assert.ok(ship, 'Ship must be connectable without a preexisting credential or EXPLABS_API_KEY');
+  console.log(JSON.stringify({ integrationName: ship.name, methods: ship.methods.map(method => ({ type: method.type, id: method.id })) }));
+  const started = await client.integration.oauth.connect({ integrationID: ship.id, methodID: 'carthagent-device', answer: {}, location }, request);
+  const deadline = Date.now() + 15000;
+  while (true) {
+    const status = (await client.integration.oauth.status({ integrationID: ship.id, attemptID: started.data.attemptID, location }, request)).data;
+    if (status.status === 'complete') break;
+    assert.ok(['pending', 'waiting'].includes(status.status), `OAuth completion failed: ${status.status}`);
+    assert.ok(Date.now() < deadline, 'OAuth completion timed out');
+    await new Promise(resolve => setTimeout(resolve, 100));
+  }
+  let models;
+  do {
+    models = (await client.model.list({ location }, request)).data.filter(model => model.providerID === ship.id);
+    if (models.some(model => model.id === 'ctg-ship-fixture')) break;
+    await new Promise(resolve => setTimeout(resolve, 100));
+  } while (Date.now() < deadline);
+  console.log(JSON.stringify({ modelRequests, models: models.map(model => ({ id: model.id, providerID: model.providerID, connected: model.connected, status: model.status })) }));
+  assert.ok(models.some(model => model.id === 'ctg-ship-fixture'), 'Successful Ship OAuth must publish discovered models in the real native model inventory without EXPLABS_API_KEY');
+  assert.equal(ship.name, 'Carthagent Ship', 'The connect picker must show the Ship name');
+  assert.deepEqual(integrations.data.map(item => item.id).sort(), ['anthropic', 'experiential-labs', 'google', 'openai', 'xai'], 'Login must contain only the curated major integrations');
+  const providers = (await client.provider.list({ location }, request)).data;
+  assert.ok(!providers.some(provider => /^opencode(?:-|$)/.test(provider.id)), 'The upstream provider must not be available');
+  const paths = runtimePaths({ root: temp });
+  const credentialBeforeStop = (await client.credential.list(request)).find(entry => entry.integrationID === ship.id);
+  assert.ok(credentialBeforeStop?.active, 'Ship must have a persisted active credential');
+  const info = await client.server.info(request);
+  assert.equal(info.pid, child.pid);
+  await mkdir(join(temp, 'state/opencode'), { recursive: true });
+  await writeFile(paths.serviceFile, JSON.stringify({ id: 'ship-model-regression', pid: child.pid, url: endpoint, password, runtimeIdentity: { version: info.version } }), { mode: 0o600 });
+  const closed = once(child, 'close');
+  const stopStartedAt = performance.now();
+  try {
+    const stopped = await promisify(execFile)(process.execPath, [join(root, 'bin/ctg.mjs'), 'native', 'service', 'stop'], { cwd, env: { ...env, CTG_OPENCODE_HOME: temp }, timeout: 15000 });
+    assert.match(stopped.stdout, /Stopped the registered native service/);
+    await closed;
+  } catch (error) {
+    try {
+      console.error('Native Ship fixture service-stop failure evidence:', JSON.stringify(await fixtureStopDiagnostics({ child, output, elapsedMs: performance.now() - stopStartedAt })));
+    } catch {
+      console.error('Native Ship fixture service-stop failure evidence unavailable.');
+    }
+    throw error;
+  }
+  const restarted = await startHost();
+  const credentialAfterStop = (await restarted.client.credential.list(request)).find(entry => entry.id === credentialBeforeStop.id);
+  assert.deepEqual(credentialAfterStop, credentialBeforeStop, 'Explicit service stop must preserve the active authenticated credential across restart');
+  assert.ok((await readFile(join(temp, 'database.sqlite'))).length > 0, 'Explicit service stop must preserve the native database');
+  console.log('Explicit native service stop preserved credentials and database.');
+
+} finally {
+  if (child && child.exitCode === null && child.signalCode === null) {
+    const closed = once(child, 'close', { signal: AbortSignal.timeout(10_000) });
+    // No PTYs are spawned here; stop this exact server like the service-stop command does.
+    child.kill('SIGTERM');
+    const timer = setTimeout(() => { if (child.exitCode === null && child.signalCode === null) child.kill('SIGKILL'); }, 5000);
+    try { await closed; }
+    finally { clearTimeout(timer); }
+  }
+  cloud.closeAllConnections();
+  await new Promise(resolve => cloud.close(resolve));
+  if (process.platform === 'win32' && verificationUri) {
+    await promisify(execFile)('powershell.exe', ['-NoProfile', '-NonInteractive', '-Command', stopFixtureBrowser], {
+      env: { ...process.env, CTG_NATIVE_FIXTURE_URL: verificationUri }, windowsHide: true, timeout: 20_000,
+    });
+  }
+  await rm(temp, { recursive: true, force: true, maxRetries: 12, retryDelay: 250 });
+  await assert.rejects(access(temp), { code: 'ENOENT' });
+  console.log('Native Ship fixture shutdown and temporary-directory cleanup completed.');
+}

package/tools/test-native-ship-walkthrough.mjs

@@ -0,0 +1,96 @@
+#!/usr/bin/env node
+import assert from 'node:assert/strict';
+import { readFile } from 'node:fs/promises';
+import { latestReport } from '../lib/reports.mjs';
+import { nativeFixture, streamText } from './native-fixture.mjs';
+
+const requirement = 'fixture content is correct';
+const design = {
+  components: [{ id: 'fixture', responsibility: 'Write the fixture output', excludes: ['production behavior'], layer: 'core', dependencies: [], externalDependencies: [], requirements: [requirement] }],
+  ports: [], risks: [],
+  scenarios: [
+    { id: 'valid', requirement, kind: 'positive', path: ['fixture'], input: 'correct output', expected: 'check passes', assertion: 'exact UTF-8 file contents match', checks: ['fixture-check'] },
+    { id: 'invalid', requirement, kind: 'failure', path: ['fixture'], input: 'broken output', expected: 'check fails', assertion: 'wrong contents trigger an assertion failure', checks: ['fixture-check'] },
+  ],
+};
+const plan = {
+  goal: 'Exercise native Ship from approval through a repaired verified handoff',
+  assumptions: [], artifacts: ['fixture.txt'], outputs: ['fixture.txt'],
+  steps: [{ id: 'fixture', title: 'Create and verify fixture output' }],
+  acceptance: [{ requirement, checks: ['fixture-check'] }],
+  checks: [{ id: 'fixture-check', kind: 'test', argv: ['node', '-e', 'require("node:assert/strict").equal(require("node:fs").readFileSync("fixture.txt", "utf8"), "fixture output\\n")'], timeoutSeconds: 5 }],
+  design,
+};
+const designReview = {
+  challenges: ['Does broken content actually fail the checker?'],
+  walkthroughs: design.scenarios.map(item => ({ scenario: item.id, trace: `${item.input} -> fixture -> ${item.expected}`, assertion: item.assertion })),
+  findings: [], limitations: ['Model-authored fixture review, not independent assurance.'],
+};
+const call = (name, input) => `await tools.carthagent[${JSON.stringify(name)}](${JSON.stringify(input)})`;
+const finish = { status: 'verified', change: 'Created fixture.txt with the required exact UTF-8 content.', review: 'Exact content check and repaired failure inspected.', launch: 'Fixture check executed in this disposable workspace.', limitations: ['Fixture-only walkthrough; no production or visual assurance.'] };
+const actions = [
+  { code: `return ${call('delivery_plan', plan)}` },
+  { code: `return ${call('delivery_finish', finish)}` },
+  { code: `return ${call('delivery_design', { action: 'validate' })}` },
+  { code: `const capture = String(${call('delivery_design', { action: 'inspect' })}); const captureId = JSON.parse(capture).captureId; if (!captureId) throw Error("Missing design capture"); return await tools.carthagent.delivery_design({ action: "review", captureId, review: ${JSON.stringify(designReview)} })` },
+  { code: `return ${call('delivery_design', { action: 'approve' })}` },
+  { shell: 'printf broken > fixture.txt' },
+  { code: `return ${call('delivery_check', { id: 'all' })}` },
+  { code: `return ${call('delivery_finish', finish)}` },
+  { shell: "printf 'fixture output\\n' > fixture.txt" },
+  { code: `return ${call('delivery_progress', { step: 'fixture', status: 'done' })}` },
+  { code: `return ${call('delivery_check', { id: 'all' })}` },
+  { code: `const capture = JSON.parse(String(${call('delivery_review', { action: 'inspect' })})); return await tools.carthagent.delivery_review({ action: "record", captureId: capture.id, coverage: [{ requirement: ${JSON.stringify(requirement)}, status: "demonstrated", assertions: "The real checker rejected broken content, then accepted the repaired exact UTF-8 contents." }], probes: ["Observed assertion failure before repair and a passing exact-content assertion afterward."], findings: [], limitations: ["Model-authored fixture review; not independent production assurance."] })` },
+  { code: `return ${call('delivery_finish', finish)}` },
+];
+let stage = 0;
+const host = await nativeFixture({
+  pluginOptions: { delivery: true, deliveryOptions: { workflow: 'strict' } },
+  respond(body, response) {
+    const lastUser = JSON.stringify([...body.messages].reverse().find(item => item.role === 'user'));
+    if (lastUser.includes('WALKTHROUGH_RESUME') || lastUser.includes('WALKTHROUGH_LITE')) return streamText(response, 'WALKTHROUGH_RESUMED');
+    const action = actions[stage++];
+    if (!action) return streamText(response, 'WALKTHROUGH_VERIFIED');
+    const name = action.shell ? 'shell' : 'execute';
+    assert.ok(body.tools.some(tool => tool.function?.name === name), `${name} must be admitted at walkthrough stage ${stage}`);
+    const delta = { role: 'assistant', tool_calls: [{ index: 0, id: `walkthrough-${stage}`, type: 'function', function: { name, arguments: JSON.stringify(action.shell ? { command: action.shell } : { code: action.code }) } }] };
+    response.writeHead(200, { 'content-type': 'text/event-stream' });
+    response.end(`data: ${JSON.stringify({ id: `walkthrough-${stage}`, object: 'chat.completion.chunk', created: 1, model: 'fixture', choices: [{ index: 0, delta, finish_reason: 'tool_calls' }] })}\n\ndata: [DONE]\n\n`);
+  },
+});
+try {
+  const session = await host.client.session.create({ location: host.location, model: host.model, agent: 'ship', metadata: { 'carthagent.options': { workflow: 'strict' } }, title: 'Native Ship full lifecycle' }, host.request());
+  await host.active();
+  await host.client.session.prompt({ sessionID: session.id, text: 'Run the strict Ship fixture walkthrough.' }, host.request());
+  await host.client.session.wait({ sessionID: session.id }, host.request(90_000));
+  const report = latestReport(host.cwd);
+  assert.equal(report?.state.status, 'verified', JSON.stringify(await host.client.session.context({ sessionID: session.id }, host.request())));
+  assert.equal(report.state.workflowMode, 'strict');
+  assert.ok(report.state.planning.approval);
+  assert.ok(report.state.planning.started);
+  assert.equal(report.state.evidence['fixture-check'].passed, true);
+  assert.ok(report.state.reviewEvidence);
+  assert.equal(await readFile(`${host.cwd}/fixture.txt`, 'utf8'), 'fixture output\n');
+  const history = JSON.stringify(await host.client.message.list({ sessionID: session.id }, host.request()));
+  assert.match(history, /Cannot verify:/);
+  assert.match(history, /passed.{0,40}false/);
+  assert.equal(stage, actions.length + 1);
+  const runID = report.state.runId;
+  await host.stop();
+  const client = await host.start();
+  await host.active();
+  await client.session.prompt({ sessionID: session.id, text: 'WALKTHROUGH_RESUME inspect the saved handoff without changing files.' }, host.request());
+  await client.session.wait({ sessionID: session.id }, host.request());
+  assert.equal(latestReport(host.cwd).state.runId, runID);
+  assert.equal(latestReport(host.cwd).state.status, 'verified');
+  await client.session.switchAgent({ sessionID: session.id, agent: 'lite' }, host.request());
+  const requestsBefore = host.requests.length;
+  await client.session.prompt({ sessionID: session.id, text: 'WALKTHROUGH_LITE respond directly.' }, host.request());
+  await client.session.wait({ sessionID: session.id }, host.request());
+  const liteRequest = host.requests.slice(requestsBefore).at(-1);
+  assert.equal(liteRequest.tools.some(tool => tool.function?.name.startsWith('carthagent_delivery_')), false);
+  assert.equal((await client.session.get({ sessionID: session.id }, host.request())).agent, 'lite');
+  console.log(JSON.stringify({ runtime: host.runtimeIdentity.runtimeVersion, strictApproval: 'passed', failedCheckAndRepair: 'passed', reviewAndVerifiedFinish: 'passed', serviceRestartAndResume: 'passed', liteSwitch: 'passed', providerRequests: host.requests.length }));
+} finally {
+  await host.close();
+}

package/tools/test-native-slash-commands.mjs

@@ -0,0 +1,125 @@
+#!/usr/bin/env node
+/** Run real slash-command acceptance with a trusted owned runtime and loopback-only provider. */
+import assert from 'node:assert/strict';
+import { spawn, spawnSync } from 'node:child_process';
+import { mkdtemp, readFile, rm, writeFile } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import { join, resolve } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { preflightNativeTestRuntimeArtifact } from './native-runtime-identity.mjs';
+
+const root = resolve(fileURLToPath(new URL('..', import.meta.url)));
+const ownedRoot = process.env.CTG_OWNED_OPENCODE_RUNTIME;
+const manifestPath = process.env.CTG_TEST_RUNTIME_RELEASE_MANIFEST;
+assert.ok(ownedRoot, 'CTG_OWNED_OPENCODE_RUNTIME must select the explicit candidate artifact');
+assert.ok(manifestPath, 'CTG_TEST_RUNTIME_RELEASE_MANIFEST must point at the trusted release manifest');
+const preflight = await preflightNativeTestRuntimeArtifact({ ownedRoot, expectedManifestPath: manifestPath });
+const binary = join(resolve(ownedRoot), `cli-${process.platform}-${process.arch}`, 'bin', process.platform === 'win32' ? 'opencode.exe' : 'opencode');
+
+const artifact = process.env.CTG_SLASH_ACCEPTANCE_ARTIFACT ?? join(root, `ctg-slash-acceptance-${process.pid}.json`);
+const temp = await mkdtemp(join(tmpdir(), 'ctg-slash-acceptance-'));
+const fixturePath = join(temp, 'fixture.json');
+const logsPath = process.env.CTG_SLASH_ACCEPTANCE_LOGS ?? join(temp, 'fixture.log');
+let fixture;
+let fixtureChild;
+try {
+  const script = `
+import { once } from 'node:events';
+import { writeFile as writeFixtureFile } from 'node:fs/promises';
+import { join as joinPath } from 'node:path';
+import { nativeFixture } from './tools/native-fixture.mjs';
+const plugin = process.argv[1];
+const host = await nativeFixture({ plugin, verifyInventory: true,
+  env: { CTG_OWNED_OPENCODE_RUNTIME: process.env.CTG_OWNED_OPENCODE_RUNTIME,
+    CTG_TEST_RUNTIME_RELEASE_MANIFEST: process.env.CTG_TEST_RUNTIME_RELEASE_MANIFEST },
+  respond(body, response) {
+    const messages = body.messages ?? [];
+    const latest = [...messages].reverse().find(message => message.role === 'user');
+    const text = typeof latest?.content === 'string' ? latest.content : JSON.stringify(latest?.content ?? '');
+    globalThis.providerPrompts ??= [];
+    globalThis.providerPrompts.push(text);
+    void writeFixtureFile(joinPath(host.temp, 'provider-prompts.json'), JSON.stringify(globalThis.providerPrompts));
+    const reply = text.includes('RAW_SENTINEL') ? 'RAW_FIXTURE_REPLY'
+      : text.includes('framed task marker') ? 'GUIDE_FIXTURE_REPLY'
+      : 'FIXTURE_REPLY';
+    const chunk = (delta, finish_reason = null) => 'data: ' + JSON.stringify({ id:'ctg-slash-offline', object:'chat.completion.chunk', created:1, model:'fixture', choices:[{index:0,delta,finish_reason}] }) + '\\n\\n';
+    response.writeHead(200, { 'content-type':'text/event-stream', connection:'close' });
+    response.end(chunk({role:'assistant',content:reply}) + chunk({},'stop') + 'data: [DONE]\\n\\n');
+  }});
+try {
+ const session = await host.client.session.create({ location:host.location, model:host.model, title:'slash command acceptance' }, host.request());
+ await host.active();
+ const info = { temp:host.temp, cwd:host.cwd, baseUrl:host.baseUrl, password:host.password,
+   sessionID:session.id, pluginReadiness:host.pluginObservation,
+    providerRequests:host.requests.length, providerLog:joinPath(host.temp, 'provider-prompts.json') };
+ process.stdout.write(JSON.stringify(info)+'\\n');
+ process.once('SIGTERM', async()=>{await host.close({preserveTemp:false});process.exit(0)});
+ await new Promise(()=>{});
+} catch(error) { await host.close({preserveTemp:false}); throw error; }
+`;
+  fixtureChild = spawn(process.execPath, ['--input-type=module', '-e', script, join(root, 'plugins/carthagent')], {
+    cwd: root,
+    env: {
+      PATH: process.env.PATH ?? '/usr/bin:/bin',
+      LANG: process.env.LANG ?? 'C.UTF-8',
+      CTG_OWNED_OPENCODE_RUNTIME: resolve(ownedRoot),
+      CTG_TEST_RUNTIME_RELEASE_MANIFEST: resolve(manifestPath),
+      NODE_OPTIONS: process.env.NODE_OPTIONS ?? '',
+    },
+    stdio: ['ignore', 'pipe', 'pipe'],
+  });
+  let stderr = '';
+  fixtureChild.stderr.setEncoding('utf8').on('data', chunk => { stderr = (stderr + chunk).slice(-12000); });
+  const line = await new Promise((resolveLine, reject) => {
+    let stdout = '';
+    const timer = setTimeout(() => reject(new Error(`native fixture startup timeout\n${stderr}`)), 60_000);
+    fixtureChild.stdout.setEncoding('utf8').on('data', chunk => {
+      stdout += chunk;
+      const newline = stdout.indexOf('\n');
+      if (newline !== -1) { clearTimeout(timer); resolveLine(stdout.slice(0, newline)); }
+    });
+    fixtureChild.once('exit', (code, signal) => {
+      clearTimeout(timer);
+      reject(new Error(`native fixture exited ${code ?? signal}: ${stderr}`));
+    });
+  });
+  fixture = JSON.parse(line);
+  assert.equal(fixture.pluginReadiness?.pluginId, 'carthagent');
+  assert.equal(fixture.pluginReadiness?.observed, 'active');
+  await writeFile(fixturePath, JSON.stringify(fixture));
+  const python = process.env.PYTHON ?? 'python3';
+  const args = [join(root, 'tools/test-native-slash-commands.py'), '--binary', binary,
+    '--owned-root', resolve(ownedRoot), '--release-manifest', resolve(manifestPath),
+    '--fixture', fixturePath, '--artifact', artifact];
+  const result = spawnSync(python, args, {
+    cwd: root, encoding: 'utf8', timeout: 180_000,
+    env: { PATH: process.env.PATH ?? '/usr/bin:/bin', LANG: process.env.LANG ?? 'C.UTF-8',
+      CTG_OWNED_OPENCODE_RUNTIME: resolve(ownedRoot),
+      CTG_TEST_RUNTIME_RELEASE_MANIFEST: resolve(manifestPath),
+      CTG_SLASH_ACCEPTANCE_LOGS: logsPath },
+  });
+  if (result.stdout) process.stdout.write(result.stdout);
+  if (result.stderr) process.stderr.write(result.stderr);
+  await writeFile(logsPath, JSON.stringify({ stdout: result.stdout, stderr: result.stderr,
+    status: result.status, signal: result.signal, error: result.error?.message ?? null }, null, 2) + '\n');
+  if (result.error) throw result.error;
+  const proof = JSON.parse(await readFile(artifact, 'utf8'));
+  if (proof.status === 'PARTIAL') {
+    process.stderr.write(`Slash acceptance partial; inspect retained proof and logs: ${artifact} · ${logsPath}\n`);
+    process.exitCode = 2;
+  } else {
+    assert.equal(result.status, 0, `slash acceptance failed; retained logs: ${logsPath}`);
+    assert.equal(proof.status, 'PASS');
+  }
+  assert.equal(proof.binarySha256, preflight.identity.binarySha256);
+  assert.equal(proof.scope, 'Linux POSIX PTY; actual native plugin slash submissions; offline loopback provider');
+  process.stdout.write(`Retained acceptance proof: ${artifact}\nRetained runner logs: ${logsPath}\n`);
+} finally {
+  if (fixtureChild && fixtureChild.exitCode === null) {
+    fixtureChild.kill('SIGTERM');
+    await Promise.race([new Promise(resolveExit => fixtureChild.once('exit', resolveExit)), new Promise(resolveExit => setTimeout(resolveExit, 7000))]);
+    if (fixtureChild.exitCode === null) fixtureChild.kill('SIGKILL');
+  }
+  // Fixture files are outside the repository; proof and logs are retained.
+  await rm(temp, { recursive: true, force: true });
+}