@aria_asi/cli 0.2.40 → 0.2.41

package/scripts/self-test-hive-session-coordination.mjs

@@ -0,0 +1,156 @@
+#!/usr/bin/env node
+
+import assert from 'node:assert/strict';
+import { randomUUID } from 'node:crypto';
+
+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 ownerSession = `codex-hive-coordination-owner-${stamp}`;
+const peerSession = `codex-hive-coordination-peer-${stamp}`;
+const outsiderSession = `codex-hive-coordination-outsider-${stamp}`;
+const threadId = `thread-hive-coordination-${stamp}`;
+const lifecycleMessageId = `hive-coordination-life-${stamp}`;
+const directMessageId = `hive-coordination-direct-${stamp}`;
+const completedMessageId = `hive-coordination-complete-${stamp}`;
+
+async function request(method, route, body = null) {
+  const response = await fetch(`${runtimeUrl}${route}`, {
+    method,
+    headers: body ? { 'Content-Type': 'application/json' } : {},
+    body: body ? JSON.stringify(body) : undefined,
+  });
+  const text = await response.text();
+  let json = null;
+  try { json = text ? JSON.parse(text) : null; } catch {}
+  return { response, json, text };
+}
+
+async function post(route, body) {
+  const result = await request('POST', route, body);
+  assert.equal(result.response.ok, true, `${route} failed: ${result.response.status} ${result.text}`);
+  return result.json;
+}
+
+async function get(route) {
+  const result = await request('GET', route);
+  assert.equal(result.response.ok, true, `${route} failed: ${result.response.status} ${result.text}`);
+  return result.json;
+}
+
+async function patch(route, body) {
+  return await request('PATCH', route, body);
+}
+
+const storage = await get('/api/hive/storage');
+assert.equal(storage.ok, true);
+assert.ok(['file', 'postgres'].includes(storage.storage.mode), 'Hive storage mode must be explicit');
+assert.ok([null, 'postgres_must_be_localhost'].includes(storage.storage.postgres_forbidden_reason), 'Hive storage must be local Postgres or file-backed');
+assert.equal(storage.storage.state_paths.file_touches.endsWith('hive-file-touches.jsonl'), true);
+
+const lifecycle = await post('/api/hive/session-lifecycle', {
+  message_id: lifecycleMessageId,
+  session_id: ownerSession,
+  thread_id: threadId,
+  event: 'heartbeat',
+  status: 'active',
+  intent_summary: 'hive coordination regression lifecycle',
+  file_claims: [{ path: 'packages/aria-connector/runtime-src/service.mjs', intent: 'coordination-test' }],
+  client_identity: {
+    client_install_id: 'hive-coordination-self-test',
+    workspace_id: 'rei-ai-brain',
+  },
+});
+assert.equal(lifecycle.ok, true);
+assert.equal(lifecycle.file_touch.files.length, 1);
+
+const direct = await post('/api/hive/session-message', {
+  message_id: directMessageId,
+  from_session_id: ownerSession,
+  to_session_id: peerSession,
+  thread_id: threadId,
+  topic: 'coordination.self-test',
+  body: {
+    message: 'direct coordination self-test',
+    file_claims: [{ path: 'packages/aria-connector/hooks/aria-pre-tool-gate.mjs', intent: 'coordination-test' }],
+  },
+  client_identity: {
+    client_install_id: 'hive-coordination-self-test',
+    workspace_id: 'rei-ai-brain',
+  },
+});
+assert.equal(direct.ok, true);
+assert.equal(direct.file_touch.files.length, 1);
+
+const completedLifecycle = await post('/api/hive/session-lifecycle', {
+  message_id: completedMessageId,
+  session_id: ownerSession,
+  thread_id: threadId,
+  event: 'turn_complete',
+  status: 'completed',
+  intent_summary: 'hive coordination regression lifecycle complete',
+  file_claims: [{ path: 'packages/aria-connector/runtime-src/service.mjs', intent: 'coordination-test-complete' }],
+  client_identity: {
+    client_install_id: 'hive-coordination-self-test',
+    workspace_id: 'rei-ai-brain',
+  },
+});
+assert.equal(completedLifecycle.ok, true);
+assert.equal(completedLifecycle.thread.status, 'completed');
+
+const peerDefaultInbox = await get(`/api/hive/session-message?session_id=${encodeURIComponent(peerSession)}&limit=20`);
+assert.equal(peerDefaultInbox.ok, true);
+assert.ok(peerDefaultInbox.messages.some((message) => message.message_id === directMessageId), 'peer inbox must include direct message');
+assert.ok(!peerDefaultInbox.messages.some((message) => message.message_id === lifecycleMessageId), 'default inbox must not include broadcasts');
+assert.equal(peerDefaultInbox.include_broadcasts, false);
+
+const peerBroadcastInbox = await get(`/api/hive/session-message?session_id=${encodeURIComponent(peerSession)}&include_broadcasts=true&thread_id=${encodeURIComponent(threadId)}&limit=20`);
+assert.ok(peerBroadcastInbox.messages.some((message) => message.message_id === lifecycleMessageId), 'include_broadcasts=true must include thread broadcast');
+
+const filteredInbox = await get(`/api/hive/session-message?session_id=${encodeURIComponent(peerSession)}&thread_id=${encodeURIComponent(threadId)}&topic=coordination.self-test&limit=20`);
+assert.deepEqual(filteredInbox.messages.map((message) => message.message_id), [directMessageId]);
+
+const unsafePatch = await patch('/api/hive/session-message', { message_id: directMessageId });
+assert.equal(unsafePatch.response.status, 400, 'mark-read must require session_id');
+
+const outsiderPatch = await patch('/api/hive/session-message', { message_id: directMessageId, session_id: outsiderSession });
+assert.equal(outsiderPatch.response.ok, true);
+assert.equal(outsiderPatch.json.rows_updated, 0, 'non-recipient must not mark another session message read');
+
+const peerPatch = await patch('/api/hive/session-message', { message_id: directMessageId, session_id: peerSession });
+assert.equal(peerPatch.response.ok, true);
+assert.equal(peerPatch.json.rows_updated, 1, 'recipient must mark direct message read');
+
+const peerUnreadAfterRead = await get(`/api/hive/session-message?session_id=${encodeURIComponent(peerSession)}&thread_id=${encodeURIComponent(threadId)}&topic=coordination.self-test&limit=20`);
+assert.ok(!peerUnreadAfterRead.messages.some((message) => message.message_id === directMessageId), 'read direct message must not appear in unread inbox');
+
+const thread = await get(`/api/hive/session-thread?session_id=${encodeURIComponent(ownerSession)}&thread_id=${encodeURIComponent(threadId)}&limit=5`);
+assert.equal(thread.threads.length, 1);
+assert.ok(thread.threads[0].participants.includes(ownerSession));
+assert.ok(thread.threads[0].participants.includes(peerSession));
+assert.equal(thread.threads[0].status, 'completed');
+
+const completedThread = await get(`/api/hive/session-thread?session_id=${encodeURIComponent(ownerSession)}&thread_id=${encodeURIComponent(threadId)}&status=completed&limit=5`);
+assert.equal(completedThread.threads.length, 1);
+
+const touches = await get(`/api/hive/file-touch?thread_id=${encodeURIComponent(threadId)}&limit=20`);
+assert.ok(touches.touches.some((touch) => touch.message_id === lifecycleMessageId), 'lifecycle touch row missing');
+assert.ok(touches.touches.some((touch) => touch.message_id === directMessageId), 'message touch row missing');
+assert.ok(touches.touches.some((touch) => touch.message_id === completedMessageId), 'completed lifecycle touch row missing');
+
+console.log(JSON.stringify({
+  ok: true,
+  runtimeUrl,
+  ownerSession,
+  peerSession,
+  threadId,
+  assertions: {
+    defaultInboxExcludesBroadcasts: true,
+    scopedFilters: true,
+    markReadRequiresSession: true,
+    markReadOwnership: true,
+    lifecycleThreadCompletion: true,
+    storageStatus: true,
+    threadReadback: true,
+    fileTouchReadback: true,
+  },
+}, null, 2));

package/scripts/self-test-hive-wal-consumer.mjs

@@ -0,0 +1,111 @@
+#!/usr/bin/env node
+// Smoke for the hive WAL consumer helper + hook. Producer-side has been
+// wired since plan §6; this verifies the consumer side closes the loop.
+
+import { spawnSync } from 'node:child_process';
+import { resolve, dirname } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { writeFileSync, mkdtempSync, rmSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import {
+  readRecentHiveActivity,
+  summarizeOtherSessionsForContext,
+  findFileConflicts,
+  summarizeForStatusline,
+  normalizeSessionId,
+} from '../../../ops/claude-hooks/codex-native/lib/hive-wal-consumer.mjs';
+
+const HERE = dirname(fileURLToPath(import.meta.url));
+const HOOK_PATH = resolve(HERE, '..', '..', '..', 'ops', 'claude-hooks', 'codex-native', 'aria-hive-wal-consumer.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++; }
+
+// 1: normalizeSessionId strips surface prefix to raw UUID
+{
+  const a = normalizeSessionId('claude:claude:aba649c5-feaf-422f-9951-8af122190308');
+  const b = normalizeSessionId('aba649c5-feaf-422f-9951-8af122190308');
+  if (a === b && a === 'aba649c5-feaf-422f-9951-8af122190308') ok('normalizeSessionId strips surface prefix');
+  else bad('normalizeSessionId', `a=${a} b=${b}`);
+}
+
+// 2: readRecentHiveActivity returns shape {ok, entries, sessionsSeen}
+{
+  const r = readRecentHiveActivity({ maxAgeMs: 24 * 60 * 60 * 1000 });
+  if (r && typeof r.ok === 'boolean' && Array.isArray(r.entries) && typeof r.sessionsSeen === 'number') ok('readRecentHiveActivity returns expected shape');
+  else bad('readRecentHiveActivity shape', JSON.stringify(r).slice(0, 200));
+}
+
+// 3: time budget honored
+{
+  const start = Date.now();
+  readRecentHiveActivity({ maxAgeMs: 60 * 60 * 1000, timeBudgetMs: 50 });
+  const dur = Date.now() - start;
+  if (dur < 200) ok(`time-budget honored (dur=${dur}ms < 200ms)`);
+  else bad('time-budget', `dur=${dur}ms`);
+}
+
+// 4: summarizeOtherSessionsForContext returns prose with header
+{
+  const activity = readRecentHiveActivity({ maxAgeMs: 24 * 60 * 60 * 1000 });
+  const prose = summarizeOtherSessionsForContext(activity);
+  if (typeof prose === 'string' && (prose.includes('OTHER ACTIVE SESSIONS') || prose.includes('none observed'))) ok('summarizeOtherSessionsForContext emits expected prose');
+  else bad('summarizeOtherSessionsForContext', prose.slice(0, 200));
+}
+
+// 5: findFileConflicts handles empty path list cleanly
+{
+  const r = findFileConflicts({ targetPaths: [], maxAgeMs: 60 * 1000 });
+  if (r.ok === true && Array.isArray(r.conflicts) && r.conflicts.length === 0) ok('findFileConflicts: empty path list returns empty conflicts');
+  else bad('findFileConflicts empty', JSON.stringify(r));
+}
+
+// 6: summarizeForStatusline returns numeric counters
+{
+  const s = summarizeForStatusline({ maxAgeMs: 5 * 60 * 1000 });
+  if (typeof s.sessions === 'number' && typeof s.touches === 'number') ok(`summarizeForStatusline: sessions=${s.sessions} touches=${s.touches}`);
+  else bad('summarizeForStatusline', JSON.stringify(s));
+}
+
+// 7: self-exclusion works — exclude a known UUID and prove no entries for it
+{
+  const activity = readRecentHiveActivity({ maxAgeMs: 24 * 60 * 60 * 1000 });
+  if (!activity.ok || activity.entries.length === 0) {
+    ok('self-exclusion: skipped (no WAL entries to test against)');
+  } else {
+    const someSession = activity.entries[0].fromSession;
+    const filtered = readRecentHiveActivity({ maxAgeMs: 24 * 60 * 60 * 1000, excludeSessionIds: [someSession] });
+    const stillPresent = filtered.entries.some((e) => e.fromSession === someSession);
+    if (!stillPresent) ok(`self-exclusion: ${someSession.slice(0, 8)}.. excluded correctly`);
+    else bad('self-exclusion', 'excluded session still appears');
+  }
+}
+
+// 8: hook runs end-to-end and emits valid JSON with hookSpecificOutput
+{
+  const child = spawnSync('node', [HOOK_PATH], {
+    input: JSON.stringify({ session_id: 'smoke-test', thread_id: 'smoke', hook_event_name: 'UserPromptSubmit', user_prompt: 'test' }),
+    encoding: 'utf8',
+    timeout: 5000,
+  });
+  if (child.status === 0) {
+    try {
+      const parsed = JSON.parse(child.stdout);
+      if (parsed?.hookSpecificOutput?.hookEventName === 'UserPromptSubmit'
+        && typeof parsed.hookSpecificOutput.additionalContext === 'string') {
+        ok('hook end-to-end: emits valid hookSpecificOutput JSON');
+      } else {
+        bad('hook output shape', JSON.stringify(parsed).slice(0, 200));
+      }
+    } catch (err) {
+      bad('hook output parse', `${err?.message} stdout=${child.stdout.slice(0, 200)}`);
+    }
+  } else {
+    bad('hook exit code', `status=${child.status} stderr=${child.stderr.slice(0, 200)}`);
+  }
+}
+
+console.log();
+console.log(`hive-wal-consumer smoke: ${pass} pass, ${fail} fail`);
+process.exit(fail === 0 ? 0 : 1);

package/scripts/self-test-kernel-a3-a4-selection.mjs

@@ -0,0 +1,179 @@
+#!/usr/bin/env node
+// Smoke for A3 + A4 (2026-05-17):
+//   A3 — kernel returns selectedSkillIds + selectedRuntimeIds inside
+//        compilationCore (participate in deterministic compilation_hash).
+//   A4 — prior end-phase court verdicts feed into selection so the
+//        upgrade loop closes: failure verdicts in the last turn → quality
+//        skills reinforced in the next turn.
+//
+// Both invariants are verified against the vendored kernel at
+// packages/aria-connector/runtime-src/lib/kernel/. The kernel-sync gate
+// (scripts/check-kernel-sync.mjs) is the body-sha invariant; this script
+// is the BEHAVIORAL invariant on top of it.
+
+import {
+  compileCognitiveOptions,
+  selectSkillsAndRuntimes,
+  SKILL_SELECTION_MAP,
+  RUNTIME_SELECTION_MAP,
+  ACTION_CLASS_REINFORCE_MAP,
+  COURT_FAILURE_VERDICTS,
+  COURT_FAILURE_REINFORCE_SKILLS,
+} from '../runtime-src/lib/kernel/deterministic-cognitive-kernel.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++; }
+
+// 1: kernel return shape carries selectedSkillIds + selectedRuntimeIds in core
+{
+  const c = compileCognitiveOptions({
+    kind: 'default',
+    source: 'smoke',
+    summary: 'A3 core-shape probe',
+  });
+  if (Array.isArray(c.selectedSkillIds) && Array.isArray(c.selectedRuntimeIds)
+      && c.selectedSkillIds.length > 0 && c.selectedRuntimeIds.length > 0
+      && c.selectionMeta && typeof c.selectionMeta.keyUsed === 'string') {
+    ok(`A3: compilationCore carries selectedSkillIds=${c.selectedSkillIds.length} selectedRuntimeIds=${c.selectedRuntimeIds.length} keyUsed=${c.selectionMeta.keyUsed}`);
+  } else {
+    bad('A3 core shape', `selectedSkillIds=${JSON.stringify(c.selectedSkillIds)} selectedRuntimeIds=${JSON.stringify(c.selectedRuntimeIds)}`);
+  }
+}
+
+// 2: kind-keyed selection — 'edit' returns the edit-shape skill set
+{
+  const c = compileCognitiveOptions({ kind: 'edit', source: 'smoke', summary: 'A3 edit probe' });
+  const editFloor = SKILL_SELECTION_MAP.edit;
+  const missing = editFloor.filter((s) => !c.selectedSkillIds.includes(s));
+  if (missing.length === 0) ok(`A3: edit-kind selection carries the full edit-floor set (${editFloor.length} skills)`);
+  else bad('A3 edit floor coverage', `missing=${missing.join(',')}`);
+}
+
+// 3: deploy-kind selection — deploy floor present
+{
+  const c = compileCognitiveOptions({ kind: 'deploy', source: 'smoke', summary: 'A3 deploy probe' });
+  if (c.selectedSkillIds.includes('aria-harness-no-stripping') && c.selectedSkillIds.includes('predictor')) {
+    ok(`A3: deploy-kind selection carries no-stripping + predictor (${c.selectedSkillIds.length} total)`);
+  } else {
+    bad('A3 deploy selection', `selectedSkillIds=${c.selectedSkillIds.join(',')}`);
+  }
+}
+
+// 4: unknown kind falls back to default
+{
+  const c = compileCognitiveOptions({ kind: 'totally_made_up_kind', source: 'smoke', summary: 'A3 default fallback' });
+  if (c.selectionMeta.keyUsed === 'default' && c.selectedSkillIds.includes('mizan')) {
+    ok(`A3: unknown kind falls back to default key (mizan in selection)`);
+  } else {
+    bad('A3 default fallback', `keyUsed=${c.selectionMeta.keyUsed} selectedSkillIds=${c.selectedSkillIds.join(',')}`);
+  }
+}
+
+// 5: A4 — failure verdict triggers court reinforcement
+{
+  const c = compileCognitiveOptions({
+    kind: 'default',
+    source: 'smoke',
+    summary: 'A4 failure-verdict probe',
+    priorCourtVerdicts: [{ verdict: 'blocked', at: '2026-05-17T00:00:00Z' }],
+  });
+  const hasReinforce = COURT_FAILURE_REINFORCE_SKILLS.every((s) => c.selectedSkillIds.includes(s));
+  if (c.selectionMeta.courtFeedbackApplied && hasReinforce && c.selectionMeta.failureVerdictsObserved.includes('blocked')) {
+    ok(`A4: blocked-verdict triggers full court reinforcement (${COURT_FAILURE_REINFORCE_SKILLS.length} skills added)`);
+  } else {
+    bad('A4 court reinforcement', `courtFeedbackApplied=${c.selectionMeta.courtFeedbackApplied} failureVerdictsObserved=${JSON.stringify(c.selectionMeta.failureVerdictsObserved)} hasReinforce=${hasReinforce}`);
+  }
+}
+
+// 6: A4 — success verdict does NOT trigger reinforcement
+{
+  const c = compileCognitiveOptions({
+    kind: 'default',
+    source: 'smoke',
+    summary: 'A4 success-verdict probe',
+    priorCourtVerdicts: [{ verdict: 'verified', at: '2026-05-17T00:00:00Z' }],
+  });
+  if (!c.selectionMeta.courtFeedbackApplied && c.selectionMeta.failureVerdictsObserved.length === 0) {
+    ok(`A4: verified-verdict does NOT trigger reinforcement (no false-positive)`);
+  } else {
+    bad('A4 false-positive', `courtFeedbackApplied=${c.selectionMeta.courtFeedbackApplied} failureVerdictsObserved=${JSON.stringify(c.selectionMeta.failureVerdictsObserved)}`);
+  }
+}
+
+// 7: A4 — all FAILURE_VERDICTS trigger reinforcement, none of the others
+{
+  let allFailureTriggered = true;
+  for (const v of COURT_FAILURE_VERDICTS) {
+    const c = compileCognitiveOptions({ kind: 'default', priorCourtVerdicts: [{ verdict: v }] });
+    if (!c.selectionMeta.courtFeedbackApplied) { allFailureTriggered = false; break; }
+  }
+  const c2 = compileCognitiveOptions({ kind: 'default', priorCourtVerdicts: [{ verdict: 'verified_narrowly' }] });
+  if (allFailureTriggered && !c2.selectionMeta.courtFeedbackApplied) {
+    ok(`A4: every FAILURE_VERDICTS member triggers reinforcement; verified_narrowly does not`);
+  } else {
+    bad('A4 verdict membership', `allFailureTriggered=${allFailureTriggered} verifiedNarrowlyFeedback=${c2.selectionMeta.courtFeedbackApplied}`);
+  }
+}
+
+// 8: Determinism — identical input produces identical compilation_hash
+{
+  const input = {
+    kind: 'edit',
+    source: 'smoke',
+    summary: 'A3 determinism probe',
+    priorCourtVerdicts: [{ verdict: 'blocked', at: '2026-05-17T00:00:00Z' }],
+  };
+  const c1 = compileCognitiveOptions(input);
+  const c2 = compileCognitiveOptions(input);
+  if (c1.compilation_hash === c2.compilation_hash && c1.compilation_hash.length === 64) {
+    ok(`Determinism: identical input → identical compilation_hash (${c1.compilation_hash.slice(0, 16)}...)`);
+  } else {
+    bad('Determinism', `hash1=${c1.compilation_hash} hash2=${c2.compilation_hash}`);
+  }
+}
+
+// 9: Determinism — different priorCourtVerdicts → different hash
+{
+  const c1 = compileCognitiveOptions({ kind: 'edit', priorCourtVerdicts: [{ verdict: 'verified' }] });
+  const c2 = compileCognitiveOptions({ kind: 'edit', priorCourtVerdicts: [{ verdict: 'blocked' }] });
+  if (c1.compilation_hash !== c2.compilation_hash) {
+    ok(`Determinism: different verdicts → different compilation_hash (selection is part of hash)`);
+  } else {
+    bad('Hash sensitivity', `both produced ${c1.compilation_hash}`);
+  }
+}
+
+// 10: selectSkillsAndRuntimes exported & callable directly
+{
+  const s = selectSkillsAndRuntimes({ kind: 'output_emit' }, { action_class: 'sycophancy_shape' }, []);
+  if (s.selectedSkillIds.includes('aria-harness-substrate-binding')
+      && s.selectionMeta.actionClassReinforced === 'sycophancy_shape') {
+    ok(`Action-class reinforce: sycophancy_shape adds substrate-binding skill`);
+  } else {
+    bad('action_class reinforce', `selectedSkillIds=${s.selectedSkillIds.join(',')} actionClassReinforced=${s.selectionMeta.actionClassReinforced}`);
+  }
+}
+
+// 11: Selection maps are frozen (no accidental mutation)
+{
+  if (Object.isFrozen(SKILL_SELECTION_MAP) && Object.isFrozen(RUNTIME_SELECTION_MAP) && Object.isFrozen(ACTION_CLASS_REINFORCE_MAP)) {
+    ok(`Immutability: all selection maps are frozen`);
+  } else {
+    bad('mutability', `SKILL=${Object.isFrozen(SKILL_SELECTION_MAP)} RUNTIME=${Object.isFrozen(RUNTIME_SELECTION_MAP)} ACTION=${Object.isFrozen(ACTION_CLASS_REINFORCE_MAP)}`);
+  }
+}
+
+// 12: Acceptance still produces the old contract (no regression)
+{
+  const c = compileCognitiveOptions({ kind: 'output_emit', source: 'smoke', summary: 'regression probe' });
+  if (c.acceptance && c.acceptance.tadabbur_12 === true && c.acceptance.qiyas_15 === true && c.acceptance.deterministic_hash === true) {
+    ok(`Regression: acceptance contract preserved (tadabbur_12 + qiyas_15 + deterministic_hash all true)`);
+  } else {
+    bad('regression', `acceptance=${JSON.stringify(c.acceptance)}`);
+  }
+}
+
+console.log();
+console.log(`A3 + A4 kernel selection smoke: ${pass} pass, ${fail} fail`);
+process.exit(fail === 0 ? 0 : 1);

package/scripts/self-test-ledger-append.mjs

@@ -0,0 +1,175 @@
+#!/usr/bin/env node
+
+import assert from 'node:assert/strict';
+import { mkdtempSync, readFileSync, writeFileSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+
+import { applyLedgerEvent } from './aria-ledger-append.mjs';
+
+const root = mkdtempSync(join(tmpdir(), 'aria-ledger-append-'));
+const readinessPath = join(root, 'UNIVERSAL_CONNECTOR_PROMOTION_READINESS.md');
+const ledgerPath = join(root, 'UNIVERSAL_CONNECTOR_WIRING_LEDGER.md');
+const manifestPath = join(root, 'UNIVERSAL_CONNECTOR_PROMOTION_EVIDENCE_MANIFEST.json');
+
+writeFileSync(readinessPath, '# Readiness\n');
+writeFileSync(
+  ledgerPath,
+  [
+    '# Ledger',
+    '',
+    '### Current',
+    '',
+    '---',
+    '',
+    '## Standing Bottom-Of-Ledger Anti-Drift Contract',
+    '',
+    'Status: active.',
+    '',
+  ].join('\n'),
+);
+writeFileSync(
+  manifestPath,
+  JSON.stringify(
+    {
+      schema: 'test.manifest.v1',
+      entries: [
+        {
+          gateName: 'Earlier blocked gate',
+          command: 'old blocked command',
+          cwd: '/test',
+          capturedAt: '2026-05-14T00:00:00.000Z',
+          exitCode: 1,
+          stdoutSummary: 'blocked',
+          stderrSummary: '',
+          stdoutSha256: '0'.repeat(64),
+          stderrSha256: '0'.repeat(64),
+          artifactPaths: [],
+        },
+      ],
+    },
+    null,
+    2,
+  ) + '\n',
+);
+
+const skillsApplied = [
+  'aria-cognition-autofire',
+  'aria-quality-audit',
+  'aria-ledger-fleet-execution',
+  'ghazali-8lens',
+  'tadabbur',
+  'qiyas-analogy',
+  'mizan',
+  'never-guess',
+  'aria-readable-output',
+  'aria-harness-output-discipline',
+  'aria-harness-substrate-binding',
+  'aria-harness-no-stripping',
+  'aria-repo-doctrine',
+  'testing-strategy',
+  'security-review',
+];
+
+const event = {
+  schema: 'aria.ledger.append_event.v1',
+  id: 'phase48-preflight-verification-test',
+  phase: 48,
+  title: 'Phase 48 governed append test',
+  status: 'blocked_partial',
+  productionMutationPerformed: false,
+  skillsApplied,
+  artifact: {
+    relativePath: 'phase48-runtime-sidecar-preflight/TEST_PHASE48_PREFLIGHT_VERIFICATION.json',
+    content: {
+      schema: 'test.phase48.verification.v1',
+      status: 'blocked_partial',
+      productionMutationPerformed: false,
+    },
+  },
+  sections: {
+    readiness: '## Phase 48 Governed Append Test\n\n- Status: blocked partial.\n',
+    ledger: '## Phase 48 Governed Append Test\n\nStatus: blocked partial.\n',
+  },
+  manifestEntry: {
+    gateName: 'Phase 48 governed append test',
+    command: 'node scripts/aria-ledger-append.mjs --event test-event.json',
+    cwd: '/test',
+    exitCode: 0,
+    stdoutSummary: '{ ok: true }',
+    stderrSummary: '',
+    artifactPaths: ['/test/phase48-runtime-sidecar-preflight/TEST_PHASE48_PREFLIGHT_VERIFICATION.json'],
+    closesGateNames: ['Earlier blocked gate'],
+  },
+};
+
+const first = applyLedgerEvent(event, { corpusRoot: root });
+assert.equal(first.ok, true, JSON.stringify(first, null, 2));
+assert.equal(first.pending, false);
+assert.ok(first.changed.length >= 4, JSON.stringify(first, null, 2));
+
+const second = applyLedgerEvent(event, { corpusRoot: root });
+assert.equal(second.ok, true, JSON.stringify(second, null, 2));
+assert.equal(second.changed.length, 0, JSON.stringify(second, null, 2));
+assert.ok(second.skipped.length >= 4, JSON.stringify(second, null, 2));
+
+const readiness = readFileSync(readinessPath, 'utf8');
+const ledger = readFileSync(ledgerPath, 'utf8');
+const manifest = JSON.parse(readFileSync(manifestPath, 'utf8'));
+
+assert.equal(readiness.match(/Phase 48 Governed Append Test/g)?.length, 1);
+assert.equal(ledger.match(/Phase 48 Governed Append Test/g)?.length, 1);
+assert.ok(
+  ledger.indexOf('## Phase 48 Governed Append Test') <
+    ledger.indexOf('## Standing Bottom-Of-Ledger Anti-Drift Contract'),
+);
+assert.equal(manifest.entries.length, 2);
+assert.equal(manifest.entries[0].closedByGateName, 'Phase 48 governed append test');
+assert.equal(manifest.entries[0].closureStatus, 'closed_by_later_passing_evidence');
+assert.equal(typeof manifest.entries[1].capturedAt, 'string');
+assert.equal(typeof manifest.entries[1].exitCode, 'number');
+assert.equal(manifest.entries[1].stdoutSha256.length, 64);
+assert.equal(manifest.entries[1].stderrSha256.length, 64);
+assert.equal(manifest.entries[1].stdoutSha256Source, 'stdoutSummary');
+assert.equal(manifest.entries[1].stderrSha256Source, 'stderrSummary');
+
+assert.throws(
+  () =>
+    applyLedgerEvent(
+      {
+        ...event,
+        id: 'phase48-secret-rejected-test',
+        sections: { readiness: '## Secret Test\n\n- token: sk-abcdefghijklmnopqrstuvwxyz\n' },
+      },
+      { corpusRoot: root },
+    ),
+  /secret-like material/,
+);
+
+assert.throws(
+  () =>
+    applyLedgerEvent(
+      {
+        ...event,
+        id: 'phase48-path-rejected-test',
+        artifact: { ...event.artifact, relativePath: '../outside.json' },
+      },
+      { corpusRoot: root },
+    ),
+  /path traversal rejected/,
+);
+
+console.log(
+  JSON.stringify(
+    {
+      ok: true,
+      idempotent: true,
+      manifest_entry_once: true,
+      ledger_inserted_before_standing_contract: true,
+      secret_like_material_rejected: true,
+      path_traversal_rejected: true,
+    },
+    null,
+    2,
+  ),
+);