@aria_asi/cli 0.2.40 → 0.2.41

package/scripts/check-cli-wrapper-provider-contract.mjs

@@ -0,0 +1,160 @@
+#!/usr/bin/env node
+
+import assert from 'node:assert/strict';
+import { existsSync, readFileSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { dirname, join, resolve } from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const here = dirname(fileURLToPath(import.meta.url));
+const packageRoot = resolve(here, '..');
+const sourcePath = resolve(packageRoot, 'src', 'connectors', 'shell.ts');
+const source = readFileSync(sourcePath, 'utf8');
+const binPath = resolve(packageRoot, 'bin', 'aria.js');
+const binSource = readFileSync(binPath, 'utf8');
+const claudeConnectorPath = resolve(packageRoot, 'src', 'connectors', 'claude-code.ts');
+const codexConnectorPath = resolve(packageRoot, 'src', 'connectors', 'codex.ts');
+const opencodeConnectorPath = resolve(packageRoot, 'src', 'connectors', 'opencode.ts');
+const claudeConnector = readFileSync(claudeConnectorPath, 'utf8');
+const codexConnector = readFileSync(codexConnectorPath, 'utf8');
+const opencodeConnector = readFileSync(opencodeConnectorPath, 'utf8');
+
+function assertIncludes(text, token, label) {
+  assert.ok(text.includes(token), `${label} missing token: ${token}`);
+}
+
+function assertBefore(text, first, second, label) {
+  const firstIndex = text.indexOf(first);
+  const secondIndex = text.indexOf(second);
+  assert.ok(firstIndex >= 0, `${label} missing first token: ${first}`);
+  assert.ok(secondIndex >= 0, `${label} missing second token: ${second}`);
+  assert.ok(firstIndex < secondIndex, `${label} expected ${first} before ${second}`);
+}
+
+function assertNotIncludes(text, token, label) {
+  assert.ok(!text.includes(token), `${label} must not contain: ${token}`);
+}
+
+assertIncludes(source, 'ARIA_CLAUDE_USE_API_KEY', 'claude direct-login opt-in contract');
+assertIncludes(source, 'ARIA_CLAUDE_USE_ARIA_RUNTIME', 'claude runtime opt-in contract');
+assertIncludes(source, 'unset ANTHROPIC_API_KEY', 'claude direct-login default');
+assertIncludes(source, 'unset ANTHROPIC_AUTH_TOKEN', 'claude direct-login default');
+assertIncludes(source, 'unset ANTHROPIC_CUSTOM_HEADERS', 'claude direct-login default');
+assertIncludes(source, 'unset ANTHROPIC_BASE_URL', 'claude direct-login default');
+
+assertIncludes(source, 'ARIA_CODEX_USE_API_KEY', 'codex direct-provider opt-in contract');
+assertIncludes(source, 'ARIA_CODEX_USE_ARIA_RUNTIME', 'codex runtime opt-in contract');
+assertIncludes(source, 'ARIA_CODEX_USE_BRIDGE', 'codex bridge opt-in contract');
+assertIncludes(source, 'unset OPENAI_API_KEY', 'codex direct-provider default');
+assertIncludes(source, 'unset OPENAI_BASE_URL', 'codex direct-provider default');
+assertIncludes(source, 'unset OPENAI_ORG_ID', 'codex direct-provider default');
+assertIncludes(source, 'unset OPENAI_ORGANIZATION', 'codex direct-provider default');
+assertIncludes(source, 'unset OPENAI_PROJECT', 'codex direct-provider default');
+assertIncludes(source, 'aria_codex_start_async_bootstrap()', 'codex nonblocking readiness bootstrap contract');
+assertIncludes(source, 'ARIA_SESSION_ID="$_aria_bootstrap_id"', 'codex nonblocking readiness bootstrap contract');
+assertIncludes(source, 'ARIA_CODEX_READINESS_SILENT=1', 'codex nonblocking readiness bootstrap contract');
+assertIncludes(source, 'nohup node "$ARIA_UNIVERSAL_TURN_PACKET_SCRIPT" >"$_aria_bootstrap_log" 2>&1 &', 'codex nonblocking readiness bootstrap contract');
+
+assertBefore(
+  source,
+  'if [ "\\${ARIA_CODEX_USE_ARIA_RUNTIME:-0}" != "1" ] && [ "\\${ARIA_CODEX_USE_BRIDGE:-0}" != "1" ]; then',
+  'exec "${toolPath}" --remote "ws://$ARIA_CODEX_BRIDGE_HOST:$ARIA_CODEX_BRIDGE_PORT" "$@"',
+  'codex bridge routing must be opt-in',
+);
+
+assertNotIncludes(
+  source,
+  'export OPENAI_BASE_URL="\\${OPENAI_BASE_URL:-$ARIA_RUNTIME_URL/v1}"\nif [ -z "\\${ARIA_HARNESS_TOKEN:-}" ]; then',
+  'runtime injection block',
+);
+
+for (const token of ['--dry-run', '--runtime-only', '--runtime-sidecar-only', '--hooks-only', '--with-wrappers', 'installWrapper: withWrappers', 'wrappers: withWrappers ?']) {
+  assertIncludes(binSource, token, 'connector install phase contract');
+}
+
+assertIncludes(binSource, "wrappers: withWrappers ? 'enabled_by_explicit_flag' : 'skipped_by_default'", 'connector install phase contract');
+assertIncludes(binSource, "runtimeSidecarOnly && withWrappers", 'runtime sidecar wrapper exclusion contract');
+assertIncludes(binSource, "runtime-sidecar-only mode excludes shell wrapper activation", 'runtime sidecar wrapper exclusion contract');
+assertIncludes(binSource, "excluded: runtimeSidecarOnly ? ['shell_wrappers', 'provider_path_takeover', 'consult_quality_engine', 'repo_services', 'syncd'] : []", 'runtime sidecar exclusion contract');
+assertIncludes(binSource, "strict: effectiveStrict", 'runtime sidecar strictness contract');
+assertIncludes(claudeConnector, 'opts.installWrapper === true', 'Claude wrapper opt-in contract');
+assertIncludes(claudeConnector, 'Skipped Claude shell wrapper install', 'Claude wrapper opt-in contract');
+assertIncludes(codexConnector, 'opts.installWrapper === true', 'Codex wrapper opt-in contract');
+assertIncludes(codexConnector, 'Skipped Codex shell wrapper install', 'Codex wrapper opt-in contract');
+assertIncludes(opencodeConnector, 'opts.installWrapper === true', 'OpenCode wrapper opt-in contract');
+assertIncludes(opencodeConnector, 'Skipped OpenCode shell wrapper install', 'OpenCode wrapper opt-in contract');
+
+const activeWrapperChecks = [
+  {
+    path: join(homedir(), '.aria', 'wrappers', 'claude'),
+    required: [
+      'unset ANTHROPIC_API_KEY',
+      'unset ANTHROPIC_AUTH_TOKEN',
+      'unset ANTHROPIC_CUSTOM_HEADERS',
+      'unset ANTHROPIC_BASE_URL',
+      'ARIA_CLAUDE_USE_API_KEY',
+      'ARIA_CLAUDE_USE_ARIA_RUNTIME',
+      'ARIA_UNIVERSAL_TURN_PACKET_SCRIPT="$HOME/.aria/runtime/hooks/aria-universal-turn-packet.mjs"',
+      'ARIA_SURFACE_ID="claude-code" ARIA_TURN_USER_TEXT="$*" node "$ARIA_UNIVERSAL_TURN_PACKET_SCRIPT" >/dev/null',
+    ],
+    forbidden: [
+      'export ANTHROPIC_BASE_URL="${ANTHROPIC_BASE_URL:-$ARIA_RUNTIME_URL}"\nexport OPENAI_BASE_URL',
+    ],
+  },
+  {
+    path: join(homedir(), '.aria', 'wrappers', 'codex'),
+    required: [
+      'unset OPENAI_API_KEY',
+      'unset OPENAI_BASE_URL',
+      'unset OPENAI_ORG_ID',
+      'unset OPENAI_ORGANIZATION',
+      'unset OPENAI_PROJECT',
+      'ARIA_CODEX_USE_API_KEY',
+      'ARIA_CODEX_USE_ARIA_RUNTIME',
+      'ARIA_CODEX_USE_BRIDGE',
+      'ARIA_UNIVERSAL_TURN_PACKET_SCRIPT="$HOME/.aria/runtime/hooks/aria-universal-turn-packet.mjs"',
+      'aria_codex_skip_async_bootstrap()',
+      'aria_codex_start_async_bootstrap()',
+      'ARIA_SURFACE_ID="codex" \\',
+      'ARIA_SESSION_ID="$_aria_bootstrap_id"',
+      'ARIA_TURN_USER_TEXT="$*" \\',
+      'ARIA_CODEX_READINESS_SILENT=1',
+      'nohup node "$ARIA_UNIVERSAL_TURN_PACKET_SCRIPT" >"$_aria_bootstrap_log" 2>&1 &',
+      'ARIA_CODEX_ASYNC_BOOTSTRAP_LOG="$_aria_bootstrap_log"',
+    ],
+    forbidden: [
+    ],
+    before: [
+      [
+        'if [ "${ARIA_CODEX_USE_ARIA_RUNTIME:-0}" != "1" ] && [ "${ARIA_CODEX_USE_BRIDGE:-0}" != "1" ]; then',
+        '--remote "ws://$ARIA_CODEX_BRIDGE_HOST:$ARIA_CODEX_BRIDGE_PORT" "$@"',
+      ],
+    ],
+  },
+  {
+    path: join(homedir(), '.aria', 'wrappers', 'opencode'),
+    required: [
+      'ARIA_UNIVERSAL_TURN_PACKET_SCRIPT="$HOME/.aria/runtime/hooks/aria-universal-turn-packet.mjs"',
+      'ARIA_SURFACE_ID="opencode" ARIA_TURN_USER_TEXT="$*" node "$ARIA_UNIVERSAL_TURN_PACKET_SCRIPT" >/dev/null',
+    ],
+    forbidden: [],
+  },
+];
+
+for (const check of activeWrapperChecks) {
+  if (!existsSync(check.path)) continue;
+  const wrapper = readFileSync(check.path, 'utf8');
+  for (const token of check.required) assertIncludes(wrapper, token, check.path);
+  for (const token of check.forbidden) assertNotIncludes(wrapper, token, check.path);
+  for (const [first, second] of check.before || []) assertBefore(wrapper, first, second, check.path);
+}
+
+console.log(JSON.stringify({
+  ok: true,
+  checkedAt: new Date().toISOString(),
+  sourcePath,
+  binPath,
+  activeWrappersChecked: activeWrapperChecks
+    .filter((check) => existsSync(check.path))
+    .map((check) => check.path),
+}, null, 2));

package/scripts/check-client-compatibility.mjs

@@ -164,12 +164,22 @@ async function checkWrapperContracts() {
   const codexWrapperPath = join(home, '.aria', 'wrappers', 'codex');
   const claudeWrapper = readIfExists(claudeWrapperPath);
   const codexWrapper = readIfExists(codexWrapperPath);
-  assert('source-wrapper-contract', sourceShell.includes(String.raw`ANTHROPIC_BASE_URL="\${ANTHROPIC_BASE_URL:-$ARIA_RUNTIME_URL}"`), 'Generated wrapper must set Anthropic base at the runtime root.');
-  assert('source-wrapper-contract', sourceShell.includes(String.raw`OPENAI_BASE_URL="\${OPENAI_BASE_URL:-$ARIA_RUNTIME_URL/v1}"`), 'Generated wrapper must keep OpenAI base at the v1 root.');
+  // OAuth-safe contract: Claude and Codex wrappers default to direct-provider login
+  // (OAuth for Anthropic; user's own OpenAI key for Codex). Aria runtime routing
+  // is opt-in via ARIA_CLAUDE_USE_ARIA_RUNTIME=1 / ARIA_CODEX_USE_ARIA_RUNTIME=1.
+  // Asserting the unset+opt-in shape prevents regression to unconditional proxy
+  // routing, which would break OAuth refresh against api.anthropic.com.
+  assert('source-wrapper-contract', sourceShell.includes('ARIA_CLAUDE_USE_API_KEY') && sourceShell.includes('ARIA_CLAUDE_USE_ARIA_RUNTIME'), 'Source wrapper must declare Claude direct-login + runtime opt-in flags.');
+  assert('source-wrapper-contract', sourceShell.includes('unset ANTHROPIC_BASE_URL'), 'Source wrapper must unset ANTHROPIC_BASE_URL by default so OAuth refresh reaches api.anthropic.com.');
+  assert('source-wrapper-contract', sourceShell.includes(String.raw`OPENAI_BASE_URL="\${OPENAI_BASE_URL:-$ARIA_RUNTIME_URL/v1}"`), 'Source wrapper must keep OpenAI base at the v1 root for non-Codex tools.');
   assert('source-wrapper-contract', !/OPENAI_API_KEY=.*ARIA_API_KEY/.test(sourceShell), 'Generated wrapper must not copy Aria control-plane tokens into provider API keys.');
-  assert('active-claude-wrapper-contract', claudeWrapper.includes('ANTHROPIC_BASE_URL="${ANTHROPIC_BASE_URL:-$ARIA_RUNTIME_URL}"'), 'Active Claude wrapper must set Anthropic base at the runtime root.', { claudeWrapperPath });
-  assert('active-claude-wrapper-contract', !/OPENAI_API_KEY=.*ARIA_API_KEY/.test(claudeWrapper), 'Active Claude wrapper must not poison provider API key env.', { claudeWrapperPath });
-  assert('active-codex-wrapper-contract', codexWrapper.includes('ANTHROPIC_BASE_URL="${ANTHROPIC_BASE_URL:-$ARIA_RUNTIME_URL}"'), 'Active Codex wrapper must share the corrected runtime root Anthropic base.', { codexWrapperPath });
+  if (existsSync(claudeWrapperPath)) {
+    assert('active-claude-wrapper-contract', claudeWrapper.includes('unset ANTHROPIC_BASE_URL'), 'Active Claude wrapper must unset ANTHROPIC_BASE_URL by default (OAuth-safe).', { claudeWrapperPath });
+    assert('active-claude-wrapper-contract', claudeWrapper.includes('ARIA_CLAUDE_USE_API_KEY') && claudeWrapper.includes('ARIA_CLAUDE_USE_ARIA_RUNTIME'), 'Active Claude wrapper must expose Claude direct-login + runtime opt-in flags.', { claudeWrapperPath });
+    assert('active-claude-wrapper-contract', !claudeWrapper.includes('export ANTHROPIC_BASE_URL="${ANTHROPIC_BASE_URL:-$ARIA_RUNTIME_URL}"\nexport OPENAI_BASE_URL'), 'Active Claude wrapper must not unconditionally export ANTHROPIC_BASE_URL — that breaks OAuth.', { claudeWrapperPath });
+    assert('active-claude-wrapper-contract', !/OPENAI_API_KEY=.*ARIA_API_KEY/.test(claudeWrapper), 'Active Claude wrapper must not poison provider API key env.', { claudeWrapperPath });
+  }
+  assert('active-codex-wrapper-contract', codexWrapper.includes('unset ANTHROPIC_BASE_URL'), 'Active Codex wrapper must unset ANTHROPIC_BASE_URL (Codex uses OpenAI-compatible providers, not Anthropic).', { codexWrapperPath });
   assert('active-codex-wrapper-contract', codexWrapper.includes('case "${1:-}" in') && codexWrapper.includes('app-server|exec-server|exec|review'), 'Active Codex wrapper must preserve bypasses for native non-interactive subcommands.', { codexWrapperPath });
 }
 

package/scripts/check-client-smoke.mjs

@@ -0,0 +1,297 @@
+#!/usr/bin/env node
+import { spawnSync } from 'node:child_process';
+import { existsSync, mkdtempSync, readdirSync, readFileSync, rmSync, statSync } from 'node:fs';
+import { homedir, tmpdir } from 'node:os';
+import { dirname, join, resolve } from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const here = dirname(fileURLToPath(import.meta.url));
+const packageRoot = resolve(here, '..');
+const packageJson = JSON.parse(readFileSync(join(packageRoot, 'package.json'), 'utf8'));
+const smokeRoot = mkdtempSync(join(tmpdir(), 'aria-asi-client-smoke-'));
+const packDir = join(smokeRoot, 'pack');
+const globalHome = join(smokeRoot, 'global-home');
+const globalPrefix = join(smokeRoot, 'global-prefix');
+const appHome = join(smokeRoot, 'app-home');
+const appDir = join(smokeRoot, 'client-app');
+const cleanPath = '/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin';
+
+const failures = [];
+const warnings = [];
+const checks = {};
+
+function fail(label, message) {
+  failures.push({ label, message });
+}
+
+function warn(label, message) {
+  warnings.push({ label, message });
+}
+
+function run(label, command, args, options = {}) {
+  const result = spawnSync(command, args, {
+    cwd: options.cwd || packageRoot,
+    env: options.env || process.env,
+    encoding: 'utf8',
+    maxBuffer: options.maxBuffer || 64 * 1024 * 1024,
+    shell: false,
+  });
+  if (result.status !== 0) {
+    fail(label, `${command} ${args.join(' ')} failed with exit ${result.status}\n${result.stderr || result.stdout}`);
+  }
+  return result;
+}
+
+function parsePackJson(output) {
+  const stdout = String(output || '').trim();
+  const match = stdout.match(/\[\s*\{\s*"id"[\s\S]*\]\s*$/);
+  if (!match) throw new Error('npm pack did not emit a parseable JSON manifest');
+  const parsed = JSON.parse(match[0]);
+  if (!parsed[0]) throw new Error('npm pack emitted an empty manifest');
+  return parsed[0];
+}
+
+function listFiles(root, out = []) {
+  if (!existsSync(root)) return out;
+  for (const name of readdirSync(root)) {
+    const target = join(root, name);
+    const stat = statSync(target);
+    if (stat.isDirectory()) {
+      listFiles(target, out);
+    } else {
+      out.push(target);
+    }
+  }
+  return out;
+}
+
+function assertNoClientMutation(root, label) {
+  const forbidden = ['.claude', '.codex', join('.aria', 'wrappers')];
+  for (const relative of forbidden) {
+    const target = join(root, relative);
+    if (existsSync(target)) fail(label, `Dry-run client smoke created forbidden production-like path: ${target}`);
+  }
+}
+
+function safeJsonParse(text) {
+  try {
+    return JSON.parse(text);
+  } catch {
+    return null;
+  }
+}
+
+if (packageJson.name !== '@aria_asi/cli') {
+  fail('package.identity', `Expected @aria_asi/cli, observed ${packageJson.name}`);
+}
+if (packageJson.publishConfig?.registry !== 'https://npm.pkg.github.com') {
+  fail('package.registry', `Expected GitHub Packages registry, observed ${packageJson.publishConfig?.registry || '<missing>'}`);
+}
+if (packageJson.publishConfig?.access !== 'restricted') {
+  fail('package.access', `Expected restricted package access, observed ${packageJson.publishConfig?.access || '<missing>'}`);
+}
+
+for (const dir of [packDir, globalHome, globalPrefix, appHome, appDir]) {
+  run('mkdir', 'mkdir', ['-p', dir]);
+}
+
+let manifest = null;
+let tarballPath = '';
+try {
+  const pack = run('client-smoke.pack', 'npm', ['pack', '--pack-destination', packDir, '--json', '--silent'], {
+    env: {
+      ...process.env,
+      npm_config_loglevel: 'silent',
+    },
+  });
+  if (pack.status === 0) {
+    manifest = parsePackJson(pack.stdout);
+    tarballPath = join(packDir, manifest.filename);
+    checks.tarball_manifest = {
+      pass: true,
+      filename: manifest.filename,
+      entryCount: manifest.entryCount,
+      size: manifest.size,
+      unpackedSize: manifest.unpackedSize,
+    };
+  }
+} catch (error) {
+  fail('client-smoke.pack-json', error.message);
+}
+
+if (manifest) {
+  const files = new Set((manifest.files || []).map((file) => file.path));
+  const required = [
+    'package.json',
+    'README.md',
+    'CLIENT-ONBOARDING.md',
+    packageJson.bin?.aria,
+    packageJson.main?.replace(/^\.\//, ''),
+    packageJson.types?.replace(/^\.\//, ''),
+  ].filter(Boolean);
+  for (const file of required) {
+    if (!files.has(file)) fail('client-smoke.pack-required-file', `Pack manifest missing ${file}`);
+  }
+  const forbidden = [...files].filter((path) => {
+    if (path === '.env.example') return false;
+    return (
+      path.endsWith('.tgz') ||
+      path.endsWith('.log') ||
+      path.endsWith('.jsonl') ||
+      path === 'publish-summary.json' ||
+      path.startsWith('node_modules/') ||
+      path.startsWith('.aria/')
+    );
+  });
+  if (forbidden.length > 0) fail('client-smoke.pack-forbidden-file', `Pack manifest contains forbidden files: ${forbidden.join(', ')}`);
+}
+
+if (tarballPath && existsSync(tarballPath)) {
+  const tarList = run('client-smoke.tar-list', 'tar', ['-tzf', tarballPath]);
+  if (tarList.status === 0) {
+    const tarFiles = tarList.stdout.trim().split(/\n+/).filter(Boolean);
+    for (const expected of [
+      'package/bin/aria.js',
+      'package/package.json',
+      'package/dist/aria-connector/src/index.js',
+      'package/dist/aria-connector/src/index.d.ts',
+    ]) {
+      if (!tarFiles.includes(expected)) fail('client-smoke.tar-required-file', `Tarball missing ${expected}`);
+    }
+    const forbidden = tarFiles.filter((path) => /\.(tgz|log|jsonl)$/.test(path) || /(^|\/)publish-summary\.json$/.test(path));
+    if (forbidden.length > 0) fail('client-smoke.tar-forbidden-file', `Tarball contains forbidden files: ${forbidden.join(', ')}`);
+    checks.tarball_contents = { pass: forbidden.length === 0, requiredFilesChecked: 4 };
+  }
+}
+
+if (tarballPath && existsSync(tarballPath)) {
+  const globalEnv = {
+    ...process.env,
+    HOME: globalHome,
+    PATH: `${globalPrefix}/bin:${cleanPath}`,
+    ARIA_SELF_UPDATE: 'off',
+    npm_config_update_notifier: 'false',
+  };
+  run('client-smoke.global-install', 'npm', ['install', '-g', '--prefix', globalPrefix, tarballPath, '--foreground-scripts', '--loglevel=warn'], {
+    env: globalEnv,
+    cwd: smokeRoot,
+  });
+  const ariaBin = join(globalPrefix, 'bin', 'aria');
+  if (!existsSync(ariaBin)) {
+    fail('client-smoke.global-bin', `Installed aria bin missing at ${ariaBin}`);
+  } else {
+    const runtimeOnly = run('client-smoke.global-runtime-sidecar-dry-run', ariaBin, ['connect', '--dry-run', '--runtime-sidecar-only'], {
+      env: globalEnv,
+      cwd: smokeRoot,
+    });
+    const surfaces = run('client-smoke.global-surface-dry-run', ariaBin, ['connect', '--dry-run', '--surfaces=claude,codex'], {
+      env: globalEnv,
+      cwd: smokeRoot,
+    });
+    run('client-smoke.global-github-help', ariaBin, ['github', '--help'], {
+      env: globalEnv,
+      cwd: smokeRoot,
+    });
+    const runtimeJson = safeJsonParse(runtimeOnly.stdout);
+    const surfaceJson = safeJsonParse(surfaces.stdout);
+    if (runtimeJson?.installPlan?.wrappers !== 'skipped_by_default') {
+      fail('client-smoke.runtime-sidecar-wrappers', 'Runtime sidecar dry run did not keep wrappers skipped by default.');
+    }
+    if (!runtimeJson?.installPlan?.excluded?.includes('provider_path_takeover')) {
+      fail('client-smoke.runtime-sidecar-provider-boundary', 'Runtime sidecar dry run did not exclude provider path takeover.');
+    }
+    if (surfaceJson?.installPlan?.surfaces?.claude !== true || surfaceJson?.installPlan?.surfaces?.codex !== true) {
+      fail('client-smoke.surface-selection', 'Claude+Codex dry run did not select both requested surfaces.');
+    }
+    if (surfaceJson?.installPlan?.surfaces?.opencode !== false || surfaceJson?.installPlan?.surfaces?.cursor !== false) {
+      fail('client-smoke.surface-selection', 'Claude+Codex dry run selected an unrequested surface.');
+    }
+    assertNoClientMutation(globalHome, 'client-smoke.global-home-mutation');
+    checks.global_prefix_install = { pass: existsSync(ariaBin), ariaBin };
+    checks.dry_run_native_cli_protection = {
+      pass: failures.filter((item) => item.label.startsWith('client-smoke.runtime-sidecar') || item.label === 'client-smoke.surface-selection').length === 0,
+    };
+  }
+}
+
+if (tarballPath && existsSync(tarballPath)) {
+  const appEnv = {
+    ...process.env,
+    HOME: appHome,
+    PATH: `${appDir}/node_modules/.bin:${cleanPath}`,
+    ARIA_SELF_UPDATE: 'off',
+    npm_config_update_notifier: 'false',
+  };
+  run('client-smoke.app-init', 'npm', ['init', '-y'], { cwd: appDir, env: appEnv });
+  run('client-smoke.app-install', 'npm', ['install', tarballPath, '--foreground-scripts', '--loglevel=warn'], { cwd: appDir, env: appEnv });
+  const importResult = run(
+    'client-smoke.app-import',
+    'node',
+    [
+      '--input-type=module',
+      '-e',
+      "import('@aria_asi/cli').then((m)=>console.log(JSON.stringify({importOk:true,count:Object.keys(m).length,hasAriaChat:Boolean(m.AriaChat),hasGovernedSurfaceRunner:Boolean(m.GovernedSurfaceRunner)})))",
+    ],
+    { cwd: appDir, env: appEnv },
+  );
+  const importJson = safeJsonParse(importResult.stdout);
+  if (importResult.status === 0 && (!importJson?.importOk || !importJson?.hasAriaChat || !importJson?.hasGovernedSurfaceRunner)) {
+    fail('client-smoke.app-import-shape', `Import shape missing expected exports: ${importResult.stdout}`);
+  }
+  run('client-smoke.app-npx-dry-run', 'npx', ['--no', '@aria_asi/cli', 'connect', '--dry-run', '--runtime-sidecar-only'], {
+    cwd: appDir,
+    env: appEnv,
+  });
+  const audit = run('client-smoke.app-audit', 'npm', ['audit', '--omit=dev', '--json'], { cwd: appDir, env: appEnv });
+  const auditJson = safeJsonParse(audit.stdout);
+  const vulnerabilities = auditJson?.metadata?.vulnerabilities?.total;
+  if (audit.status === 0 && vulnerabilities !== 0) {
+    fail('client-smoke.app-audit-total', `Expected 0 vulnerabilities, observed ${vulnerabilities}`);
+  }
+  assertNoClientMutation(appHome, 'client-smoke.app-home-mutation');
+  checks.outside_project_import = { pass: importResult.status === 0, exports: importJson?.count };
+  checks.outside_project_audit = { pass: audit.status === 0 && vulnerabilities === 0, vulnerabilities };
+}
+
+const rcFindings = [];
+for (const rc of ['.bash_profile', '.bashrc', '.profile', '.zshrc', '.zprofile']) {
+  const path = join(homedir(), rc);
+  if (!existsSync(path)) continue;
+  const text = readFileSync(path, 'utf8');
+  if (/^\s*aria\s*\(\)\s*\{/m.test(text) && /\$HOME\/\.local\/bin\/aria/.test(text)) {
+    rcFindings.push(path);
+  }
+}
+if (rcFindings.length > 0) {
+  warn('client-smoke.host-contamination', `Host shell profile defines aria() pinned to $HOME/.local/bin/aria: ${rcFindings.join(', ')}`);
+}
+checks.host_contamination = {
+  status: rcFindings.length === 0 ? 'pass' : 'warn',
+  findings: rcFindings.length,
+};
+
+const receipt = {
+  ok: failures.length === 0,
+  package: packageJson.name,
+  version: packageJson.version,
+  publishConfig: packageJson.publishConfig,
+  smokeRoot,
+  tarball: tarballPath || null,
+  checks,
+  warnings,
+  failures,
+  clientHomeFileCounts: {
+    global: listFiles(globalHome).length,
+    app: listFiles(appHome).length,
+  },
+};
+
+if (process.env.ARIA_CLIENT_SMOKE_KEEP_TMP !== '1') {
+  rmSync(smokeRoot, { recursive: true, force: true });
+  receipt.smokeRootRemoved = true;
+} else {
+  receipt.smokeRootRemoved = false;
+}
+
+console.log(JSON.stringify(receipt, null, 2));
+if (failures.length > 0) process.exit(1);

package/scripts/check-codex-orchestrator-adoption.mjs

@@ -0,0 +1,150 @@
+#!/usr/bin/env node
+import { existsSync, readFileSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { dirname, resolve } from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const here = dirname(fileURLToPath(import.meta.url));
+const packageRoot = resolve(here, '..');
+const sourcePath = resolve(packageRoot, 'src', 'connectors', 'codex.ts');
+const activeConfigPath = process.env.ARIA_CODEX_CONFIG_PATH || resolve(homedir(), '.codex', 'config.toml');
+const failures = [];
+const warnings = [];
+
+const REQUIRED_HOOKS = [
+  {
+    event: 'user_prompt_submit',
+    index: 0,
+    command: 'aria-userprompt-submit.mjs',
+    role: 'mechanical user-prompt orchestrator',
+  },
+  {
+    event: 'pre_tool_use',
+    index: 0,
+    command: 'aria-pre-tool-use.mjs',
+    role: 'pre-tool continuity and hard-risk brake',
+  },
+  {
+    event: 'post_tool_use',
+    index: 0,
+    command: 'aria-post-tool-use.mjs',
+    role: 'post-tool observation ledger',
+  },
+  {
+    event: 'stop',
+    index: 0,
+    command: 'aria-stop.mjs',
+    role: 'output claim boundary and closeout observer',
+  },
+];
+
+function fail(check, message, details = {}) {
+  failures.push({ check, message, details });
+}
+
+function warn(check, message, details = {}) {
+  warnings.push({ check, message, details });
+}
+
+function read(pathname) {
+  return existsSync(pathname) ? readFileSync(pathname, 'utf8') : '';
+}
+
+function managedBlock(text) {
+  return text.match(/# BEGIN ARIA MANAGED HOOKS([\s\S]*?)# END ARIA MANAGED HOOKS/m)?.[1] || '';
+}
+
+function sectionBody(text, header) {
+  const escaped = header.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+  return text.match(new RegExp(`\\[${escaped}\\]\\s*\\n([\\s\\S]*?)(?=\\n\\[|$)`, 'm'))?.[1] || '';
+}
+
+function assertSourceGenerator() {
+  const source = read(sourcePath);
+  if (!source) {
+    fail('source.codex-connector', 'Codex connector source is missing.', { sourcePath });
+    return;
+  }
+  const fn = source.match(/function buildCodexHooksToml[\s\S]*?function installCodexHooksConfig/)?.[0] || '';
+  if (!fn) {
+    fail('source.codex-hook-generator', 'Could not locate buildCodexHooksToml source.');
+    return;
+  }
+  if (/enabled\s*=\s*false/.test(fn)) {
+    fail('source.codex-hook-generator', 'Codex hook generator must not disable mechanical orchestrator hooks.');
+  }
+  for (const hook of REQUIRED_HOOKS) {
+    if (!fn.includes(hook.command)) {
+      fail('source.codex-hook-generator', `Codex hook generator missing ${hook.role}.`, { command: hook.command });
+    }
+    if (!fn.includes(`enabledState('${hook.event}', ${hook.index})`)) {
+      fail('source.codex-hook-generator', `Codex hook generator must explicitly enable ${hook.event}:${hook.index}.`);
+    }
+  }
+  if (!source.includes('project-boundary-cognition.mjs')) {
+    fail('source.codex-hook-generator', 'Codex hook installer must copy project-boundary-cognition.mjs for installed UserPromptSubmit/Stop imports.');
+  }
+}
+
+function assertActiveConfig() {
+  const text = read(activeConfigPath);
+  if (!text) {
+    const message = `Active Codex config not found at ${activeConfigPath}.`;
+    if (process.env.ARIA_REQUIRE_ACTIVE_CODEX_HOOKS === '1') fail('active.codex-config', message);
+    else warn('active.codex-config', message);
+    return;
+  }
+  const block = managedBlock(text);
+  if (!block) {
+    fail('active.codex-managed-hooks', 'Active Codex config does not contain the Aria managed hooks block.', { activeConfigPath });
+    return;
+  }
+  for (const hook of REQUIRED_HOOKS) {
+    if (!block.includes(hook.command)) {
+      fail('active.codex-managed-hooks', `Active Codex config missing ${hook.role}.`, { command: hook.command });
+    }
+    const stateHeader = `hooks.state."${activeConfigPath}:${hook.event}:${hook.index}:0"`;
+    const body = sectionBody(block, stateHeader);
+    if (!body) {
+      fail('active.codex-hook-state', `Active Codex config missing hook-state for ${hook.event}:${hook.index}.`, { stateHeader });
+      continue;
+    }
+    if (/enabled\s*=\s*false/.test(body)) {
+      fail('active.codex-hook-state', `Active Codex hook-state disables ${hook.role}.`, { stateHeader });
+    }
+    if (!/enabled\s*=\s*true/.test(body)) {
+      fail('active.codex-hook-state', `Active Codex hook-state must explicitly enable ${hook.role}.`, { stateHeader });
+    }
+  }
+  const codexDir = dirname(activeConfigPath);
+  const requiredInstalledFiles = [
+    resolve(codexDir, 'hooks', 'aria-userprompt-submit.mjs'),
+    resolve(codexDir, 'hooks', 'aria-pre-tool-use.mjs'),
+    resolve(codexDir, 'hooks', 'aria-post-tool-use.mjs'),
+    resolve(codexDir, 'hooks', 'aria-stop.mjs'),
+    resolve(codexDir, 'hooks', 'lib', 'runtime-client.mjs'),
+    resolve(codexDir, 'hooks', 'lib', 'task-project-ledger.mjs'),
+    resolve(codexDir, 'lib', 'project-boundary-cognition.mjs'),
+  ];
+  for (const file of requiredInstalledFiles) {
+    if (!existsSync(file)) {
+      fail('active.codex-installed-file', 'Active Codex hook dependency is missing.', { file });
+    }
+  }
+}
+
+assertSourceGenerator();
+assertActiveConfig();
+
+const result = {
+  ok: failures.length === 0,
+  checkedAt: new Date().toISOString(),
+  sourcePath,
+  activeConfigPath,
+  requiredHooks: REQUIRED_HOOKS,
+  warnings,
+  failures,
+};
+
+console.log(JSON.stringify(result, null, 2));
+process.exit(result.ok ? 0 : 1);