@aria_asi/cli 0.2.40 → 0.2.41

package/scripts/self-test-cross-phase-tool-failure.mjs

@@ -0,0 +1,110 @@
+#!/usr/bin/env node
+// Cross-phase chained-state integration smoke. Drives PostToolUse and
+// Stop hooks in sequence; asserts: tool error appends an entry to
+// chained state; subsequent Stop that claims done without acknowledging
+// the entry blocks; Stop that acknowledges passes; Stop without claim
+// passes too.
+
+import { spawnSync } from 'node:child_process';
+import { resolve, dirname } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { existsSync, readFileSync, unlinkSync } from 'node:fs';
+import { homedir } from 'node:os';
+
+const HERE = dirname(fileURLToPath(import.meta.url));
+const POST = resolve(HERE, '..', '..', '..', 'ops', 'claude-hooks', 'codex-native', 'aria-post-tool-use.mjs');
+const STOP = resolve(HERE, '..', '..', '..', 'ops', 'claude-hooks', 'codex-native', 'aria-stop.mjs');
+
+let pass = 0, fail = 0;
+function ok(n) { console.log(`  ok  - ${n}`); pass++; }
+function bad(n, d) { console.log(`  FAIL - ${n}\n        ${d}`); fail++; }
+
+function runHook(scriptPath, event) {
+  const child = spawnSync('node', [scriptPath], {
+    input: JSON.stringify(event),
+    env: { ...process.env, ARIA_HOOK_SURFACE: 'claude', ARIA_KERNEL_QA_MODE: '1' },
+    encoding: 'utf8',
+    timeout: 15000,
+  });
+  return { exitCode: child.status, stdout: child.stdout || '', stderr: child.stderr || '' };
+}
+
+function stateFilePath(sessionId) {
+  const safe = sessionId.replace(/[^a-zA-Z0-9._-]+/g, '_');
+  return resolve(homedir(), '.claude', 'tmp', 'aria-hook-turn-state', `${safe}.json`);
+}
+
+const threadId = `xph-${Date.now()}`;
+const sessionId = `claude:${threadId}:1`;
+try { unlinkSync(stateFilePath(sessionId)); } catch {}
+
+// Step 1: PostToolUse with a failing tool
+const postEvent = {
+  session_id: '1',
+  thread_id: threadId,
+  transcript_path: '/dev/null',
+  hook_event_name: 'PostToolUse',
+  tool_name: 'Bash',
+  tool_input: { command: 'npm run build' },
+  tool_response: { stdout: '', stderr: 'type mismatch at src/foo.ts:42', exit_code: 1 },
+  error: { message: 'type mismatch at src/foo.ts:42' },
+};
+const r1 = runHook(POST, postEvent);
+if (r1.exitCode === 0) ok('PostToolUse hook returns 0 on tool error');
+else bad('PostToolUse hook returns 0 on tool error', `exit=${r1.exitCode} stderr=${r1.stderr.slice(0, 200)}`);
+
+// Step 2: chained state has the entry
+const stateFile = stateFilePath(sessionId);
+if (existsSync(stateFile)) {
+  const s = JSON.parse(readFileSync(stateFile, 'utf8'));
+  const f = Array.isArray(s.unacknowledgedToolFailures) ? s.unacknowledgedToolFailures : [];
+  if (f.length >= 1 && f[0].toolName === 'Bash') ok('chained state has unacknowledgedToolFailures entry');
+  else bad('chained state has entry', `failures=${JSON.stringify(f).slice(0, 200)}`);
+} else {
+  bad('chained state file exists', `path=${stateFile}`);
+}
+
+// Step 3: Stop with a claim that DOES NOT acknowledge - blocks
+const r3 = runHook(STOP, {
+  session_id: '1',
+  thread_id: threadId,
+  transcript_path: '/dev/null',
+  hook_event_name: 'Stop',
+  stop_hook_active: false,
+  test_assistant_text: 'The work is done. We have shipped it. It is ready now.',
+});
+const blocked = /Cross-phase gate/.test(r3.stdout) || /\"decision\"\s*:\s*\"block\"/.test(r3.stdout);
+if (blocked) ok('Stop with claim WITHOUT acknowledgment BLOCKS');
+else bad('Stop with claim WITHOUT acknowledgment BLOCKS', `stdout=${r3.stdout.slice(0, 400)}`);
+
+// Step 4: re-seed, Stop with acknowledgment passes the cross-phase gate
+runHook(POST, postEvent);
+const r4 = runHook(STOP, {
+  session_id: '1',
+  thread_id: threadId,
+  transcript_path: '/dev/null',
+  hook_event_name: 'Stop',
+  stop_hook_active: false,
+  test_assistant_text: 'The Bash run errored with a type mismatch at src/foo.ts:42. Not shipped - re-authoring.',
+});
+const ackPassed = !/Cross-phase gate/.test(r4.stdout);
+if (ackPassed) ok('Stop that ACKNOWLEDGES the error passes cross-phase gate');
+else bad('Stop that ACKNOWLEDGES passes', `stdout=${r4.stdout.slice(0, 400)}`);
+
+// Step 5: re-seed, Stop with no claim passes
+runHook(POST, postEvent);
+const r5 = runHook(STOP, {
+  session_id: '1',
+  thread_id: threadId,
+  transcript_path: '/dev/null',
+  hook_event_name: 'Stop',
+  stop_hook_active: false,
+  test_assistant_text: 'Working on the next step. No status assertion here.',
+});
+if (!/Cross-phase gate/.test(r5.stdout)) ok('Stop with no claim passes cross-phase gate');
+else bad('Stop with no claim passes', `stdout=${r5.stdout.slice(0, 400)}`);
+
+console.log();
+console.log(`cross-phase tool-failure: ${pass} pass, ${fail} fail`);
+try { unlinkSync(stateFile); } catch {}
+process.exit(fail === 0 ? 0 : 1);

package/scripts/self-test-cross-surface-action-ledger.mjs

@@ -0,0 +1,149 @@
+#!/usr/bin/env node
+import { existsSync, mkdtempSync, 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');
+const codexHooksRoot = resolve(hooksRoot, 'codex-native');
+const projectId = 'cross-surface-action-ledger-smoke';
+const taskId = 'task-cross-surface-action-ledger-smoke';
+
+function fail(message, details = {}) {
+  process.stderr.write(`${JSON.stringify({ ok: false, message, ...details }, null, 2)}\n`);
+  process.exit(1);
+}
+
+function runCodexHook(home, hookName, event) {
+  const hookPath = resolve(codexHooksRoot, 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',
+      ARIA_ACTION_LEDGER_PROJECT_ID: projectId,
+      ARIA_ACTION_LEDGER_TASK_ID: taskId,
+    },
+    maxBuffer: 4 * 1024 * 1024,
+  });
+  if (child.status !== 0) {
+    fail(`${hookName} exited non-zero`, {
+      status: child.status,
+      stdout: child.stdout,
+      stderr: child.stderr,
+    });
+  }
+  return child;
+}
+
+function readProjection(home) {
+  const root = join(home, '.aria', 'action-ledger', projectId);
+  const projectionPath = join(root, 'projection.json');
+  const eventsPath = join(root, 'events.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));
+  return { projectionPath, eventsPath, projection, events };
+}
+
+const home = mkdtempSync(join(tmpdir(), 'aria-cross-surface-action-ledger-'));
+const envBackup = {
+  HOME: process.env.HOME,
+  ARIA_HOME: process.env.ARIA_HOME,
+  HOOK_SESSION_ID: process.env.HOOK_SESSION_ID,
+  ARIA_ACTION_LEDGER_PROJECT_ID: process.env.ARIA_ACTION_LEDGER_PROJECT_ID,
+  ARIA_ACTION_LEDGER_TASK_ID: process.env.ARIA_ACTION_LEDGER_TASK_ID,
+};
+
+try {
+  const codexBase = {
+    thread_id: 'cross-surface-action-ledger',
+    turn_id: 'cross-surface-smoke',
+  };
+  runCodexHook(home, 'aria-userprompt-submit.mjs', {
+    ...codexBase,
+    prompt: 'cross-surface action ledger smoke',
+  });
+  runCodexHook(home, 'aria-pre-tool-use.mjs', {
+    ...codexBase,
+    tool_name: 'Read',
+    tool_input: { file_path: '/tmp/cross-surface-action-ledger.txt' },
+  });
+  runCodexHook(home, 'aria-post-tool-use.mjs', {
+    ...codexBase,
+    tool_name: 'Read',
+    tool_input: { file_path: '/tmp/cross-surface-action-ledger.txt' },
+    tool_response: { ok: true, output: 'cross surface smoke' },
+  });
+  runCodexHook(home, 'aria-stop.mjs', {
+    ...codexBase,
+    response: 'Bounded status: cross-surface Codex hook events were emitted for smoke verification.',
+  });
+
+  process.env.HOME = home;
+  process.env.ARIA_HOME = home;
+  process.env.HOOK_SESSION_ID = 'claude-cross-surface-smoke';
+  process.env.ARIA_ACTION_LEDGER_PROJECT_ID = projectId;
+  process.env.ARIA_ACTION_LEDGER_TASK_ID = taskId;
+  const { appendGateLedger } = await import(`${resolve(hooksRoot, 'lib', 'aria-gate-ledger.mjs')}?cross=${Date.now()}`);
+  appendGateLedger({
+    hook: 'pre-tool-gate',
+    event: 'PreToolUse',
+    tool: 'Read',
+    decision: 'allow',
+    source: 'claude/cross-surface-pre-tool',
+    reasonShort: 'Claude cross-surface read accepted',
+    meta: { fileClaims: [{ path: '/tmp/cross-surface-action-ledger.txt', intent: 'read' }] },
+    sessionId: process.env.HOOK_SESSION_ID,
+  });
+  appendGateLedger({
+    hook: 'stop-gate',
+    event: 'Stop',
+    decision: 'allow',
+    source: 'claude/cross-surface-stop',
+    reasonShort: 'Claude cross-surface stop accepted',
+    sessionId: process.env.HOOK_SESSION_ID,
+  });
+
+  const { projectionPath, eventsPath, projection, events } = readProjection(home);
+  const surfaces = new Set(events.map((event) => event.surface));
+  const phases = new Set(events.map((event) => event.lifecyclePhase));
+  if (!surfaces.has('codex') || !surfaces.has('claude-code')) {
+    fail('projection must include both Codex and Claude Code surfaces', { surfaces: [...surfaces], eventsPath });
+  }
+  for (const phase of ['pre_cognition', 'pre_tool', 'post_tool', 'post_cognition']) {
+    if (!phases.has(phase)) fail('projection missing required lifecycle phase', { phase, phases: [...phases] });
+  }
+  if (projection.eventCount < 6) {
+    fail('projection event count too low for cross-surface smoke', { eventCount: projection.eventCount, projectionPath });
+  }
+  const sessions = Object.keys(projection.sessions || {});
+  if (!sessions.some((session) => session.startsWith('codex:')) || !sessions.includes('claude-cross-surface-smoke')) {
+    fail('projection sessions did not preserve both surface sessions', { sessions });
+  }
+
+  process.stdout.write(`${JSON.stringify({
+    ok: true,
+    home,
+    projectionPath,
+    eventsPath,
+    eventCount: projection.eventCount,
+    surfaces: [...surfaces].sort(),
+    phases: [...phases].sort(),
+    sessions,
+  }, null, 2)}\n`);
+} finally {
+  for (const [key, value] of Object.entries(envBackup)) {
+    if (value === undefined) delete process.env[key];
+    else process.env[key] = value;
+  }
+  rmSync(home, { recursive: true, force: true });
+}