@aria_asi/cli 0.2.40 → 0.2.41

package/scripts/self-test-claude-code-mechanical-autofire-hive.mjs

@@ -0,0 +1,138 @@
+#!/usr/bin/env node
+
+import assert from 'node:assert/strict';
+import { mkdtempSync, readFileSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import path from 'node:path';
+import { randomUUID } from 'node:crypto';
+import { spawnSync } from 'node:child_process';
+
+const repoRoot = path.resolve(import.meta.dirname, '..', '..', '..');
+const packageRoot = path.resolve(repoRoot, 'packages', 'aria-connector');
+const runtimeUrl = (process.env.ARIA_RUNTIME_URL || 'http://127.0.0.1:4319').replace(/\/+$/, '');
+const stamp = `${Date.now().toString(36)}-${randomUUID().slice(0, 8)}`;
+const projectId = `claude-code-mechanical-autofire-hive-${stamp}`;
+const threadId = `thread-claude-code-mechanical-autofire-hive-${stamp}`;
+const sessionId = `claude-code:mechanical-autofire-hive:${stamp}`;
+const activeTaskId = 'task-2026-05-15T03-45-18-791Z-2ee60e24';
+const activePhase = '04-add-hive-skill-runtime-receipts';
+
+function asRecord(value) {
+  return value && typeof value === 'object' && !Array.isArray(value) ? value : {};
+}
+
+async function getJson(route) {
+  const response = await fetch(`${runtimeUrl}${route}`);
+  const text = await response.text();
+  let body = null;
+  try {
+    body = text ? JSON.parse(text) : null;
+  } catch {}
+  assert.equal(response.ok, true, `${route} failed: ${response.status} ${text}`);
+  return body;
+}
+
+const ariaHome = mkdtempSync(path.join(tmpdir(), 'aria-claude-mechanical-hive-'));
+const hookScript = path.join(packageRoot, 'hooks', 'aria-universal-turn-packet.mjs');
+const hook = spawnSync(process.execPath, [
+  hookScript,
+  '--surface',
+  'claude-code',
+  '--session-id',
+  sessionId,
+  '--text',
+  'Claude Code mechanical autofire Hive receipt canary: publish skill/runtime/QA/recovery/learning receipt summary and read it back.',
+], {
+  cwd: repoRoot,
+  encoding: 'utf8',
+  env: {
+    ...process.env,
+    ARIA_HOME: ariaHome,
+    ARIA_UNIVERSAL_TURN_PACKET_RECEIPT_DIR: path.join(ariaHome, 'receipts'),
+    ARIA_UNIVERSAL_TURN_PACKET_VERBOSE: '1',
+    ARIA_HIVE_PROJECT_ID: projectId,
+    ARIA_HIVE_THREAD_ID: threadId,
+    ARIA_ACTIVE_TASK_ID: activeTaskId,
+    ARIA_ACTIVE_PHASE: activePhase,
+    ARIA_CLAUDE_HOOK_MODE: 'coach-lite',
+  },
+});
+
+assert.equal(hook.status, 0, hook.stderr || hook.stdout);
+const hookOutput = JSON.parse(hook.stdout);
+assert.equal(hookOutput.ok, true, hook.stdout);
+assert.equal(hookOutput.surfaceId, 'claude-code');
+assert.equal(hookOutput.hookMode, 'coach-lite');
+
+const receipt = JSON.parse(readFileSync(hookOutput.receiptPath, 'utf8'));
+assert.equal(receipt.schema, 'aria.universal_turn_packet.live_entrypoint.v1');
+assert.equal(receipt.surfaceId, 'claude-code');
+assert.equal(receipt.skillExecutionMode, 'mechanical-receipt');
+assert.equal(receipt.hivePublication?.ok, true, JSON.stringify(receipt.hivePublication, null, 2));
+assert.equal(receipt.hivePublication?.schema, 'aria.mechanical_autofire.hive_publication_receipt.v1');
+assert.equal(receipt.hivePublication?.summary?.schema, 'aria.mechanical_autofire.hive_receipt_summary.v1');
+assert.equal(receipt.hivePublication?.summary?.counts?.firedSkills >= 25, true);
+assert.equal(receipt.hivePublication?.summary?.counts?.activeRuntimes >= 16, true);
+assert.equal(receipt.hivePublication?.summary?.counts?.activePrimitives >= 24, true);
+assert.equal(receipt.hivePublication?.summary?.counts?.activeMappings >= 24, true);
+assert.equal(receipt.hivePublication?.summary?.counts?.qaSkills >= 6, true);
+assert.equal(receipt.hivePublication?.summary?.counts?.correctionSkills >= 6, true);
+assert.equal(receipt.hivePublication?.summary?.counts?.tadabburStages, 12);
+assert.equal(receipt.hivePublication?.summary?.counts?.qiyasPerspectives, 15);
+assert.equal(receipt.hivePublication?.summary?.counts?.noorSuite, 14);
+
+const projectContext = await getJson(`/api/hive/project-context?project_id=${encodeURIComponent(projectId)}&include_touches=true&touch_limit=75`);
+assert.equal(projectContext.ok, true);
+assert.equal(projectContext.found, true);
+const capsule = asRecord(projectContext.context?.capsule);
+const latest = asRecord(capsule.latest_mechanical_autofire_receipt);
+assert.equal(latest.schema, 'aria.mechanical_autofire.hive_receipt_summary.v1');
+assert.equal(latest.surfaceId, 'claude-code');
+assert.equal(latest.sessionId, sessionId);
+assert.equal(latest.skillExecutionMode, 'mechanical-receipt');
+assert.equal(latest.counts.firedSkills >= 25, true);
+assert.equal(latest.counts.activeRuntimes >= 16, true);
+assert.equal(latest.counts.activePrimitives >= 24, true);
+assert.equal(latest.counts.activeMappings >= 24, true);
+assert.equal(latest.counts.qaSkills >= 6, true);
+assert.equal(latest.counts.correctionSkills >= 6, true);
+assert.equal(latest.learningLoop.integratedIntoNextPacket, true);
+assert.equal(Array.isArray(capsule.skill_runtime_receipts), true);
+assert.equal(capsule.skill_runtime_receipts[0].sessionId, sessionId);
+assert.equal(asRecord(capsule.latest_qa).source, 'mechanical-autofire.receipt');
+assert.equal(asRecord(capsule.latest_recovery).source, 'mechanical-autofire.receipt');
+
+const registry = await getJson(`/api/hive/session-registry?project_id=${encodeURIComponent(projectId)}&include_touches=true&touch_limit=75`);
+assert.equal(registry.ok, true);
+assert.equal(registry.found, true);
+assert.equal(registry.registry.native_provider_ok, true);
+assert.equal(registry.registry.latest_qa.source, 'mechanical-autofire.receipt');
+assert.equal(registry.registry.latest_recovery.source, 'mechanical-autofire.receipt');
+assert.ok(registry.sessions.some((session) => session.session_id === sessionId && session.surface === 'claude-code'));
+
+const messages = await getJson(`/api/hive/session-message?session_id=${encodeURIComponent(sessionId)}&thread_id=${encodeURIComponent(threadId)}&topic=mechanical-autofire.receipt&unread=false&include_broadcasts=true`);
+assert.equal(messages.ok, true);
+assert.ok(messages.messages.some((message) => message.body?.mechanical_autofire_receipt?.sessionId === sessionId));
+
+const touches = await getJson(`/api/hive/file-touch?session_id=${encodeURIComponent(sessionId)}&thread_id=${encodeURIComponent(threadId)}&limit=75`);
+assert.equal(touches.ok, true);
+assert.ok(touches.touches.some((touch) => Array.isArray(touch.files) && touch.files.some((file) => file.path === hookOutput.receiptPath)));
+
+console.log(JSON.stringify({
+  ok: true,
+  runtimeUrl,
+  projectId,
+  threadId,
+  sessionId,
+  receiptPath: hookOutput.receiptPath,
+  hivePublication: {
+    topic: receipt.hivePublication.topic,
+    projectContext: true,
+    sessionRegistry: true,
+    sessionMessage: true,
+    fileTouch: true,
+    storage: registry.storage.mode,
+    localPostgres: registry.storage.postgres_local_only,
+  },
+  counts: latest.counts,
+}, null, 2));

package/scripts/self-test-claude-code-mechanical-autofire.mjs

@@ -0,0 +1,234 @@
+#!/usr/bin/env node
+
+import assert from 'node:assert/strict';
+import { createHash, randomUUID } from 'node:crypto';
+import { existsSync, mkdtempSync, readFileSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import path from 'node:path';
+import { spawnSync } from 'node:child_process';
+
+const repoRoot = path.resolve(import.meta.dirname, '..', '..', '..');
+const packageRoot = path.resolve(repoRoot, 'packages', 'aria-connector');
+const runtimeUrl = (process.env.ARIA_RUNTIME_URL || 'http://127.0.0.1:4319').replace(/\/+$/, '');
+const stamp = `${Date.now().toString(36)}-${randomUUID().slice(0, 8)}`;
+const projectId = `claude-code-mechanical-autofire-e2e-${stamp}`;
+const threadId = `thread-claude-code-mechanical-autofire-e2e-${stamp}`;
+const activeTaskId = 'task-2026-05-15T03-45-18-791Z-2ee60e24';
+const activePhase = '06-canary-claude-code-end-to-end';
+
+function asRecord(value) {
+  return value && typeof value === 'object' && !Array.isArray(value) ? value : {};
+}
+
+function sha256File(filePath) {
+  return createHash('sha256').update(readFileSync(filePath)).digest('hex');
+}
+
+function runCommand(label, command, args, options = {}) {
+  const child = spawnSync(command, args, {
+    cwd: options.cwd || repoRoot,
+    encoding: 'utf8',
+    env: { ...process.env, ...(options.env || {}) },
+  });
+  assert.equal(child.status, 0, `${label} failed\nstdout:\n${child.stdout}\nstderr:\n${child.stderr}`);
+  return child;
+}
+
+async function getJson(route) {
+  const response = await fetch(`${runtimeUrl}${route}`);
+  const text = await response.text();
+  let body = null;
+  try {
+    body = text ? JSON.parse(text) : null;
+  } catch {}
+  assert.equal(response.ok, true, `${route} failed: ${response.status} ${text}`);
+  return body;
+}
+
+function runHook(sessionId, text) {
+  const ariaHome = mkdtempSync(path.join(tmpdir(), 'aria-claude-mechanical-e2e-'));
+  const hookScript = path.join(packageRoot, 'hooks', 'aria-universal-turn-packet.mjs');
+  const hook = spawnSync(process.execPath, [
+    hookScript,
+    '--surface',
+    'claude-code',
+    '--session-id',
+    sessionId,
+    '--text',
+    text,
+  ], {
+    cwd: repoRoot,
+    encoding: 'utf8',
+    env: {
+      ...process.env,
+      ARIA_HOME: ariaHome,
+      ARIA_UNIVERSAL_TURN_PACKET_RECEIPT_DIR: path.join(ariaHome, 'receipts'),
+      ARIA_UNIVERSAL_TURN_PACKET_VERBOSE: '1',
+      ARIA_HIVE_PROJECT_ID: projectId,
+      ARIA_HIVE_THREAD_ID: threadId,
+      ARIA_ACTIVE_TASK_ID: activeTaskId,
+      ARIA_ACTIVE_PHASE: activePhase,
+      ARIA_CLAUDE_HOOK_MODE: 'coach-lite',
+    },
+  });
+  assert.equal(hook.status, 0, hook.stderr || hook.stdout);
+  const output = JSON.parse(hook.stdout);
+  const receipt = JSON.parse(readFileSync(output.receiptPath, 'utf8'));
+  return { output, receipt };
+}
+
+function assertReceipt(receipt, sessionId, { requiresPriorLearning }) {
+  assert.equal(receipt.schema, 'aria.universal_turn_packet.live_entrypoint.v1');
+  assert.equal(receipt.ok, true, JSON.stringify(receipt.qa, null, 2));
+  assert.equal(receipt.degraded, false);
+  assert.equal(receipt.surfaceId, 'claude-code');
+  assert.equal(receipt.sessionId, sessionId);
+  assert.equal(receipt.hookMode, 'coach-lite');
+  assert.equal(receipt.skillExecutionMode, 'mechanical-receipt');
+  assert.equal(receipt.skillExecutionReceipt?.ok, true);
+  assert.equal(receipt.loadedSkillIds.length >= 25, true);
+  assert.equal(receipt.activeRuntimes.length >= 16, true);
+  assert.equal(receipt.activePrimitives.length >= 24, true);
+  assert.equal(receipt.activeMappings.length >= 24, true);
+  assert.equal(receipt.qaSkills.length >= 6, true);
+  assert.equal(receipt.correctionSkills.length >= 6, true);
+  assert.equal(receipt.cognitiveRuntimeReceipts?.tadabbur?.stageCount, 12);
+  assert.equal(receipt.cognitiveRuntimeReceipts?.qiyas?.perspectiveCount, 15);
+  assert.equal(receipt.cognitiveRuntimeReceipts?.noor?.noorSuiteCount, 14);
+  assert.equal(receipt.doctrineRuntimeReceipt?.ok, true);
+  assert.equal(receipt.doctrineRuntimeReceipt?.noFakeValidation, true);
+  assert.equal(receipt.hiveObserverSourceTopology?.ok, true);
+  assert.equal(receipt.qa?.status, 'pass');
+  assert.deepEqual(receipt.qa?.findings, []);
+  assert.equal(receipt.promptChars > 0, true);
+  assert.equal(receipt.learningLoop?.schema, 'aria.dalio_reflexion_learning_loop.v1');
+  assert.equal(receipt.learningLoop?.style, 'dalio_reflexion');
+  assert.equal(receipt.learningLoop?.boundedRepair?.allowedAttempts, 1);
+  assert.equal(receipt.learningLoop?.correctionCycle?.status, 'verified');
+  assert.equal(receipt.learningLoop?.integratedIntoNextPacket, true);
+  assert.equal(receipt.learningLoop?.priorHiveLearningIntegrated, requiresPriorLearning);
+  assert.equal(receipt.hivePublication?.ok, true, JSON.stringify(receipt.hivePublication, null, 2));
+  assert.equal(receipt.hivePublication?.summary?.counts?.firedSkills >= 25, true);
+  assert.equal(receipt.hivePublication?.summary?.counts?.activeRuntimes >= 16, true);
+  assert.equal(receipt.hivePublication?.summary?.counts?.activePrimitives >= 24, true);
+  assert.equal(receipt.hivePublication?.summary?.counts?.activeMappings >= 24, true);
+  assert.equal(receipt.hivePublication?.summary?.counts?.qaSkills >= 6, true);
+  assert.equal(receipt.hivePublication?.summary?.counts?.correctionSkills >= 6, true);
+  assert.equal(receipt.hivePublication?.summary?.counts?.tadabburStages, 12);
+  assert.equal(receipt.hivePublication?.summary?.counts?.qiyasPerspectives, 15);
+  assert.equal(receipt.hivePublication?.summary?.counts?.noorSuite, 14);
+}
+
+const packageHook = path.join(packageRoot, 'hooks', 'aria-universal-turn-packet.mjs');
+const opsHook = path.join(repoRoot, 'ops', 'claude-hooks', 'aria-universal-turn-packet.mjs');
+const liveRuntimeHook = path.join(process.env.HOME || '', '.aria', 'runtime', 'hooks', 'aria-universal-turn-packet.mjs');
+assert.equal(existsSync(packageHook), true, packageHook);
+assert.equal(existsSync(opsHook), true, opsHook);
+assert.equal(existsSync(liveRuntimeHook), true, liveRuntimeHook);
+const hookHashes = {
+  package: sha256File(packageHook),
+  ops: sha256File(opsHook),
+  liveRuntime: sha256File(liveRuntimeHook),
+};
+assert.equal(hookHashes.package, hookHashes.ops, 'package and ops hook hashes must match');
+assert.equal(hookHashes.package, hookHashes.liveRuntime, 'package and live runtime hook hashes must match');
+
+const providerContract = runCommand(
+  'CLI wrapper provider contract',
+  process.execPath,
+  [path.join(packageRoot, 'scripts', 'check-cli-wrapper-provider-contract.mjs')],
+  { cwd: packageRoot },
+);
+const providerContractJson = JSON.parse(providerContract.stdout);
+assert.equal(providerContractJson.ok, true);
+const activeWrappersChecked = providerContractJson.activeWrappersChecked || [];
+const activeClaudeWrapper = path.join(process.env.HOME || '', '.aria', 'wrappers', 'claude');
+if (existsSync(activeClaudeWrapper)) {
+  assert.ok(activeWrappersChecked.some((wrapperPath) => wrapperPath.endsWith('/.aria/wrappers/claude')));
+}
+assert.ok(activeWrappersChecked.some((wrapperPath) => wrapperPath.endsWith('/.aria/wrappers/codex')));
+
+const firstSessionId = `claude-code:mechanical-autofire-e2e:first:${stamp}`;
+const secondSessionId = `claude-code:mechanical-autofire-e2e:second:${stamp}`;
+const first = runHook(
+  firstSessionId,
+  'Claude Code end-to-end mechanical autofire canary first turn: publish compact skill/runtime/Hive/QA learning receipt before native provider execution.',
+);
+assertReceipt(first.receipt, firstSessionId, { requiresPriorLearning: false });
+
+const second = runHook(
+  secondSessionId,
+  'Claude Code end-to-end mechanical autofire canary second turn: prove latest Hive QA and reflexion learning are reinjected before native provider execution.',
+);
+assertReceipt(second.receipt, secondSessionId, { requiresPriorLearning: true });
+assert.equal(second.receipt.priorHiveLearning?.ok, true);
+assert.equal(second.receipt.priorHiveLearning?.latestLearningLoop?.schema, 'aria.dalio_reflexion_learning_loop.v1');
+
+const projectContext = await getJson(`/api/hive/project-context?project_id=${encodeURIComponent(projectId)}&include_touches=true&touch_limit=100`);
+assert.equal(projectContext.ok, true);
+assert.equal(projectContext.found, true);
+const capsule = asRecord(projectContext.context?.capsule);
+const latest = asRecord(capsule.latest_mechanical_autofire_receipt);
+assert.equal(latest.schema, 'aria.mechanical_autofire.hive_receipt_summary.v1');
+assert.equal(latest.surfaceId, 'claude-code');
+assert.equal(latest.sessionId, secondSessionId);
+assert.equal(latest.skillExecutionMode, 'mechanical-receipt');
+assert.equal(latest.counts.firedSkills >= 25, true);
+assert.equal(latest.counts.activeRuntimes >= 16, true);
+assert.equal(latest.counts.activePrimitives >= 24, true);
+assert.equal(latest.counts.activeMappings >= 24, true);
+assert.equal(latest.counts.qaSkills >= 6, true);
+assert.equal(latest.counts.correctionSkills >= 6, true);
+assert.equal(latest.learningLoop.schema, 'aria.dalio_reflexion_learning_loop.v1');
+assert.equal(asRecord(capsule.latest_learning_loop).schema, 'aria.dalio_reflexion_learning_loop.v1');
+assert.equal(asRecord(capsule.latest_qa).source, 'mechanical-autofire.receipt');
+assert.equal(asRecord(capsule.latest_recovery).source, 'mechanical-autofire.receipt');
+assert.equal(Array.isArray(capsule.skill_runtime_receipts), true);
+assert.equal(capsule.skill_runtime_receipts[0].sessionId, secondSessionId);
+
+const registry = await getJson(`/api/hive/session-registry?project_id=${encodeURIComponent(projectId)}&include_touches=true&touch_limit=100`);
+assert.equal(registry.ok, true);
+assert.equal(registry.found, true);
+assert.equal(registry.storage.mode, 'postgres');
+assert.equal(registry.storage.postgres_local_only, true);
+assert.equal(registry.registry.native_provider_ok, true);
+assert.ok(registry.sessions.some((session) => session.session_id === firstSessionId && session.surface === 'claude-code'));
+assert.ok(registry.sessions.some((session) => session.session_id === secondSessionId && session.surface === 'claude-code'));
+const secondRegistrySession = registry.sessions.find((session) => session.session_id === secondSessionId && session.surface === 'claude-code');
+assert.equal(secondRegistrySession?.native_provider_mode, true);
+assert.equal(secondRegistrySession?.provider_auth_owner, 'native-cli');
+
+const messages = await getJson(`/api/hive/session-message?session_id=${encodeURIComponent(secondSessionId)}&thread_id=${encodeURIComponent(threadId)}&topic=mechanical-autofire.receipt&unread=false&include_broadcasts=true`);
+assert.equal(messages.ok, true);
+assert.ok(messages.messages.some((message) => message.body?.mechanical_autofire_receipt?.sessionId === secondSessionId));
+assert.ok(messages.messages.some((message) => message.body?.learning_loop_marker?.schema === 'aria.dalio_reflexion_learning_loop.v1'));
+
+const touches = await getJson(`/api/hive/file-touch?session_id=${encodeURIComponent(secondSessionId)}&thread_id=${encodeURIComponent(threadId)}&limit=100`);
+assert.equal(touches.ok, true);
+assert.ok(touches.touches.some((touch) => Array.isArray(touch.files) && touch.files.some((file) => file.path === second.output.receiptPath)));
+
+console.log(JSON.stringify({
+  ok: true,
+  runtimeUrl,
+  projectId,
+  threadId,
+  firstSessionId,
+  secondSessionId,
+  providerBoundary: {
+    noProviderCliInvokedByCanary: true,
+    nativeProviderAuthOwner: secondRegistrySession.provider_auth_owner,
+    activeWrappersChecked: providerContractJson.activeWrappersChecked,
+  },
+  hookHashes,
+  receiptPaths: [first.output.receiptPath, second.output.receiptPath],
+  priorHiveLearningIntegrated: second.receipt.learningLoop.priorHiveLearningIntegrated,
+  hivePublication: {
+    storage: registry.storage.mode,
+    localPostgres: registry.storage.postgres_local_only,
+    projectContext: true,
+    sessionRegistry: true,
+    sessionMessage: true,
+    fileTouch: true,
+  },
+  counts: latest.counts,
+}, null, 2));

package/scripts/self-test-codebase-awareness-atlas-delta.mjs

@@ -0,0 +1,159 @@
+#!/usr/bin/env node
+import { spawn, spawnSync } from 'node:child_process';
+import { chmodSync, existsSync, mkdirSync, readFileSync, rmSync, writeFileSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { dirname, join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+async function waitFor(predicate, label, timeoutMs = 12_000) {
+  const started = Date.now();
+  while (Date.now() - started < timeoutMs) {
+    const value = predicate();
+    if (value) return value;
+    await sleep(150);
+  }
+  throw new Error(`timed out waiting for ${label}`);
+}
+
+function readJson(path) {
+  return JSON.parse(readFileSync(path, 'utf8'));
+}
+
+function runCommand(command, args, options = {}) {
+  const result = spawnSync(command, args, {
+    encoding: 'utf8',
+    stdio: ['ignore', 'pipe', 'pipe'],
+    ...options,
+  });
+  if (result.error) throw result.error;
+  if (result.status !== 0) {
+    throw new Error(`${command} ${args.join(' ')} failed: ${result.stderr || result.stdout}`);
+  }
+}
+
+const root = mkdtemp();
+const home = join(root, 'home');
+const repo = join(root, 'repo');
+const fakeAtlas = join(root, 'fake-atlas.mjs');
+const fakeAtlasLog = join(root, 'fake-atlas-log.jsonl');
+const statePath = join(home, '.aria', 'codebase-awareness-state.json');
+let daemonStderr = '';
+
+function mkdtemp() {
+  const dir = join(tmpdir(), `aria-codebase-awareness-atlas-delta-${process.pid}-${Date.now()}`);
+  mkdirSync(dir, { recursive: true, mode: 0o700 });
+  return dir;
+}
+
+try {
+  mkdirSync(join(repo, 'src'), { recursive: true });
+  mkdirSync(dirname(statePath), { recursive: true, mode: 0o700 });
+  writeFileSync(join(repo, 'package.json'), JSON.stringify({ name: 'delta-smoke', version: '0.0.0' }), 'utf8');
+  writeFileSync(join(repo, 'src', 'index.ts'), 'export const first = 1;\n', 'utf8');
+  runCommand('git', ['init'], { cwd: repo });
+  runCommand('git', ['add', '.'], { cwd: repo });
+  runCommand('git', ['commit', '-m', 'initial', '--no-gpg-sign'], { cwd: repo });
+  writeFileSync(
+    fakeAtlas,
+    `#!/usr/bin/env node
+import { appendFileSync } from 'node:fs';
+const log = process.env.FAKE_ATLAS_LOG;
+if (log) appendFileSync(log, JSON.stringify({ argv: process.argv.slice(2), at: new Date().toISOString() }) + '\\n');
+process.stdout.write(JSON.stringify({ ok: true, delta_ingest: { ok: true, changed: true, noop: false, event_id: 42, high_watermark: 42, reason: 'updated' } }) + '\\n');
+`,
+    { mode: 0o755 },
+  );
+  chmodSync(fakeAtlas, 0o755);
+
+  const scriptDir = dirname(fileURLToPath(import.meta.url));
+  const ariaBin = existsSync(join(process.cwd(), 'bin', 'aria.js'))
+    ? join(process.cwd(), 'bin', 'aria.js')
+    : join(scriptDir, '..', 'bin', 'aria.js');
+  if (!existsSync(ariaBin)) {
+    throw new Error(`Could not resolve aria CLI binary: ${ariaBin}`);
+  }
+  const child = spawn(process.execPath, [ariaBin, 'codebase-awareness', 'start'], {
+    cwd: repo,
+    env: {
+      ...process.env,
+      HOME: home,
+      ARIA_CODEBASE_AWARENESS_REPOS: repo,
+      ARIA_CODEBASE_AWARENESS_ATLAS_BIN: fakeAtlas,
+      ARIA_CODEBASE_AWARENESS_HEARTBEAT_MS: '5000',
+      ARIA_CODEBASE_AWARENESS_REFRESH_MS: '120000',
+      FAKE_ATLAS_LOG: fakeAtlasLog,
+    },
+    stdio: ['ignore', 'pipe', 'pipe'],
+  });
+
+  child.stderr.on('data', (chunk) => { daemonStderr += chunk.toString('utf8'); });
+
+  try {
+    await waitFor(
+      () => {
+        if (!existsSync(statePath)) return null;
+        const state = readJson(statePath);
+        const watchesRepo = Array.isArray(state.watchedRepos) && state.watchedRepos.includes(repo);
+        const scannedRepo = Array.isArray(state.repoSnapshots) && state.repoSnapshots.some((entry) => entry.path === repo);
+        return state.status === 'watching' && watchesRepo && scannedRepo ? state : null;
+      },
+      'daemon watcher ready for temp repo',
+    );
+    await sleep(1800);
+    writeFileSync(join(repo, 'src', 'index.ts'), 'export const first = 2;\n', 'utf8');
+    await waitFor(() => existsSync(fakeAtlasLog) && readFileSync(fakeAtlasLog, 'utf8').trim().length > 0, 'fake atlas delta invocation');
+    const invocation = JSON.parse(readFileSync(fakeAtlasLog, 'utf8').trim().split('\n').at(-1));
+
+    if (!invocation.argv.includes('delta-ingest') || !invocation.argv.includes('file')) {
+      throw new Error(`fake atlas saw wrong argv: ${JSON.stringify(invocation.argv)}`);
+    }
+    if (!invocation.argv.includes(join(repo, 'src', 'index.ts'))) {
+      throw new Error(`fake atlas did not receive changed file path: ${JSON.stringify(invocation.argv)}`);
+    }
+    const state = await waitFor(
+      () => {
+        const current = readJson(statePath);
+        return current.deltaIngestSuccess >= 1 && current.lastDeltaIngestPath === join(repo, 'src', 'index.ts') ? current : null;
+      },
+      'state records fake Atlas delta success for changed file',
+    );
+    if (state.deltaIngestSuccess < 1 || state.deltaIngestFailures !== 0) {
+      throw new Error(`unexpected delta counters: ${JSON.stringify(state, null, 2)}`);
+    }
+    if (state.lastDeltaIngestNoop) {
+      throw new Error(`expected non-noop delta ingest: ${JSON.stringify(state, null, 2)}`);
+    }
+
+    process.stdout.write(JSON.stringify({
+      ok: true,
+      invoked_argv: invocation.argv,
+      state: {
+        lastDeltaIngestPath: state.lastDeltaIngestPath,
+        lastDeltaIngestEventId: state.lastDeltaIngestEventId,
+        deltaIngestSuccess: state.deltaIngestSuccess,
+        deltaIngestFailures: state.deltaIngestFailures,
+      },
+    }, null, 2) + '\n');
+  } finally {
+    child.kill('SIGTERM');
+    await sleep(250);
+  }
+} catch (error) {
+  process.stderr.write(`${error instanceof Error ? error.message : String(error)}\n`);
+  if (existsSync(statePath)) {
+    process.stderr.write(`state=${readFileSync(statePath, 'utf8')}\n`);
+  }
+  if (existsSync(fakeAtlasLog)) {
+    process.stderr.write(`fake_atlas_log=${readFileSync(fakeAtlasLog, 'utf8')}\n`);
+  }
+  if (daemonStderr) {
+    process.stderr.write(`daemon_stderr=${daemonStderr}\n`);
+  }
+  process.exitCode = 1;
+} finally {
+  rmSync(root, { recursive: true, force: true });
+}