@aria_asi/cli 0.2.39 → 0.2.41

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

@@ -0,0 +1,179 @@
+#!/usr/bin/env node
+
+import { chmodSync, mkdirSync, readFileSync, rmSync, writeFileSync } from 'node:fs';
+import { mkdtempSync } from 'node:fs';
+import { spawnSync } from 'node:child_process';
+import { spawn } from 'node:child_process';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { setTimeout as sleep } from 'node:timers/promises';
+
+const repoRoot = process.cwd();
+const cliPath = join(repoRoot, 'packages', 'aria-connector', 'bin', 'aria.js');
+const STATE_FILE = 'codebase-awareness-state.json';
+const ATLAS_CALL_LOG = 'atlas-calls.log';
+
+function createWorkspace() {
+  const workspace = mkdtempSync(join(tmpdir(), 'codebase-awareness-delta-'));
+  const home = join(workspace, 'home');
+  const repo = join(workspace, 'repo');
+  mkdirSync(repo, { recursive: true });
+  mkdirSync(home, { recursive: true });
+  return {
+    workspace,
+    home,
+    repo,
+    atlasLog: join(workspace, ATLAS_CALL_LOG),
+  };
+}
+
+function resolveStatePath(homeDir) {
+  return join(homeDir, '.aria', STATE_FILE);
+}
+
+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}`);
+  }
+}
+
+function writeFile(filePath, content) {
+  writeFileSync(filePath, content, { encoding: 'utf8' });
+}
+
+function writeAtlasShim(atlasBin, atlasLogPath) {
+  writeFile(atlasBin, [
+    '#!/usr/bin/env node',
+    'const { appendFileSync } = require("node:fs");',
+    'appendFileSync(process.env.ATLAS_SMOKE_LOG || "' + ATLAS_CALL_LOG.replace(/\\/g, '\\\\') + '", process.argv.slice(2).join(" ") + "\\n");',
+    'process.stdout.write(\'{"ok":true}\\n\');',
+    'process.exit(0);',
+  ].join('\n'));
+}
+
+function readState(pathname) {
+  return JSON.parse(readFileSync(pathname, 'utf8'));
+}
+
+async function waitForState(pathname, predicate, retries = 20, intervalMs = 500) {
+  for (let attempt = 0; attempt < retries; attempt += 1) {
+    try {
+      const state = readState(pathname);
+      if (predicate(state)) return state;
+    } catch {}
+    await sleep(intervalMs);
+  }
+  return null;
+}
+
+async function waitForAtlasCalls(atlasLogPath, retries = 20, intervalMs = 500) {
+  for (let attempt = 0; attempt < retries; attempt += 1) {
+    try {
+      const lines = readFileSync(atlasLogPath, 'utf8').split('\n').map((line) => line.trim()).filter(Boolean);
+      if (lines.length) return lines;
+    } catch {}
+    await sleep(intervalMs);
+  }
+  return [];
+}
+
+async function main() {
+  const workspace = createWorkspace();
+  const targetFile = join(workspace.repo, 'README.md');
+  const statePath = resolveStatePath(workspace.home);
+  const atlasBin = join(workspace.home, '.aria', 'atlas', 'bin', 'atlas');
+  const atlasBinDir = join(workspace.home, '.aria', 'atlas', 'bin');
+  const env = {
+    ...process.env,
+    HOME: workspace.home,
+    ATLAS_SMOKE_LOG: workspace.atlasLog,
+    ARIA_CODEBASE_AWARENESS_ATLAS_BIN: atlasBin,
+  };
+  const expectedChangedFile = targetFile;
+
+  mkdirSync(atlasBinDir, { recursive: true });
+  writeAtlasShim(atlasBin, workspace.atlasLog);
+  chmodSync(atlasBin, 0o755);
+
+  runCommand('git', ['init'], { cwd: workspace.repo });
+  writeFile(targetFile, 'initial');
+  runCommand('git', ['add', '.'], { cwd: workspace.repo });
+  runCommand('git', ['commit', '-m', 'initial', '--no-gpg-sign'], { cwd: workspace.repo });
+
+  const daemon = spawn(process.execPath, [cliPath, 'codebase-awareness', 'start'], {
+    cwd: workspace.repo,
+    env,
+    stdio: ['ignore', 'inherit', 'inherit'],
+  });
+
+  try {
+    await sleep(1800);
+    writeFile(targetFile, 'updated');
+
+    const deltaState = await waitForState(statePath, (state) => (
+      Number.isFinite(state.deltaIngestSuccess) && state.deltaIngestSuccess > 0
+    ));
+    const lastSuccessAt = deltaState?.lastDeltaIngestAt;
+    const atlasCalls = await waitForAtlasCalls(workspace.atlasLog);
+
+    if (!deltaState) {
+      throw new Error('Timed out waiting for delta ingest success state.');
+    }
+    if (!atlasCalls.length) {
+      throw new Error('Fake Atlas CLI was not invoked for the changed file.');
+    }
+    if (deltaState.lastDeltaIngestNoop) {
+      throw new Error(`Delta ingest was a noop: ${String(deltaState.lastDeltaIngestNoopReason)}`);
+    }
+    if (deltaState.lastDeltaIngestPath !== expectedChangedFile) {
+      throw new Error(`Expected lastDeltaIngestPath=${expectedChangedFile}, got ${String(deltaState.lastDeltaIngestPath)}`);
+    }
+    if (deltaState.deltaIngestFailures > 0) {
+      throw new Error(`Expected zero deltaIngestFailures, got ${deltaState.deltaIngestFailures}.`);
+    }
+
+    mkdirSync(join(workspace.repo, 'noop-smoke-dir'), { recursive: true });
+    const noopState = await waitForState(statePath, (state) => {
+      if (!state.lastDeltaIngestAt || state.lastDeltaIngestAt === lastSuccessAt) return false;
+      return state.lastDeltaIngestNoop === true && state.lastDeltaIngestNoopReason;
+    });
+
+    if (!noopState) {
+      throw new Error('Timed out waiting for no-op delta state after directory change.');
+    }
+    if (noopState.lastDeltaIngestNoopReason !== 'no delta file candidate') {
+      throw new Error(`Expected no-op reason "no delta file candidate", got ${String(noopState.lastDeltaIngestNoopReason)}.`);
+    }
+    if (noopState.lastDeltaIngestPath !== null) {
+      throw new Error(`Expected lastDeltaIngestPath=null on no-op, got ${String(noopState.lastDeltaIngestPath)}.`);
+    }
+
+    console.log(JSON.stringify({
+      ok: true,
+      repo: workspace.repo,
+      lastDeltaIngestPath: deltaState.lastDeltaIngestPath,
+      deltaIngestSuccess: deltaState.deltaIngestSuccess,
+      lastDeltaIngestNoop: noopState.lastDeltaIngestNoop,
+      lastDeltaIngestNoopReason: noopState.lastDeltaIngestNoopReason,
+      atlasCalls,
+    }, null, 2));
+  } finally {
+    daemon.kill('SIGTERM');
+    await new Promise((resolve) => {
+      daemon.once('exit', resolve);
+      daemon.kill('SIGTERM');
+    });
+    rmSync(workspace.workspace, { recursive: true, force: true });
+  }
+}
+
+main().catch((error) => {
+  console.error(`self-test failed: ${error?.message || error}`);
+  process.exit(1);
+});

package/scripts/self-test-codex-live-hook-parity.mjs

@@ -0,0 +1,84 @@
+#!/usr/bin/env node
+
+import assert from 'node:assert/strict';
+import { createHash } from 'node:crypto';
+import { existsSync, readFileSync } from 'node:fs';
+import { homedir } from 'node:os';
+import path from 'node:path';
+
+const connectorRoot = path.resolve(import.meta.dirname, '..');
+const home = process.env.HOME || homedir();
+
+const pairs = [
+  {
+    surface: 'codex',
+    source: path.join(connectorRoot, 'hooks', 'codex-native', 'aria-userprompt-submit.mjs'),
+    live: path.join(home, '.codex', 'hooks', 'aria-userprompt-submit.mjs'),
+  },
+  {
+    surface: 'codex',
+    source: path.join(connectorRoot, 'hooks', 'codex-native', 'lib', 'runtime-client.mjs'),
+    live: path.join(home, '.codex', 'hooks', 'lib', 'runtime-client.mjs'),
+  },
+  {
+    surface: 'aria-runtime',
+    source: path.join(connectorRoot, 'hooks', 'codex-native', 'aria-userprompt-submit.mjs'),
+    live: path.join(home, '.aria', 'runtime', 'hooks', 'codex-native', 'aria-userprompt-submit.mjs'),
+  },
+  {
+    surface: 'aria-runtime',
+    source: path.join(connectorRoot, 'hooks', 'codex-native', 'lib', 'runtime-client.mjs'),
+    live: path.join(home, '.aria', 'runtime', 'hooks', 'codex-native', 'lib', 'runtime-client.mjs'),
+  },
+  {
+    surface: 'opencode',
+    source: path.join(connectorRoot, 'hooks', 'codex-native', 'aria-userprompt-submit.mjs'),
+    live: path.join(home, '.opencode', 'hooks', 'codex-native', 'aria-userprompt-submit.mjs'),
+  },
+  {
+    surface: 'opencode',
+    source: path.join(connectorRoot, 'hooks', 'codex-native', 'lib', 'runtime-client.mjs'),
+    live: path.join(home, '.opencode', 'hooks', 'codex-native', 'lib', 'runtime-client.mjs'),
+  },
+];
+
+function sha256File(filePath) {
+  return createHash('sha256').update(readFileSync(filePath)).digest('hex');
+}
+
+const results = pairs.map((pair) => {
+  const sourceExists = existsSync(pair.source);
+  const liveExists = existsSync(pair.live);
+  const sourceSha256 = sourceExists ? sha256File(pair.source) : null;
+  const liveSha256 = liveExists ? sha256File(pair.live) : null;
+  return {
+    ...pair,
+    sourceExists,
+    liveExists,
+    sourceSha256,
+    liveSha256,
+    byteIdentical: Boolean(sourceSha256 && liveSha256 && sourceSha256 === liveSha256),
+  };
+});
+
+const drift = results.filter((result) => !result.byteIdentical);
+assert.deepEqual(
+  drift.map(({ surface, source, live, sourceSha256, liveSha256 }) => ({
+    surface,
+    source,
+    live,
+    sourceSha256,
+    liveSha256,
+  })),
+  [],
+  'Codex native hook source/live parity drift detected',
+);
+
+console.log(JSON.stringify({
+  ok: true,
+  test: 'codex-live-hook-parity',
+  checkedPairs: results.length,
+  surfaces: [...new Set(results.map((result) => result.surface))],
+  results,
+  predicate: 'Codex native userprompt hook and runtime client are byte-identical across package source and live Codex, Aria runtime, and OpenCode hook locations.',
+}, null, 2));

package/scripts/self-test-codex-native-action-ledger.mjs

@@ -0,0 +1,167 @@
+#!/usr/bin/env node
+import { existsSync, mkdtempSync, readdirSync, readFileSync, rmSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join, resolve } from 'node:path';
+import { spawnSync } from 'node:child_process';
+
+const repoRoot = resolve(import.meta.dirname, '..', '..', '..');
+const hooksRoot = resolve(repoRoot, 'packages', 'aria-connector', 'hooks', 'codex-native');
+
+function fail(message, details = {}) {
+  process.stderr.write(`${JSON.stringify({ ok: false, message, ...details }, null, 2)}\n`);
+  process.exit(1);
+}
+
+function runHook(home, hookName, event) {
+  const hookPath = resolve(hooksRoot, hookName);
+  const child = spawnSync(process.execPath, [hookPath], {
+    input: `${JSON.stringify(event)}\n`,
+    encoding: 'utf8',
+    env: {
+      ...process.env,
+      HOME: home,
+      ARIA_HOME: home,
+      ARIA_CODEX_READINESS_SILENT: '1',
+      ARIA_CODEX_TICKER_STDERR: '0',
+      ARIA_REMOTE_COACH_ENABLED: '0',
+      ARIA_RUNTIME_URL: 'http://127.0.0.1:1',
+    },
+    maxBuffer: 4 * 1024 * 1024,
+  });
+  if (child.status !== 0) {
+    fail(`${hookName} exited non-zero`, {
+      status: child.status,
+      stdout: child.stdout,
+      stderr: child.stderr,
+    });
+  }
+  const stdout = String(child.stdout || '').trim();
+  if (stdout) {
+    const lines = stdout.split(/\n/).filter(Boolean);
+    for (const line of lines) {
+      try {
+        JSON.parse(line);
+      } catch (error) {
+        fail(`${hookName} stdout line is not JSON`, {
+          line,
+          error: error instanceof Error ? error.message : String(error),
+        });
+      }
+    }
+  }
+  return child;
+}
+
+function findProjection(home) {
+  const root = join(home, '.aria', 'action-ledger');
+  if (!existsSync(root)) fail('action ledger root was not created', { root });
+  const projectDirs = readdirSync(root, { withFileTypes: true }).filter((entry) => entry.isDirectory());
+  if (projectDirs.length !== 1) fail('expected one action ledger project directory', {
+    root,
+    projectDirs: projectDirs.map((entry) => entry.name),
+  });
+  const projectionPath = join(root, projectDirs[0].name, 'projection.json');
+  const eventsPath = join(root, projectDirs[0].name, 'events.jsonl');
+  const publishOutboxPath = join(root, projectDirs[0].name, 'publish-outbox.jsonl');
+  if (!existsSync(projectionPath)) fail('projection.json was not created', { projectionPath });
+  if (!existsSync(eventsPath)) fail('events.jsonl was not created', { eventsPath });
+  const projection = JSON.parse(readFileSync(projectionPath, 'utf8'));
+  const events = readFileSync(eventsPath, 'utf8').split(/\r?\n/).filter(Boolean).map((line) => JSON.parse(line));
+  const publishOutbox = existsSync(publishOutboxPath)
+    ? readFileSync(publishOutboxPath, 'utf8').split(/\r?\n/).filter(Boolean).map((line) => JSON.parse(line))
+    : [];
+  return { projectionPath, eventsPath, publishOutboxPath, projection, events, publishOutbox };
+}
+
+const home = mkdtempSync(join(tmpdir(), 'aria-codex-native-action-ledger-'));
+
+try {
+  const base = {
+    thread_id: 'native-action-ledger',
+    turn_id: 'native-action-ledger-smoke',
+  };
+
+  runHook(home, 'aria-userprompt-submit.mjs', {
+    ...base,
+    prompt: 'build native action ledger integration with rigorous QA',
+  });
+
+  runHook(home, 'aria-pre-tool-use.mjs', {
+    ...base,
+    tool_name: 'Read',
+    tool_input: {
+      file_path: '/tmp/native-action-ledger-input.txt',
+    },
+  });
+
+  runHook(home, 'aria-post-tool-use.mjs', {
+    ...base,
+    tool_name: 'Read',
+    tool_input: {
+      file_path: '/tmp/native-action-ledger-input.txt',
+    },
+    tool_response: {
+      ok: true,
+      output: 'native action ledger read smoke',
+    },
+  });
+
+  runHook(home, 'aria-stop.mjs', {
+    ...base,
+    response: 'Bounded status: native action ledger smoke produced hook events. Evidence: temp-home projection is inspected by this test. Next action: continue QA.',
+  });
+
+  const { projectionPath, eventsPath, publishOutboxPath, projection, events, publishOutbox } = findProjection(home);
+  const phases = new Set(events.map((event) => event.lifecyclePhase));
+  for (const phase of ['pre_cognition', 'pre_tool', 'post_tool', 'post_cognition']) {
+    if (!phases.has(phase)) {
+      fail('missing native action ledger phase', { phase, phases: [...phases], eventsPath });
+    }
+  }
+  if (projection.eventCount < 4) {
+    fail('projection did not include all native hook action events', {
+      eventCount: projection.eventCount,
+      projectionPath,
+    });
+  }
+  if (!projection.latestEvent?.eventId) {
+    fail('projection latestEvent is missing', { projection });
+  }
+  const sessionIds = new Set(events.map((event) => event.sessionId));
+  if (sessionIds.size !== 1) {
+    fail('native hook events did not share one session id', { sessionIds: [...sessionIds] });
+  }
+  const eventHashes = events.map((event) => event.eventHash).filter(Boolean);
+  if (eventHashes.length !== events.length) {
+    fail('one or more action events lack eventHash', { events });
+  }
+  if (publishOutbox.length < events.length) {
+    fail('codex native action events were not queued for runtime/Hive publish when runtime was unreachable', {
+      events: events.length,
+      publishOutbox: publishOutbox.length,
+      publishOutboxPath,
+    });
+  }
+  for (const row of publishOutbox) {
+    if (row.schema !== 'aria.codex_native_action_publish_failure.v1') {
+      fail('unexpected publish outbox schema', { row, publishOutboxPath });
+    }
+    if (!row.eventId || !row.recovery || row.event?.schema !== 'aria.action_event.v1') {
+      fail('publish outbox row lacks replay evidence', { row, publishOutboxPath });
+    }
+  }
+
+  process.stdout.write(`${JSON.stringify({
+    ok: true,
+    home,
+    projectionPath,
+    eventsPath,
+    publishOutboxPath,
+    eventCount: projection.eventCount,
+    publishOutboxCount: publishOutbox.length,
+    phases: [...phases].sort(),
+    latestEvent: projection.latestEvent,
+  }, null, 2)}\n`);
+} finally {
+  rmSync(home, { recursive: true, force: true });
+}

package/scripts/self-test-codex-native-hook-json-contract.mjs

@@ -0,0 +1,74 @@
+#!/usr/bin/env node
+import { mkdtempSync, rmSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join, resolve } from 'node:path';
+import { spawnSync } from 'node:child_process';
+
+const repoRoot = resolve(import.meta.dirname, '..', '..', '..');
+const hookPath = resolve(repoRoot, 'packages', 'aria-connector', 'hooks', 'codex-native', 'aria-live-ticker.mjs');
+
+function fail(message, details = {}) {
+  process.stderr.write(`${JSON.stringify({ ok: false, message, ...details }, null, 2)}\n`);
+  process.exit(1);
+}
+
+const home = mkdtempSync(join(tmpdir(), 'aria-codex-hook-contract-'));
+
+try {
+  const event = {
+    prompt: 'codex native hook json contract smoke',
+    thread_id: 'codex-native-hook-contract',
+    turn_id: 'json-contract-1',
+  };
+  const child = spawnSync(process.execPath, [hookPath], {
+    input: `${JSON.stringify(event)}\n`,
+    encoding: 'utf8',
+    env: {
+      ...process.env,
+      HOME: home,
+      ARIA_CODEX_TICKER_STDERR: '0',
+    },
+    maxBuffer: 1024 * 1024,
+  });
+
+  if (child.status !== 0) {
+    fail('hook exited non-zero', { status: child.status, stderr: child.stderr, stdout: child.stdout });
+  }
+  if (child.stderr !== '') {
+    fail('hook wrote stderr while stderr ticker disabled', { stderr: child.stderr });
+  }
+
+  const stdout = String(child.stdout || '');
+  const lines = stdout.trim().split(/\n/).filter(Boolean);
+  if (lines.length !== 1) {
+    fail('hook stdout must contain exactly one JSON line', { stdout });
+  }
+
+  let parsed;
+  try {
+    parsed = JSON.parse(lines[0]);
+  } catch (error) {
+    fail('hook stdout is not valid JSON', { stdout, error: error instanceof Error ? error.message : String(error) });
+  }
+
+  const output = parsed?.hookSpecificOutput;
+  if (output?.hookEventName !== 'UserPromptSubmit') {
+    fail('hookSpecificOutput.hookEventName must be UserPromptSubmit', { parsed });
+  }
+  if (typeof output?.additionalContext !== 'string') {
+    fail('hookSpecificOutput.additionalContext must be a string', { parsed });
+  }
+  if (!output.additionalContext.startsWith('Harness ')) {
+    fail('additionalContext must contain the harness ticker line', { parsed });
+  }
+
+  process.stdout.write(`${JSON.stringify({
+    ok: true,
+    hook: 'aria-live-ticker.mjs',
+    stdoutLines: lines.length,
+    stderrBytes: Buffer.byteLength(child.stderr || ''),
+    additionalContextType: typeof output.additionalContext,
+  })}\n`);
+} finally {
+  rmSync(home, { recursive: true, force: true });
+}

package/scripts/self-test-codex-orchestrator-continuity.mjs

@@ -0,0 +1,113 @@
+#!/usr/bin/env node
+import { spawnSync } from 'node:child_process';
+import { mkdtempSync, readFileSync, rmSync } from 'node:fs';
+import { tmpdir } 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 hookPath = resolve(packageRoot, 'hooks', 'codex-native', 'aria-userprompt-submit.mjs');
+const home = mkdtempSync(resolve(tmpdir(), 'aria-codex-orchestrator-continuity-'));
+const event = {
+  hookEventName: 'UserPromptSubmit',
+  thread_id: 'orchestrator-continuity-smoke',
+  turn_id: 'runtime-down',
+  prompt: 'Non-trivial Aria hook architecture task that must fire skills mechanically.',
+};
+
+function fail(message, details = {}) {
+  console.error(JSON.stringify({ ok: false, message, details }, null, 2));
+  rmSync(home, { recursive: true, force: true });
+  process.exit(1);
+}
+
+const result = spawnSync(process.execPath, [hookPath], {
+  encoding: 'utf8',
+  timeout: 15000,
+  cwd: packageRoot,
+  env: {
+    ...process.env,
+    ARIA_HOOK_EVENT_JSON: JSON.stringify(event),
+    HOME: home,
+    ARIA_RUNTIME_URL: 'http://127.0.0.1:9',
+    ARIA_HARNESS_TICKER_SIDECAR: '0',
+    ARIA_CODEX_READINESS_SILENT: '1',
+    ARIA_SELF_UPDATE: 'off',
+  },
+});
+
+if (result.error) fail('Codex UserPromptSubmit continuity smoke errored.', { error: result.error.message });
+if (result.status !== 0) fail('Codex UserPromptSubmit continuity smoke exited non-zero.', {
+  status: result.status,
+  stderr: result.stderr,
+  stdout: result.stdout,
+});
+
+let parsed = null;
+try {
+  parsed = JSON.parse(String(result.stdout || '').trim());
+} catch (error) {
+  fail('Codex UserPromptSubmit continuity smoke did not emit JSON.', {
+    error: error instanceof Error ? error.message : String(error),
+    stdout: result.stdout,
+    stderr: result.stderr,
+  });
+}
+
+if (parsed?.decision === 'block') {
+  fail('Codex UserPromptSubmit must not deadlock on runtime-down low-risk prompt start.', { parsed });
+}
+
+const context = String(parsed?.hookSpecificOutput?.additionalContext || '');
+const firedMatch = context.match(/Mechanical skills fired:\s*(\d+)\/(\d+)/);
+const fired = firedMatch ? Number(firedMatch[1]) : 0;
+const floor = firedMatch ? Number(firedMatch[2]) : 0;
+
+if (parsed?.hookSpecificOutput?.hookEventName !== 'UserPromptSubmit') {
+  fail('Codex UserPromptSubmit continuity smoke missing hookSpecificOutput.', { parsed });
+}
+if (!context.includes('ARIA CODEX ORCHESTRATOR CONTINUITY')) {
+  fail('Codex UserPromptSubmit continuity smoke missing owner-visible continuity context.', { context });
+}
+if (!context.includes('local-mechanical-orchestrator')) {
+  fail('Codex UserPromptSubmit continuity smoke missing local mechanical orchestrator mode.', { context });
+}
+if (!Number.isFinite(fired) || !Number.isFinite(floor) || fired < floor || floor < 25) {
+  fail('Codex UserPromptSubmit continuity smoke did not preserve the mechanical skill floor.', { fired, floor, context });
+}
+if (!context.includes('Claim boundary: runtime/hive/garden receipts are unverified')) {
+  fail('Codex UserPromptSubmit continuity smoke must preserve runtime-proof claim boundary.', { context });
+}
+
+const statePath = resolve(home, '.codex', 'tmp', 'aria-hook-turn-state', 'codex_orchestrator-continuity-smoke_runtime-down.json');
+let state = null;
+try {
+  state = JSON.parse(readFileSync(statePath, 'utf8'));
+} catch (error) {
+  fail('Codex UserPromptSubmit continuity smoke did not persist turn state.', {
+    statePath,
+    error: error instanceof Error ? error.message : String(error),
+  });
+}
+if (state?.readiness?.status !== 'degraded_local_continuity') {
+  fail('Codex UserPromptSubmit local continuity must not persist readiness.status=ready.', {
+    readiness: state?.readiness || null,
+  });
+}
+if (state?.claimScopes?.readiness !== 'local_continuity_only') {
+  fail('Codex UserPromptSubmit local continuity must scope readiness to local_continuity_only.', {
+    claimScopes: state?.claimScopes || null,
+  });
+}
+
+rmSync(home, { recursive: true, force: true });
+console.log(JSON.stringify({
+  ok: true,
+  hookPath,
+  runtimeDownReleasedPrompt: true,
+  firedSkillCount: fired,
+  minimumSkillFloor: floor,
+  readinessStatus: state.readiness.status,
+  readinessClaimScope: state.claimScopes.readiness,
+}, null, 2));