@aria_asi/cli 0.2.39 → 0.2.41

package/scripts/self-test-evaluate-with-kernel.mjs

@@ -0,0 +1,111 @@
+#!/usr/bin/env node
+// self-test-evaluate-with-kernel — smoke test for G0 helper.
+//
+// Asserts:
+//   1. deterministic hash on identical input
+//   2. different hash on different input
+//   3. acceptance.tadabbur_12 + qiyas_15 true on a normal observation
+//   4. unverified-trust observation downgrades autonomy
+//   5. invalid input returns ok=false (no throw)
+//   6. compilation_hash matches sha256 contract
+
+import assert from 'node:assert/strict';
+import { createHash } from 'node:crypto';
+import { evaluateWithKernel, TADABBUR_STAGES, QIYAS_PERSPECTIVES } from '../runtime-src/lib/evaluate-with-kernel.mjs';
+
+const failures = [];
+function pass(name) { console.log(`  ok  - ${name}`); }
+function fail(name, err) { failures.push({ name, err: err.message || String(err) }); console.log(`  FAIL - ${name}: ${err.message || err}`); }
+function check(name, fn) { try { fn(); pass(name); } catch (e) { fail(name, e); } }
+
+// --- Fixture: a normal code-review observation with evidence ---
+const codeObs = {
+  kind: 'code_quality_finding',
+  source: 'codebase',
+  severity: 'medium',
+  title: 'Missing test for rate_limited branch',
+  attrs: { path: 'src/handlers/leads.ts', hasTests: true },
+};
+const codeEvidence = [
+  { anchor_type: 'command', source: 'npm test', observed: 'rate_limited test missing', expected: 'rate_limited branch covered' },
+];
+
+console.log('test: G0 evaluate-with-kernel');
+
+check('returns ok=true for valid observation', () => {
+  const r = evaluateWithKernel({ surface: 'test', phase: 'test', observation: codeObs, evidence: codeEvidence, predicate: 'rate_limited branch has dedicated test' });
+  assert.equal(r.ok, true);
+  assert.ok(r.receiptHash, 'receiptHash present');
+  assert.equal(typeof r.receiptHash, 'string');
+  assert.equal(r.receiptHash.length, 64, 'receiptHash is sha256 hex (64 chars)');
+});
+
+check('deterministic: identical input → identical hash', () => {
+  const r1 = evaluateWithKernel({ surface: 'test', phase: 'test', observation: codeObs, evidence: codeEvidence, predicate: 'rate_limited branch has dedicated test' });
+  const r2 = evaluateWithKernel({ surface: 'test', phase: 'test', observation: codeObs, evidence: codeEvidence, predicate: 'rate_limited branch has dedicated test' });
+  assert.equal(r1.receiptHash, r2.receiptHash, 'hashes must match across identical calls');
+});
+
+check('different observation → different hash', () => {
+  const r1 = evaluateWithKernel({ surface: 'test', phase: 'test', observation: codeObs, evidence: codeEvidence });
+  const altObs = { ...codeObs, title: 'Missing test for stripe_error branch' };
+  const r2 = evaluateWithKernel({ surface: 'test', phase: 'test', observation: altObs, evidence: codeEvidence });
+  assert.notEqual(r1.receiptHash, r2.receiptHash, 'changing observation must change hash');
+});
+
+check('acceptance: tadabbur_12 + qiyas_15 + deterministic_hash', () => {
+  const r = evaluateWithKernel({ surface: 'test', phase: 'test', observation: codeObs, evidence: codeEvidence });
+  assert.equal(r.acceptance.tadabbur_12, true, 'tadabbur 12 stages must run');
+  assert.equal(r.acceptance.qiyas_15, true, 'qiyas 15 perspectives must run');
+  assert.equal(r.acceptance.deterministic_hash, true);
+  assert.equal(r.tadabbur.stage_count, TADABBUR_STAGES.length, '12 stages');
+  assert.equal(r.qiyas.perspective_count, QIYAS_PERSPECTIVES.length, '15 perspectives');
+});
+
+check('source trust: command-anchored evidence → direct_observed', () => {
+  const r = evaluateWithKernel({ surface: 'test', phase: 'test', observation: codeObs, evidence: codeEvidence });
+  assert.equal(r.sourceTrust, 'direct_observed');
+});
+
+check('unverified observation: no evidence → high-autonomy options rejected', () => {
+  const r = evaluateWithKernel({ surface: 'test', phase: 'test', observation: codeObs, evidence: [] });
+  assert.equal(r.sourceTrust, 'unverified');
+  // top option should be observe_only when nothing else passes
+  assert.ok(r.topOption);
+  // At least one option in the full set must be rejected for unverified+severity
+  const compilation = r;
+  // top option's autonomy must be 1 (observe_only) since higher autonomy gets rejected
+  assert.equal(r.topOption.option_id, 'observe_only', 'unverified → observe_only wins');
+});
+
+check('decision: allow|observe_only|force_reauthor|block are the only values', () => {
+  const r1 = evaluateWithKernel({ surface: 'test', phase: 'test', observation: codeObs, evidence: codeEvidence });
+  const r2 = evaluateWithKernel({ surface: 'test', phase: 'test', observation: codeObs, evidence: [] });
+  for (const r of [r1, r2]) {
+    assert.ok(['allow', 'observe_only', 'force_reauthor', 'block'].includes(r.decision), `decision in domain: got ${r.decision}`);
+  }
+});
+
+check('invalid input: missing observation → ok=false, decision=block, no throw', () => {
+  const r = evaluateWithKernel({ surface: 'test', phase: 'test' });
+  assert.equal(r.ok, false);
+  assert.equal(r.decision, 'block');
+  assert.ok(r.error);
+  assert.equal(r.error.kind, 'invalid_input');
+});
+
+check('recovery directive: human-readable prose for every decision', () => {
+  const r1 = evaluateWithKernel({ surface: 'test', phase: 'test', observation: codeObs, evidence: codeEvidence });
+  assert.equal(typeof r1.recoveryDirective, 'string');
+  assert.ok(r1.recoveryDirective.length > 20);
+});
+
+console.log('');
+if (failures.length === 0) {
+  console.log(`all ${9} checks passed`);
+  process.exit(0);
+} else {
+  console.log(`${failures.length} FAILURE(S):`);
+  for (const f of failures) console.log(`  - ${f.name}: ${f.err}`);
+  process.exit(1);
+}

package/scripts/self-test-first-class-output-delta-proof.mjs

@@ -0,0 +1,307 @@
+#!/usr/bin/env node
+
+import assert from 'node:assert/strict';
+import { createHash } from 'node:crypto';
+import { existsSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import path from 'node:path';
+
+const runtimeUrl = (process.env.ARIA_RUNTIME_URL || 'http://127.0.0.1:4319').replace(/\/+$/, '');
+
+const requiredSkills = [
+  'aria-cognition-autofire',
+  'aria-first-class-operating-contract',
+  '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',
+  'mizan',
+  'ghazali-8lens',
+  'aria-noor-cognitives',
+  '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',
+  'aria-business-frame',
+  'aria-business-audit',
+  'aria-revenue-engine',
+  'aria-retention-engine',
+  'aria-gtm-architect',
+  'aria-senior-code-cookbook',
+  'aria-senior-code-audit',
+  'testing-strategy',
+  'security-review',
+  'architecture-decision',
+  'api-design',
+  'observability',
+  'error-handling',
+  'aria-decision-mizan',
+  'aria-aristotle-cognitives',
+  'aria-forge-guardrails',
+  'aria-harness-deploy',
+  'aria-harness-onboarding',
+  'aria-harness-output-discipline',
+  'aria-frontend-architect',
+  'aria-fullstack-orchestrator',
+  'aria-research-orchestrator',
+  'cross-domain-24',
+  'fitrah-guard',
+  'noor-recognition',
+  'ladunni-22',
+  'ijtihad-novel',
+  'ilham-intuition',
+  'istiqra-induction',
+  'ruh-basis',
+  'soul-domains',
+  'deepsoul-emotional',
+  'aria-repo-audit',
+  'aria-live-ops',
+  'aria-memory-index',
+  'aria-ops',
+];
+
+const baseBody = {
+  surface: 'codex',
+  surfaceId: 'first-class-output-delta-proof',
+  task: 'prove mechanical skill and runtime substrate changes output behavior without overstating live provider evidence',
+  prompt: [
+    'Name the highest-impact next engineering action for Aria mechanical autofire.',
+    'Include expected vs observed evidence, QA finding, correction action, verification predicate, and ledger learning.',
+    'Bound claims if live provider output has not been verified.',
+  ].join(' '),
+  docs: [{ title: 'eval-contract', content: 'same task and evidence request for both arms' }],
+  files: {},
+  metadata: {
+    source: 'self-test-first-class-output-delta-proof',
+    universalTurnPacket: true,
+    requiredSkills,
+  },
+  requiredSkills,
+};
+
+function sha256(value) {
+  return createHash('sha256').update(String(value)).digest('hex');
+}
+
+function readArg(name) {
+  const index = process.argv.indexOf(name);
+  if (index === -1) return '';
+  return process.argv[index + 1] || '';
+}
+
+async function postPrompt(body) {
+  const response = await fetch(`${runtimeUrl}/build-system-prompt`, {
+    method: 'POST',
+    headers: { 'content-type': 'application/json' },
+    body: JSON.stringify(body),
+  });
+  const text = await response.text();
+  let parsed = {};
+  try {
+    parsed = text ? JSON.parse(text) : {};
+  } catch {
+    parsed = { raw: text };
+  }
+  assert.equal(response.ok, true, `runtime /build-system-prompt status=${response.status}`);
+  assert.equal(parsed.ok, true, 'runtime prompt build ok');
+  return parsed;
+}
+
+function summarizeSubstrateArm(label, data) {
+  const prompt = String(data.prompt || '');
+  const receipt = data.skillExecutionReceipt || {};
+  const substrate = receipt.substrateKernelExecution || {};
+  const cognitive = receipt.cognitiveRuntimeReceipts || {};
+  const qaCorrection = receipt.qaCorrectionLearningReceipt || receipt.qaCorrectionReceipt || {};
+  return {
+    label,
+    promptSha256: sha256(prompt),
+    promptChars: prompt.length,
+    hasMechanicalReceiptBlock: prompt.includes('ARIA MECHANICAL SKILL EXECUTION RECEIPT'),
+    hasFullSkillBodies: prompt.includes('<skill_content '),
+    hasForcedBodyBlock: prompt.includes('ARIA RUNTIME FORCED SKILL LOAD'),
+    executedSkillCount: Array.isArray(receipt.executedSkillIds) ? receipt.executedSkillIds.length : 0,
+    executedOperatorCount: Array.isArray(substrate.executedOperatorIds) ? substrate.executedOperatorIds.length : 0,
+    hasSubstrateReceipt: substrate.ok === true && substrate.mode === 'deterministic_sidecar_kernel',
+    hasQaCorrection: qaCorrection.ok === true || qaCorrection.learningFeedsNextSelection === true,
+    hasQiyasTadabbur: cognitive?.tadabbur?.stageCount === 12 && cognitive?.qiyas?.perspectiveCount === 15,
+    hasNoorBoundary: typeof cognitive?.noor?.semanticBoundary === 'string'
+      && cognitive.noor.semanticBoundary.includes('not generic pattern recognition'),
+  };
+}
+
+function substrateQualityScore(summary) {
+  return [
+    summary.hasMechanicalReceiptBlock,
+    summary.hasSubstrateReceipt,
+    summary.executedSkillCount >= 50,
+    summary.executedOperatorCount >= 25,
+    summary.hasQaCorrection,
+    summary.hasQiyasTadabbur,
+    summary.hasNoorBoundary,
+    !summary.hasFullSkillBodies,
+    !summary.hasForcedBodyBlock,
+    summary.promptChars > 500 && summary.promptChars < 25000,
+  ].filter(Boolean).length;
+}
+
+function scoreOutputArtifact(label, text) {
+  const value = String(text || '');
+  const checks = {
+    namesConcreteAction: /\b(next action|next step|implement|verify|run)\b/i.test(value),
+    expectedObserved: /\b(expected|observed|predicate|verification)\b/i.test(value),
+    qaLoop: /\b(QA|finding|correct|correction|harden|re-test|verify)\b/i.test(value),
+    ledgerEvidence: /\b(ledger|receipt|evidence|test|exit=0|status=|hash)\b/i.test(value),
+    boundedClaim: /\b(unverified|bounded|degraded|partial|claim boundary|not live provider)\b/i.test(value),
+    learningLoop: /\b(lesson|reflexion|Dalio|learning|feeds next)\b/i.test(value),
+    noRawDump: !/\b(phaseReceipts|skillExecutionReceipt|executedOperatorIdsHash)\b/.test(value),
+    noFalseClosure: !/\b(complete|production ready|fully done|guaranteed)\b/i.test(value),
+  };
+  const score = Object.values(checks).filter(Boolean).length;
+  return {
+    label,
+    sha256: sha256(value),
+    chars: value.length,
+    score,
+    checks,
+  };
+}
+
+function loadOutputArtifacts() {
+  const baselinePath = readArg('--baseline-output');
+  const substratePath = readArg('--substrate-output');
+  if (baselinePath || substratePath) {
+    assert.ok(baselinePath && substratePath, 'both --baseline-output and --substrate-output are required');
+    assert.ok(existsSync(baselinePath), `missing baseline output artifact: ${baselinePath}`);
+    assert.ok(existsSync(substratePath), `missing substrate output artifact: ${substratePath}`);
+    return {
+      mode: 'artifact_scored',
+      cleanup: null,
+      baselinePath,
+      substratePath,
+      baselineText: readFileSync(baselinePath, 'utf8'),
+      substrateText: readFileSync(substratePath, 'utf8'),
+    };
+  }
+
+  const dir = mkdtempSync(path.join(tmpdir(), 'aria-output-delta-proof-'));
+  const baselinePathLocal = path.join(dir, 'baseline.txt');
+  const substratePathLocal = path.join(dir, 'substrate.txt');
+  writeFileSync(
+    baselinePathLocal,
+    'I will improve the system. It should be fine after more gates.',
+    'utf8',
+  );
+  writeFileSync(
+    substratePathLocal,
+    [
+      'Next action: add the output-delta verifier and run it before claiming live behavior improvement.',
+      'Expected vs observed: expected provider-output evidence; observed only substrate receipts so far.',
+      'QA finding: live provider output remains unverified; correction is to require paired output artifacts for provider proof.',
+      'Verification predicate: scorer scoreDelta >= 3 and substrate artifact score >= 7.',
+      'Ledger evidence: record receipt hash and test exit=0.',
+      'Learning: Dalio/Reflexion lesson feeds next selection by preventing receipt-only victory claims.',
+      'Claim boundary: fixture smoke proves the scorer contract, not live provider output.',
+    ].join('\n'),
+    'utf8',
+  );
+  return {
+    mode: 'fixture_scorer_contract',
+    cleanup: () => rmSync(dir, { recursive: true, force: true }),
+    baselinePath: baselinePathLocal,
+    substratePath: substratePathLocal,
+    baselineText: readFileSync(baselinePathLocal, 'utf8'),
+    substrateText: readFileSync(substratePathLocal, 'utf8'),
+  };
+}
+
+const baseline = await postPrompt({
+  ...baseBody,
+  sessionId: `first-class-output-baseline-${Date.now()}`,
+  skillExecutionMode: 'full-prompt',
+  metadata: {
+    ...baseBody.metadata,
+    skillExecutionMode: 'full-prompt',
+  },
+});
+
+const substrate = await postPrompt({
+  ...baseBody,
+  sessionId: `first-class-output-substrate-${Date.now()}`,
+  skillExecutionMode: 'mechanical-receipt',
+  metadata: {
+    ...baseBody.metadata,
+    skillExecutionMode: 'mechanical-receipt',
+  },
+});
+
+const baselineSubstrate = summarizeSubstrateArm('before_full_prompt_body_load', baseline);
+const afterSubstrate = summarizeSubstrateArm('after_mechanical_substrate_execution', substrate);
+baselineSubstrate.qualityScore = substrateQualityScore(baselineSubstrate);
+afterSubstrate.qualityScore = substrateQualityScore(afterSubstrate);
+
+assert.equal(afterSubstrate.hasSubstrateReceipt, true, 'after arm has deterministic substrate receipt');
+assert.equal(afterSubstrate.hasMechanicalReceiptBlock, true, 'after arm has mechanical receipt block');
+assert.equal(afterSubstrate.hasFullSkillBodies, false, 'after arm does not stuff full skill bodies');
+assert.equal(afterSubstrate.hasForcedBodyBlock, false, 'after arm does not include forced body block');
+assert.ok(afterSubstrate.executedSkillCount >= 50, 'after arm executes at least 50 skills');
+assert.ok(afterSubstrate.executedOperatorCount >= 25, 'after arm executes at least 25 operators');
+assert.ok(afterSubstrate.qualityScore > baselineSubstrate.qualityScore, 'after arm beats baseline substrate score');
+
+const outputs = loadOutputArtifacts();
+let providerBaseline = null;
+let providerSubstrate = null;
+try {
+  providerBaseline = scoreOutputArtifact('baseline_provider_output', outputs.baselineText);
+  providerSubstrate = scoreOutputArtifact('substrate_provider_output', outputs.substrateText);
+  const scoreDelta = providerSubstrate.score - providerBaseline.score;
+  assert.ok(scoreDelta >= 3, `provider-output score delta too small: ${scoreDelta}`);
+  assert.ok(providerSubstrate.score >= 7, `substrate output artifact score too low: ${providerSubstrate.score}`);
+} finally {
+  if (typeof outputs.cleanup === 'function') outputs.cleanup();
+}
+
+const providerOutputProof = outputs.mode === 'artifact_scored'
+  ? {
+      status: 'artifact_scored',
+      claimBoundary: 'paired output artifacts were scored; the scorer does not prove provider causality by itself',
+      baselinePath: outputs.baselinePath,
+      substratePath: outputs.substratePath,
+      scoreDelta: providerSubstrate.score - providerBaseline.score,
+    }
+  : {
+      status: 'fixture_only_not_live_provider',
+      claimBoundary: 'default run proves scorer contract and substrate delta only; pass --baseline-output and --substrate-output for real provider-output artifacts',
+      baselinePath: outputs.baselinePath,
+      substratePath: outputs.substratePath,
+      scoreDelta: providerSubstrate.score - providerBaseline.score,
+    };
+
+console.log(JSON.stringify({
+  ok: true,
+  test: 'first-class-output-delta-proof',
+  substrateDelta: {
+    baseline: baselineSubstrate,
+    substrate: afterSubstrate,
+    scoreDelta: afterSubstrate.qualityScore - baselineSubstrate.qualityScore,
+  },
+  providerOutputProof,
+  providerScores: {
+    baseline: providerBaseline,
+    substrate: providerSubstrate,
+  },
+  verificationPredicate: 'substrate arm has mechanical receipt, >=50 fired skills, >=25 operators, no skill-body stuffing; provider scorer requires paired output artifacts for live-output claims.',
+}, null, 2));

package/scripts/self-test-goal-contract-output-qa.mjs

@@ -0,0 +1,73 @@
+#!/usr/bin/env node
+import assert from 'node:assert/strict';
+
+import {
+  buildUniversalConnectorGoalContract,
+  evaluateGoalContractOutput,
+} from '../hooks/lib/goal-contract-quality.mjs';
+import { analyzeDomainOutputQuality } from '../hooks/lib/domain-output-quality.mjs';
+
+const userText =
+  'Continue with the next best move. Fire at minimum 15 skills and tell me how far from production we are.';
+const contract = buildUniversalConnectorGoalContract({ userText, phase: 'self-test' });
+
+assert.equal(contract.selectedSkills.length, 25, 'goal contract should inject 25 high-impact corpus skills');
+assert.equal(contract.selectedRuntimes.length, 16, 'goal contract should inject all 16 required runtimes');
+assert.match(contract.actualGoal, /Wire extracted books/i);
+
+const good = evaluateGoalContractOutput(
+  [
+    'Status: integration-ready, not production-ready.',
+    'Actual goal: wire extracted books, doctrines, skills, runtimes, primitives, mappings, connectors, hooks, sidecars, and agent surfaces so output improves automatically.',
+    'Evidence: registry smoke and sandbox consumer QA passed; live forced-selection wiring is pending.',
+    'QA: QIYAS, Tadabbur, Mizan, Ghazali, Tafakkur, and Fitrah found the next highest-impact action is to promote the sandbox corpus registry into the real connector hook path.',
+    'Next highest-impact step: wire the registry into forced-selection and run behavioral QA on actual Claude/Codex/OpenCode continuation prompts.',
+  ].join('\n'),
+  { userText, goalContract: contract }
+);
+
+assert.equal(good.hardBlock, false, 'good output should not hard block');
+assert.equal(good.pass, true, 'good output should pass goal QA');
+
+const handoff = evaluateGoalContractOutput('What would you like me to do next?', {
+  userText,
+  goalContract: contract,
+});
+assert.equal(handoff.hardBlock, true, 'obvious next-action handoff should hard block');
+
+const falseReady = evaluateGoalContractOutput('Everything is production ready and complete.', {
+  userText,
+  goalContract: contract,
+});
+assert.equal(falseReady.hardBlock, true, 'unbounded production-ready claim should hard block');
+
+const receiptDrift = evaluateGoalContractOutput(
+  'Phase 55 added receipts, gates, ledgers, canaries, and drift checks. Done.',
+  { userText, goalContract: contract }
+);
+assert.equal(receiptDrift.hardBlock, true, 'support-mechanism drift plus done claim should hard block');
+assert.ok(
+  receiptDrift.warnings.some((warning) => warning.includes('support mechanisms dominate')),
+  'support-mechanism drift should be diagnosed'
+);
+
+const domain = analyzeDomainOutputQuality('What would you like me to do next?', { userText });
+assert.ok(
+  domain.blockers.some((blocker) => blocker.includes('goal-contract')),
+  'domain output quality should compose goal-contract QA'
+);
+assert.ok(domain.repairs.length > 0, 'domain output quality should return concrete repair guidance');
+
+console.log(
+  JSON.stringify(
+    {
+      ok: true,
+      selected_skills: contract.selectedSkills.length,
+      selected_runtimes: contract.selectedRuntimes.length,
+      good_score: good.score,
+      hard_blocks_checked: 3,
+    },
+    null,
+    2
+  )
+);

package/scripts/self-test-goal-contract.mjs

@@ -0,0 +1,35 @@
+// Goal-contract regression smoke. Self-contained; reads ARIA_KERNEL_QA_MODE env.
+import * as m from '/home/hamzaibrahim1/rei-ai-brain/ops/claude-hooks/codex-native/lib/runtime-client.mjs';
+
+const cases = [
+  ['A. probe narration (continuation)',
+   'continue. exit 0, sha256 byte-identical, 9/9 pass, smoke verified empirically.',
+   'next', false],
+  ['B. real claim (continuation)',
+   'continue. The work is complete. We have shipped the kernel refactor and it is production ready.',
+   'next', true],
+  ['C. real claim NO continuation [6]',
+   'The work is complete. Production ready.',
+   'hello', true],
+  ['D. edit-target literal',
+   'continue. Edit runtime-client.mjs to add a regex matching production ready / completed.',
+   'continue patch', false],
+  ['E. code fence literal',
+   'continue. Patching: `/production ready|complete|done/i`',
+   'continue patch', false],
+  ['F. benign Q&A',
+   'The sky appears blue because of Rayleigh scattering.',
+   'why is sky blue', false],
+];
+
+const mode = process.env.ARIA_KERNEL_QA_MODE === '1' ? 'kernel-mode' : 'regex-mode';
+console.log(`-- ${mode} --`);
+let pass = 0, fail = 0;
+for (const [name, text, userText, expected] of cases) {
+  const qa = m.evaluateGoalContractOutput(text, { userText });
+  const ok = qa.hardBlock === expected;
+  if (ok) pass++; else fail++;
+  console.log(`  ${ok ? 'PASS' : 'FAIL'}  ${name}`);
+}
+console.log(`  ${pass} pass / ${fail} fail`);
+process.exit(fail === 0 ? 0 : 1);

package/scripts/self-test-governed-adapters.mjs

@@ -0,0 +1,105 @@
+import { existsSync, readFileSync } from 'node:fs';
+import { homedir } from 'node:os';
+import path from 'node:path';
+
+import {
+  DEFAULT_SANDBOX_ROOT,
+  GovernedSurfaceRunner,
+} from '../dist/aria-connector/src/governed-surface-runner.js';
+import {
+  requireGovernedConnectorMutation,
+} from '../dist/aria-connector/src/connectors/governed-adapter.js';
+
+function row(name, pass, evidence = {}) {
+  return { name, pass: pass === true, evidence };
+}
+
+function sourceContains(filePath, needles) {
+  if (!existsSync(filePath)) {
+    return row(`source_${path.basename(filePath)}_exists`, false, { filePath });
+  }
+  const text = readFileSync(filePath, 'utf8');
+  const missing = needles.filter((needle) => !text.includes(needle));
+  return row(`source_${path.basename(filePath)}_uses_governance`, missing.length === 0, {
+    filePath,
+    missing,
+  });
+}
+
+async function expectBlocked(surfaceId, targetPath) {
+  try {
+    await requireGovernedConnectorMutation({
+      surfaceId,
+      action: 'install',
+      targetPath,
+      reason: `adapter smoke for ${surfaceId}`,
+      opts: {
+        sessionId: `governed-adapter-smoke-${process.pid}`,
+        sandboxRoot: path.join(DEFAULT_SANDBOX_ROOT, 'adapter-smoke'),
+      },
+    });
+    return row(`${surfaceId}_active_target_blocked`, false, {
+      targetPath,
+      blocked: false,
+    });
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    return row(`${surfaceId}_active_target_blocked`, /blocked/.test(message), {
+      targetPath,
+      blocked: true,
+      message,
+    });
+  }
+}
+
+async function outputSurfaceSmoke() {
+  const runner = new GovernedSurfaceRunner({
+    sessionId: `governed-adapter-smoke-${process.pid}`,
+    governanceLedgerRoot: path.join(DEFAULT_SANDBOX_ROOT, 'adapter-smoke', 'ledgers'),
+  });
+  const verdict = await runner.validateOutput({
+    text: 'This is complete without proof.',
+    surfaceId: 'aria-chat',
+    sessionId: `governed-adapter-smoke-${process.pid}`,
+    timeoutMs: 3000,
+  });
+  return row('aria_chat_uses_governed_output_block', !verdict.passed && verdict.severity === 'block', {
+    passed: verdict.passed,
+    severity: verdict.severity,
+    violations: verdict.violations,
+  });
+}
+
+async function run() {
+  const home = homedir();
+  const distRoot = path.resolve('dist', 'aria-connector', 'src');
+  const rows = [
+    sourceContains(path.join(distRoot, 'chat.js'), ['GovernedSurfaceRunner', "surfaceId: 'aria-chat'"]),
+    sourceContains(path.join(distRoot, 'connectors', 'shell.js'), ['requireGovernedConnectorMutation']),
+    sourceContains(path.join(distRoot, 'connectors', 'codex.js'), ['requireGovernedConnectorMutation']),
+    sourceContains(path.join(distRoot, 'connectors', 'claude-code.js'), ['requireGovernedConnectorMutation']),
+    sourceContains(path.join(distRoot, 'connectors', 'opencode.js'), ['requireGovernedConnectorMutation']),
+    sourceContains(path.join(distRoot, 'connectors', 'cursor.js'), ['requireGovernedConnectorMutation']),
+    await expectBlocked('codex', path.join(home, '.codex')),
+    await expectBlocked('claude-code', path.join(home, '.claude')),
+    await expectBlocked('opencode', path.join(home, '.opencode')),
+    await expectBlocked('shell', path.join(home, '.aria', 'wrappers')),
+    await expectBlocked('cursor', path.join(process.cwd(), '.cursorrules')),
+    await outputSurfaceSmoke(),
+  ];
+
+  const summary = {
+    ok: rows.every((item) => item.pass),
+    total: rows.length,
+    passed: rows.filter((item) => item.pass).length,
+    failed: rows.filter((item) => !item.pass).length,
+    rows,
+  };
+  console.log(JSON.stringify(summary, null, 2));
+  process.exit(summary.ok ? 0 : 1);
+}
+
+run().catch((error) => {
+  console.error(JSON.stringify({ ok: false, error: error.stack || error.message }, null, 2));
+  process.exit(1);
+});