@aria_asi/cli 0.2.39 → 0.2.41

package/scripts/self-test-compiled-workunit.mjs

@@ -0,0 +1,214 @@
+#!/usr/bin/env node
+
+import assert from 'node:assert/strict';
+import { existsSync, mkdirSync, mkdtempSync, readFileSync, writeFileSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import path from 'node:path';
+import { spawnSync } from 'node:child_process';
+
+import {
+  persistCompiledWorkUnit,
+  projectActionLedger,
+  readActionLedgerEvents,
+  recordActionEventLocal,
+  validateCompiledWorkUnitForExecution,
+} from '../dist/aria-connector/src/action-ledger-core.js';
+
+const repoRoot = path.resolve(new URL('../../../..', import.meta.url).pathname);
+const connectorRoot = path.resolve(new URL('..', import.meta.url).pathname);
+const home = mkdtempSync(path.join(tmpdir(), 'aria-compiled-workunit-'));
+const projectId = 'aria-task-compiled-workunit-smoke';
+const taskId = 'compiled-workunit-smoke';
+const workUnitId = 'cwu_compiled_workunit_smoke';
+const now = new Date().toISOString();
+
+function buildUnit(overrides = {}) {
+  return {
+    schema: 'aria.compiled_work_unit.v1',
+    workUnitId,
+    sourceIntent: {
+      schema: 'aria.work_intent.v1',
+      source: 'manual_cli',
+      sourceId: taskId,
+      projectKey: projectId,
+      rawText: 'prove CompiledWorkUnit persistence',
+      normalizedGoal: 'prove CompiledWorkUnit persistence',
+      requestedMode: 'execute',
+      priority: 'P0',
+      acceptanceCriteria: ['kernel hash required', 'kernel mutation required'],
+      externalBinding: { provider: 'cli', objectId: taskId, writableStatus: true, lastSyncAt: now },
+    },
+    createdAt: now,
+    updatedAt: now,
+    atlas: {
+      snapshotId: 370,
+      contextHash: 'atlas-context-smoke',
+      dossierTargets: ['packages/aria-connector/src/action-ledger-core.ts'],
+      riskGraphRefs: [],
+      sentinelFindingRefs: [],
+    },
+    kernel: {
+      compilationHash: 'kernel-smoke-hash',
+      sourceTrust: 'substrate_recorded',
+      classification: { taskClass: 'architecture_runtime' },
+      tadabbur12: {
+        ok: true,
+        stageCount: 12,
+        mutations: [
+          {
+            stage: 'COLLAPSE',
+            mutationType: 'verification_added',
+            after: 'compiled work unit execution requires kernel hash and mutation',
+            reason: 'P0 must reject raw execution without kernel compilation evidence.',
+          },
+        ],
+      },
+      qiyas15: {
+        ok: true,
+        perspectiveCount: 15,
+        rows: Array.from({ length: 15 }, (_, index) => ({
+          perspective: `perspective-${index + 1}`,
+          verdict: 'accept',
+          finding: 'ledger smoke row has explicit evidence and authority cap',
+        })),
+      },
+      rankedOptions: [
+        {
+          optionId: 'parent-task-runner',
+          action: 'execute under parent task runner',
+          rank: 1,
+          constraintsApplied: ['kernel_hash_required', 'kernel_mutation_required'],
+          verificationPredicate: 'projection records compiledWorkUnitId',
+          maxAutonomyLevel: 2,
+        },
+      ],
+      rejectedOptions: [
+        {
+          optionId: 'raw-execute',
+          rejectedBecause: 'raw execution has no kernel receipt',
+          evidence: 'self-test missing hash and missing mutation assertions',
+        },
+      ],
+    },
+    authority: {
+      maxAutonomyLevel: 2,
+      approvalRequired: false,
+      allowedRepos: [repoRoot],
+      allowedPaths: ['packages/aria-connector/src/action-ledger-core.ts'],
+      forbiddenPaths: ['secrets'],
+      forbiddenActions: ['credential_access'],
+    },
+    execution: {
+      taskId,
+      phaseIds: ['01-smoke'],
+      director: {
+        role: 'director',
+        modelOrSurface: 'codex',
+        responsibilities: ['verify compiled work unit persistence'],
+      },
+      workers: [],
+      verificationPredicates: ['validateCompiledWorkUnitForExecution(unit).ok === true'],
+      qaCourtRequired: true,
+    },
+    ledgers: {
+      actionLedgerProjectId: projectId,
+      actionEventIds: [],
+      hiveThreadId: `thread-${taskId}`,
+      runtimeReceiptIds: ['runtime-receipt-smoke'],
+    },
+    externalBindings: [{ provider: 'cli', objectId: taskId, writableStatus: true, lastSyncAt: now }],
+    status: 'compiled',
+    ...overrides,
+  };
+}
+
+const missingHash = buildUnit({ kernel: { ...buildUnit().kernel, compilationHash: '' } });
+assert.equal(validateCompiledWorkUnitForExecution(missingHash).ok, false, 'missing kernel hash must be rejected');
+assert.match(validateCompiledWorkUnitForExecution(missingHash).gaps.join('\n'), /kernel compilation hash missing/);
+
+const missingMutation = buildUnit({
+  kernel: {
+    ...buildUnit().kernel,
+    tadabbur12: { ...buildUnit().kernel.tadabbur12, mutations: [] },
+  },
+});
+assert.equal(validateCompiledWorkUnitForExecution(missingMutation).ok, false, 'missing mutation must be rejected');
+assert.match(validateCompiledWorkUnitForExecution(missingMutation).gaps.join('\n'), /kernel mutation/);
+
+const unit = buildUnit();
+const persisted = persistCompiledWorkUnit(unit, { home, projectId });
+assert.equal(persisted.ok, true);
+assert.equal(validateCompiledWorkUnitForExecution(unit).executable, true);
+assert.equal(existsSync(persisted.path), true, 'compiled work unit file missing');
+assert.equal(JSON.parse(readFileSync(persisted.path, 'utf8')).workUnitId, workUnitId);
+
+recordActionEventLocal({
+  surface: 'aria-task',
+  sessionId: 'aria-cli-task-runner',
+  threadId: `thread-${taskId}`,
+  projectId,
+  taskId,
+  phaseId: '01-smoke',
+  lifecyclePhase: 'task_phase',
+  status: 'active',
+  cwd: repoRoot,
+  intent: 'record compiled work unit in action-ledger projection',
+  compiledWorkUnit: persisted.summary,
+}, { home, projectId });
+
+const events = readActionLedgerEvents({ home, projectId, taskId });
+const projection = projectActionLedger(events);
+assert.equal(projection.tasks[taskId].compiledWorkUnitId, workUnitId);
+assert.equal(projection.tasks[taskId].authorityCap, 2);
+assert.equal(projection.compiledWorkUnits[workUnitId].status, 'compiled');
+assert.equal(projection.compiledWorkUnits[workUnitId].path, persisted.path);
+
+const taskDir = path.join(home, '.aria', 'cli-tasks');
+mkdirSync(taskDir, { recursive: true });
+writeFileSync(path.join(taskDir, `${taskId}.json`), JSON.stringify({
+  schema: 'aria.cli_task.v2',
+  taskId,
+  goal: 'compiled work unit status smoke',
+  cwd: repoRoot,
+  status: 'active',
+  createdAt: now,
+  updatedAt: now,
+  requiredSkills: [],
+  forcedSkillLoad: null,
+  compiledWorkUnit: unit,
+  compiledWorkUnitPath: persisted.path,
+  compiledWorkUnitValidation: validateCompiledWorkUnitForExecution(unit),
+  checkpoints: [],
+  phases: [],
+  activePhaseId: null,
+  recovery: { attempts: 0, lastReason: null, lastAt: null },
+}, null, 2));
+
+const status = spawnSync(process.execPath, [path.join(connectorRoot, 'bin/aria.js'), 'task', 'status', taskId], {
+  cwd: connectorRoot,
+  env: {
+    ...process.env,
+    ARIA_HOME: home,
+    HOME: home,
+    ARIA_RUNTIME_URL: 'http://127.0.0.1:1',
+    ARIA_SELF_UPDATE: 'off',
+    ARIA_NOOR_HOOK: 'off',
+  },
+  encoding: 'utf8',
+  timeout: 15000,
+});
+
+assert.equal(status.status, 0, status.stderr || status.stdout);
+assert.ok(status.stdout.trim(), `status command produced empty stdout; stderr=${status.stderr || ''}; signal=${status.signal || ''}; error=${status.error?.message || ''}`);
+const statusJson = JSON.parse(status.stdout);
+assert.equal(statusJson.compiledWorkUnit.summary.workUnitId, workUnitId);
+assert.equal(statusJson.compiledWorkUnit.validation.ok, true);
+assert.equal(statusJson.actionLedger.task.compiledWorkUnitId, workUnitId);
+
+console.log(JSON.stringify({
+  ok: true,
+  persistedPath: persisted.path,
+  projectionCompiledWorkUnitId: projection.tasks[taskId].compiledWorkUnitId,
+  authorityCap: projection.tasks[taskId].authorityCap,
+  statusExposesCompiledWorkUnitId: statusJson.compiledWorkUnit.summary.workUnitId,
+}, null, 2));

package/scripts/self-test-continuation-output-smoke.mjs

@@ -0,0 +1,101 @@
+#!/usr/bin/env node
+
+import assert from 'node:assert/strict';
+import { readFileSync } 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 continuationPrompt =
+  'Continue Phase 41. Use QA-as-gate and prove continuation output improves without dumping receipts.';
+
+function evaluate(text, userText = continuationPrompt) {
+  return analyzeDomainOutputQuality(text, { userText });
+}
+
+function assertRepair(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 lifecycleDump = `[ARIA PLAYGROUND ACTIVE LIFECYCLE RUN]
+{
+  "namespace": "aria-playground",
+  "surface": "claude",
+  "phaseReceipts": [
+${Array.from({ length: 42 }, (_, index) => `    { "phase": "phase_${index}", "status": "executed", "receiptId": "receipt_${index}" }`).join(',\n')}
+  ]
+}`;
+
+const receiptResult = assertRepair(
+  'receipt-heavy continuation output',
+  lifecycleDump,
+  'owner-visible answer is receipt-heavy',
+  'status line',
+);
+
+const microStepResult = assertRepair(
+  'micro-step continuation output',
+  'I can continue this. What would you like me to do next?',
+  'must name the next highest-impact step',
+  'current next highest-impact step',
+);
+
+const gateChaseResult = assertRepair(
+  'gate-chasing continuation output',
+  'Next step: create more stop gates and stricter gates so every future output blocks first.',
+  'gate-chasing default detected',
+  'expected-vs-observed QA',
+);
+
+const rawReceiptRequested = evaluate(lifecycleDump, 'Please show the full receipt block exactly as raw JSON.');
+assert.deepEqual(rawReceiptRequested.blockers, [], JSON.stringify(rawReceiptRequested, null, 2));
+
+const qaAsGateOutput = evaluate(
+  [
+    'Actual goal: wire extracted books, doctrines, skills, runtimes, CLIs, connectors, and agent surfaces into operating behavior so output improves automatically.',
+    'Status: Phase 41 bounded continuation-output smoke is the next highest-impact step.',
+    'Evidence: Codex and Claude prompt surfaces include the Autofire Quality Continuation Contract; the shared stop gate checks receipt-heavy, micro-step, and gate-chasing drift.',
+    'QA-as-gate: expected owner-readable continuation output; observed likely drift patterns; correction adds structured repair paths; verification is this focused smoke.',
+    'Learning: future continuation answers must name the next highest-impact step and keep raw receipts in artifacts unless explicitly requested.',
+  ].join('\n'),
+);
+assert.deepEqual(qaAsGateOutput.blockers, [], JSON.stringify(qaAsGateOutput, null, 2));
+
+const codexSource = readFileSync(path.join(connectorRoot, 'src', 'connectors', 'codex.ts'), 'utf8');
+const claudeSource = readFileSync(path.join(connectorRoot, 'src', 'connectors', 'claude-code.ts'), 'utf8');
+const stopGateSource = readFileSync(path.join(connectorRoot, 'hooks', 'aria-stop-gate.mjs'), 'utf8');
+
+assert.ok(codexSource.includes('## Autofire Quality Continuation Contract'), 'Codex prompt surface missing continuation contract');
+assert.ok(claudeSource.includes('ARIA_AUTOFIRE_QUALITY_CONTINUATION_CONTRACT'), 'Claude prompt surface missing continuation contract');
+assert.ok(stopGateSource.includes('Repair path:'), 'Stop gate must surface repair paths for output QA blockers');
+
+console.log(
+  JSON.stringify(
+    {
+      ok: true,
+      receipt_heavy_blocked: receiptResult.blockers.length > 0,
+      receipt_heavy_repair_present: receiptResult.repairs.length > 0,
+      micro_step_blocked: microStepResult.blockers.length > 0,
+      micro_step_repair_present: microStepResult.repairs.length > 0,
+      gate_chasing_blocked: gateChaseResult.blockers.length > 0,
+      gate_chasing_repair_present: gateChaseResult.repairs.length > 0,
+      raw_receipt_request_allowed: rawReceiptRequested.blockers.length === 0,
+      qa_as_gate_output_passed: qaAsGateOutput.blockers.length === 0,
+      codex_contract_present: true,
+      claude_contract_present: true,
+      stop_gate_repair_path_present: true,
+    },
+    null,
+    2,
+  ),
+);

package/scripts/self-test-cross-cli-fleet-ticker.mjs

@@ -0,0 +1,85 @@
+#!/usr/bin/env node
+// Smoke for the cross-CLI fleet aggregator + ticker render. Closes #69.
+
+import {
+  aggregateCrossCliFleetState,
+  renderCrossCliStatusline,
+} from '../../../ops/claude-hooks/codex-native/lib/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: aggregator returns expected shape
+{
+  const f = aggregateCrossCliFleetState({ maxAgeMs: 24 * 60 * 60 * 1000, timeBudgetMs: 800 });
+  if (f && typeof f.ok === 'boolean'
+    && Array.isArray(f.surfaces)
+    && typeof f.totalSkills === 'number'
+    && typeof f.totalSkillsUnique === 'number'
+    && typeof f.totalSessions === 'number'
+    && typeof f.totalReceipts === 'number'
+    && typeof f.durationMs === 'number'
+    && f.surfaceTotals && typeof f.surfaceTotals === 'object') {
+    ok('aggregator returns expected shape');
+  } else {
+    bad('aggregator shape', JSON.stringify(f).slice(0, 300));
+  }
+}
+
+// 2: surfaces enumerated cross-CLI (expect at least claude-code + codex)
+{
+  const f = aggregateCrossCliFleetState({ maxAgeMs: 24 * 60 * 60 * 1000, timeBudgetMs: 800 });
+  if (f.surfaces.includes('claude-code') && f.surfaces.includes('codex')) {
+    ok(`surfaces enumerate claude-code + codex (got ${f.surfaces.length}: ${f.surfaces.join(',')})`);
+  } else {
+    bad('surfaces enumeration', `got ${f.surfaces}`);
+  }
+}
+
+// 3: totals across multiple surfaces aggregate (not just one)
+{
+  const f = aggregateCrossCliFleetState({ maxAgeMs: 24 * 60 * 60 * 1000, perSurfaceLimit: 30, timeBudgetMs: 1500 });
+  const nonZeroSurfaces = Object.entries(f.surfaceTotals).filter(([, t]) => t.receipts > 0).map(([s]) => s);
+  if (nonZeroSurfaces.length >= 2) {
+    ok(`fleet aggregates across ${nonZeroSurfaces.length} surfaces: ${nonZeroSurfaces.join(',')}`);
+  } else {
+    bad('multi-surface aggregation', `only ${nonZeroSurfaces.length} surface(s) reported receipts`);
+  }
+}
+
+// 4: skill-fires count > 0 (must read firedSkillIds, not the missing firedSkillCount)
+{
+  const f = aggregateCrossCliFleetState({ maxAgeMs: 24 * 60 * 60 * 1000, perSurfaceLimit: 30, timeBudgetMs: 1500 });
+  if (f.totalSkills > 0 && f.totalSkillsUnique > 0) {
+    ok(`real skill counts (totalSkills=${f.totalSkills}, totalSkillsUnique=${f.totalSkillsUnique})`);
+  } else {
+    bad('skill counts', `totalSkills=${f.totalSkills} totalSkillsUnique=${f.totalSkillsUnique} — firedSkillIds path may be wrong`);
+  }
+}
+
+// 5: time budget honored
+{
+  const start = Date.now();
+  aggregateCrossCliFleetState({ maxAgeMs: 24 * 60 * 60 * 1000, perSurfaceLimit: 30, timeBudgetMs: 250 });
+  const dur = Date.now() - start;
+  if (dur < 800) ok(`time budget honored (dur=${dur}ms)`);
+  else bad('time budget', `dur=${dur}ms`);
+}
+
+// 6: renderer produces 'Aria fleet' prefixed line
+{
+  const out = renderCrossCliStatusline({
+    baseRender: 'Aria ready | skills 0 | saved 0 | lessons 48 | atlas #178 35.6kN | sentinel high 3 | latest evolution_candidate',
+    maxAgeMs: 24 * 60 * 60 * 1000,
+  });
+  if (typeof out === 'string' && out.startsWith('Aria fleet') && out.includes('surfaces:') && out.includes('skills:') && out.includes('atlas')) {
+    ok('renderer produces fleet-shaped statusline with surfaces/skills + atlas tail preserved');
+  } else {
+    bad('renderer output shape', out.slice(0, 200));
+  }
+}
+
+console.log();
+console.log(`cross-CLI fleet ticker smoke: ${pass} pass, ${fail} fail`);
+process.exit(fail === 0 ? 0 : 1);

package/scripts/self-test-cross-cli-hive-adoption.mjs

@@ -0,0 +1,125 @@
+#!/usr/bin/env node
+
+import assert from 'node:assert/strict';
+import { randomUUID } from 'node:crypto';
+
+import { bindCrossCliHiveSession } from '../dist/aria-connector/src/cross-cli-hive-binding.js';
+
+const runtimeUrl = (process.env.ARIA_RUNTIME_URL || 'http://127.0.0.1:4319').replace(/\/+$/, '');
+const projectId = process.env.ARIA_CROSS_CLI_HIVE_PROJECT_ID || 'cross-cli-hive-adoption';
+const threadId = process.env.ARIA_CROSS_CLI_HIVE_THREAD_ID || 'thread-aria-task-task-2026-05-15T03-15-54-050Z-9141a57d';
+const activeTaskId = process.env.ARIA_CROSS_CLI_HIVE_TASK_ID || 'task-2026-05-15T03-15-54-050Z-9141a57d';
+const activePhase = process.env.ARIA_CROSS_CLI_HIVE_PHASE || '04-codex-shell-adoption-canary';
+const cwd = process.env.ARIA_CROSS_CLI_HIVE_CWD || process.cwd();
+const stamp = `${Date.now().toString(36)}-${randomUUID().slice(0, 8)}`;
+
+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;
+}
+
+async function bind(surface, role, fileClaims) {
+  const result = await bindCrossCliHiveSession({
+    surface,
+    cwd,
+    projectId,
+    threadId,
+    activeTaskId,
+    activePhase,
+    role,
+    sessionId: `${surface}:phase62:${stamp}`,
+    source: 'self-test-cross-cli-hive-adoption',
+    sourceArtifact: 'packages/aria-connector/scripts/self-test-cross-cli-hive-adoption.mjs',
+    nativeProviderMode: true,
+    providerAuthOwner: 'native-cli',
+    capabilities: ['hive-session-bind', 'file-touch', 'registry-readback'],
+    fileClaims,
+    extraContext: {
+      canary: 'phase62-cross-cli-hive-adoption',
+      provider_auth_policy: 'native-provider-auth-only',
+    },
+  });
+  assert.equal(result.ok, true, `${surface} binding failed`);
+  assert.deepEqual(result.warnings, [], `${surface} binding warnings`);
+  assert.equal(result.session.native_provider_mode, true);
+  assert.equal(result.session.provider_auth_owner, 'native-cli');
+  assert.equal(Boolean(result.lifecycle?.ok), true, `${surface} lifecycle write failed`);
+  assert.equal(Boolean(result.projectContext), true, `${surface} project-context write missing`);
+  assert.equal(Boolean(result.fileTouch?.ok), true, `${surface} file-touch write failed`);
+  return result;
+}
+
+const codex = await bind('codex', 'current-codex-cli-canary', [
+  {
+    path: 'packages/aria-connector/src/cross-cli-hive-binding.ts',
+    intent: 'codex canary uses shared cross-cli Hive primitive',
+    status: 'claimed',
+  },
+  {
+    path: 'codex/plans/aria-civilizational-corpus-skills/CROSS_CLI_HIVE_ADOPTION_LEDGER.md',
+    intent: 'codex canary updates execution ledger',
+    status: 'claimed',
+  },
+]);
+
+const shell = await bind('shell', 'shell-cli-canary', [
+  {
+    path: 'packages/aria-connector/scripts/self-test-cross-cli-hive-adoption.mjs',
+    intent: 'shell canary uses shared cross-cli Hive primitive',
+    status: 'claimed',
+  },
+  {
+    path: 'codex/plans/aria-civilizational-corpus-skills/CROSS_CLI_HIVE_ADOPTION_MANIFEST.json',
+    intent: 'shell canary updates execution manifest',
+    status: 'claimed',
+  },
+]);
+
+const registry = await getJson(`/api/hive/session-registry?project_id=${encodeURIComponent(projectId)}&include_touches=true&touch_limit=50`);
+assert.equal(registry.ok, true);
+assert.equal(registry.found, true);
+assert.equal(registry.registry.native_provider_ok, true);
+
+const sessions = Array.isArray(registry.sessions) ? registry.sessions : [];
+const sessionIds = sessions.map((session) => session.session_id);
+assert.ok(sessionIds.includes(codex.session.session_id), 'registry missing Codex canary session');
+assert.ok(sessionIds.includes(shell.session.session_id), 'registry missing shell canary session');
+assert.ok(registry.registry.surfaces.includes('codex'), 'registry missing codex surface');
+assert.ok(registry.registry.surfaces.includes('shell'), 'registry missing shell surface');
+
+for (const session of sessions.filter((entry) => [codex.session.session_id, shell.session.session_id].includes(entry.session_id))) {
+  assert.equal(session.native_provider_mode, true, `${session.session_id} native provider mode drifted`);
+  assert.equal(session.provider_auth_owner, 'native-cli', `${session.session_id} provider auth owner drifted`);
+  assert.equal(session.active_phase, activePhase, `${session.session_id} active phase drifted`);
+}
+
+const touchedPaths = new Set((Array.isArray(registry.touched_files) ? registry.touched_files : []).map((entry) => entry.path));
+assert.ok(touchedPaths.has('packages/aria-connector/scripts/self-test-cross-cli-hive-adoption.mjs'), 'registry touched files missing shell canary script');
+assert.ok(touchedPaths.has('packages/aria-connector/src/cross-cli-hive-binding.ts'), 'registry touched files missing shared primitive');
+
+console.log(JSON.stringify({
+  ok: true,
+  runtimeUrl,
+  projectId,
+  threadId,
+  activePhase,
+  sessions: {
+    codex: codex.session.session_id,
+    shell: shell.session.session_id,
+  },
+  registry: {
+    sessionCount: registry.registry.session_count,
+    activeSessionCount: registry.registry.active_session_count,
+    staleSessionCount: registry.registry.stale_session_count,
+    surfaces: registry.registry.surfaces,
+    nativeProviderOk: registry.registry.native_provider_ok,
+    touchedFiles: registry.touched_files.length,
+    touches: registry.touches.length,
+    storage: registry.storage.mode,
+    localPostgres: registry.storage.postgres_local_only,
+  },
+}, null, 2));

package/scripts/self-test-cross-cli-hive-learning.mjs

@@ -0,0 +1,146 @@
+#!/usr/bin/env node
+
+import assert from 'node:assert/strict';
+import { randomUUID } from 'node:crypto';
+
+import { bindCrossCliHiveSession } from '../dist/aria-connector/src/cross-cli-hive-binding.js';
+
+const runtimeUrl = (process.env.ARIA_RUNTIME_URL || 'http://127.0.0.1:4319').replace(/\/+$/, '');
+const projectId = process.env.ARIA_CROSS_CLI_HIVE_PROJECT_ID || 'cross-cli-hive-adoption';
+const threadId = process.env.ARIA_CROSS_CLI_HIVE_THREAD_ID || 'thread-aria-task-task-2026-05-15T03-15-54-050Z-9141a57d';
+const activeTaskId = process.env.ARIA_CROSS_CLI_HIVE_TASK_ID || 'task-2026-05-15T03-15-54-050Z-9141a57d';
+const activePhase = process.env.ARIA_CROSS_CLI_HIVE_PHASE || '05-qa-learning-cross-cli-canary';
+const cwd = process.env.ARIA_CROSS_CLI_HIVE_CWD || process.cwd();
+const stamp = `${Date.now().toString(36)}-${randomUUID().slice(0, 8)}`;
+const qaMarker = `phase05-learning-${stamp}`;
+
+const latestQa = {
+  marker: qaMarker,
+  phase_id: activePhase,
+  ok: true,
+  gaps: [],
+  qa_file: 'codex/plans/aria-civilizational-corpus-skills/phase62-cross-cli-hive-adoption/PHASE_05_QA_LEARNING_CROSS_CLI_CANARY_QA.md',
+  learned_principle: 'Cross-CLI sessions must read QA and recovery state from Hive context, not hidden chat memory.',
+};
+
+const latestRecovery = {
+  marker: qaMarker,
+  phase_id: activePhase,
+  correction_required: false,
+  recovery_in_progress: false,
+  future_preflight: 'registered sessions must verify latest_qa and latest_recovery before completion claims',
+};
+
+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;
+}
+
+async function bind(surface, role, extra = {}) {
+  const result = await bindCrossCliHiveSession({
+    surface,
+    cwd,
+    projectId,
+    threadId,
+    activeTaskId,
+    activePhase,
+    role,
+    sessionId: `${surface}:phase62-learning:${stamp}`,
+    source: 'self-test-cross-cli-hive-learning',
+    sourceArtifact: 'packages/aria-connector/scripts/self-test-cross-cli-hive-learning.mjs',
+    nativeProviderMode: true,
+    providerAuthOwner: 'native-cli',
+    capabilities: ['hive-session-bind', 'qa-learning-readback', 'recovery-learning-readback'],
+    fileClaims: [
+      {
+        path: 'packages/aria-connector/scripts/self-test-cross-cli-hive-learning.mjs',
+        intent: `${surface} learning canary`,
+        status: 'claimed',
+      },
+      {
+        path: 'codex/plans/aria-civilizational-corpus-skills/CROSS_CLI_HIVE_ADOPTION_LEDGER.md',
+        intent: `${surface} learning evidence ledger`,
+        status: 'claimed',
+      },
+    ],
+    ...extra,
+  });
+  assert.equal(result.ok, true, `${surface} learning bind failed`);
+  assert.deepEqual(result.warnings, [], `${surface} learning bind warnings`);
+  assert.equal(result.session.native_provider_mode, true);
+  assert.equal(result.session.provider_auth_owner, 'native-cli');
+  return result;
+}
+
+const publisher = await bind('codex', 'qa-learning-publisher', {
+  latestQa,
+  latestRecovery,
+  extraContext: {
+    canary: 'phase62-cross-cli-learning-publisher',
+    qa_marker: qaMarker,
+  },
+});
+
+const reader = await bind('shell', 'qa-learning-reader', {
+  extraContext: {
+    canary: 'phase62-cross-cli-learning-reader',
+    expects_qa_marker: qaMarker,
+  },
+});
+
+const readerCapsule = asRecord(reader.projectContext?.capsule);
+assert.equal(asRecord(readerCapsule.latest_qa).marker, qaMarker, 'peer context missing propagated latest_qa');
+assert.equal(asRecord(readerCapsule.latest_recovery).marker, qaMarker, 'peer context missing propagated latest_recovery');
+
+const registry = await getJson(`/api/hive/session-registry?project_id=${encodeURIComponent(projectId)}&include_touches=true&touch_limit=75`);
+assert.equal(registry.ok, true);
+assert.equal(registry.found, true);
+assert.equal(registry.registry.native_provider_ok, true);
+assert.equal(asRecord(registry.registry.latest_qa).marker, qaMarker, 'registry missing propagated latest_qa');
+assert.equal(asRecord(registry.registry.latest_recovery).marker, qaMarker, 'registry missing propagated latest_recovery');
+
+const projectContext = await getJson(`/api/hive/project-context?project_id=${encodeURIComponent(projectId)}&include_touches=true&touch_limit=75`);
+const capsule = asRecord(projectContext.context?.capsule);
+assert.equal(asRecord(capsule.latest_qa).marker, qaMarker, 'project context missing propagated latest_qa');
+assert.equal(asRecord(capsule.latest_recovery).marker, qaMarker, 'project context missing propagated latest_recovery');
+
+const sessionIds = new Set((Array.isArray(registry.sessions) ? registry.sessions : []).map((session) => session.session_id));
+assert.ok(sessionIds.has(publisher.session.session_id), 'registry missing learning publisher session');
+assert.ok(sessionIds.has(reader.session.session_id), 'registry missing learning reader session');
+
+console.log(JSON.stringify({
+  ok: true,
+  runtimeUrl,
+  projectId,
+  threadId,
+  activePhase,
+  qaMarker,
+  sessions: {
+    publisher: publisher.session.session_id,
+    reader: reader.session.session_id,
+  },
+  readback: {
+    registryLatestQaMarker: registry.registry.latest_qa.marker,
+    registryLatestRecoveryMarker: registry.registry.latest_recovery.marker,
+    projectLatestQaMarker: capsule.latest_qa.marker,
+    projectLatestRecoveryMarker: capsule.latest_recovery.marker,
+    peerContextLatestQaMarker: readerCapsule.latest_qa.marker,
+    peerContextLatestRecoveryMarker: readerCapsule.latest_recovery.marker,
+    nativeProviderOk: registry.registry.native_provider_ok,
+    surfaces: registry.registry.surfaces,
+    sessionCount: registry.registry.session_count,
+    activeSessionCount: registry.registry.active_session_count,
+    touchedFiles: registry.touched_files.length,
+    touches: registry.touches.length,
+    storage: registry.storage.mode,
+    localPostgres: registry.storage.postgres_local_only,
+  },
+}, null, 2));