carthagent 1.0.7 → 1.1.0-beta.1

package/tools/native-owned-runtime-env.sh

@@ -0,0 +1,47 @@
+#!/usr/bin/env bash
+
+# Configure fixture-seeder identity selection for an explicitly selected owned
+# runtime. The PTY client may still receive --binary directly; the Node fixture
+# must resolve through the owned-root path so runtimeIdentity does not treat an
+# ambient CTG_OPENCODE_BIN override as an upstream selection.
+configure_native_owned_runtime() {
+  local binary="$1" owned_root="$2" release_manifest="$3"
+  if [[ ! -x "$binary" ]]; then
+    printf 'Owned native runtime is missing or not executable: %s\n' "$binary" >&2
+    return 2
+  fi
+  if [[ ! -f "$release_manifest" ]]; then
+    printf 'Trusted CTG runtime release record is required: %s\n' "$release_manifest" >&2
+    return 2
+  fi
+  local runtime_helper="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)/native-runtime-identity.mjs"
+  local canonical_binary canonical_root canonical_manifest
+  canonical_binary="$(realpath "$binary")"
+  canonical_root="$(realpath "$owned_root")"
+  canonical_manifest="$(realpath "$release_manifest")"
+  if command -v cygpath >/dev/null 2>&1; then
+    runtime_helper="$(cygpath -w "$runtime_helper")"
+    canonical_binary="$(cygpath -w "$canonical_binary")"
+    canonical_root="$(cygpath -w "$canonical_root")"
+    canonical_manifest="$(cygpath -w "$canonical_manifest")"
+  fi
+  if ! node --input-type=module - "$runtime_helper" "$canonical_binary" "$canonical_root" "$canonical_manifest" >/dev/null <<'NODE'
+import { readFile } from 'node:fs/promises';
+import { pathToFileURL } from 'node:url';
+const { loadNativeTestRuntime } = await import(pathToFileURL(process.argv[2]).href);
+const identity = await loadNativeTestRuntime({
+  binary: process.argv[3],
+  ownedRoot: process.argv[4],
+  expectedManifest: JSON.parse(await readFile(process.argv[5], 'utf8')),
+  env: process.env,
+});
+process.stdout.write(`${JSON.stringify(identity)}\n`);
+NODE
+  then
+    printf 'Owned native runtime failed trusted identity verification; refusing to launch fixture seeder.\n' >&2
+    return 2
+  fi
+  export CTG_OWNED_OPENCODE_RUNTIME="$canonical_root"
+  export CTG_TEST_RUNTIME_RELEASE_MANIFEST="$canonical_manifest"
+  unset CTG_OPENCODE_BIN
+}

package/tools/native-paired-guards.mjs

@@ -0,0 +1,282 @@
+/** Fail-closed checks shared by paired native performance fixtures. */
+import { existsSync, lstatSync, readFileSync, readdirSync, realpathSync, readlinkSync, statSync } from 'node:fs';
+import { createHash } from 'node:crypto';
+import { createRequire } from 'node:module';
+import path from 'node:path';
+import { dirname, resolve, join, extname } from 'node:path';
+
+export function assertCompletePluginSource(sourceRoot) {
+  const root = resolve(sourceRoot);
+  const required = ['package-lock.json', 'lib/ship-auth.mjs', 'plugins/carthagent/index.ts', 'plugins/carthagent/src/index.ts',
+    'plugins/carthagent/src/rpc.ts', 'plugins/carthagent/package.json',
+    'plugins/carthagent/src/server/session-controls.ts', 'plugins/carthagent/src/server/providers.ts',
+    'plugins/carthagent/src/server/device-auth.ts', 'plugins/carthagent/src/server/workspace-rpc.ts',
+    'plugins/carthagent/src/server/pull-request-rpc.ts', 'plugins/carthagent/src/server/archive-rpc.ts'];
+  const missing = required.filter(path => !existsSync(join(root, path)));
+  if (missing.length) throw new Error(`Incomplete native plugin source snapshot; missing ${missing.join(', ')}`);
+  assertPluginImportDependencies(join(root, 'plugins/carthagent/src/index.ts'));
+  assertWorkspacePluginResolution(root);
+  return { sourceRoot: root, requiredFiles: required };
+}
+
+export function assertWorkspacePluginResolution(sourceRoot) {
+  const root = resolve(sourceRoot);
+  const searchPaths = createRequire(join(root, 'plugins/carthagent/package.json')).resolve.paths('@opencode/plugin') ?? [];
+  const physicalPlugin = searchPaths.map(directory => join(directory, '@opencode/plugin')).find(directory => existsSync(directory));
+  const expectedPlugin = resolve(root, 'node_modules/@opencode/plugin');
+  if (!physicalPlugin || !existsSync(expectedPlugin) || realpathSync(physicalPlugin) !== realpathSync(expectedPlugin)) {
+    throw new Error(`Plugin workspace dependency identity mismatch: ${physicalPlugin} does not resolve to ${expectedPlugin}`);
+  }
+  return true;
+}
+
+export function hashDependencyPackages(nodeModulesRoot, sourcePackageJson, sourceRootOverride) {
+  const root = resolve(nodeModulesRoot);
+  const sourceRoot = resolve(sourceRootOverride ?? resolve(sourcePackageJson, '..'));
+  const packages = ['@opencode/cli', '@opencode/client', '@opencode/plugin'];
+  const sourceManifest = JSON.parse(readFileSync(sourcePackageJson, 'utf8'));
+  const pluginManifest = JSON.parse(readFileSync(join(sourceRoot, 'plugins/carthagent/package.json'), 'utf8'));
+  const lock = JSON.parse(readFileSync(join(sourceRoot, 'package-lock.json'), 'utf8'));
+  return Object.fromEntries(packages.map(name => {
+    const packageRoot = name === '@opencode/plugin' ? join(sourceRoot, 'node_modules/@opencode/plugin') : join(root, name);
+    const manifestPath = join(packageRoot, 'package.json');
+    if (!existsSync(manifestPath)) throw new Error(`Pinned dependency package is missing: ${manifestPath}`);
+    const bytes = readFileSync(manifestPath);
+    const manifest = JSON.parse(bytes.toString('utf8'));
+    const lockVersion = name === '@opencode/plugin'
+      ? lock.packages?.['node_modules/@opencode/plugin']?.version ?? lock.packages?.['plugins/carthagent']?.dependencies?.[name]
+      : lock.packages?.[`node_modules/${name}`]?.version;
+    const sourceRequirement = sourceManifest.dependencies?.[name] ?? sourceManifest.devDependencies?.[name] ??
+      pluginManifest.dependencies?.[name] ?? lock.packages?.['']?.dependencies?.[name] ?? lock.packages?.['']?.devDependencies?.[name];
+    if (sourceRequirement !== manifest.version) {
+      throw new Error(`Installed ${name}@${manifest.version} does not match source requirement ${sourceRequirement ?? '<missing>'}`);
+    }
+    if (lockVersion !== manifest.version) throw new Error(`Installed ${name}@${manifest.version} does not match selected lockfile ${lockVersion ?? '<missing>'}`);
+    const tree = createHash('sha256');
+    const visit = directory => {
+      for (const entry of readdirSync(directory).sort()) {
+        const path = join(directory, entry);
+        const relative = path.slice(packageRoot.length + 1);
+        const stat = lstatSync(path);
+        tree.update(`${relative}\0`);
+        if (stat.isSymbolicLink()) tree.update(`link:${readlinkSync(path)}\0`);
+        else if (stat.isDirectory()) { tree.update('dir\0'); visit(path); }
+        else if (stat.isFile()) tree.update(createHash('sha256').update(readFileSync(path)).digest());
+      }
+    };
+    visit(packageRoot);
+    return [name, { version: manifest.version, realpath: realpathSync(packageRoot),
+      packageJsonSha256: createHash('sha256').update(bytes).digest('hex'), treeSha256: tree.digest('hex') }];
+  }));
+}
+
+export function hashDependencyInstall(nodeModulesRoot) {
+  const root = resolve(nodeModulesRoot);
+  const digest = createHash('sha256');
+  const visitedDirectories = new Set();
+  const visitedFiles = new Set();
+  const visit = directory => {
+    const canonical = realpathSync(directory);
+    if (visitedDirectories.has(canonical)) return;
+    visitedDirectories.add(canonical);
+    digest.update(`directory:${canonical}\0`);
+    for (const entry of readdirSync(directory).sort()) {
+      const path = join(directory, entry);
+      const relative = path.slice(root.length + 1);
+      const stat = lstatSync(path);
+      digest.update(`${relative}\0`);
+      if (stat.isSymbolicLink()) {
+        const target = realpathSync(path);
+        digest.update(`link:${readlinkSync(path)}=>${target}\0`);
+        const targetStat = statSync(path);
+        if (targetStat.isDirectory()) visit(path);
+        else if (targetStat.isFile()) {
+          if (!visitedFiles.has(target)) {
+            visitedFiles.add(target);
+            digest.update(createHash('sha256').update(readFileSync(path)).digest());
+          }
+        }
+      }
+      else if (stat.isDirectory()) { digest.update('dir\0'); visit(path); }
+      else if (stat.isFile()) {
+        const canonicalFile = realpathSync(path);
+        if (!visitedFiles.has(canonicalFile)) {
+          visitedFiles.add(canonicalFile);
+          digest.update(createHash('sha256').update(readFileSync(path)).digest());
+        }
+      }
+    }
+  };
+  visit(root);
+  return { realpath: realpathSync(root), treeSha256: digest.digest('hex') };
+}
+
+export function assertDependencyPackageIdentity(expected, observed) {
+  if (!expected || !observed || expected.realpath !== observed.realpath || expected.treeSha256 !== observed.treeSha256) {
+    throw new Error('Dependency install identity mismatch');
+  }
+  return true;
+}
+
+export function assertPluginImportDependencies(pluginEntry) {
+  const sourceRoot = realpathSync(resolve(dirname(pluginEntry), '../../..'));
+  const canonicalEntry = realpathSync(resolve(pluginEntry));
+  if (!isPathWithinRoot(sourceRoot, canonicalEntry)) {
+    throw new Error(`Plugin source entry resolves outside immutable tree: ${canonicalEntry}`);
+  }
+  const scan = new Set();
+  const pending = [canonicalEntry];
+  const imports = [];
+  while (pending.length) {
+    const file = pending.pop();
+    if (scan.has(file)) continue;
+    scan.add(file);
+    const contents = readFileSync(file, 'utf8');
+    for (const specifier of [...contents.matchAll(/(?:import|export)\s+(?:[^'";]+?\s+from\s+)?['"]([^'"]+)['"]/gm)].map(match => match[1])) {
+      imports.push(specifier);
+      if (!specifier.startsWith('.')) continue;
+      const importedPath = resolve(dirname(file), specifier);
+      const candidates = extname(importedPath)
+        ? [importedPath]
+        : [`${importedPath}.ts`, `${importedPath}.tsx`, `${importedPath}.mjs`, `${importedPath}.js`, `${importedPath}.json`, join(importedPath, 'index.ts'), join(importedPath, 'index.js')];
+      const importedFile = candidates.find(candidate => existsSync(candidate));
+      let canonicalImportedFile;
+      try {
+        if (importedFile) canonicalImportedFile = realpathSync(importedFile);
+      } catch {}
+      if (!canonicalImportedFile || !isPathWithinRoot(sourceRoot, canonicalImportedFile)) {
+        throw new Error(`Plugin source import is missing from immutable tree: ${specifier} (${importedFile})`);
+      }
+      pending.push(canonicalImportedFile);
+    }
+  }
+  const sourceImports = [...new Set(imports.filter(specifier => specifier.startsWith('.')))];
+  const workspaceImports = imports.filter(specifier => specifier === '@opencode/plugin' || specifier.startsWith('@opencode/plugin/'));
+  if (scan.size > 1 && !workspaceImports.includes('@opencode/plugin')) throw new Error('Plugin entry does not import the pinned @opencode/plugin runtime');
+  return { sourceImports, workspaceImports };
+}
+
+export function isPathWithinRoot(root, target, pathApi = path) {
+  const importedRelative = pathApi.relative(root, target);
+  return importedRelative === '' || (importedRelative !== '..' &&
+    !importedRelative.startsWith(`..${pathApi.sep}`) && !importedRelative.startsWith(pathApi.sep) &&
+    !/^[a-zA-Z]:[\\/]/.test(importedRelative));
+}
+
+export function assertPluginCondition(inventory, enabled) {
+  if (!Array.isArray(inventory)) throw new Error('Native plugin inventory is missing or malformed');
+  const carthagent = inventory.filter(plugin => plugin?.id === 'carthagent' ||
+    (typeof plugin?.id === 'string' && plugin.id.startsWith('carthagent.')));
+  if (enabled) {
+    const active = carthagent.find(plugin => plugin.id === 'carthagent' && plugin.state?.status === 'active');
+    if (!active) {
+      const details = carthagent.map(plugin => ({ id: plugin.id, status: plugin.state?.status, error: plugin.state?.error }));
+      throw new Error(`Expected native Carthagent plugin to be active; observed ${JSON.stringify(details)}`);
+    }
+    return { expected: 'active', observed: 'active', pluginId: 'carthagent' };
+  }
+  const enabledPlugins = inventory.filter(plugin => plugin?.id === 'carthagent' ||
+    (typeof plugin?.id === 'string' && plugin.id.startsWith('carthagent.')));
+  if (enabledPlugins.length) {
+    const details = enabledPlugins.map(plugin => ({ id: plugin.id, status: plugin.state?.status }));
+    throw new Error(`Baseline must have no Carthagent plugin; observed ${JSON.stringify(details)}`);
+  }
+  return { expected: 'absent', observed: 'absent', pluginId: 'carthagent' };
+}
+
+export function aggregateConditionExit(statuses, interrupted = false) {
+  const expected = ['baseline-1', 'ctg-1', 'ctg-2', 'baseline-2'];
+  if (interrupted || !statuses || expected.some(name => !Number.isInteger(statuses[name]) || statuses[name] !== 0)) return 1;
+  return 0;
+}
+
+export function assertSelectedSourceHead(selectedCommit, checkoutHead) {
+  if (typeof selectedCommit !== 'string' || !/^[a-f0-9]{40}$/.test(selectedCommit) ||
+      typeof checkoutHead !== 'string' || !/^[a-f0-9]{40}$/.test(checkoutHead) || selectedCommit !== checkoutHead) {
+    throw new Error(`Selected source commit must equal the current integration checkout HEAD (selected=${selectedCommit ?? '<missing>'}, HEAD=${checkoutHead ?? '<missing>'})`);
+  }
+  return true;
+}
+
+export function resolveFixtureSourceRoot(plugin, executionRoot) {
+  return plugin ? resolve(plugin, '../..') : resolve(executionRoot);
+}
+
+export function assertSnapshotProvenance(provenance, { verifyArtifactFiles = false } = {}) {
+  for (const key of ['binarySha256', 'binaryVersion', 'sourceCommit', 'sourceCheckoutHead', 'sourceTree',
+    'sourceSnapshotSha256', 'packageLockSha256', 'dependencyNodeModulesRealpath',
+    'installedPackageLockSha256', 'sourceComponentSha256', 'harnessComponentSha256', 'sourceArchiveSha256',
+    'executionSnapshotTar', 'executionSnapshotSha256', 'sourceSnapshotTar', 'binary', 'dependencyInstallSha256', 'dependencyInstallRealpath',
+    'sourceCheckoutStatusSha256']) {
+    if (typeof provenance?.[key] !== 'string' || !provenance[key]) throw new Error(`Missing provenance field: ${key}`);
+  }
+  if (typeof provenance.sourceCheckoutDirtyStatus !== 'string' || typeof provenance.harnessDirtyStatus !== 'string') {
+    throw new Error('Missing checkout dirty-state status provenance');
+  }
+  if (provenance.binaryVersion !== '2.0.32' || !/^[a-f0-9]{64}$/.test(provenance.binarySha256) ||
+      !/^[a-f0-9]{40}$/.test(provenance.sourceCommit) || provenance.sourceCheckoutHead !== provenance.sourceCommit ||
+      !/^[a-f0-9]{40}$/.test(provenance.sourceTree) ||
+      !/^[a-f0-9]{64}$/.test(provenance.sourceSnapshotSha256) || !/^[a-f0-9]{64}$/.test(provenance.packageLockSha256) ||
+      !/^[a-f0-9]{64}$/.test(provenance.sourceComponentSha256) || !/^[a-f0-9]{64}$/.test(provenance.harnessComponentSha256) ||
+      !/^[a-f0-9]{64}$/.test(provenance.sourceArchiveSha256) ||
+      !/^[a-f0-9]{64}$/.test(provenance.executionSnapshotSha256) ||
+      !/^[a-f0-9]{64}$/.test(provenance.dependencyInstallSha256) ||
+      !/^[a-f0-9]{64}$/.test(provenance.sourceCheckoutStatusSha256) ||
+      !provenance.dependencyNodeModulesRealpath.startsWith('/') || !provenance.dependencyInstallRealpath.startsWith('/')) {
+    throw new Error('Pinned binary or source snapshot provenance is invalid');
+  }
+  if (typeof provenance.sourceDirty !== 'boolean' || typeof provenance.sourceCheckoutDirty !== 'boolean' ||
+      provenance.sourceCheckoutDirty !== (provenance.sourceCheckoutDirtyStatus.length > 0) ||
+      createHash('sha256').update(provenance.sourceCheckoutDirtyStatus).digest('hex') !== provenance.sourceCheckoutStatusSha256 ||
+      typeof provenance.harnessDirty !== 'boolean' ||
+      provenance.harnessDirty !== (provenance.harnessDirtyStatus.length > 0)) {
+    throw new Error('Checkout dirty-state provenance is invalid');
+  }
+  if (provenance.sourceDirty !== false) throw new Error('Source snapshot must be created from a clean immutable commit');
+  const dependencyPackages = provenance.dependencyPackages;
+  if (!dependencyPackages || typeof dependencyPackages !== 'object') throw new Error('Pinned dependency package provenance is missing');
+  for (const name of ['@opencode/cli', '@opencode/client', '@opencode/plugin']) {
+    const item = dependencyPackages[name];
+    if (item?.version !== '2.0.32' || typeof item.realpath !== 'string' || !item.realpath.startsWith('/') ||
+        !/^[a-f0-9]{64}$/.test(item.packageJsonSha256 ?? '') || !/^[a-f0-9]{64}$/.test(item.treeSha256 ?? '')) {
+      throw new Error(`Pinned dependency provenance is invalid for ${name}`);
+    }
+  }
+  if (provenance.installedPackageLockSha256 !== provenance.packageLockSha256) {
+    throw new Error('Installed dependencies are not identical to the selected source lockfile');
+  }
+  if (verifyArtifactFiles) {
+    const binaryPath = provenance.binary;
+    const sourceTar = provenance.sourceSnapshotTar;
+    const executionTar = provenance.executionSnapshotTar;
+    for (const [label, path, expected] of [
+      ['binary', binaryPath, provenance.binarySha256],
+      ['source archive', sourceTar, provenance.sourceArchiveSha256],
+      ['execution snapshot', executionTar, provenance.executionSnapshotSha256],
+    ]) {
+      if (typeof path !== 'string' || !existsSync(path) || createHash('sha256').update(readFileSync(path)).digest('hex') !== expected) {
+        throw new Error(`${label} artifact hash does not match manifest provenance`);
+      }
+    }
+    const dependencyInstall = hashDependencyInstall(provenance.dependencyNodeModulesRealpath);
+    if (dependencyInstall.treeSha256 !== provenance.dependencyInstallSha256 || dependencyInstall.realpath !== provenance.dependencyInstallRealpath) {
+      throw new Error('dependency install artifact hash does not match manifest provenance');
+    }
+  }
+  return true;
+}
+
+export function verifySnapshotIdentity(expected, observed, { verifyArtifactFiles = true } = {}) {
+  assertSnapshotProvenance(observed, { verifyArtifactFiles });
+  for (const key of ['binarySha256', 'binaryVersion', 'sourceCommit', 'sourceCheckoutHead', 'sourceTree',
+    'sourceDirty', 'sourceCheckoutDirty', 'sourceCheckoutDirtyStatus', 'sourceCheckoutStatusSha256', 'harnessDirty', 'harnessDirtyStatus',
+    'sourceSnapshotSha256', 'packageLockSha256', 'dependencyNodeModulesRealpath',
+    'installedPackageLockSha256', 'sourceComponentSha256', 'harnessComponentSha256', 'sourceArchiveSha256',
+    'executionSnapshotTar', 'executionSnapshotSha256', 'sourceSnapshotTar', 'binary', 'dependencyInstallSha256', 'dependencyInstallRealpath']) {
+    if (expected?.[key] !== observed[key]) throw new Error(`Snapshot identity mismatch for ${key}`);
+  }
+  if (JSON.stringify(expected?.dependencyPackages) !== JSON.stringify(observed.dependencyPackages)) {
+    throw new Error('Snapshot identity mismatch for dependencyPackages');
+  }
+  return true;
+}

package/tools/native-paired-manifest.mjs

@@ -0,0 +1,72 @@
+/** Serialize paired-run provenance with JSON's typed, escaped representation. */
+import { resolve } from 'node:path';
+import { pathToFileURL } from 'node:url';
+import { createHash } from 'node:crypto';
+export function createPairedManifest(fields) {
+  const sourceCheckoutDirtyStatus = fields.sourceCheckoutDirtyStatus ?? '';
+  const harnessDirtyStatus = fields.harnessDirtyStatus ?? '';
+  const manifest = {
+    createdAt: fields.createdAt,
+    binary: fields.binary,
+    binaryVersion: fields.binaryVersion,
+    compatibilityVersion: fields.compatibilityVersion ?? fields.binaryVersion,
+    runtimeVersion: fields.runtimeVersion ?? fields.binaryVersion,
+    runtimeSourceRevision: fields.runtimeSourceRevision,
+    runtimePatchSha256: fields.runtimePatchSha256,
+    runtimeLockSha256: fields.runtimeLockSha256,
+    binarySha256: fields.binarySha256,
+    expectedHostVersion: '2.0.32',
+    sourceCheckout: fields.sourceCheckout,
+    sourceCheckoutHead: fields.sourceCheckoutHead,
+    sourceCheckoutDirty: sourceCheckoutDirtyStatus.length > 0,
+    sourceCheckoutDirtyStatus,
+    sourceCheckoutStatusSha256: createHash('sha256').update(sourceCheckoutDirtyStatus).digest('hex'),
+    sourceCommit: fields.sourceCommit,
+    sourceTree: fields.sourceTree,
+    sourceDirty: false,
+    sourceSnapshotTar: fields.sourceSnapshotTar,
+    sourceArchiveSha256: fields.sourceArchiveSha256,
+    executionSnapshotTar: fields.executionSnapshotTar,
+    executionSnapshotSha256: fields.executionSnapshotSha256,
+    sourceSnapshotSha256: fields.sourceSnapshotSha256,
+    packageLockSha256: fields.packageLockSha256,
+    installedPackageLockSha256: fields.installedPackageLockSha256,
+    dependencyNodeModulesRealpath: fields.dependencyNodeModulesRealpath,
+    dependencyInstallSha256: fields.dependencyInstallSha256,
+    dependencyInstallRealpath: fields.dependencyInstallRealpath,
+    dependencyPackages: fields.dependencyPackages,
+    harnessWorktree: fields.harnessWorktree,
+    harnessCommit: fields.harnessCommit,
+    harnessDirty: harnessDirtyStatus.length > 0,
+    harnessDirtyStatus,
+    harnessSourceManifestSha256: fields.harnessSourceManifestSha256,
+    order: ['baseline-1', 'ctg-1', 'ctg-2', 'baseline-2'],
+    samplesPerRun: fields.samplesPerRun,
+    warmup: 'one input key excluded; both switch destinations visited before measured alternating switches',
+    terminal: '36 rows x 120 columns',
+    thresholds: { inputP95Ms: 50, switchP95Ms: 150, workspaceRenderMs: 300 },
+    measurementScope: 'keypress or Enter through select/read/VT parsing to parsed PTY screen evidence; not compositor/GPU presentation; no observer-overhead subtraction',
+    hostSampling: 'one-second load-average and MemAvailable observations throughout each run\'s switch/input window',
+    pairedConditions: 'one condition server at a time; fresh disposable profiles/databases with equivalent same-project session titles/prompts/markers; same pinned binary and 36x120 PTY; CTG loaded from complete selected source archive',
+    pluginRequirement: 'the raw native plugin.list inventory must show carthagent active plus health RPC for CTG; no carthagent id or namespace for baseline; state is observed, never inferred from the mode flag',
+    identityRequirement: 'binaryVersion and compatibilityVersion are the exact compatibility contract 2.0.32; runtimeVersion is captured separately from exact native runtime --version and exact server.info.version. Owned binaries require loadNativeTestRuntime with the trusted release manifest (default lib/opencode/runtime-release.json or CTG_TEST_RUNTIME_RELEASE_MANIFEST) and optional CTG_TEST_RUNTIME_SHA256; adjacent ctg-runtime.json is provenance only, never the trust source.',
+    sustainedMemoryAcceptance: 'plan proposal only, not authorized: serial baseline and CTG each warm 5 minutes, then collect exactly 1500 planned 1-second monotonic-index slots over 25 minutes. Record actual monotonic timestamps/lateness; >250ms lateness, duplicate/missing slots, missing process/PID/sample fail; no zero-fill/interpolation/drop; align by slot index not jittered timestamp. Block 0=slots 0-299; final block=1200-1499. Combined process-tree RSS B0/C0=condition medians in block 0; D[n]=(CTG[n]-C0)-(baseline[n]-B0). Proposed retained-growth max D<=128 MiB; proposed observable-plateau median(D[1200..1499])-median(D[0..299])<=32 MiB. Preserve separate TUI/server/combined traces and slot timestamps/lateness. RSS sums may double-count shared pages; this is a process-tree RSS proxy, not unique physical memory. Require exact finite deterministic loopback replay specification with fixed request count, payload/chunk sizes, pacing and reconnect positions, identical byte-for-byte between conditions. Engineering finite-window criteria, not mathematical long-term guarantees; review before authorization.',
+    workspaceUiAcceptance: 'the native compatibility target includes cached /ctg-workspace UI load <=300ms; a strict post-submit PTY route/data-render observation is required, RPC-only timing does not satisfy it',
+    sustainedMemoryDiagnosticDesign: 'plan only; use indexed monotonic one-second slots with <=250ms lateness, 1500 slots, fixed blocks 0-299 and 1200-1499; fail on missing PID/process/sample, duplicate/missing slot, excessive lateness, or mismatched deterministic loopback replay. Retain TUI/server/combined RSS, slot timestamps/lateness, host load/memory, per-request bytes/chunks/timing, reconnect/error counts and cleanup. Proposed combined-RSS statistic and 128/32 MiB criteria are specified in sustainedMemoryAcceptance and require review and explicit authorization before execution.',
+    sourceComponentSha256: fields.sourceComponentSha256,
+    harnessComponentSha256: fields.harnessComponentSha256,
+    acceptance: 'diagnostic until operator confirms controlled window and independent review; thresholds unchanged',
+  };
+  return manifest;
+}
+
+if (process.argv[1] && import.meta.url === pathToFileURL(resolve(process.argv[1])).href) {
+  const input = await new Promise((resolve, reject) => {
+    let value = '';
+    process.stdin.setEncoding('utf8');
+    process.stdin.on('data', chunk => { value += chunk; });
+    process.stdin.on('end', () => resolve(value));
+    process.stdin.on('error', reject);
+  });
+  process.stdout.write(`${JSON.stringify(createPairedManifest(JSON.parse(input)), null, 2)}\n`);
+}

package/tools/native-paired-orchestration.sh

@@ -0,0 +1,51 @@
+#!/usr/bin/env bash
+
+# Shared ABBA driver used by the paired runner and its offline orchestration test.
+register_paired_exit_cleanup() {
+  trap "$1" EXIT
+}
+
+remove_paired_workdir() {
+  local path="${1:-}"
+  if [[ "$path" == /tmp/ctg-native-paired.* && "$path" != *..* ]]; then
+    rm -rf -- "$path"
+  fi
+}
+
+run_paired_abba() {
+  local callback="$1" statuses_file="$2" guard_module="$3" interrupted_flag="$4"
+  local label mode status exit_status
+  for label in baseline-1 ctg-1 ctg-2 baseline-2; do
+    case "$label" in
+      baseline-*) mode=baseline ;;
+      ctg-*) mode=ctg ;;
+    esac
+    set +e
+    "$callback" "$label" "$mode"
+    status=$?
+    set -e
+    # A callback may own richer failure reporting, but it cannot erase its
+    # process failure by having already recorded a success status.
+    if [[ "$status" -ne 0 ]]; then
+      local status_tmp="${statuses_file}.update.$$"
+      if ! awk -F '\t' -v name="$label" -v failed_status="$status" 'BEGIN { OFS="\t" } $1 == name { $2=failed_status; found=1 } { print } END { if (!found) print name, failed_status }' \
+        "$statuses_file" > "$status_tmp" 2>/dev/null; then
+        printf '%s\t%s\n' "$label" "$status" > "$status_tmp"
+      fi
+      mv -- "$status_tmp" "$statuses_file"
+    elif ! awk -F '\t' -v name="$label" '$1 == name { found=1 } END { exit !found }' "$statuses_file" 2>/dev/null; then
+      printf '%s\t1\n' "$label" >> "$statuses_file"
+    fi
+  done
+  paired_exit_status="$(node --input-type=module - "$statuses_file" "$guard_module" "$interrupted_flag" <<'NODE'
+import { readFileSync } from 'node:fs';
+import { pathToFileURL } from 'node:url';
+const { aggregateConditionExit } = await import(pathToFileURL(process.argv[3]).href);
+const statuses = Object.fromEntries(readFileSync(process.argv[2], 'utf8').trim().split('\n').filter(Boolean).map(line => {
+  const [name, status] = line.split('\t');
+  return [name, Number(status)];
+}));
+process.stdout.write(String(aggregateConditionExit(statuses, process.argv[4] === '1')));
+NODE
+)"
+}

package/tools/native-plugin-readiness.mjs

@@ -0,0 +1,33 @@
+/** Wait for plugin initialization, preserving the host inventory as evidence. */
+export async function waitForPluginActive(pluginID, {
+  listPlugins,
+  timeoutMs = 15_000,
+  hostOutput = () => '',
+  pollIntervalMs = 100,
+}) {
+  const deadline = Date.now() + timeoutMs;
+  let inventory;
+  while (true) {
+    const remainingMs = deadline - Date.now();
+    if (remainingMs <= 0) {
+      throw new Error(`Timed out waiting for plugin ${pluginID} to become active; observed ${JSON.stringify(inventory?.data ?? [])}\nHost output:\n${hostOutput()}`);
+    }
+    try {
+      inventory = await listPlugins(remainingMs);
+    } catch (error) {
+      if (Date.now() >= deadline) {
+        throw new Error(`Timed out waiting for plugin ${pluginID} to become active; last observed inventory ${JSON.stringify(inventory?.data ?? [])}; inventory request failed: ${error.message}\nHost output:\n${hostOutput()}`, { cause: error });
+      }
+      throw error;
+    }
+    const plugin = inventory.data.find((entry) => entry.id === pluginID);
+    if (plugin?.state?.status === 'active') return plugin;
+    if (plugin?.state?.status === 'error') {
+      throw new Error(`Plugin ${pluginID} failed to initialize: ${JSON.stringify(plugin)}\nHost output:\n${hostOutput()}`);
+    }
+    if (Date.now() >= deadline) {
+      throw new Error(`Timed out waiting for plugin ${pluginID} to become active; observed ${JSON.stringify(inventory.data)}\nHost output:\n${hostOutput()}`);
+    }
+    await new Promise((done) => setTimeout(done, Math.min(pollIntervalMs, Math.max(0, deadline - Date.now()))));
+  }
+}

package/tools/native-plugin-readiness.test.mjs

@@ -0,0 +1,53 @@
+import assert from 'node:assert/strict';
+import test from 'node:test';
+import { waitForPluginActive } from './native-plugin-readiness.mjs';
+
+test('waits through plugin visibility and loading until active', async () => {
+  const inventories = [
+    { data: [] },
+    { data: [{ id: 'carthagent', state: { status: 'loading' } }] },
+    { data: [{ id: 'carthagent', state: { status: 'active' } }] },
+  ];
+  let calls = 0;
+  const plugin = await waitForPluginActive('carthagent', {
+    listPlugins: async () => inventories[calls++],
+    pollIntervalMs: 1,
+  });
+  assert.equal(plugin.state.status, 'active');
+  assert.equal(calls, 3);
+});
+
+test('fails immediately with plugin and host diagnostics on initialization error', async () => {
+  let calls = 0;
+  await assert.rejects(waitForPluginActive('carthagent', {
+    listPlugins: async () => {
+      calls++;
+      return { data: [{ id: 'carthagent', state: { status: 'error', error: 'fixture failure' } }] };
+    },
+    hostOutput: () => 'host tail fixture',
+  }), /carthagent.*error.*fixture failure.*host tail fixture/s);
+  assert.equal(calls, 1);
+});
+
+test('times out with the last observed plugin states and host diagnostics', async () => {
+  await assert.rejects(waitForPluginActive('carthagent', {
+    listPlugins: async () => ({ data: [{ id: 'carthagent', state: { status: 'loading' } }] }),
+    timeoutMs: 5,
+    pollIntervalMs: 1,
+    hostOutput: () => 'host tail fixture',
+  }), /Timed out.*carthagent.*loading.*host tail fixture/s);
+});
+
+test('bounds an in-flight inventory request by readiness deadline', async () => {
+  let observedTimeout;
+  await assert.rejects(waitForPluginActive('carthagent', {
+    listPlugins: async timeoutMs => {
+      observedTimeout = timeoutMs;
+      await new Promise(done => setTimeout(done, 11));
+      throw new DOMException('request timeout', 'TimeoutError');
+    },
+    timeoutMs: 10,
+    hostOutput: () => 'host tail fixture',
+  }), /Timed out.*inventory request failed.*host tail fixture/s);
+  assert.ok(observedTimeout > 0 && observedTimeout <= 10);
+});

package/tools/native-pty-invocation.mjs

@@ -0,0 +1,26 @@
+/** Build the Python PTY arguments while preserving the identity gate's digest. */
+export function nativePtySmokeArgs({ root, binary, plugin, selection, probe }) {
+  if (!/^[a-f0-9]{64}$/.test(selection.binarySha256 ?? '')) {
+    throw new Error('Native PTY selection is missing its independently verified lowercase SHA-256 digest.');
+  }
+  const args = [
+    `${root}/tools/native-pty-smoke.py`, '--binary', binary, '--plugin', plugin,
+    '--command', probe.command, '--expect', probe.expect, '--ready', '◆ CTG',
+    ...(probe.secondEnter ? ['--second-enter'] : ['--confirm']),
+  ];
+  for (const next of probe.next ?? []) args.push('--after-command', next.command, '--after-expect', next.expect);
+  if (probe.dismissCompletion) args.push('--dismiss-completion');
+  if (probe.postSubmitMarker) args.push('--post-submit-marker', probe.postSubmitMarker);
+  if (probe.capture) args.push('--capture', probe.capture);
+  if (probe.color) args.push('--expect-color', probe.color);
+  if (probe.initialTheme) args.push('--initial-theme', probe.initialTheme);
+  if (probe.nodeExecutable) args.push('--node-executable', probe.nodeExecutable);
+  if (probe.commandArgs) args.push('--command-args', probe.commandArgs);
+  if (probe.expectedTheme) args.push('--expect-theme', probe.expectedTheme);
+  if (probe.expectStartupColor) args.push('--expect-startup-color');
+  if (probe.writeInitialTheme) args.push('--write-initial-theme');
+  if (probe.stateDir) args.push('--state-dir', probe.stateDir);
+  if (probe.reuseState) args.push('--reuse-state');
+  args.push('--expected-sha256', selection.binarySha256);
+  return args;
+}