@aria_asi/cli 0.2.40 → 0.2.41

package/scripts/self-test-codex-readable-recovery.mjs

@@ -0,0 +1,94 @@
+#!/usr/bin/env node
+
+import assert from 'node:assert/strict';
+import { readFileSync } from 'node:fs';
+import { join } from 'node:path';
+
+const packageRoot = join(import.meta.dirname, '..');
+const sourcePath = join(packageRoot, 'src', 'connectors', 'codex.ts');
+const source = readFileSync(sourcePath, 'utf8');
+
+const fnStart = source.indexOf('export function fullCognitionMethodGaps');
+const fnEnd = source.indexOf('function normalizeValidationIssue', fnStart);
+
+assert.ok(fnStart > 0 && fnEnd > fnStart, 'Could not locate fullCognitionMethodGaps function bounds');
+
+const slice = source.slice(fnStart, fnEnd);
+
+assert.match(
+  slice,
+  /ownerVisibleText\(text\)/,
+  'fullCognitionMethodGaps must evaluate the owner-visible surface, not raw hidden method payloads',
+);
+
+assert.match(
+  slice,
+  /raw Qiyas method dump is on the owner surface/,
+  'Codex stop recovery must still block raw Qiyas dumps on the owner surface',
+);
+
+assert.match(
+  slice,
+  /raw Tadabbur stage dump is on the owner surface/,
+  'Codex stop recovery must still block raw Tadabbur dumps on the owner surface',
+);
+
+assert.match(
+  slice,
+  /Method coverage is proven by runtime skill-load state/,
+  'Codex stop recovery must bind method coverage to runtime skill-load state',
+);
+
+assert.doesNotMatch(
+  slice,
+  /missing Qiyas-15 perspective:/,
+  'Codex stop recovery must not demand Qiyas-15 labels in owner-facing output',
+);
+
+assert.doesNotMatch(
+  slice,
+  /missing full Tadabbur stage:/,
+  'Codex stop recovery must not demand Tadabbur stage labels in owner-facing output',
+);
+
+const normalizationStart = source.indexOf('function normalizeValidationIssue');
+const normalizationEnd = source.indexOf('function uniqueStrings', normalizationStart);
+assert.ok(normalizationStart > 0 && normalizationEnd > normalizationStart, 'Could not locate normalizeValidationIssue function bounds');
+const normalizationSlice = source.slice(normalizationStart, normalizationEnd);
+
+assert.match(
+  normalizationSlice,
+  /feedback_full_harness_binding_must_be_structural/,
+  'Codex recovery must recognize the structural harness binding doctrine',
+);
+
+assert.match(
+  normalizationSlice,
+  /executed SDK primitive evidence/,
+  'Structural harness binding recovery must demand executed SDK primitive evidence',
+);
+
+const recoveryStart = source.indexOf('export function formatCodexRecoveryBlock');
+const recoveryEnd = source.indexOf('export function emitJson', recoveryStart);
+assert.ok(recoveryStart > 0 && recoveryEnd > recoveryStart, 'Could not locate formatCodexRecoveryBlock function bounds');
+const recoverySlice = source.slice(recoveryStart, recoveryEnd);
+
+assert.match(
+  recoverySlice,
+  /Structural harness binding blocker/,
+  'Codex recovery block must provide a doctrine-specific structural harness rewrite path',
+);
+
+assert.match(
+  recoverySlice,
+  /SDK evidence: <primitive> <receipt\/path\/status>/,
+  'Structural harness recovery must require an owner-visible SDK evidence line',
+);
+
+assert.match(
+  recoverySlice,
+  /no production writes were performed/,
+  'Structural harness recovery must replace ambiguous read-only wording with concrete no-write evidence',
+);
+
+console.log('OK self-test-codex-readable-recovery');

package/scripts/self-test-codex-self-harness.mjs

@@ -0,0 +1,538 @@
+#!/usr/bin/env node
+
+import assert from 'node:assert/strict';
+import { createHash } from 'node:crypto';
+import { spawn } from 'node:child_process';
+import { existsSync, mkdirSync, readFileSync, writeFileSync, appendFileSync } from 'node:fs';
+import { createRequire } from 'node:module';
+import { createServer } from 'node:net';
+import { homedir } from 'node:os';
+import path from 'node:path';
+import { pathToFileURL } from 'node:url';
+
+const require = createRequire(import.meta.url);
+const { WebSocketServer, WebSocket } = require('ws');
+
+const repoRoot = path.resolve(import.meta.dirname, '..', '..', '..');
+const connectorRoot = path.resolve(repoRoot, 'packages', 'aria-connector');
+const bridgeSourcePath = path.join(connectorRoot, 'runtime-src', 'codex-bridge.mjs');
+const bridgeExecutablePath = path.join(connectorRoot, 'dist', 'runtime', 'codex-bridge.mjs');
+const runtimeUrl = (process.env.ARIA_RUNTIME_URL || 'http://127.0.0.1:4319').replace(/\/+$/, '');
+const sessionId = `codex-self-harness-${process.pid}`;
+const sandboxRoot = path.join('/tmp/aria-playground-surfaces', 'codex-self-harness');
+const ledgerPath = path.join(sandboxRoot, 'ledger.jsonl');
+const lastRunPath = path.join(sandboxRoot, 'last-run.json');
+
+const REQUIRED_SKILLS = Object.freeze([
+  'aria-cognition-autofire',
+  'aria-cognition-batch',
+  'aria-quality-audit',
+  'aria-repo-doctrine',
+  'aria-http-harness-client',
+  'aria-harness-substrate-binding',
+  'aria-axioms-first-principles',
+  'never-guess',
+  'tadabbur',
+  'tadabbur-ops',
+  'tafakkur',
+  'qiyas-analogy',
+  'forge-quality-rules',
+  'aria-task-codex-executor',
+  'aria-backend-architect',
+  'aria-harness-no-stripping',
+  'aria-readable-output',
+  'aria-ledger-fleet-execution',
+  'predictor',
+  'aria-aristotle-pre-phase',
+  'aria-aristotle-intra-phase',
+  'aria-aristotle-post-phase',
+  'mizan',
+  'ghazali-8lens',
+  'aria-noor-cognitives',
+]);
+
+const REQUIRED_SKILL_FLOOR = 50;
+
+const TASK_TEXT = [
+  'Codex self-harness test for pre-cognition, pre-tool, intra-tool, intra-cognition, post-tool, post-cognition, QA correction, QA verification, and learning-loop integration.',
+  'The test surface is aria-connector/Codex itself. It must not import, call, or route through the flawed streamConversation chat lifecycle.',
+  'All evidence must be sandboxed under aria-playground paths.',
+].join('\n');
+
+function sha256(value) {
+  return createHash('sha256').update(String(value)).digest('hex');
+}
+
+function extractInputText(input) {
+  if (!Array.isArray(input)) return '';
+  const parts = [];
+  for (const item of input) {
+    if (!item || typeof item !== 'object') continue;
+    if (typeof item.text === 'string' && item.text.trim()) parts.push(item.text.trim());
+    if (Array.isArray(item.content)) {
+      for (const contentItem of item.content) {
+        if (contentItem && typeof contentItem.text === 'string' && contentItem.text.trim()) parts.push(contentItem.text.trim());
+      }
+    }
+  }
+  return parts.join('\n\n').trim();
+}
+
+function readToken() {
+  for (const value of [process.env.ARIA_HARNESS_TOKEN, process.env.ARIA_API_KEY, process.env.ARIA_MASTER_TOKEN]) {
+    if (typeof value === 'string' && value.trim()) return value.trim();
+  }
+  const ownerTokenPath = path.join(homedir(), '.aria', 'owner-token');
+  if (existsSync(ownerTokenPath)) return readFileSync(ownerTokenPath, 'utf8').trim();
+  const licensePath = path.join(homedir(), '.aria', 'license.json');
+  if (existsSync(licensePath)) {
+    const raw = readFileSync(licensePath, 'utf8');
+    const parsed = JSON.parse(raw);
+    return String(parsed.harnessToken || parsed.token || '').trim();
+  }
+  return '';
+}
+
+async function getJson(url) {
+  const response = await fetch(url);
+  const text = await response.text();
+  const data = text ? JSON.parse(text) : null;
+  if (!response.ok) throw new Error(`GET ${url} failed: ${response.status} ${text}`);
+  return data;
+}
+
+async function postJson(pathname, body) {
+  const token = readToken();
+  assert.ok(token, 'Aria owner token or harness token is required for runtime POST self-test');
+  const response = await fetch(`${runtimeUrl}${pathname}`, {
+    method: 'POST',
+    headers: {
+      'content-type': 'application/json',
+      authorization: `Bearer ${token}`,
+    },
+    body: JSON.stringify(body),
+  });
+  const text = await response.text();
+  const data = text ? JSON.parse(text) : null;
+  if (!response.ok) throw new Error(`POST ${pathname} failed: ${response.status} ${text}`);
+  return data;
+}
+
+function resolveSkillPath(skillId) {
+  const roots = [
+    path.join(connectorRoot, 'skills', 'aria-cognition'),
+    path.join(connectorRoot, 'skills'),
+    path.join(homedir(), '.codex', 'skills', 'aria-cognition'),
+    path.join(homedir(), '.codex', 'skills'),
+    path.join(homedir(), '.agents', 'skills'),
+  ];
+  for (const root of roots) {
+    const candidate = path.join(root, skillId, 'SKILL.md');
+    if (existsSync(candidate)) return candidate;
+  }
+  return null;
+}
+
+function loadSkillEvidence() {
+  const rows = REQUIRED_SKILLS.map((skillId) => {
+    const filePath = resolveSkillPath(skillId);
+    assert.ok(filePath, `missing required skill file: ${skillId}`);
+    const body = readFileSync(filePath, 'utf8');
+    assert.ok(body.includes('#') || body.includes('TRIGGER') || body.includes('Use when'), `skill has no readable body marker: ${skillId}`);
+    return {
+      skillId,
+      path: filePath,
+      chars: body.length,
+      hash: sha256(body),
+      cookbookRefs: [...body.matchAll(/references\/([a-zA-Z0-9_.-]+\.md)/g)].map((match) => match[1]),
+    };
+  });
+  assert.ok(rows.length >= REQUIRED_SKILL_FLOOR, `expected at least ${REQUIRED_SKILL_FLOOR} skills, got ${rows.length}`);
+  return rows;
+}
+
+function scanSourceForForbiddenChatPath() {
+  const sources = [
+    { label: 'self-test', text: readFileSync(import.meta.filename, 'utf8') },
+    { label: 'codex-bridge', text: readFileSync(bridgeSourcePath, 'utf8') },
+  ];
+  const patterns = [
+    /from\s+['"][^'"]*streamConversation[^'"]*['"]/i,
+    /import\s*\([^)]*streamConversation[^)]*\)/i,
+    /\bstreamConversation\s*\(/,
+    /fetch\s*\([^)]*\/chat/i,
+    /POST\s+\/chat/i,
+  ];
+  const violations = [];
+  for (const source of sources) {
+    for (const rx of patterns) {
+      if (rx.test(source.text)) violations.push({ source: source.label, pattern: String(rx) });
+    }
+  }
+  return {
+    pass: violations.length === 0,
+    violations,
+  };
+}
+
+function scanBridgeForcedSkillWiring() {
+  const source = readFileSync(bridgeSourcePath, 'utf8');
+  const requiredMarkers = [
+    'CODEX_FORCED_SKILLS',
+    'ARIA_CODEX_BRIDGE_EXTERNAL_DOWNSTREAM',
+    'ARIA_CODEX_BRIDGE_LOG_PATH',
+    '/build-system-prompt',
+    'prependForcedPromptToInput',
+    'forceSkillPromptOnTurnStart',
+    'ariaForcedSkillIds',
+    'ariaForcedSkillPromptHash',
+    'forcedSkillReceipt',
+    'codex_forced_skill_prompt',
+    'missingCookbooks',
+    'recordMizanPreOnce',
+  ];
+  const missingMarkers = requiredMarkers.filter((marker) => !source.includes(marker));
+  const forcedSkillIds = REQUIRED_SKILLS.filter((skillId) => source.includes(`'${skillId}'`) || source.includes(`"${skillId}"`));
+  const orderingPredicate = source.includes('if (pending.forcedSkillReceipt && !state.forcedSkillReceipt) state.forcedSkillReceipt = pending.forcedSkillReceipt;\n      void recordMizanPreOnce(pending.threadId, turnId);');
+  return {
+    pass: missingMarkers.length === 0 && forcedSkillIds.length >= REQUIRED_SKILL_FLOOR && orderingPredicate,
+    path: bridgeSourcePath,
+    missingMarkers,
+    forcedSkillIds,
+    forcedSkillCount: forcedSkillIds.length,
+    orderingPredicate,
+  };
+}
+
+function wait(ms) {
+  return new Promise((resolvePromise) => {
+    setTimeout(resolvePromise, ms);
+  });
+}
+
+async function getFreePort() {
+  return await new Promise((resolvePromise, rejectPromise) => {
+    const server = createServer();
+    server.once('error', rejectPromise);
+    server.listen(0, '127.0.0.1', () => {
+      const address = server.address();
+      const port = typeof address === 'object' && address ? address.port : 0;
+      server.close(() => resolvePromise(port));
+    });
+  });
+}
+
+async function openWebSocket(url) {
+  let lastError = null;
+  for (let attempt = 0; attempt < 50; attempt += 1) {
+    try {
+      return await new Promise((resolvePromise, rejectPromise) => {
+        const socket = new WebSocket(url);
+        socket.once('open', () => resolvePromise(socket));
+        socket.once('error', rejectPromise);
+      });
+    } catch (error) {
+      lastError = error;
+      await wait(100);
+    }
+  }
+  throw lastError || new Error(`websocket not reachable: ${url}`);
+}
+
+async function runBridgeRewriteSmoke() {
+  const bridgePort = await getFreePort();
+  const downstreamPort = await getFreePort();
+  const downstreamUrl = `ws://127.0.0.1:${downstreamPort}`;
+  const bridgeUrl = `ws://127.0.0.1:${bridgePort}`;
+  const bridgeLogPath = path.join(sandboxRoot, 'codex-bridge-e2e.log');
+  let forwardedMessage = null;
+  const upstreamMessages = [];
+  let bridgeExit = null;
+
+  const downstreamServer = new WebSocketServer({
+    host: '127.0.0.1',
+    port: downstreamPort,
+    perMessageDeflate: false,
+  });
+  downstreamServer.on('connection', (socket) => {
+    socket.on('message', (data) => {
+      forwardedMessage = JSON.parse(typeof data === 'string' ? data : data.toString());
+      socket.send(JSON.stringify({
+        id: forwardedMessage.id,
+        result: {
+          turn: { id: 'turn-codex-self-harness-e2e' },
+        },
+      }));
+    });
+  });
+  if (!downstreamServer.address()) {
+    await new Promise((resolvePromise, rejectPromise) => {
+      downstreamServer.once('listening', resolvePromise);
+      downstreamServer.once('error', rejectPromise);
+    });
+  }
+
+  const bridgeProcess = spawn(process.execPath, [bridgeExecutablePath], {
+    cwd: connectorRoot,
+    env: {
+      ...process.env,
+      ARIA_RUNTIME_URL: runtimeUrl,
+      ARIA_CODEX_BRIDGE_PORT: String(bridgePort),
+      ARIA_CODEX_DOWNSTREAM_URL: downstreamUrl,
+      ARIA_CODEX_BRIDGE_EXTERNAL_DOWNSTREAM: '1',
+      ARIA_CODEX_BRIDGE_LOG_PATH: bridgeLogPath,
+      ARIA_REMOTE_COACH_ENABLED: '0',
+      ARIA_RUNTIME_COACH_ENABLED: '0',
+      ARIA_COACH_REMOTE_ENABLED: '0',
+    },
+    stdio: ['ignore', 'ignore', 'pipe'],
+  });
+  bridgeProcess.stderr.on('data', (chunk) => {
+    appendFileSync(bridgeLogPath, `[child stderr] ${String(chunk)}`);
+  });
+  bridgeProcess.once('exit', (code, signal) => {
+    bridgeExit = { code, signal: signal || null };
+  });
+
+  let upstream = null;
+  try {
+    upstream = await openWebSocket(bridgeUrl);
+    upstream.on('message', (data) => {
+      try {
+        upstreamMessages.push(JSON.parse(typeof data === 'string' ? data : data.toString()));
+      } catch {
+        upstreamMessages.push({ raw: typeof data === 'string' ? data : data.toString() });
+      }
+    });
+    upstream.send(JSON.stringify({
+      id: 'codex-self-harness-e2e-turn',
+      method: 'turn/start',
+      params: {
+        threadId: 'thread-codex-self-harness-e2e',
+        cwd: connectorRoot,
+        input: [{ type: 'text', text: TASK_TEXT }],
+      },
+    }));
+
+    for (let attempt = 0; attempt < 600 && !forwardedMessage && !bridgeExit; attempt += 1) {
+      await wait(100);
+    }
+  } finally {
+    try { upstream?.close(); } catch {}
+    try { bridgeProcess.kill('SIGTERM'); } catch {}
+    await new Promise((resolvePromise) => downstreamServer.close(resolvePromise));
+  }
+
+  assert.ok(forwardedMessage, `mock downstream did not receive a bridged turn/start message; bridgeExit=${JSON.stringify(bridgeExit)} upstreamMessages=${JSON.stringify(upstreamMessages).slice(0, 2000)}`);
+  assert.equal(forwardedMessage.method, 'turn/start', 'bridge must forward turn/start after mutation');
+  const forwardedText = extractInputText(forwardedMessage.params?.input || []);
+  const forwardedSkillIds = Array.isArray(forwardedMessage.params?.ariaForcedSkillIds)
+    ? forwardedMessage.params.ariaForcedSkillIds
+    : [];
+  const promptHash = forwardedMessage.params?.ariaForcedSkillPromptHash || null;
+  const pass = (
+    forwardedText.includes('--- ARIA CODEX FORCED COGNITION PACKET ---') &&
+    forwardedText.includes('--- CURRENT USER REQUEST ---') &&
+    REQUIRED_SKILLS.every((skillId) => forwardedText.includes(`<skill_content name="${skillId}"`)) &&
+    forwardedSkillIds.length >= REQUIRED_SKILL_FLOOR &&
+    typeof promptHash === 'string' &&
+    /^[a-f0-9]{64}$/i.test(promptHash)
+  );
+  return {
+    pass,
+    bridgeUrl,
+    downstreamUrl,
+    bridgeLogPath,
+    forwardedSkillCount: forwardedSkillIds.length,
+    promptHash,
+    forwardedTextHash: sha256(forwardedText),
+    forwardedTextChars: forwardedText.length,
+  };
+}
+
+function buildLearningLoop() {
+  return {
+    style: 'dalio_reflexion',
+    observedPain: 'The previous chat lifecycle smoke wrote production-facing state while trying to test sandbox behavior.',
+    rootCause: 'The test target was coupled to a broad conversation path with side-effecting cognition, garden, embedding, and persistence hooks.',
+    principle: 'For harness validation, test the Codex connector and mounted runtime skill-loading mechanism directly before any chat route is allowed into scope.',
+    integratedIntoActions: [
+      'force-load required skills through /build-system-prompt',
+      'record QA correction in an aria-playground ledger',
+      'prove forbidden chat-route imports and calls are absent',
+      'keep the verification surface under packages/aria-connector instead of apps/arias-soul chat lifecycle',
+    ],
+  };
+}
+
+function receipt(phase, ok, evidence = {}) {
+  return {
+    phase,
+    ok: ok === true,
+    evidence,
+    at: new Date().toISOString(),
+  };
+}
+
+async function run() {
+  mkdirSync(sandboxRoot, { recursive: true });
+  const { evaluateSkillGate } = await import(pathToFileURL(path.join(connectorRoot, 'hooks', 'lib', 'skill-autoload-gate-impl.mjs')));
+  const skillEvidence = loadSkillEvidence();
+  const forbiddenChatScan = scanSourceForForbiddenChatPath();
+  const bridgeSourceScan = scanBridgeForcedSkillWiring();
+  assert.equal(bridgeSourceScan.pass, true, JSON.stringify(bridgeSourceScan, null, 2));
+
+  const autoloadGate = evaluateSkillGate({
+    sessionId,
+    surface: 'codex-self-harness',
+    text: TASK_TEXT,
+    toolName: 'apply_patch',
+    isMutation: true,
+    autoLoadAvailable: true,
+    requiredSkillsOverride: REQUIRED_SKILLS,
+    requiredSkillsReason: 'Codex self-harness requires the full minimum skill pack for forced cognition testing',
+    loadedSkills: REQUIRED_SKILLS,
+  });
+  assert.equal(autoloadGate.ok, true, JSON.stringify(autoloadGate, null, 2));
+  assert.deepEqual(autoloadGate.missingSkills, [], 'all required skills must be loaded before runtime prompt build');
+
+  const health = await getJson(`${runtimeUrl}/health`);
+  assert.equal(health.ok, true, 'mounted runtime health must be ok');
+
+  const promptBuild = await postJson('/build-system-prompt', {
+    sessionId,
+    surface: 'codex',
+    message: TASK_TEXT,
+    requiredSkills: REQUIRED_SKILLS,
+    allowOwnerBypass: true,
+    injection: {
+      harness: {
+        packet: {
+          harness: [
+            'surface=codex-self-harness',
+            'namespace=aria-playground',
+            'purpose=force skill firing before cognition, before tool use, during tool use, after tool use, QA correction, and learning integration',
+          ].join('\n'),
+          sessionId,
+          sandboxNamespace: 'aria-playground',
+        },
+      },
+      task: TASK_TEXT,
+      docs: [
+        {
+          title: 'Codex self-harness QA contract',
+          content: 'Use the connector runtime directly. Do not route this smoke through chat lifecycle code.',
+        },
+      ],
+      files: {},
+      loadedAt: new Date().toISOString(),
+    },
+  });
+  assert.equal(promptBuild.ok, true, 'runtime prompt build must return ok');
+  assert.ok(promptBuild.loadedSkillIds.length >= REQUIRED_SKILL_FLOOR, `runtime loaded only ${promptBuild.loadedSkillIds.length} skills`);
+  assert.deepEqual(promptBuild.missingSkillIds, [], `missing runtime skills: ${promptBuild.missingSkillIds.join(', ')}`);
+  assert.deepEqual(promptBuild.missingCookbooks || [], [], `missing runtime cookbooks: ${JSON.stringify(promptBuild.missingCookbooks || [])}`);
+  for (const skillId of REQUIRED_SKILLS) {
+    assert.ok(promptBuild.loadedSkillIds.includes(skillId), `runtime did not load skill: ${skillId}`);
+    assert.ok(promptBuild.prompt.includes(`<skill_content name="${skillId}"`), `prompt missing skill_content for ${skillId}`);
+  }
+  assert.ok(promptBuild.prompt.includes('ARIA RUNTIME FORCED SKILL LOAD'), 'prompt must contain forced skill load block');
+  assert.ok(promptBuild.prompt.includes('8-Lens') || promptBuild.prompt.includes('8-lens'), 'prompt must include 8-lens substrate');
+  assert.ok(!/from\s+['"][^'"]*streamConversation|streamConversation\s*\(|POST\s+\/chat|fetch\s*\([^)]*\/chat/i.test(promptBuild.prompt), 'prompt must not route through streamConversation or /chat');
+
+  const bridgeRewriteSmoke = await runBridgeRewriteSmoke();
+  assert.equal(bridgeRewriteSmoke.pass, true, JSON.stringify(bridgeRewriteSmoke, null, 2));
+
+  const qaFinding = {
+    findingId: 'qa-streamconversation-test-surface',
+    severity: 'block',
+    statement: 'Testing through the chat lifecycle is not an acceptable proof target for connector/Codex skill firing.',
+    detectedOn: 'prior apps/arias-soul chat lifecycle smoke',
+  };
+  const qaCorrection = {
+    findingId: qaFinding.findingId,
+    correction: 'Use packages/aria-connector runtime /build-system-prompt plus local skill-autoload classification as the first self-test surface.',
+    changedSurface: 'codex-self-harness',
+    forbiddenSurface: 'apps/arias-soul streamConversation chat lifecycle',
+  };
+  const learningLoop = buildLearningLoop();
+
+  const receipts = [
+    receipt('pre_cognition', autoloadGate.ok, {
+      requiredSkills: autoloadGate.requiredSkills,
+      loadedSkills: autoloadGate.loadedSkills,
+    }),
+    receipt('pre_tool', health.ok, {
+      runtime: health.runtime,
+      runtimeId: health.runtimeId,
+      endpoint: 'GET /health',
+    }),
+    receipt('intra_tool', promptBuild.ok, {
+      endpoint: 'POST /build-system-prompt',
+      loadedSkillCount: promptBuild.loadedSkillIds.length,
+      loadedSkillHashCount: promptBuild.loadedSkillHashes.length,
+      bridgeSourceScan,
+    }),
+    receipt('bridge_rewrite_e2e', bridgeRewriteSmoke.pass, bridgeRewriteSmoke),
+    receipt('intra_cognition', promptBuild.prompt.includes('ARIA RUNTIME FORCED SKILL LOAD'), {
+      promptHash: sha256(promptBuild.prompt),
+      promptChars: promptBuild.prompt.length,
+    }),
+    receipt('post_tool', promptBuild.missingSkillIds.length === 0 && (promptBuild.missingCookbooks || []).length === 0, {
+      missingSkillIds: promptBuild.missingSkillIds,
+      loadedCookbooks: promptBuild.loadedCookbooks || [],
+      missingCookbooks: promptBuild.missingCookbooks || [],
+    }),
+    receipt('post_cognition', skillEvidence.length >= REQUIRED_SKILL_FLOOR, {
+      skillCount: skillEvidence.length,
+      skillHashes: Object.fromEntries(skillEvidence.map((row) => [row.skillId, row.hash])),
+    }),
+    receipt('qa_finding', true, qaFinding),
+    receipt('qa_correction', true, qaCorrection),
+    receipt('qa_verification', forbiddenChatScan.pass && bridgeRewriteSmoke.pass && promptBuild.loadedSkillIds.length >= REQUIRED_SKILL_FLOOR, {
+      forbiddenChatScan,
+      bridgeSourceScan,
+      bridgeRewriteSmoke,
+      expectedPredicate: `forbiddenChatScan.pass=true and bridgeSourceScan.pass=true and bridgeRewriteSmoke.pass=true and loadedSkillIds>=${REQUIRED_SKILL_FLOOR} and missingSkillIds=0`,
+    }),
+    receipt('learning_loop', learningLoop.integratedIntoActions.length >= 4, learningLoop),
+  ];
+  assert.ok(receipts.every((entry) => entry.ok), JSON.stringify(receipts.filter((entry) => !entry.ok), null, 2));
+
+  const summary = {
+    ok: true,
+    sessionId,
+    runtimeUrl,
+    surface: 'codex-self-harness',
+    sandboxRoot,
+    skillsActive: REQUIRED_SKILLS.length,
+    runtimeLoadedSkills: promptBuild.loadedSkillIds.length,
+    missingSkillIds: promptBuild.missingSkillIds,
+    missingCookbooks: promptBuild.missingCookbooks || [],
+    forbiddenChatScan,
+    bridgeSourceScan,
+    bridgeRewriteSmoke,
+    receipts,
+    learningLoop,
+    verificationPredicate: `exit=0, skillsActive>=${REQUIRED_SKILL_FLOOR}, runtimeLoadedSkills>=${REQUIRED_SKILL_FLOOR}, missingSkillIds=0, missingCookbooks=0, forbiddenChatScan.pass=true, bridgeSourceScan.pass=true, bridgeRewriteSmoke.pass=true, all receipts ok`,
+  };
+
+  appendFileSync(ledgerPath, `${JSON.stringify(summary)}\n`);
+  writeFileSync(lastRunPath, `${JSON.stringify(summary, null, 2)}\n`);
+  console.log(JSON.stringify(summary, null, 2));
+}
+
+run().catch((error) => {
+  const failure = {
+    ok: false,
+    sessionId,
+    error: error instanceof Error ? error.stack || error.message : String(error),
+  };
+  try {
+    mkdirSync(sandboxRoot, { recursive: true });
+    appendFileSync(ledgerPath, `${JSON.stringify(failure)}\n`);
+    writeFileSync(lastRunPath, `${JSON.stringify(failure, null, 2)}\n`);
+  } catch {}
+  console.error(JSON.stringify(failure, null, 2));
+  process.exit(1);
+});