@aria_asi/cli 0.2.40 → 0.2.41

package/scripts/self-test-owner-airtable-sync.mjs

@@ -0,0 +1,181 @@
+#!/usr/bin/env node
+import assert from 'node:assert/strict';
+import { existsSync, mkdirSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+
+import { syncOwnerStatusAirtable } from './sync-owner-status-airtable.mjs';
+
+function makeResponse(status, payload) {
+  return {
+    ok: status >= 200 && status < 300,
+    status,
+    async text() {
+      return JSON.stringify(payload || {});
+    },
+  };
+}
+
+const home = mkdtempSync(join(tmpdir(), 'aria-owner-airtable-sync-'));
+const taskDir = join(home, 'tasks');
+const runtimeStateDir = join(home, 'runtime-state');
+const actionLedgerDir = join(home, 'action-ledger');
+const outDir = join(home, 'owner-export');
+const secretsEnv = join(home, 'airtable.env');
+const statePath = join(home, 'state', 'latest.json');
+const projectId = 'airtable-sync-smoke';
+const taskId = 'task-airtable-sync-smoke';
+const projectRoot = join(actionLedgerDir, projectId);
+const tokenEnvName = ['AIRTABLE', 'ACCESS', 'TOKEN'].join('_');
+const baseEnvName = ['AIRTABLE', 'ARIA', 'BASE', 'ID'].join('_');
+
+try {
+  mkdirSync(taskDir, { recursive: true });
+  mkdirSync(runtimeStateDir, { recursive: true });
+  mkdirSync(projectRoot, { recursive: true });
+  writeFileSync(secretsEnv, [
+    `${tokenEnvName}='unit_test_token_no_network'`,
+    `${baseEnvName}='app_airtable_sync_smoke'`,
+    '',
+  ].join('\n'), { mode: 0o600 });
+  writeFileSync(join(taskDir, `${taskId}.json`), JSON.stringify({
+    taskId,
+    status: 'active',
+    goal: 'owner Airtable sync smoke',
+    updatedAt: '2026-05-17T20:00:00.000Z',
+    createdAt: '2026-05-17T20:00:00.000Z',
+    phases: [
+      {
+        phaseId: '01-sync',
+        title: 'Sync',
+        status: 'active',
+        consumerReceipts: [{
+          at: '2026-05-17T20:01:00.000Z',
+          boundary: 'qa',
+          status: 'partial',
+          summary: 'needs replay queue visibility',
+          correction: { gaps: ['queue row not visible'], action: 'sync Airtable queue table' },
+        }],
+      },
+    ],
+    checkpoints: [{ at: '2026-05-17T20:02:00.000Z', phaseId: '01-sync', status: 'active', summary: 'sync started' }],
+  }, null, 2));
+  writeFileSync(join(runtimeStateDir, 'end-of-phase-qa-court-latest.json'), JSON.stringify({
+    generated_at: '2026-05-17T20:03:00.000Z',
+    claim_gate: { verdict: 'pass' },
+  }, null, 2));
+  const event = {
+    schema: 'aria.action_event.v1',
+    eventId: 'ev_airtable_sync_smoke',
+    actionId: 'act_airtable_sync_smoke',
+    sessionId: 'codex:airtable-sync-smoke',
+    threadId: 'codex:airtable-sync-smoke',
+    surface: 'codex',
+    projectId,
+    taskId,
+    phaseId: '01-sync',
+    lifecyclePhase: 'post_tool',
+    status: 'blocked',
+    createdAt: '2026-05-17T20:04:00.000Z',
+    eventHash: 'hash-airtable-sync-smoke',
+  };
+  writeFileSync(join(projectRoot, 'events.jsonl'), `${JSON.stringify(event)}\n`);
+  writeFileSync(join(projectRoot, 'projection.json'), JSON.stringify({
+    schema: 'aria.action_ledger_projection.v1',
+    generatedAt: '2026-05-17T20:04:00.000Z',
+    eventCount: 1,
+    latestEvent: {
+      eventId: event.eventId,
+      actionId: event.actionId,
+      surface: event.surface,
+      lifecyclePhase: event.lifecyclePhase,
+      status: event.status,
+      createdAt: event.createdAt,
+    },
+    tasks: { [taskId]: { taskId, status: 'blocked' } },
+    sessions: { [event.sessionId]: { sessionId: event.sessionId } },
+    correctionRequired: true,
+    latestQa: { ok: false, gaps: ['runtime publish queued'] },
+    latestAtlas: { status: 'grounded', target: 'packages/aria-connector/bin/aria.js' },
+    sentinelFindings: [{ id: 'sentinel-1' }],
+  }, null, 2));
+  writeFileSync(join(projectRoot, 'publish-outbox.jsonl'), `${JSON.stringify({
+    schema: 'aria.action_event_publish_pending.v1',
+    at: '2026-05-17T20:05:00.000Z',
+    eventId: event.eventId,
+    actionId: event.actionId,
+    projectId,
+    taskId,
+    phaseId: event.phaseId,
+    recovery: 'queued_for_action_event_publish_replay',
+    event,
+  })}\n`);
+
+  const calls = [];
+  const createdTables = [];
+  const apiFetch = async (url, options = {}) => {
+    const parsed = new URL(url);
+    calls.push({ method: options.method || 'GET', path: parsed.pathname, body: options.body ? JSON.parse(options.body) : null });
+    if (parsed.pathname.endsWith('/meta/bases/app_airtable_sync_smoke/tables') && (!options.method || options.method === 'GET')) {
+      return makeResponse(200, { tables: [{ id: 'tblDefault', name: 'Table 1', fields: [{ name: 'Name' }] }, ...createdTables] });
+    }
+    if (parsed.pathname.endsWith('/meta/bases/app_airtable_sync_smoke/tables') && options.method === 'POST') {
+      const body = JSON.parse(options.body);
+      const created = { id: `tbl${createdTables.length + 1}`, name: body.name, fields: body.fields };
+      createdTables.push(created);
+      return makeResponse(200, created);
+    }
+    if (options.method === 'PATCH' && parsed.pathname.startsWith('/v0/app_airtable_sync_smoke/')) {
+      const body = JSON.parse(options.body);
+      return makeResponse(200, { records: body.records.map((record, index) => ({ id: `rec${index}`, fields: record.fields })) });
+    }
+    return makeResponse(404, { error: 'unexpected fake Airtable request' });
+  };
+
+  const result = await syncOwnerStatusAirtable({
+    taskDir,
+    runtimeStateDir,
+    actionLedgerDir,
+    outDir,
+    secretsEnv,
+    statePath,
+    taskId,
+    atlasSocket: join(home, 'missing-atlas.sock'),
+    apiFetch,
+  });
+
+  assert.equal(result.ok, true);
+  assert.equal(result.baseId, 'app_airtable_sync_smoke');
+  assert.equal(result.dashboardRows, 9);
+  assert.ok(result.ownerBoardRows >= 8);
+  assert.equal(result.ownerSyncRows, 3);
+  assert.equal(result.deferredRows, 2);
+  assert.ok(result.atlasRows >= 2);
+  assert.ok(result.schemaResults.some((entry) => entry.table === 'OwnerBoard' && entry.action === 'created'));
+  assert.ok(result.schemaResults.some((entry) => entry.table === 'Dashboard' && entry.action === 'created'));
+  assert.ok(result.schemaResults.some((entry) => entry.table === 'OwnerAirtableSync' && entry.action === 'created'));
+  assert.ok(result.schemaResults.some((entry) => entry.table === 'DeferredLedger' && entry.action === 'created'));
+  assert.ok(result.schemaResults.some((entry) => entry.table === 'AtlasContext' && entry.action === 'created'));
+  assert.ok(result.syncResults.some((entry) => entry.table === 'OwnerBoard' && entry.rows === result.ownerBoardRows));
+  assert.ok(result.syncResults.some((entry) => entry.table === 'OwnerAirtableSync' && entry.rows === 3));
+  assert.ok(result.syncResults.some((entry) => entry.table === 'DeferredLedger' && entry.rows === 2));
+  assert.ok(result.syncResults.some((entry) => entry.table === 'ActionLedgerPublishQueue' && entry.rows === 1 && entry.upserted === 1));
+  assert.ok(calls.some((call) => call.method === 'PATCH' && call.body?.performUpsert?.fieldsToMergeOn?.includes('record_key')));
+  assert.ok(calls.some((call) => call.method === 'PATCH' && call.path.endsWith('/OwnerBoard') && call.body.records.some((record) => record.fields.card_title === 'Make Atlas own mirroring its runtime repo to GitHub')));
+  assert.ok(calls.some((call) => call.method === 'PATCH' && call.path.endsWith('/DeferredLedger') && call.body.records.some((record) => record.fields.deferred_id === 'action-ledger-publish-replay-controls' && record.fields.readable_status === 'open')));
+  assert.equal(existsSync(statePath), true);
+  const state = JSON.parse(readFileSync(statePath, 'utf8'));
+  assert.equal(state.schema, 'aria.owner_airtable_sync.v1');
+
+  process.stdout.write(`${JSON.stringify({
+    ok: true,
+    createdTableCount: createdTables.length,
+    syncTables: result.syncResults.map((entry) => ({ table: entry.table, rows: entry.rows })),
+    dashboardRows: result.dashboardRows,
+    ownerBoardRows: result.ownerBoardRows,
+    ownerSyncRows: result.ownerSyncRows,
+    atlasRows: result.atlasRows,
+  }, null, 2)}\n`);
+} finally {
+  rmSync(home, { recursive: true, force: true });
+}

package/scripts/self-test-owner-sheets-action-ledger.mjs

@@ -0,0 +1,100 @@
+#!/usr/bin/env node
+import assert from 'node:assert/strict';
+import { existsSync, mkdirSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+
+import { exportOwnerGoogleSheetsCsv } from './export-owner-status-sheets.mjs';
+
+const home = mkdtempSync(join(tmpdir(), 'aria-owner-sheets-action-ledger-'));
+const taskDir = join(home, 'tasks');
+const runtimeStateDir = join(home, 'runtime-state');
+const actionLedgerDir = join(home, 'action-ledger');
+const outDir = join(home, 'owner-sheets');
+const projectId = 'owner-sheets-action-ledger-smoke';
+const taskId = 'task-owner-sheets-action-ledger-smoke';
+const projectRoot = join(actionLedgerDir, projectId);
+
+try {
+  mkdirSync(taskDir, { recursive: true });
+  mkdirSync(runtimeStateDir, { recursive: true });
+  mkdirSync(projectRoot, { recursive: true });
+  writeFileSync(join(taskDir, `${taskId}.json`), JSON.stringify({
+    taskId,
+    status: 'active',
+    goal: 'owner sheets action ledger smoke',
+    updatedAt: '2026-05-17T12:00:00.000Z',
+    createdAt: '2026-05-17T12:00:00.000Z',
+    phases: [{ phaseId: '01-smoke', title: 'Smoke', status: 'active', consumerReceipts: [] }],
+    checkpoints: [{ at: '2026-05-17T12:01:00.000Z', phaseId: '01-smoke', status: 'active', summary: 'smoke started' }],
+  }, null, 2));
+  writeFileSync(join(runtimeStateDir, 'end-of-phase-qa-court-latest.json'), JSON.stringify({
+    generated_at: '2026-05-17T12:02:00.000Z',
+    claim_gate: { verdict: 'pass' },
+  }, null, 2));
+  const event = {
+    schema: 'aria.action_event.v1',
+    eventId: 'ev_owner_sheets_smoke',
+    actionId: 'act_owner_sheets_smoke',
+    sessionId: 'codex:owner-sheets-smoke',
+    threadId: 'codex:owner-sheets-smoke',
+    surface: 'codex',
+    projectId,
+    taskId,
+    phaseId: '01-smoke',
+    lifecyclePhase: 'post_tool',
+    status: 'blocked',
+    createdAt: '2026-05-17T12:03:00.000Z',
+    eventHash: 'hash-owner-sheets-smoke',
+  };
+  writeFileSync(join(projectRoot, 'events.jsonl'), `${JSON.stringify(event)}\n`);
+  writeFileSync(join(projectRoot, 'projection.json'), JSON.stringify({
+    schema: 'aria.action_ledger_projection.v1',
+    generatedAt: '2026-05-17T12:03:00.000Z',
+    eventCount: 1,
+    latestEvent: {
+      eventId: event.eventId,
+      actionId: event.actionId,
+      surface: event.surface,
+      lifecyclePhase: event.lifecyclePhase,
+      status: event.status,
+      createdAt: event.createdAt,
+    },
+    tasks: { [taskId]: { taskId, status: 'blocked' } },
+    sessions: { [event.sessionId]: { sessionId: event.sessionId } },
+    correctionRequired: true,
+    latestQa: { ok: false, gaps: ['runtime publish queued'] },
+    latestAtlas: { status: 'grounded', target: 'action-ledger' },
+    sentinelFindings: [],
+  }, null, 2));
+  writeFileSync(join(projectRoot, 'publish-outbox.jsonl'), `${JSON.stringify({
+    schema: 'aria.action_event_publish_pending.v1',
+    at: '2026-05-17T12:04:00.000Z',
+    eventId: event.eventId,
+    actionId: event.actionId,
+    projectId,
+    taskId,
+    phaseId: event.phaseId,
+    recovery: 'queued_for_action_event_publish_replay',
+    event,
+  })}\n`);
+
+  const manifest = exportOwnerGoogleSheetsCsv({ taskDir, runtimeStateDir, actionLedgerDir, outDir, taskId });
+  const tableNames = manifest.tables.map((table) => table.name);
+  assert.ok(tableNames.includes('ActionLedger'));
+  assert.ok(tableNames.includes('ActionLedgerPublishQueue'));
+  const ledgerCsv = readFileSync(join(outDir, 'ActionLedger.csv'), 'utf8');
+  const queueCsv = readFileSync(join(outDir, 'ActionLedgerPublishQueue.csv'), 'utf8');
+  assert.match(ledgerCsv, /publish_outbox_count/);
+  assert.match(ledgerCsv, /owner-sheets-action-ledger-smoke/);
+  assert.match(queueCsv, /queued_for_action_event_publish_replay/);
+  assert.equal(existsSync(join(outDir, 'latest.json')), true);
+
+  process.stdout.write(`${JSON.stringify({
+    ok: true,
+    outDir,
+    tables: tableNames,
+  }, null, 2)}\n`);
+} finally {
+  rmSync(home, { recursive: true, force: true });
+}

package/scripts/self-test-production-preflight.mjs

@@ -0,0 +1,78 @@
+import { existsSync } from 'node:fs';
+import { homedir } from 'node:os';
+import path from 'node:path';
+
+import {
+  requireGovernedConnectorMutation,
+} from '../dist/aria-connector/src/connectors/governed-adapter.js';
+
+function row(name, pass, evidence = {}) {
+  return { name, pass: pass === true, evidence };
+}
+
+function envFlag(name) {
+  const value = process.env[name];
+  return value === '1' || value === 'true' || value === 'yes';
+}
+
+async function expectBlocked(surfaceId, targetPath) {
+  try {
+    await requireGovernedConnectorMutation({
+      surfaceId,
+      action: 'install',
+      targetPath,
+      reason: `production preflight for ${surfaceId}`,
+      opts: {
+        sessionId: `production-preflight-${process.pid}`,
+      },
+    });
+    return row(`${surfaceId}_production_target_blocked_without_receipt`, false, {
+      targetPath,
+      exists: existsSync(targetPath),
+      blocked: false,
+    });
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    return row(`${surfaceId}_production_target_blocked_without_receipt`, /blocked/.test(message), {
+      targetPath,
+      exists: existsSync(targetPath),
+      blocked: true,
+      message,
+    });
+  }
+}
+
+async function run() {
+  const home = homedir();
+  const targetRows = [
+    await expectBlocked('codex', path.join(home, '.codex')),
+    await expectBlocked('claude-code', path.join(home, '.claude')),
+    await expectBlocked('opencode', path.join(home, '.opencode')),
+    await expectBlocked('shell', path.join(home, '.aria', 'wrappers')),
+    await expectBlocked('cursor', path.join(process.cwd(), '.cursorrules')),
+  ];
+  const rows = [
+    row('production_approval_env_absent', !envFlag('ARIA_CONNECTOR_PRODUCTION_APPROVED'), {
+      present: Boolean(process.env.ARIA_CONNECTOR_PRODUCTION_APPROVED),
+    }),
+    row('production_receipt_env_absent', !process.env.ARIA_CONNECTOR_GOVERNANCE_RECEIPT, {
+      present: Boolean(process.env.ARIA_CONNECTOR_GOVERNANCE_RECEIPT),
+    }),
+    ...targetRows,
+  ];
+
+  const summary = {
+    ok: rows.every((item) => item.pass),
+    total: rows.length,
+    passed: rows.filter((item) => item.pass).length,
+    failed: rows.filter((item) => !item.pass).length,
+    rows,
+  };
+  console.log(JSON.stringify(summary, null, 2));
+  process.exit(summary.ok ? 0 : 1);
+}
+
+run().catch((error) => {
+  console.error(JSON.stringify({ ok: false, error: error.stack || error.message }, null, 2));
+  process.exit(1);
+});

package/scripts/self-test-project-boundary-cognition.mjs

@@ -0,0 +1,79 @@
+#!/usr/bin/env node
+import assert from 'node:assert/strict';
+import {
+  PROJECT_END_QIYAS_PERSPECTIVES,
+  PROJECT_START_TADABBUR_QUESTIONS,
+  buildProjectStartBoundary,
+  detectProjectBoundaryNeed,
+  evaluateProjectEndBoundary,
+  formatProjectBoundaryPrompt,
+} from '../hooks/lib/project-boundary-cognition.mjs';
+
+function makeEndReceipt({ qiyasCount = 15, tadabburCount = 12, verdict = 'verified' } = {}) {
+  return {
+    cognitive_qiyas_15: { status: qiyasCount === 15 ? 'pass' : 'partial', perspectives: qiyasCount },
+    cognitive_tadabbur_12: { status: tadabburCount === 12 ? 'pass' : 'partial', stages: tadabburCount },
+    qiyas_15_pass: PROJECT_END_QIYAS_PERSPECTIVES.slice(0, qiyasCount).map((perspective) => ({
+      perspective,
+      verdict: 'ok',
+      evidence_anchor: 'ev_test',
+    })),
+    claim_gate: { verdict },
+  };
+}
+
+const trivial = detectProjectBoundaryNeed('thanks', '');
+assert.equal(trivial.required, false, 'trivial turns should not require project boundary cognition');
+
+const projectStartMissing = buildProjectStartBoundary({
+  userText: 'continue the connector project and fix the ledger first class',
+  cognitiveRuntimeReceipts: null,
+});
+assert.equal(projectStartMissing.required, true);
+assert.equal(projectStartMissing.ok, false, 'project work must not pass start boundary without Tadabbur-12');
+assert.equal(projectStartMissing.startTadabbur.questions.length, PROJECT_START_TADABBUR_QUESTIONS.length);
+
+const projectStartPass = buildProjectStartBoundary({
+  userText: 'continue the connector project and fix the ledger first class',
+  cognitiveRuntimeReceipts: {
+    tadabbur: { ok: true, mode: 'full', stageCount: 12 },
+    qiyas: { ok: true, mode: 'full', perspectiveCount: 15 },
+  },
+});
+assert.equal(projectStartPass.ok, true, 'Tadabbur-12 should satisfy the project start boundary');
+assert.match(formatProjectBoundaryPrompt(projectStartPass), /Automatic start questions:/);
+assert.match(formatProjectBoundaryPrompt(projectStartPass), /End Qiyas pending: 15 perspectives/);
+
+const ownerCorrection = detectProjectBoundaryNeed('the missing fix is you shouldnt need an owner correction, I corrected this 100k times', '');
+assert.equal(ownerCorrection.required, true, 'owner correction language must trigger project boundary cognition');
+assert.equal(ownerCorrection.ownerCorrection, true);
+
+const projectEndPass = evaluateProjectEndBoundary({
+  userText: 'finish the hook project end to end',
+  assistantText: 'Implemented and verified from receipt evidence.',
+  endPhaseQaAutofire: { receipt: makeEndReceipt() },
+});
+assert.equal(projectEndPass.ok, true, 'Qiyas-15 + Tadabbur-12 receipt should satisfy project closeout');
+
+const projectEndFail = evaluateProjectEndBoundary({
+  userText: 'finish the hook project end to end',
+  assistantText: 'Implemented and verified from receipt evidence.',
+  endPhaseQaAutofire: { receipt: makeEndReceipt({ qiyasCount: 14 }) },
+});
+assert.equal(projectEndFail.ok, false, 'project closeout must reject incomplete Qiyas');
+assert.deepEqual(projectEndFail.missing, ['qiyas_15_perspective_count', 'qiyas_15_pass_entries']);
+
+const claimGateFail = evaluateProjectEndBoundary({
+  userText: 'finish the hook project end to end',
+  assistantText: 'Implemented and verified from receipt evidence.',
+  endPhaseQaAutofire: { receipt: makeEndReceipt({ verdict: 'partial' }) },
+});
+assert.equal(claimGateFail.ok, false, 'project closeout must reject unbounded claim gate verdicts');
+assert.equal(claimGateFail.missing.includes('claim_gate_verified_or_narrowly_verified'), true);
+
+console.log(JSON.stringify({
+  ok: true,
+  checked: 'project_boundary_cognition',
+  startQuestions: PROJECT_START_TADABBUR_QUESTIONS.length,
+  endPerspectives: PROJECT_END_QIYAS_PERSPECTIVES.length,
+}, null, 2));

package/scripts/self-test-qa-exec-kernel.mjs

@@ -0,0 +1,34 @@
+// QA-exec hard-risk smoke. Self-contained; reads no env.
+import * as m from '/home/hamzaibrahim1/rei-ai-brain/ops/claude-hooks/codex-native/lib/runtime-client.mjs';
+
+const cases = [
+  // [name, text, action, expected_hardBlock]
+  ['A. deploy + self-claim NO evidence',
+   'We deployed the service. The release is complete and production ready. No probe data attached.',
+   'write', true],
+  ['B. deploy + self-claim WITH probe evidence',
+   'We deployed the service. Probe returned exit 0, sha256 byte-identical, 9/9 pass verified empirically.',
+   'write', false],
+  ['C. edit-target with release vocab literal',
+   'Edit runtime-client.mjs to add a regex matching production ready / release ready / completed for the gate.',
+   'write', false],
+  ['D. code fence with release vocab',
+   'Patching: the regex `/production ready|release ready|done/i` matches release vocab in self-claim shape.',
+   'write', false],
+  ['E. benign code change small target',
+   'edit file.js to fix a typo',
+   'write', false],
+  ['F. delete action hard-risk always',
+   'rm -rf /tmp/cache',
+   'delete', true],
+];
+
+let pass = 0, fail = 0;
+for (const [name, text, action, expected] of cases) {
+  const qa = m.evaluateQaExecutionKernel({ action, text, phase: 'pre_tool' });
+  const ok = qa.hardBlock === expected;
+  if (ok) pass++; else fail++;
+  console.log(`  ${ok ? 'PASS' : 'FAIL'}  ${name}` + (ok ? '' : `  (got hardBlock=${qa.hardBlock}, hardFindings=${JSON.stringify(qa.hardFindings).slice(0, 120)})`));
+}
+console.log(`  ${pass} pass / ${fail} fail`);
+process.exit(fail === 0 ? 0 : 1);

package/scripts/self-test-qa-recovery-learning-loop.mjs

@@ -0,0 +1,113 @@
+#!/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 = `qa-recovery-learning-loop-${stamp}`;
+const threadId = `thread-qa-recovery-learning-loop-${stamp}`;
+const activeTaskId = 'task-2026-05-15T03-45-18-791Z-2ee60e24';
+const activePhase = '05-add-qa-recovery-learning-loop';
+
+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;
+}
+
+function runHook(sessionId, text) {
+  const ariaHome = mkdtempSync(path.join(tmpdir(), 'aria-qa-recovery-learning-'));
+  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 };
+}
+
+const firstSessionId = `claude-code:qa-learning:first:${stamp}`;
+const secondSessionId = `claude-code:qa-learning:second:${stamp}`;
+const first = runHook(firstSessionId, 'First QA recovery learning-loop canary turn publishes Dalio/reflexion marker.');
+
+assert.equal(first.receipt.learningLoop.schema, 'aria.dalio_reflexion_learning_loop.v1');
+assert.equal(first.receipt.learningLoop.style, 'dalio_reflexion');
+assert.equal(first.receipt.learningLoop.integratedIntoNextPacket, true);
+assert.equal(first.receipt.learningLoop.boundedRepair.allowedAttempts, 1);
+assert.equal(first.receipt.learningLoop.correctionCycle.status, 'verified');
+assert.equal(first.receipt.hivePublication.summary.learningLoop.schema, 'aria.dalio_reflexion_learning_loop.v1');
+assert.equal(first.receipt.hivePublication.summary.learningLoop.boundedRepair.allowedAttempts, 1);
+
+const second = runHook(secondSessionId, 'Second QA recovery learning-loop canary turn must pull prior Hive learning into the packet.');
+
+assert.equal(second.receipt.priorHiveLearning.ok, true);
+assert.equal(second.receipt.priorHiveLearning.latestLearningLoop.schema, 'aria.dalio_reflexion_learning_loop.v1');
+assert.equal(second.receipt.learningLoop.priorHiveLearningIntegrated, true);
+assert.equal(second.receipt.learningLoop.priorHiveLearningMarker, first.receipt.hivePublication.summary.receiptHash || first.output.receiptPath);
+assert.equal(second.receipt.learningLoop.boundedRepair.remainingAttempts, 0);
+
+const projectContext = await getJson(`/api/hive/project-context?project_id=${encodeURIComponent(projectId)}&include_touches=true&touch_limit=75`);
+const capsule = asRecord(projectContext.context?.capsule);
+const latestLearning = asRecord(capsule.latest_learning_loop);
+assert.equal(latestLearning.schema, 'aria.dalio_reflexion_learning_loop.v1');
+assert.equal(latestLearning.source, 'mechanical-autofire.receipt');
+assert.equal(latestLearning.boundedRepair.allowedAttempts, 1);
+assert.equal(latestLearning.correctionStatus, 'verified');
+assert.equal(asRecord(capsule.latest_qa).source, 'mechanical-autofire.receipt');
+assert.equal(asRecord(capsule.latest_recovery).source, 'mechanical-autofire.receipt');
+
+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.ok(messages.messages.some((message) => message.body?.learning_loop_marker?.schema === 'aria.dalio_reflexion_learning_loop.v1'));
+
+console.log(JSON.stringify({
+  ok: true,
+  runtimeUrl,
+  projectId,
+  threadId,
+  firstSessionId,
+  secondSessionId,
+  priorHiveLearningIntegrated: second.receipt.learningLoop.priorHiveLearningIntegrated,
+  latestLearningLoop: {
+    schema: latestLearning.schema,
+    source: latestLearning.source,
+    correctionStatus: latestLearning.correctionStatus,
+    boundedRepairAllowedAttempts: latestLearning.boundedRepair.allowedAttempts,
+  },
+}, null, 2));