@aria_asi/cli 0.2.39 → 0.2.41

package/scripts/self-test-mechanical-autofire-resolver.mjs

@@ -0,0 +1,296 @@
+import assert from 'node:assert/strict';
+import { readFileSync } from 'node:fs';
+import path from 'node:path';
+
+import {
+  GovernedSurfaceRunner,
+  UNIVERSAL_TURN_PACKET_CORRECTION_SKILL_FLOOR,
+  UNIVERSAL_TURN_PACKET_HIVE_OBSERVER_FLOOR,
+  UNIVERSAL_TURN_PACKET_HIVE_SOURCE_FLOOR,
+  UNIVERSAL_TURN_PACKET_MAPPING_FLOOR,
+  UNIVERSAL_TURN_PACKET_PRIMITIVE_FLOOR,
+  UNIVERSAL_TURN_PACKET_QA_SKILL_FLOOR,
+  UNIVERSAL_TURN_PACKET_RUNTIME_FLOOR,
+  UNIVERSAL_TURN_PACKET_SKILL_FLOOR,
+  UNIVERSAL_TURN_PACKET_SKILLS,
+} from '../dist/aria-connector/src/index.js';
+
+const RUNTIME_URL = (process.env.ARIA_RUNTIME_URL || 'http://127.0.0.1:4319').replace(/\/+$/, '');
+const repoRoot = path.resolve(import.meta.dirname, '..', '..', '..');
+const sessionId = `mechanical-autofire-resolver-${process.pid}`;
+const surfaceId = 'claude-code';
+const userText = [
+  'Claude Code mechanical autofire resolver test.',
+  'Promote runtime and SDK receipts for Claude Code with full Tadabbur, full Qiyas, Mizan, Noor, Hive observer/source topology, QA correction, and owner approval packet safety.',
+  'Do not route Claude provider auth through Aria runtime.',
+].join(' ');
+const correctionFindings = [
+  'Autofire must not mean prompt-loaded skills.',
+  'Runtime route and SDK runner must agree on selected operators.',
+  'Provider prompt must stay compact mechanical-receipt mode.',
+];
+const requiredSkills = [
+  ...UNIVERSAL_TURN_PACKET_SKILLS,
+  'aria-quality-audit',
+  'tadabbur',
+  'qiyas-analogy',
+];
+
+function readJson(relativePath) {
+  return JSON.parse(readFileSync(path.join(repoRoot, relativePath), 'utf8'));
+}
+
+const expectedRuntimes = readJson('codex/plans/aria-civilizational-corpus-skills/proposed-runtimes-index.json')
+  .runtimes.map((runtime) => runtime.name).sort();
+const expectedPrimitives = readJson('codex/plans/aria-civilizational-corpus-skills/proposed-primitives-index.json')
+  .primitives.map((primitive) => primitive.name).sort();
+const expectedMappings = readJson('codex/plans/aria-civilizational-corpus-skills/proposed-cross-domain-mappings.json')
+  .mappings.map((mapping) => mapping.primitive).sort();
+
+function uniqueSorted(values) {
+  return [...new Set(values.filter((item) => typeof item === 'string' && item.trim()).map((item) => item.trim()))].sort();
+}
+
+async function postJson(pathname, body) {
+  const response = await fetch(`${RUNTIME_URL}${pathname}`, {
+    method: 'POST',
+    headers: { 'content-type': 'application/json' },
+    body: JSON.stringify(body),
+  });
+  const text = await response.text();
+  let data;
+  try {
+    data = text ? JSON.parse(text) : null;
+  } catch {
+    data = { raw: text };
+  }
+  assert.equal(response.ok, true, `${pathname} failed (${response.status}): ${text.slice(0, 500)}`);
+  return data;
+}
+
+function summarizeRuntime(data) {
+  return {
+    ok: data.ok,
+    mode: data.skillExecutionMode,
+    loadedSkillCount: Array.isArray(data.loadedSkillIds) ? data.loadedSkillIds.length : 0,
+    firedSkillCount: Array.isArray(data.skillExecutionReceipt?.firedSkillIds) ? data.skillExecutionReceipt.firedSkillIds.length : 0,
+    activeRuntimeCount: Array.isArray(data.activeRuntimes) ? data.activeRuntimes.length : 0,
+    activePrimitiveCount: Array.isArray(data.activePrimitives) ? data.activePrimitives.length : 0,
+    activeMappingCount: Array.isArray(data.activeMappings) ? data.activeMappings.length : 0,
+    qaSkillCount: Array.isArray(data.qaSkills) ? data.qaSkills.length : 0,
+    correctionSkillCount: Array.isArray(data.correctionSkills) ? data.correctionSkills.length : 0,
+    taskClass: data.taskClass,
+    ownerApprovalRequired: data.ownerApprovalPacket?.required === true,
+    ownerApprovalBlocksProduction: data.ownerApprovalPacket?.blocksProductionPromotion === true,
+    hiveObserverCount: Array.isArray(data.hiveObserverSourceTopology?.observerSurfaces) ? data.hiveObserverSourceTopology.observerSurfaces.length : 0,
+    hiveSourceCount: Array.isArray(data.hiveObserverSourceTopology?.sourceSurfaces) ? data.hiveObserverSourceTopology.sourceSurfaces.length : 0,
+  };
+}
+
+function assertRuntimeContract(data, options = {}) {
+  const expectOwnerApprovalRequired = options.expectOwnerApprovalRequired !== false;
+  assert.equal(data.ok, true, JSON.stringify(summarizeRuntime(data), null, 2));
+  assert.equal(data.skillExecutionMode, 'mechanical-receipt', 'runtime must build compact mechanical receipts');
+  assert.equal(data.skillExecutionReceipt?.schema, 'aria.skill_execution_receipt.v1', 'runtime must emit skill execution receipt schema');
+  assert.equal(data.skillExecutionReceipt?.ok, true, JSON.stringify(summarizeRuntime(data), null, 2));
+  assert.ok(Array.isArray(data.loadedSkillIds) && data.loadedSkillIds.length >= UNIVERSAL_TURN_PACKET_SKILL_FLOOR, 'loaded skills must meet floor');
+  assert.ok(Array.isArray(data.skillExecutionReceipt.firedSkillIds) && data.skillExecutionReceipt.firedSkillIds.length >= UNIVERSAL_TURN_PACKET_SKILL_FLOOR, 'fired skills must meet floor');
+  assert.deepEqual(uniqueSorted(data.activeRuntimes), expectedRuntimes, 'runtime route must select every registry runtime');
+  assert.deepEqual(uniqueSorted(data.activePrimitives), expectedPrimitives, 'runtime route must select every registry primitive');
+  assert.deepEqual(uniqueSorted(data.activeMappings), expectedMappings, 'runtime route must select every registry mapping');
+  assert.ok(Array.isArray(data.qaSkills) && data.qaSkills.length >= UNIVERSAL_TURN_PACKET_QA_SKILL_FLOOR, 'QA skills must meet floor');
+  assert.ok(Array.isArray(data.correctionSkills) && data.correctionSkills.length >= UNIVERSAL_TURN_PACKET_CORRECTION_SKILL_FLOOR, 'correction skills must meet floor');
+  assert.equal(data.cognitiveRuntimeReceipts?.ok, true, 'cognitive runtime bundle must pass');
+  assert.equal(data.cognitiveRuntimeReceipts?.tadabbur?.stageCount, 12, 'Tadabbur full depth must run 12 stages');
+  assert.equal(data.cognitiveRuntimeReceipts?.qiyas?.perspectiveCount, 15, 'Qiyas full depth must run 15 perspectives');
+  assert.equal(data.cognitiveRuntimeReceipts?.mizan?.ok, true, 'Mizan receipt must pass');
+  assert.equal(data.cognitiveRuntimeReceipts?.noor?.noorSuiteCount, 14, 'Noor suite count must be 14');
+  assert.equal(data.hiveObserverSourceTopology?.ok, true, 'Hive observer/source topology must pass');
+  assert.ok(data.hiveObserverSourceTopology.observerSurfaces.length >= UNIVERSAL_TURN_PACKET_HIVE_OBSERVER_FLOOR, 'Hive observer floor must pass');
+  assert.ok(data.hiveObserverSourceTopology.sourceSurfaces.length >= UNIVERSAL_TURN_PACKET_HIVE_SOURCE_FLOOR, 'Hive source floor must pass');
+  assert.equal(data.ownerApprovalPacket?.schema, 'aria.owner_final_approval_packet.v1', 'owner approval packet must be present');
+  assert.equal(data.ownerApprovalPacket?.required, expectOwnerApprovalRequired, 'owner approval requirement must match task sensitivity');
+  assert.equal(data.ownerApprovalPacket?.blocksProductionPromotion, expectOwnerApprovalRequired, 'owner approval packet must only block production promotion when approval is required');
+  assert.equal(String(data.prompt || '').includes('<skill_content '), false, 'mechanical mode must not inject full skill bodies');
+  assert.equal(String(data.prompt || '').includes('ARIA RUNTIME FORCED SKILL LOAD'), false, 'mechanical mode must not use forced full prompt block');
+  assert.ok(String(data.prompt || '').length < 75000, `mechanical prompt must stay compact; observed=${String(data.prompt || '').length}`);
+}
+
+function assertSdkContract(receipt) {
+  assert.equal(receipt.ok, true, JSON.stringify({
+    surfaceId: receipt.surfaceId,
+    qaStatus: receipt.qa?.status,
+    findings: receipt.qa?.findings,
+    activeRuntimeCount: receipt.activeRuntimes.length,
+    activePrimitiveCount: receipt.activePrimitives.length,
+    activeMappingCount: receipt.activeMappings.length,
+  }, null, 2));
+  assert.equal(receipt.surfaceId, surfaceId, 'SDK receipt must preserve Claude Code surface');
+  assert.equal(receipt.skillExecutionMode, 'mechanical-receipt', 'SDK must request mechanical receipt mode');
+  assert.equal(receipt.skillExecutionReceipt?.schema, 'aria.skill_execution_receipt.v1', 'SDK must expose runtime skill receipt');
+  assert.deepEqual(uniqueSorted(receipt.activeRuntimes), expectedRuntimes, 'SDK must expose every registry runtime');
+  assert.deepEqual(uniqueSorted(receipt.activePrimitives), expectedPrimitives, 'SDK must expose every registry primitive');
+  assert.deepEqual(uniqueSorted(receipt.activeMappings), expectedMappings, 'SDK must expose every registry mapping');
+  assert.ok(receipt.qaSkills.length >= UNIVERSAL_TURN_PACKET_QA_SKILL_FLOOR, 'SDK QA skill floor must pass');
+  assert.ok(receipt.correctionSkills.length >= UNIVERSAL_TURN_PACKET_CORRECTION_SKILL_FLOOR, 'SDK correction skill floor must pass');
+  assert.equal(receipt.cognitiveRuntimeReceipts?.tadabbur?.stageCount, 12, 'SDK Tadabbur full depth must pass');
+  assert.equal(receipt.cognitiveRuntimeReceipts?.qiyas?.perspectiveCount, 15, 'SDK Qiyas full depth must pass');
+  assert.equal(receipt.ownerApprovalPacket?.blocksProductionPromotion, true, 'SDK default owner approval must block promotion');
+  assert.equal(receipt.promptChars < 75000, true, `SDK mechanical prompt must stay compact; observed=${receipt.promptChars}`);
+}
+
+async function main() {
+  const direct = await postJson('/build-system-prompt', {
+    sessionId: `${sessionId}-direct`,
+    surface: surfaceId,
+    message: userText,
+    requiredSkills,
+    allowOwnerBypass: true,
+    injection: {
+      harness: {
+        packet: {
+          sessionId: `${sessionId}-direct`,
+          surfaceId,
+          universalTurnPacket: true,
+          phaseContract: ['pre_cognition', 'pre_tool', 'intra_tool', 'intra_cognition', 'post_tool', 'post_cognition'],
+          correctionFindings,
+        },
+      },
+      task: userText,
+      docs: [
+        {
+          title: 'Mechanical autofire resolver test',
+          content: 'Runtime route and SDK runner must select the same mechanical operator floors.',
+        },
+      ],
+      files: {},
+      loadedAt: new Date().toISOString(),
+    },
+    metadata: {
+      source: 'self-test-mechanical-autofire-resolver',
+      universalTurnPacket: true,
+      skillExecutionMode: 'mechanical-receipt',
+      requiredSkills,
+      correctionFindings,
+    },
+    skillExecutionMode: 'mechanical-receipt',
+  });
+  assertRuntimeContract(direct);
+
+  const weakTextDirect = await postJson('/build-system-prompt', {
+    sessionId: `${sessionId}-weak-text-direct`,
+    surface: surfaceId,
+    message: 'so why did u leave ryntime down if its down? thats a failure',
+    requiredSkills,
+    allowOwnerBypass: true,
+    injection: {
+      harness: {
+        packet: {
+          sessionId: `${sessionId}-weak-text-direct`,
+          surfaceId,
+          universalTurnPacket: true,
+          phaseContract: ['pre_cognition', 'pre_tool', 'intra_tool', 'intra_cognition', 'post_tool', 'post_cognition'],
+          correctionFindings: [],
+        },
+      },
+      task: 'weak text universal packet regression',
+      docs: [
+        {
+          title: 'Weak text universal packet regression',
+          content: 'Universal packet mode must force full cognitive receipts even when owner text has typos or weak classifier keywords.',
+        },
+      ],
+      files: {},
+      loadedAt: new Date().toISOString(),
+    },
+    metadata: {
+      source: 'self-test-mechanical-autofire-resolver-weak-text',
+      universalTurnPacket: true,
+      skillExecutionMode: 'mechanical-receipt',
+      requiredSkills,
+      correctionFindings: [],
+    },
+    skillExecutionMode: 'mechanical-receipt',
+  });
+  assertRuntimeContract(weakTextDirect, { expectOwnerApprovalRequired: false });
+  assert.equal(weakTextDirect.taskClassReceipt?.requiresFullDepth, true, 'universal packet must force full depth for weak text');
+  assert.ok(
+    Array.isArray(weakTextDirect.taskClassReceipt?.tags) && weakTextDirect.taskClassReceipt.tags.includes('universal_turn_packet'),
+    'universal packet tag must drive full depth independent of lexical classifier matches',
+  );
+  assert.equal(
+    weakTextDirect.weakQaEnhancementLoopReceipt?.schema,
+    'aria.weak_qa_enhancement_loop_receipt.v1',
+    'weak QA path must emit a first-class enhancement loop receipt',
+  );
+  assert.equal(weakTextDirect.weakQaEnhancementLoopReceipt?.nextRoundRequired, true, 'weak QA must force another enhancement round');
+  assert.equal(weakTextDirect.weakQaEnhancementLoopReceipt?.ownerApprovalRequired, false, 'weak QA enhancement round must not become owner approval');
+  assert.equal(weakTextDirect.weakQaEnhancementLoopReceipt?.tadabburQuestionCount, 12, 'weak QA enhancement round must question through Tadabbur-12');
+  assert.equal(weakTextDirect.weakQaEnhancementLoopReceipt?.qiyasQuestionCount, 15, 'weak QA enhancement round must question through Qiyas-15');
+  assert.ok(
+    Array.isArray(weakTextDirect.selectedExtraOperators) && weakTextDirect.selectedExtraOperators.includes('qa-first-class-enhancement-loop-runtime'),
+    'weak QA must select the first-class enhancement loop runtime',
+  );
+
+  const correctiveDoctrineText = [
+    'Finding: deterministic-one-attempt-then-skip is the broken pattern.',
+    'Evidence boundary: observed in the recovery route.',
+    'Verification predicate: pass when the runtime retries or heals instead of adopting the pattern.',
+    'Next action: repair the matcher.',
+    'Learning/reflexion loop: store the lesson and use it in future QA.',
+  ].join(' ');
+  const correctiveDoctrine = await postJson('/full-chain', {
+    text: correctiveDoctrineText,
+    fetchPacket: true,
+    packetRequest: {
+      platform: surfaceId,
+      message: correctiveDoctrineText,
+    },
+    metadata: {
+      surface: surfaceId,
+      source: 'self-test-mechanical-autofire-corrective-doctrine-use',
+    },
+  });
+  assert.equal(correctiveDoctrine.pass, true, 'corrective doctrine mentions must not hard-block QA output');
+  assert.equal(correctiveDoctrine.failures?.[0]?.severity, 'warn', 'corrective doctrine mention must remain observable as a warning');
+  assert.equal(correctiveDoctrine.doctrine?.hits?.[0]?.correctiveUse, true, 'corrective doctrine mention must be classified as use/mention, not adoption');
+
+  const runner = new GovernedSurfaceRunner({ sessionId: `${sessionId}-sdk` });
+  const sdk = await runner.buildUniversalTurnPacket({
+    surfaceId,
+    sessionId: `${sessionId}-sdk`,
+    userText,
+    correctionFindings,
+    requiredSkills,
+  });
+  assertSdkContract(sdk);
+
+  assert.deepEqual(uniqueSorted(direct.skillExecutionReceipt.firedSkillIds), uniqueSorted(sdk.skillExecutionReceipt.firedSkillIds), 'runtime route and SDK must fire the same skill ids');
+  assert.deepEqual(uniqueSorted(direct.selectedExtraOperators), uniqueSorted(sdk.selectedExtraOperators), 'runtime route and SDK must select the same task-class extra operators');
+  assert.equal(direct.taskClass, sdk.taskClass, 'runtime route and SDK must agree on task class');
+  assert.equal(direct.hiveObserverSourceTopology?.coherenceHash, sdk.hiveObserverSourceTopology?.coherenceHash, 'runtime route and SDK must agree on Hive topology coherence hash');
+
+  process.stdout.write(`${JSON.stringify({
+    ok: true,
+    surfaceId,
+    runtime: summarizeRuntime(direct),
+    sdk: {
+      ok: sdk.ok,
+      skillExecutionMode: sdk.skillExecutionMode,
+      loadedSkillCount: sdk.loadedSkillIds.length,
+      firedSkillCount: sdk.skillExecutionReceipt.firedSkillIds.length,
+      activeRuntimeCount: sdk.activeRuntimes.length,
+      activePrimitiveCount: sdk.activePrimitives.length,
+      activeMappingCount: sdk.activeMappings.length,
+      qaSkillCount: sdk.qaSkills.length,
+      correctionSkillCount: sdk.correctionSkills.length,
+      taskClass: sdk.taskClass,
+      ownerApprovalBlocksProduction: sdk.ownerApprovalPacket?.blocksProductionPromotion === true,
+    },
+  }, null, 2)}\n`);
+}
+
+main().catch((error) => {
+  process.stderr.write(`[self-test-mechanical-autofire-resolver] ${error instanceof Error ? error.stack || error.message : String(error)}\n`);
+  process.exitCode = 1;
+});

package/scripts/self-test-no-consult-cognitive-skills-output.mjs

@@ -0,0 +1,135 @@
+#!/usr/bin/env node
+
+import assert from 'node:assert/strict';
+import { mkdirSync, readFileSync, writeFileSync } from 'node:fs';
+import path from 'node:path';
+
+import { analyzeDomainOutputQuality } from '../hooks/lib/domain-output-quality.mjs';
+
+const connectorRoot = path.resolve(import.meta.dirname, '..');
+const phase43Prompt =
+  'Continue Phase 43. Wire no-consult cognitive-skills QA through the Aria runtime sidecar/control plane without making /consult the quality engine.';
+
+const requiredSkills = [
+  'aria-cognition-autofire',
+  'aria-cognition-batch',
+  'aria-quality-audit',
+  'aria-ledger-fleet-execution',
+  'aria-axioms-first-principles',
+  'ghazali-8lens',
+  'tadabbur',
+  'tadabbur-ops',
+  'tafakkur',
+  'qiyas-analogy',
+  'mizan',
+  'never-guess',
+  'aria-noor-cognitives',
+  'aria-readable-output',
+  'aria-harness-output-discipline',
+  'aria-harness-substrate-binding',
+  'aria-harness-no-stripping',
+  'aria-task-codex-executor',
+  'aria-repo-doctrine',
+  'aria-senior-code-audit',
+  'testing-strategy',
+  'code-review',
+  'observability',
+  'security-review',
+  'forge-quality-rules',
+];
+
+function evaluate(text, userText = phase43Prompt) {
+  return analyzeDomainOutputQuality(text, { userText });
+}
+
+function assertBlock(label, text, expectedBlocker, expectedRepair) {
+  const result = evaluate(text);
+  assert.ok(
+    result.blockers.some((blocker) => blocker.includes(expectedBlocker)),
+    `${label} missing blocker ${expectedBlocker}; result=${JSON.stringify(result, null, 2)}`,
+  );
+  assert.ok(
+    result.repairs.some((repair) => repair.includes(expectedRepair)),
+    `${label} missing repair ${expectedRepair}; result=${JSON.stringify(result, null, 2)}`,
+  );
+  return result;
+}
+
+const consultDependency = assertBlock(
+  'consult API dependency',
+  [
+    'Status: pending because I need to call the consult API.',
+    'Evidence: I will consult the API to find the answer.',
+    'QA-as-gate: use the consult response as the quality source.',
+    'Next highest-impact step: ask the owner to allow the consult route.',
+  ].join('\n'),
+  'consult API dependency detected',
+  'local cognitive skills plus deterministic QA',
+);
+
+const unsupportedInventory = assertBlock(
+  'unsupported numeric inventory continuation claim',
+  [
+    'Status: All six component bundles mapped; wiring started.',
+    'Evidence: 14/22 target surfaces have live extraction feeds; 8 pending connector alignment.',
+    'QA-as-gate: Must verify each surface reacts correctly to extracted input before releasing to production.',
+    'Next highest-impact step: Prioritize the two CLI surfaces with highest daily invocation volume.',
+  ].join('\n'),
+  'unsupported numeric or inventory claim detected',
+  'concrete artifact',
+);
+
+const anchoredInventory = evaluate(
+  [
+    'Status: Phase 43 report is verified.',
+    'Evidence: 14/22 target surfaces claim comes from `phase43-report.json` stdout_sha256=abc123 and ledger row Gate 13.',
+    'QA-as-gate: expected artifact-bound numeric evidence; observed hash and ledger row are present; correction is not needed.',
+    'Next highest-impact step: wire the same deterministic QA into the stop-gate path.',
+  ].join('\n'),
+);
+assert.deepEqual(anchoredInventory.blockers, [], JSON.stringify(anchoredInventory, null, 2));
+
+const acceptedSkillDriven = evaluate(
+  [
+    'Actual goal: wire extracted books, doctrines, skills, runtimes, CLIs, connectors, and agent surfaces into operating behavior so outputs improve automatically.',
+    `Skills fired: ${requiredSkills.join(', ')}.`,
+    'Architecture boundary: Codex and Claude are first-class execution surfaces; Aria runtime is the localhost sidecar/control plane.',
+    'Status: Phase 43 wires no-consult cognitive-skills QA into the shared output path.',
+    'Evidence: the shared domain-output QA rejects external-advisory dependence, unsupported inventory claims, receipt-heavy output, micro-step deferral, and gate-chasing.',
+    'QA-as-gate: expected local skills plus deterministic QA; observed accepted output has actual goal, skill bundle, correction, verification, learning, and next step.',
+    'Correction: local cognitive skills and runtime sidecar/control-plane checks are the structural path.',
+    'Verification: run `npm --prefix packages/aria-connector run check:no-consult-cognitive-skills-output` and require all negative controls rejected.',
+    'Learning: optional Codex/Claude execution can supply evidence later, but the quality decision stays local and deterministic.',
+    'Next highest-impact step: update readiness and ledger with Phase 43 runtime-path evidence.',
+  ].join('\n'),
+);
+assert.deepEqual(acceptedSkillDriven.blockers, [], JSON.stringify(acceptedSkillDriven, null, 2));
+
+const stopGateSource = readFileSync(path.join(connectorRoot, 'hooks', 'aria-stop-gate.mjs'), 'utf8');
+const domainQaSource = readFileSync(path.join(connectorRoot, 'hooks', 'lib', 'domain-output-quality.mjs'), 'utf8');
+
+assert.ok(stopGateSource.includes('analyzeDomainOutputQuality'), 'Stop gate must call shared domain output QA');
+assert.ok(domainQaSource.includes('consult API dependency detected'), 'Domain QA must reject consult API dependency');
+assert.ok(domainQaSource.includes('unsupported numeric or inventory claim detected'), 'Domain QA must reject unsupported continuation inventory claims');
+
+const report = {
+  ok: true,
+  schema: 'aria.connector.phase43_no_consult_cognitive_skills_output.v1',
+  consult_api_dependency_blocked: consultDependency.blockers.length > 0,
+  consult_api_dependency_repair_present: consultDependency.repairs.length > 0,
+  unsupported_inventory_blocked: unsupportedInventory.blockers.length > 0,
+  unsupported_inventory_repair_present: unsupportedInventory.repairs.length > 0,
+  anchored_inventory_allowed: anchoredInventory.blockers.length === 0,
+  skill_driven_owner_readable_output_allowed: acceptedSkillDriven.blockers.length === 0,
+  stop_gate_uses_shared_domain_output_qa: true,
+  runtime_sidecar_boundary: 'codex_claude_execution_surfaces__aria_runtime_sidecar_control_plane',
+  required_skill_count: requiredSkills.length,
+};
+
+const outPath = process.env.ARIA_PHASE43_NO_CONSULT_RUNTIME_REPORT_OUT;
+if (outPath) {
+  mkdirSync(path.dirname(outPath), { recursive: true });
+  writeFileSync(outPath, `${JSON.stringify(report, null, 2)}\n`);
+}
+
+console.log(JSON.stringify(report, null, 2));

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

@@ -0,0 +1,196 @@
+#!/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 {
+  ownerAirtableSyncQueuePath,
+  recordActionEventLocal,
+} from '../dist/aria-connector/src/action-ledger-core.js';
+import { drainOwnerAirtableSyncQueue } from './drain-owner-airtable-sync-queue.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-queue-'));
+const taskDir = join(home, 'tasks');
+const runtimeStateDir = join(home, 'runtime-state');
+const outDir = join(home, 'owner-export');
+const statePath = join(home, 'owner-airtable-state.json');
+const drainStatePath = join(home, 'owner-airtable-drain-state.json');
+const drainHistoryPath = join(home, 'owner-airtable-drain-history.jsonl');
+const projectId = 'owner-airtable-queue-smoke';
+const taskId = 'task-owner-airtable-queue-smoke';
+
+try {
+  mkdirSync(taskDir, { recursive: true });
+  mkdirSync(runtimeStateDir, { recursive: true });
+  writeFileSync(join(taskDir, `${taskId}.json`), JSON.stringify({
+    taskId,
+    status: 'active',
+    goal: 'owner Airtable queue smoke',
+    updatedAt: '2026-05-17T22:10:00.000Z',
+    createdAt: '2026-05-17T22:10:00.000Z',
+    phases: [{ phaseId: '01-queue', title: 'Queue', status: 'active', consumerReceipts: [] }],
+    checkpoints: [],
+  }, null, 2));
+  writeFileSync(join(runtimeStateDir, 'end-of-phase-qa-court-latest.json'), JSON.stringify({
+    generated_at: '2026-05-17T22:10:00.000Z',
+    claim_gate: { verdict: 'pass' },
+  }, null, 2));
+
+  const local = recordActionEventLocal({
+    surface: 'codex',
+    sessionId: 'codex:owner-airtable-queue-smoke',
+    threadId: 'codex:owner-airtable-queue-smoke',
+    projectId,
+    taskId,
+    phaseId: '01-queue',
+    lifecyclePhase: 'post_tool',
+    status: 'verified',
+    intent: 'queue owner Airtable sync after action-ledger event',
+    atlas: { status: 'grounded', target: 'packages/aria-connector/src/action-ledger-core.ts' },
+  }, { home, projectId });
+
+  const queuePath = ownerAirtableSyncQueuePath({ home });
+  assert.equal(existsSync(queuePath), true, 'owner Airtable queue missing');
+  const queuedLines = readFileSync(queuePath, 'utf8').trim().split('\n');
+  assert.equal(queuedLines.length, 1);
+  const queued = JSON.parse(queuedLines[0]);
+  assert.equal(queued.eventId, local.event.eventId);
+  assert.equal(local.projection.ownerAirtableSyncQueuePath, queuePath);
+
+  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_owner_airtable_queue_smoke/tables') && (!options.method || options.method === 'GET')) {
+      return makeResponse(200, { tables: createdTables });
+    }
+    if (parsed.pathname.endsWith('/meta/bases/app_owner_airtable_queue_smoke/tables') && options.method === 'POST') {
+      const body = JSON.parse(options.body);
+      createdTables.push({ id: `tbl${createdTables.length + 1}`, name: body.name, fields: body.fields });
+      return makeResponse(200, createdTables[createdTables.length - 1]);
+    }
+    if (options.method === 'PATCH' && parsed.pathname.startsWith('/v0/app_owner_airtable_queue_smoke/')) {
+      const body = JSON.parse(options.body);
+      if (parsed.pathname.endsWith('/Dashboard')) {
+        for (const record of body.records) {
+          assert.equal(typeof record.fields.metric, 'string', 'Dashboard metric must be sent as Airtable text');
+        }
+      }
+      return makeResponse(200, { records: body.records.map((record, index) => ({ id: `rec${index}`, fields: record.fields })) });
+    }
+    return makeResponse(404, { error: parsed.pathname });
+  };
+
+  const drained = await drainOwnerAirtableSyncQueue({
+    queuePath,
+    statePath: drainStatePath,
+    historyPath: drainHistoryPath,
+    lockDir: join(home, 'sync-drain.lock'),
+    syncOptions: {
+      token: 'unit_test_token_no_network',
+      baseId: 'app_owner_airtable_queue_smoke',
+      taskDir,
+      runtimeStateDir,
+      actionLedgerDir: join(home, '.aria', 'action-ledger'),
+      outDir,
+      statePath,
+      atlasSocket: join(home, 'missing-atlas.sock'),
+      apiFetch,
+    },
+  });
+
+  assert.equal(drained.ok, true);
+  assert.equal(drained.drained, 1);
+  assert.equal(drained.syncOk, true);
+  assert.equal(readFileSync(queuePath, 'utf8'), '');
+  assert.equal(drained.sync.dashboardRows, 9);
+  assert.ok(drained.sync.ownerBoardRows >= 8);
+  assert.equal(drained.sync.ownerSyncRows, 3);
+  assert.equal(drained.sync.deferredRows, 2);
+  assert.equal(drained.sync.atlasRows >= 2, true);
+  assert.equal(createdTables.length, 12);
+  assert.equal(calls.some((call) => call.method === 'PATCH'), true);
+  assert.equal(JSON.parse(readFileSync(drainStatePath, 'utf8')).drained, 1);
+  assert.equal(existsSync(drainHistoryPath), true);
+  assert.equal(readFileSync(drainHistoryPath, 'utf8').trim().split('\n').length, 1);
+
+  const failureQueuePath = join(home, 'failure-sync-queue.jsonl');
+  const failureStatePath = join(home, 'failure-drain-state.json');
+  const failureHistoryPath = join(home, 'failure-drain-history.jsonl');
+  writeFileSync(failureQueuePath, `${JSON.stringify({
+    schema: 'aria.owner_airtable_sync_needed.v1',
+    at: '2026-05-17T22:12:00.000Z',
+    projectId,
+    taskId,
+    eventId: 'ev_owner_airtable_failure',
+    status: 'blocked',
+  })}\n`);
+  const failureTables = [];
+  const failureFetch = async (url, options = {}) => {
+    const parsed = new URL(url);
+    if (parsed.pathname.endsWith('/meta/bases/app_owner_airtable_queue_failure/tables') && (!options.method || options.method === 'GET')) {
+      return makeResponse(200, { tables: failureTables });
+    }
+    if (parsed.pathname.endsWith('/meta/bases/app_owner_airtable_queue_failure/tables') && options.method === 'POST') {
+      const body = JSON.parse(options.body);
+      failureTables.push({ id: `tblFailure${failureTables.length + 1}`, name: body.name, fields: body.fields });
+      return makeResponse(200, failureTables[failureTables.length - 1]);
+    }
+    if (options.method === 'PATCH' && parsed.pathname.startsWith('/v0/app_owner_airtable_queue_failure/')) {
+      return makeResponse(422, { error: 'forced sync failure' });
+    }
+    return makeResponse(404, { error: parsed.pathname });
+  };
+  const failed = await drainOwnerAirtableSyncQueue({
+    queuePath: failureQueuePath,
+    statePath: failureStatePath,
+    historyPath: failureHistoryPath,
+    lockDir: join(home, 'failure-sync-drain.lock'),
+    syncOptions: {
+      token: 'unit_test_token_no_network',
+      baseId: 'app_owner_airtable_queue_failure',
+      taskDir,
+      runtimeStateDir,
+      actionLedgerDir: join(home, '.aria', 'action-ledger'),
+      outDir,
+      statePath: join(home, 'failure-owner-state.json'),
+      ownerAirtableDir: home,
+      atlasSocket: join(home, 'missing-atlas.sock'),
+      apiFetch: failureFetch,
+    },
+  });
+
+  assert.equal(failed.ok, false);
+  assert.equal(failed.syncOk, false);
+  assert.match(failed.syncError, /Airtable PATCH/);
+  assert.equal(readFileSync(failureQueuePath, 'utf8').trim().length > 0, true);
+  assert.equal(JSON.parse(readFileSync(failureStatePath, 'utf8')).ok, false);
+  assert.equal(readFileSync(failureHistoryPath, 'utf8').trim().split('\n').length, 1);
+
+  console.log(JSON.stringify({
+    ok: true,
+    queuePath,
+    drained: drained.drained,
+    failurePersisted: failed.ok === false && existsSync(failureStatePath),
+    createdTableCount: createdTables.length,
+    dashboardRows: drained.sync.dashboardRows,
+    ownerBoardRows: drained.sync.ownerBoardRows,
+    ownerSyncRows: drained.sync.ownerSyncRows,
+    atlasRows: drained.sync.atlasRows,
+  }, null, 2));
+} finally {
+  rmSync(home, { recursive: true, force: true });
+}