@aria_asi/cli 0.2.39 → 0.2.41

package/scripts/self-test-action-ledger-core.mjs

@@ -0,0 +1,190 @@
+#!/usr/bin/env node
+
+import assert from 'node:assert/strict';
+import { existsSync, mkdtempSync, readFileSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import path from 'node:path';
+
+import {
+  actionLedgerPaths,
+  projectActionLedger,
+  readActionLedgerEvents,
+  readActionLedgerPublishOutbox,
+  recordActionEvent,
+  recordActionEventLocal,
+  replayActionLedgerPublishOutbox,
+} from '../dist/aria-connector/src/action-ledger-core.js';
+
+const home = mkdtempSync(path.join(tmpdir(), 'aria-action-ledger-core-'));
+const projectId = 'action-ledger-core-smoke';
+const taskId = 'task-action-ledger-core-smoke';
+const threadId = 'thread-action-ledger-core-smoke';
+const sessionId = 'codex:action-ledger-core-smoke';
+
+const first = recordActionEventLocal({
+  surface: 'codex',
+  sessionId,
+  threadId,
+  projectId,
+  taskId,
+  phaseId: '01-scope',
+  lifecyclePhase: 'pre_prompt',
+  status: 'active',
+  cwd: process.cwd(),
+  intent: 'start native Codex turn and bind action ledger',
+  fileClaims: [
+    { path: 'packages/aria-connector/src/action-ledger-core.ts', intent: 'shared event spine', status: 'claimed' },
+  ],
+  skillReceipt: { ok: true, firedSkillCount: 122, floor: 50 },
+  runtimeReceipt: { ok: true, runtimes: 16 },
+  atlas: {
+    status: 'grounded',
+    contextHash: 'atlas-context-smoke',
+    snapshotId: 92,
+    verificationPredicates: ['action ledger projection contains Atlas context'],
+  },
+  sentinelFindings: [
+    { id: 1445, severity: 'high', source: 'codebase', kind: 'possible_command_injection', status: 'routed', target: 'src/sentinel/watchers/codebase.mjs' },
+  ],
+}, { home, projectId });
+
+assert.equal(first.ok, true);
+assert.equal(existsSync(first.paths.eventsPath), true, 'events jsonl missing');
+assert.equal(existsSync(first.paths.projectionPath), true, 'projection missing');
+assert.equal(first.projection.eventCount, 1);
+assert.equal(first.projection.latestAtlas?.contextHash, 'atlas-context-smoke');
+assert.equal(first.projection.sentinelFindings.length, 1);
+
+recordActionEventLocal({
+  surface: 'aria-task',
+  sessionId: 'aria-cli-task-runner',
+  threadId,
+  projectId,
+  taskId,
+  phaseId: '01-scope',
+  lifecyclePhase: 'task_qa',
+  status: 'repaired',
+  intent: 'QA found a low-risk gap and converted it into correction work',
+  qaReceipt: { ok: false, gaps: ['missing shared projection proof'] },
+  correctionPlan: { required: true, action: 'add projection smoke assertion' },
+  learningDelta: {
+    style: 'dalio_reflexion_i_tibaar',
+    lesson: 'Action ledger must feed the next phase projection before claims.',
+    nextAction: 'read projection before phase close',
+  },
+}, { home, projectId });
+
+const final = recordActionEventLocal({
+  surface: 'aria-task',
+  sessionId: 'aria-cli-task-runner',
+  threadId,
+  projectId,
+  taskId,
+  phaseId: '01-scope',
+  lifecyclePhase: 'task_complete',
+  status: 'completed',
+  intent: 'complete phase after projection evidence exists',
+  qaReceipt: { ok: true, gaps: [] },
+}, { home, projectId });
+
+const events = readActionLedgerEvents({ home, projectId, taskId });
+assert.equal(events.length, 3);
+const projection = projectActionLedger(events);
+assert.equal(projection.eventCount, 3);
+assert.equal(projection.tasks[taskId]?.status, 'completed');
+assert.equal(projection.tasks[taskId]?.activePhase, '01-scope');
+assert.equal(projection.correctionRequired, true, 'projection must preserve prior correction requirement until a consumer clears it explicitly');
+assert.equal(projection.latestLearningDelta?.lesson, 'Action ledger must feed the next phase projection before claims.');
+assert.equal(projection.latestQa?.ok, true);
+assert.equal(projection.latestAtlas?.contextHash, 'atlas-context-smoke');
+assert.equal(projection.sentinelFindings.length, 1);
+
+const paths = actionLedgerPaths({ home, projectId });
+const rawLines = readFileSync(paths.eventsPath, 'utf8').trim().split('\n');
+assert.equal(rawLines.length, 3);
+assert.equal(JSON.parse(readFileSync(paths.projectionPath, 'utf8')).eventCount, 3);
+
+const publishedRoutes = [];
+const published = await recordActionEvent({
+  surface: 'codex',
+  sessionId,
+  threadId,
+  projectId,
+  taskId,
+  phaseId: '02-execute',
+  lifecyclePhase: 'post_tool',
+  status: 'verified',
+  intent: 'publish action event through runtime adapter',
+  evidenceRefs: [{ kind: 'test_receipt', sha256: final.event.eventHash }],
+}, {
+  home,
+  projectId,
+  postJson: async (route, body) => {
+    publishedRoutes.push({ route, body });
+    return { ok: true, route };
+  },
+});
+
+assert.equal(published.ok, true);
+assert.equal(published.publication?.ok, true);
+assert.deepEqual(publishedRoutes.map((entry) => entry.route), [
+  '/api/hive/session-lifecycle',
+  '/api/hive/project-context',
+  '/task-project-ledger/event',
+]);
+assert.equal(publishedRoutes[0].body.body.action_event.schema, 'aria.action_event.v1');
+assert.equal(publishedRoutes[1].body.capsule.latest_action_event.event_id, published.event.eventId);
+assert.equal(publishedRoutes[2].body.evidence.actionEventHash, published.event.eventHash);
+
+const queued = await recordActionEvent({
+  surface: 'codex',
+  sessionId,
+  threadId,
+  projectId,
+  taskId,
+  phaseId: '03-replay',
+  lifecyclePhase: 'post_tool',
+  status: 'blocked',
+  intent: 'queue action event after runtime publish failure',
+}, {
+  home,
+  projectId,
+  postJson: async () => {
+    throw new Error('runtime offline for replay smoke');
+  },
+});
+assert.equal(queued.ok, false);
+let outbox = readActionLedgerPublishOutbox({ home, projectId });
+assert.equal(outbox.length, 1);
+assert.equal(outbox[0].event?.eventId, queued.event.eventId);
+
+const replayRoutes = [];
+const replay = await replayActionLedgerPublishOutbox({
+  home,
+  projectId,
+  postJson: async (route, body) => {
+    replayRoutes.push({ route, body });
+    return { ok: true, route };
+  },
+});
+assert.equal(replay.ok, true);
+assert.equal(replay.attempted, 1);
+assert.equal(replay.replayed, 1);
+assert.equal(replay.remaining, 0);
+assert.deepEqual(replayRoutes.map((entry) => entry.route), [
+  '/api/hive/session-lifecycle',
+  '/api/hive/project-context',
+  '/task-project-ledger/event',
+]);
+outbox = readActionLedgerPublishOutbox({ home, projectId });
+assert.equal(outbox.length, 0);
+
+console.log(JSON.stringify({
+  ok: true,
+  home,
+  projectId,
+  taskId,
+  events: readActionLedgerEvents({ home, projectId, taskId }).length,
+  publishedRoutes: publishedRoutes.map((entry) => entry.route),
+  replayedRoutes: replayRoutes.map((entry) => entry.route),
+}, null, 2));

package/scripts/self-test-approval-receipt-binding.mjs

@@ -0,0 +1,122 @@
+import { mkdir, writeFile } from 'node:fs/promises';
+import { homedir } from 'node:os';
+import path from 'node:path';
+
+import {
+  DEFAULT_SANDBOX_ROOT,
+} from '../dist/aria-connector/src/governed-surface-runner.js';
+import {
+  readConnectorProductionApproval,
+  requireGovernedConnectorMutation,
+} from '../dist/aria-connector/src/connectors/governed-adapter.js';
+
+function row(name, pass, evidence = {}) {
+  return { name, pass: pass === true, evidence };
+}
+
+async function writeApproval(name, body) {
+  const root = path.join(DEFAULT_SANDBOX_ROOT, 'approval-binding');
+  await mkdir(root, { recursive: true });
+  const filePath = path.join(root, `${name}.json`);
+  await writeFile(filePath, `${JSON.stringify(body, null, 2)}\n`, 'utf8');
+  return filePath;
+}
+
+async function expectBlocked(name, args, pattern) {
+  try {
+    await requireGovernedConnectorMutation(args);
+    return row(name, false, { blocked: false });
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    return row(name, pattern.test(message), { blocked: true, message });
+  }
+}
+
+async function run() {
+  const home = homedir();
+  const scratchRoot = path.join(DEFAULT_SANDBOX_ROOT, 'approval-binding', 'allowed');
+  await mkdir(scratchRoot, { recursive: true });
+  const validApproval = await writeApproval('valid', {
+    approved: true,
+    receipt: 'approval-binding-smoke-receipt',
+    allowedTargetRoots: [scratchRoot],
+    surfaceIds: ['codex'],
+    expiresAt: new Date(Date.now() + 60_000).toISOString(),
+    issuedBy: 'package-smoke',
+    reason: 'approval binding smoke',
+  });
+  const expiredApproval = await writeApproval('expired', {
+    approved: true,
+    receipt: 'expired-approval-binding-smoke-receipt',
+    allowedTargetRoots: [scratchRoot],
+    surfaceIds: ['codex'],
+    expiresAt: new Date(Date.now() - 60_000).toISOString(),
+  });
+
+  const priorApproved = process.env.ARIA_CONNECTOR_PRODUCTION_APPROVED;
+  const priorReceipt = process.env.ARIA_CONNECTOR_GOVERNANCE_RECEIPT;
+  process.env.ARIA_CONNECTOR_PRODUCTION_APPROVED = '1';
+  process.env.ARIA_CONNECTOR_GOVERNANCE_RECEIPT = 'env-only-receipt';
+  const envOnly = await expectBlocked('env_only_production_receipt_rejected', {
+    surfaceId: 'codex',
+    action: 'install',
+    targetPath: path.join(home, '.codex'),
+    reason: 'env-only approval smoke',
+    opts: { sessionId: `approval-binding-${process.pid}` },
+  }, /production_approval_file_required/);
+  if (priorApproved === undefined) delete process.env.ARIA_CONNECTOR_PRODUCTION_APPROVED;
+  else process.env.ARIA_CONNECTOR_PRODUCTION_APPROVED = priorApproved;
+  if (priorReceipt === undefined) delete process.env.ARIA_CONNECTOR_GOVERNANCE_RECEIPT;
+  else process.env.ARIA_CONNECTOR_GOVERNANCE_RECEIPT = priorReceipt;
+
+  const parsedValid = readConnectorProductionApproval({ approvalFile: validApproval });
+  const parsedExpired = readConnectorProductionApproval({ approvalFile: expiredApproval });
+  const activeTarget = await expectBlocked('approval_file_does_not_cover_active_target', {
+    surfaceId: 'codex',
+    action: 'install',
+    targetPath: path.join(home, '.codex'),
+    reason: 'approval active target scope smoke',
+    opts: {
+      approvalFile: validApproval,
+      sessionId: `approval-binding-${process.pid}`,
+    },
+  }, /target_outside_allowed_roots|production_approval_file_required|mutating_action_requires_verified_receipt/);
+  const wrongSurface = await expectBlocked('approval_file_surface_scope_enforced', {
+    surfaceId: 'opencode',
+    action: 'install',
+    targetPath: path.join(home, '.opencode'),
+    reason: 'approval surface scope smoke',
+    opts: {
+      approvalFile: validApproval,
+      sessionId: `approval-binding-${process.pid}`,
+    },
+  }, /production_approval_file_required|target_outside_allowed_roots|mutating_action_requires_verified_receipt/);
+
+  const rows = [
+    envOnly,
+    row('valid_approval_file_parses', parsedValid?.approved === true && parsedValid.receipt === 'approval-binding-smoke-receipt', {
+      parsed: Boolean(parsedValid),
+      roots: parsedValid?.allowedTargetRoots?.length ?? 0,
+    }),
+    row('expired_approval_file_rejected', parsedExpired === null, {
+      parsed: Boolean(parsedExpired),
+    }),
+    activeTarget,
+    wrongSurface,
+  ];
+
+  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);
+});

package/scripts/self-test-autofire-quality-output.mjs

@@ -0,0 +1,110 @@
+#!/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 repoRoot = path.resolve(connectorRoot, '..', '..');
+
+const continuationUserText =
+  'Continue Phase 40. Fire skills and wire QA-as-gate into the runtime continuation surfaces.';
+
+function blockerLabels(text, userText = continuationUserText) {
+  return analyzeDomainOutputQuality(text, { userText }).blockers;
+}
+
+function assertBlocks(label, text, expectedFragment, userText = continuationUserText) {
+  const blockers = blockerLabels(text, userText);
+  assert.ok(
+    blockers.some((blocker) => blocker.includes(expectedFragment)),
+    `${label} did not block on ${expectedFragment}; blockers=${JSON.stringify(blockers, null, 2)}`,
+  );
+}
+
+function assertPasses(label, text, userText = continuationUserText) {
+  const blockers = blockerLabels(text, userText);
+  assert.deepEqual(blockers, [], `${label} unexpectedly blocked: ${JSON.stringify(blockers, null, 2)}`);
+}
+
+const receiptDump = `[ARIA PLAYGROUND ACTIVE LIFECYCLE RUN]
+{
+  "namespace": "aria-playground",
+  "surface": "codex",
+  "phaseReceipts": [
+${Array.from({ length: 36 }, (_, index) => `    { "phase": "p${index}", "status": "executed", "receiptId": "r${index}" }`).join(',\n')}
+  ]
+}`;
+
+assertBlocks(
+  'receipt-heavy owner surface',
+  receiptDump,
+  'owner-visible answer is receipt-heavy',
+);
+
+assertPasses(
+  'raw receipt requested by owner',
+  receiptDump,
+  'Please print the exact active lifecycle JSON receipt block.',
+);
+
+assertBlocks(
+  'micro-step deferral',
+  'I can continue. What would you like me to do next?',
+  'must name the next highest-impact step',
+);
+
+assertBlocks(
+  'gate chasing default',
+  'Next step: add stricter gates around every final answer before allowing more work.',
+  'gate-chasing default detected',
+);
+
+assertPasses(
+  'qa-as-gate continuation closeout',
+  [
+    'Actual goal: wire extracted corpus into skills, runtimes, CLIs, connectors, and agent surfaces so output improves automatically.',
+    'Next highest-impact step: wire the QA-as-gate metric into Codex and Claude continuation surfaces.',
+    'QA-as-gate: expected owner-readable output, observed receipt-heavy drift risk, correction added stop-gate checks, verification passed focused smoke, learning recorded for the next action.',
+  ].join('\n'),
+);
+
+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');
+
+for (const [label, source] of [
+  ['codex connector', codexSource],
+  ['claude connector', claudeSource],
+]) {
+  assert.ok(source.includes('Autofire Quality Continuation Contract') || source.includes('ARIA_AUTOFIRE_QUALITY_CONTINUATION_CONTRACT'), `${label} missing autofire quality continuation contract`);
+  assert.ok(source.includes('Actual goal: wire extracted books'), `${label} missing actual goal wording`);
+  assert.ok(source.includes('Forced QA is the ordinary gate'), `${label} missing QA-as-gate wording`);
+  assert.ok(source.includes('Do not dump lifecycle receipts or raw JSON'), `${label} missing owner-readable receipt-dump guard`);
+}
+
+assert.ok(
+  stopGateSource.includes('userText: lastUserMessage'),
+  'stop gate must pass last user message into domain output QA',
+);
+
+console.log(
+  JSON.stringify(
+    {
+      ok: true,
+      receipt_heavy_rejected: true,
+      raw_receipt_request_allowed: true,
+      micro_step_rejected: true,
+      gate_chasing_rejected: true,
+      qa_as_gate_output_allowed: true,
+      codex_prompt_contract_present: true,
+      claude_prompt_contract_present: true,
+      stop_gate_user_context_present: true,
+      repoRoot,
+    },
+    null,
+    2,
+  ),
+);

package/scripts/self-test-claude-code-action-ledger.mjs

@@ -0,0 +1,132 @@
+#!/usr/bin/env node
+import { existsSync, mkdtempSync, readdirSync, readFileSync, rmSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join, resolve } from 'node:path';
+
+function fail(message, details = {}) {
+  process.stderr.write(`${JSON.stringify({ ok: false, message, ...details }, null, 2)}\n`);
+  process.exit(1);
+}
+
+function findProjection(home) {
+  const root = join(home, '.aria', 'action-ledger');
+  if (!existsSync(root)) fail('action ledger root was not created', { root });
+  const projectDirs = readdirSync(root, { withFileTypes: true }).filter((entry) => entry.isDirectory());
+  if (projectDirs.length !== 1) fail('expected one action ledger project directory', {
+    root,
+    projectDirs: projectDirs.map((entry) => entry.name),
+  });
+  const projectionPath = join(root, projectDirs[0].name, 'projection.json');
+  const eventsPath = join(root, projectDirs[0].name, 'events.jsonl');
+  const publishOutboxPath = join(root, projectDirs[0].name, 'publish-outbox.jsonl');
+  if (!existsSync(projectionPath)) fail('projection.json was not created', { projectionPath });
+  if (!existsSync(eventsPath)) fail('events.jsonl was not created', { eventsPath });
+  if (!existsSync(publishOutboxPath)) fail('publish-outbox.jsonl was not created', { publishOutboxPath });
+  const projection = JSON.parse(readFileSync(projectionPath, 'utf8'));
+  const events = readFileSync(eventsPath, 'utf8').split(/\r?\n/).filter(Boolean).map((line) => JSON.parse(line));
+  const publishOutbox = readFileSync(publishOutboxPath, 'utf8').split(/\r?\n/).filter(Boolean).map((line) => JSON.parse(line));
+  return { projectionPath, eventsPath, publishOutboxPath, projection, events, publishOutbox };
+}
+
+const home = mkdtempSync(join(tmpdir(), 'aria-claude-code-action-ledger-'));
+const priorHome = process.env.HOME;
+const priorAriaHome = process.env.ARIA_HOME;
+const priorSession = process.env.HOOK_SESSION_ID;
+const priorProject = process.env.ARIA_ACTION_LEDGER_PROJECT_ID;
+const priorTask = process.env.ARIA_ACTION_LEDGER_TASK_ID;
+
+try {
+  process.env.HOME = home;
+  process.env.ARIA_HOME = home;
+  process.env.HOOK_SESSION_ID = 'claude-code-action-ledger-smoke';
+  process.env.ARIA_ACTION_LEDGER_PROJECT_ID = 'claude-code-action-ledger-smoke';
+  process.env.ARIA_ACTION_LEDGER_TASK_ID = 'task-claude-code-action-ledger-smoke';
+
+  const helperPath = resolve(import.meta.dirname, '..', 'hooks', 'lib', 'aria-gate-ledger.mjs');
+  const { appendGateLedger } = await import(`${helperPath}?test=${Date.now()}`);
+
+  appendGateLedger({
+    hook: 'userprompt',
+    event: 'UserPromptSubmit',
+    decision: 'allow',
+    source: 'claude/userprompt',
+    reasonShort: 'Claude prompt accepted for pre-cognition',
+    sessionId: process.env.HOOK_SESSION_ID,
+  });
+  appendGateLedger({
+    hook: 'pre-tool-gate',
+    event: 'PreToolUse',
+    tool: 'Read',
+    decision: 'allow',
+    source: 'claude/pre-tool',
+    reasonShort: 'Claude read tool accepted',
+    meta: { fileClaims: [{ path: '/tmp/claude-code-action-ledger.txt', intent: 'read' }] },
+    sessionId: process.env.HOOK_SESSION_ID,
+  });
+  appendGateLedger({
+    hook: 'outcome-record',
+    event: 'PostToolUse',
+    tool: 'Read',
+    decision: 'allow',
+    source: 'claude/post-tool',
+    reasonShort: 'Claude read outcome recorded',
+    sessionId: process.env.HOOK_SESSION_ID,
+  });
+  appendGateLedger({
+    hook: 'stop-gate',
+    event: 'Stop',
+    decision: 'warn',
+    source: 'claude/stop',
+    reasonShort: 'Claude stop QA recorded a recoverable finding',
+    sessionId: process.env.HOOK_SESSION_ID,
+  });
+
+  const { projectionPath, eventsPath, publishOutboxPath, projection, events, publishOutbox } = findProjection(home);
+  const phases = new Set(events.map((event) => event.lifecyclePhase));
+  for (const phase of ['pre_cognition', 'pre_tool', 'post_tool', 'post_cognition']) {
+    if (!phases.has(phase)) fail('missing Claude action ledger phase', { phase, phases: [...phases] });
+  }
+  if (projection.eventCount !== 4) fail('unexpected projection event count', {
+    expected: 4,
+    observed: projection.eventCount,
+    projectionPath,
+  });
+  if (!events.every((event) => event.surface === 'claude-code')) {
+    fail('all events must be claude-code surface', { events });
+  }
+  if (!events.some((event) => event.lifecyclePhase === 'post_cognition' && event.status === 'repaired')) {
+    fail('warn stop decision must project as repaired post_cognition event', { events });
+  }
+  if (!events.some((event) => Array.isArray(event.fileClaims) && event.fileClaims.some((claim) => claim.path === '/tmp/claude-code-action-ledger.txt'))) {
+    fail('pre-tool file claim was not preserved', { events });
+  }
+  if (publishOutbox.length !== 4) {
+    fail('Claude action events must be queued for runtime replay', {
+      expected: 4,
+      observed: publishOutbox.length,
+      publishOutboxPath,
+    });
+  }
+  if (!publishOutbox.every((entry) => entry.event?.surface === 'claude-code')) {
+    fail('Claude publish outbox entries must preserve action events', { publishOutbox });
+  }
+
+  process.stdout.write(`${JSON.stringify({
+    ok: true,
+    home,
+    projectionPath,
+    eventsPath,
+    publishOutboxPath,
+    eventCount: projection.eventCount,
+    publishOutboxCount: publishOutbox.length,
+    phases: [...phases].sort(),
+    latestEvent: projection.latestEvent,
+  }, null, 2)}\n`);
+} finally {
+  if (priorHome === undefined) delete process.env.HOME; else process.env.HOME = priorHome;
+  if (priorAriaHome === undefined) delete process.env.ARIA_HOME; else process.env.ARIA_HOME = priorAriaHome;
+  if (priorSession === undefined) delete process.env.HOOK_SESSION_ID; else process.env.HOOK_SESSION_ID = priorSession;
+  if (priorProject === undefined) delete process.env.ARIA_ACTION_LEDGER_PROJECT_ID; else process.env.ARIA_ACTION_LEDGER_PROJECT_ID = priorProject;
+  if (priorTask === undefined) delete process.env.ARIA_ACTION_LEDGER_TASK_ID; else process.env.ARIA_ACTION_LEDGER_TASK_ID = priorTask;
+  rmSync(home, { recursive: true, force: true });
+}