@aria_asi/cli 0.2.40 → 0.2.41

package/scripts/self-test-substrate-output-quality-eval.mjs

@@ -0,0 +1,171 @@
+#!/usr/bin/env node
+
+import assert from 'node:assert/strict';
+import { createHash } from 'node:crypto';
+
+const runtimeUrl = process.env.ARIA_RUNTIME_URL || 'http://127.0.0.1:4319';
+
+const requiredSkills = [
+  'aria-cognition-autofire',
+  'tadabbur',
+  'qiyas-analogy',
+  'mizan',
+  'aria-quality-audit',
+  'aria-harness-substrate-binding',
+  'aria-ledger-fleet-execution',
+  'aria-repo-doctrine',
+  'aria-senior-code-audit',
+  'testing-strategy',
+];
+
+const baseBody = {
+  surface: 'codex',
+  surfaceId: 'substrate-output-quality-eval',
+  task: 'blind before-after substrate output quality eval for autofire wiring',
+  prompt: 'Plan the next engineering action for universal mechanical autofire. Require evidence, QA, correction, and ledger continuity.',
+  docs: [{ title: 'eval-fixture', content: 'same task text for both arms' }],
+  files: {},
+  metadata: {
+    source: 'self-test-substrate-output-quality-eval',
+    universalTurnPacket: true,
+    requiredSkills,
+  },
+  requiredSkills,
+};
+
+function sha256(value) {
+  return createHash('sha256').update(String(value)).digest('hex');
+}
+
+async function postPrompt(body) {
+  const endpoint = `${runtimeUrl.replace(/\/+$/, '')}/build-system-prompt`;
+  let lastError = null;
+  for (let attempt = 1; attempt <= 4; attempt += 1) {
+    try {
+      const response = await fetch(endpoint, {
+        method: 'POST',
+        headers: { 'content-type': 'application/json' },
+        body: JSON.stringify(body),
+      });
+      if (response.ok || attempt === 4) {
+        assert.equal(response.ok, true, `runtime /build-system-prompt status=${response.status}`);
+        return response.json();
+      }
+      lastError = new Error(`runtime /build-system-prompt status=${response.status}`);
+    } catch (error) {
+      lastError = error;
+    }
+    await new Promise((resolve) => setTimeout(resolve, 300 * attempt));
+  }
+  throw lastError || new Error('runtime /build-system-prompt did not return a response');
+}
+
+function summarizeArm(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 || {};
+  const hasFullSkillBodies = prompt.includes('<skill_content ');
+  const hasForcedBodyBlock = prompt.includes('ARIA RUNTIME FORCED SKILL LOAD');
+  const hasMechanicalReceiptBlock = prompt.includes('ARIA MECHANICAL SKILL EXECUTION RECEIPT');
+  const hasSubstrateReceipt = substrate.ok === true && substrate.mode === 'deterministic_sidecar_kernel';
+  const hasQaCorrection = qaCorrection.ok === true || qaCorrection.learningFeedsNextSelection === true;
+  const hasQiyasTadabbur = cognitive?.tadabbur?.stageCount === 12 && cognitive?.qiyas?.perspectiveCount === 15;
+  const promptChars = prompt.length;
+  const promptBudgetOk = promptChars < 75000;
+  const scoreItems = [
+    hasMechanicalReceiptBlock,
+    hasSubstrateReceipt,
+    Array.isArray(substrate.executedOperatorIds) && substrate.executedOperatorIds.length >= 25,
+    hasQaCorrection,
+    hasQiyasTadabbur,
+    promptBudgetOk,
+    !hasFullSkillBodies,
+    !hasForcedBodyBlock,
+  ];
+  return {
+    label,
+    promptSha256: sha256(prompt),
+    promptChars,
+    hasFullSkillBodies,
+    hasForcedBodyBlock,
+    hasMechanicalReceiptBlock,
+    hasSubstrateReceipt,
+    executedSkillCount: Array.isArray(receipt.executedSkillIds) ? receipt.executedSkillIds.length : 0,
+    executedOperatorCount: Array.isArray(substrate.executedOperatorIds) ? substrate.executedOperatorIds.length : 0,
+    hasQaCorrection,
+    hasQiyasTadabbur,
+    promptBudgetOk,
+    qualityScore: scoreItems.filter(Boolean).length,
+  };
+}
+
+function blindScore(summaries) {
+  const blinded = summaries
+    .map((summary) => ({
+      blindId: `arm-${sha256(summary.promptSha256).slice(0, 8)}`,
+      hiddenLabel: summary.label,
+      features: {
+        promptChars: summary.promptChars,
+        hasFullSkillBodies: summary.hasFullSkillBodies,
+        hasForcedBodyBlock: summary.hasForcedBodyBlock,
+        hasMechanicalReceiptBlock: summary.hasMechanicalReceiptBlock,
+        hasSubstrateReceipt: summary.hasSubstrateReceipt,
+        executedOperatorCount: summary.executedOperatorCount,
+        hasQaCorrection: summary.hasQaCorrection,
+        hasQiyasTadabbur: summary.hasQiyasTadabbur,
+        promptBudgetOk: summary.promptBudgetOk,
+      },
+      qualityScore: summary.qualityScore,
+    }))
+    .sort((left, right) => left.blindId.localeCompare(right.blindId));
+  const ranked = [...blinded].sort((left, right) => right.qualityScore - left.qualityScore);
+  return { blinded, ranked };
+}
+
+const baseline = await postPrompt({
+  ...baseBody,
+  sessionId: `substrate-output-quality-baseline-${Date.now()}`,
+  skillExecutionMode: 'full-prompt',
+  metadata: {
+    ...baseBody.metadata,
+    skillExecutionMode: 'full-prompt',
+  },
+});
+
+const substrate = await postPrompt({
+  ...baseBody,
+  sessionId: `substrate-output-quality-mechanical-${Date.now()}`,
+  skillExecutionMode: 'mechanical-receipt',
+  metadata: {
+    ...baseBody.metadata,
+    skillExecutionMode: 'mechanical-receipt',
+  },
+});
+
+assert.equal(baseline.ok, true, 'baseline prompt build ok');
+assert.equal(substrate.ok, true, 'substrate prompt build ok');
+
+const baselineSummary = summarizeArm('before_full_prompt_body_load', baseline);
+const substrateSummary = summarizeArm('after_mechanical_substrate_execution', substrate);
+const blind = blindScore([baselineSummary, substrateSummary]);
+const winner = blind.ranked[0];
+
+assert.equal(substrateSummary.hasSubstrateReceipt, true, 'after arm has substrate execution receipt');
+assert.equal(substrateSummary.hasMechanicalReceiptBlock, true, 'after arm has mechanical receipt block');
+assert.equal(substrateSummary.hasFullSkillBodies, false, 'after arm does not stuff full skill bodies');
+assert.equal(substrateSummary.hasForcedBodyBlock, false, 'after arm does not include forced body block');
+assert.ok(substrateSummary.executedOperatorCount >= 25, 'after arm executes at least 25 operators');
+assert.ok(substrateSummary.qualityScore > baselineSummary.qualityScore, 'after arm wins blind quality score');
+assert.equal(winner.hiddenLabel, 'after_mechanical_substrate_execution', 'blind winner is the mechanical substrate arm');
+
+console.log(JSON.stringify({
+  ok: true,
+  test: 'substrate-output-quality-eval',
+  blindWinner: winner.blindId,
+  baseline: baselineSummary,
+  substrate: substrateSummary,
+  scoreDelta: substrateSummary.qualityScore - baselineSummary.qualityScore,
+  blindRanked: blind.ranked.map(({ blindId, qualityScore }) => ({ blindId, qualityScore })),
+}, null, 2));

package/scripts/self-test-task-closeout-drift.mjs

@@ -0,0 +1,97 @@
+#!/usr/bin/env node
+
+import assert from 'node:assert/strict';
+import { mkdtempSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import path from 'node:path';
+import { spawnSync } from 'node:child_process';
+import { fileURLToPath } from 'node:url';
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const packageRoot = path.resolve(__dirname, '..');
+const repoRoot = path.resolve(packageRoot, '..', '..');
+const ariaHome = mkdtempSync(path.join(tmpdir(), 'aria-task-closeout-drift-'));
+const taskRoot = path.join(ariaHome, '.aria', 'cli-tasks');
+mkdirSync(taskRoot, { recursive: true, mode: 0o700 });
+
+const taskId = 'closeout-drift-smoke';
+const state = {
+  schema: 'aria.cli_task.v2',
+  taskId,
+  goal: 'Detect checkpoint plus QA evidence that was not reconciled into phase state.',
+  cwd: repoRoot,
+  status: 'active',
+  createdAt: '2026-05-16T00:00:00.000Z',
+  updatedAt: '2026-05-16T00:01:00.000Z',
+  requiredSkills: [],
+  forcedSkillLoad: null,
+  projectContext: null,
+  qualityLoops: [{
+    at: '2026-05-16T00:03:00.000Z',
+    taskId,
+    phaseId: 'unknown',
+    source: 'qa',
+    qaFile: '/tmp/PHASE_02_TURN_SUBSTRATE_PACKET_HARDENING_QA.md',
+    ok: true,
+    gaps: [],
+    artifactSha256: 'abc123',
+  }],
+  checkpoints: [{
+    at: '2026-05-16T00:02:00.000Z',
+    phase: '02-implement-turn-substrate-qa-packet',
+    summary: 'Evidence exists, but phase state did not close.',
+    evidence: 'synthetic fixture',
+  }],
+  phases: [
+    {
+      phaseId: '01-scope',
+      title: 'scope',
+      status: 'completed',
+      createdAt: '2026-05-16T00:00:00.000Z',
+      startedAt: '2026-05-16T00:00:00.000Z',
+      completedAt: '2026-05-16T00:01:00.000Z',
+      attempts: 1,
+    },
+    {
+      phaseId: '02-02-implement-turn-substrate-qa-packet',
+      title: '02-implement-turn-substrate-qa-packet',
+      status: 'pending',
+      createdAt: '2026-05-16T00:00:00.000Z',
+      attempts: 0,
+    },
+  ],
+  activePhaseId: null,
+  recovery: { attempts: 0, lastReason: null, lastAt: null },
+};
+
+writeFileSync(path.join(taskRoot, `${taskId}.json`), `${JSON.stringify(state, null, 2)}\n`, { mode: 0o600 });
+
+const result = spawnSync(process.execPath, [
+  path.join(packageRoot, 'bin', 'aria.js'),
+  'task',
+  'status',
+  taskId,
+], {
+  cwd: repoRoot,
+  env: {
+    ...process.env,
+    ARIA_HOME: ariaHome,
+    ARIA_RUNTIME_URL: 'http://127.0.0.1:9',
+  },
+  encoding: 'utf8',
+  maxBuffer: 1024 * 1024,
+});
+
+assert.equal(result.status, 0, `aria task status must succeed with runtime health captured as unavailable: ${result.stderr || result.stdout}`);
+const payload = JSON.parse(result.stdout);
+assert.equal(payload.partialCloseoutDrift.kind, 'partial_closeout_drift');
+assert.equal(payload.partialCloseoutDrift.driftedPhaseCount, 1);
+assert.equal(payload.partialCloseoutDrift.driftedPhases[0].phaseId, '02-02-implement-turn-substrate-qa-packet');
+assert.equal(payload.partialCloseoutDrift.driftedPhases[0].artifactSha256, 'abc123');
+
+console.log(JSON.stringify({
+  ok: true,
+  checked: 'partial_closeout_drift',
+  taskId,
+  driftedPhaseCount: payload.partialCloseoutDrift.driftedPhaseCount,
+}, null, 2));

package/scripts/self-test-task-project-ledger-readiness.mjs

@@ -0,0 +1,43 @@
+#!/usr/bin/env node
+
+import assert from 'node:assert/strict';
+import { mkdtempSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import path from 'node:path';
+import { updateTaskProjectLedger } from '../opencode-plugins/harness-context/task-project-ledger.mjs';
+
+const ledgerRoot = mkdtempSync(path.join(tmpdir(), 'aria-task-project-ledger-'));
+const env = {
+  ...process.env,
+  ARIA_TASK_PROJECT_LEDGER_DIR: ledgerRoot,
+};
+
+const result = updateTaskProjectLedger({
+  platform: 'aria-cli-task',
+  phase: 'phase_complete',
+  source: 'task-project-ledger-readiness-smoke',
+  event: {
+    taskId: 'task-ledger-readiness-smoke',
+    cwd: '/tmp/readiness-project',
+    goal: 'Verify task/project ledger readiness gates understand task goals and nested QA evidence.',
+  },
+  evidence: {
+    qa: { ok: true, gaps: [] },
+    qaLearningLoop: { ok: true, gaps: [] },
+    endPhaseQaAutofire: { verdict: 'verified' },
+  },
+  env,
+});
+
+assert.equal(result.ledger.qualityGates.intent_boundary.status, 'passed');
+assert.equal(result.ledger.qualityGates.scope_boundary.status, 'passed');
+assert.equal(result.ledger.qualityGates.verification_trace.status, 'passed');
+assert.equal(result.ledger.controls.readinessClaimAllowed, true);
+assert.deepEqual(result.ledger.controls.missingReadinessGates, []);
+
+console.log(JSON.stringify({
+  ok: true,
+  checked: 'task_project_ledger_readiness',
+  ledgerPath: result.paths.ledgerPath,
+  readinessClaimAllowed: result.ledger.controls.readinessClaimAllowed,
+}, null, 2));

package/scripts/self-test-task-runner-phase-consumer.mjs

@@ -0,0 +1,134 @@
+import assert from 'node:assert/strict';
+import { existsSync, mkdtempSync, readFileSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import path from 'node:path';
+import { spawnSync } from 'node:child_process';
+
+const repoRoot = path.resolve(import.meta.dirname, '..', '..', '..');
+const packageRoot = path.resolve(repoRoot, 'packages', 'aria-connector');
+const taskRunnerSource = readFileSync(path.join(packageRoot, 'src', 'task-runner.ts'), 'utf8');
+
+function includesAll(label, text, markers) {
+  const missing = markers.filter((marker) => !text.includes(marker));
+  assert.deepEqual(missing, [], `${label} missing markers: ${missing.join(', ')}`);
+}
+
+includesAll('task runner phase consumer source', taskRunnerSource, [
+  'UNIVERSAL_TURN_PACKET_SKILLS',
+  'UNIVERSAL_TURN_PACKET_PHASES',
+  "skillExecutionMode: 'mechanical-receipt'",
+  'universalTurnPacket: true',
+  'aria.task_phase_consumer_receipt.v1',
+  'function buildTaskPhaseConsumerReceipt',
+  'function appendTaskPhaseConsumerReceipt',
+  'async function consumeTaskPhaseBoundary',
+  'taskConsumerReceipts',
+  'consumerReceipts',
+  'run_loop_forced_skill_refire',
+  'run_loop_pre_phase_receipt',
+  'run_loop_mid_phase_receipt',
+  'run_loop_phase_qa_failed',
+  'run_loop_recovery_cycle',
+  'run_loop_phase_complete',
+  'async function closeTask',
+  'task_close_blocked',
+  'task_closed',
+  "subCommand === 'close' || subCommand === 'finalize'",
+  'dalio_reflexion_i_tibaar',
+  'fullSkillBodiesInjected',
+  'cognitiveRuntimeReceipts',
+  'hiveObserverSourceTopology',
+  'qaSkillCount',
+  'correctionSkillCount',
+]);
+
+if (process.env.ARIA_TASK_RUNNER_PHASE_CONSUMER_LIVE_SMOKE === '1') {
+  const ariaHome = mkdtempSync(path.join(tmpdir(), 'aria-task-runner-phase-consumer-'));
+  const taskId = `phase-consumer-${process.pid}`;
+  const ariaBin = path.join(packageRoot, 'bin', 'aria.js');
+  const env = {
+    ...process.env,
+    ARIA_HOME: ariaHome,
+  };
+
+  function runAria(args, expectedStatus = 0) {
+    const result = spawnSync(process.execPath, [ariaBin, 'task', ...args], {
+      cwd: repoRoot,
+      encoding: 'utf8',
+      env,
+      maxBuffer: 20 * 1024 * 1024,
+    });
+    assert.equal(result.status, expectedStatus, [
+      `aria task ${args.join(' ')} exited ${result.status}`,
+      result.stdout,
+      result.stderr,
+    ].join('\n'));
+    return result;
+  }
+
+  runAria([
+    'start',
+    '--id',
+    taskId,
+    '--goal',
+    'live smoke for task-runner universal phase consumer receipt',
+    '--phases',
+    'wire consumer receipt',
+  ]);
+  runAria(['next', taskId]);
+  runAria([
+    'run',
+    taskId,
+    '--summary',
+    'phase consumer receipt smoke executed',
+    '--evidence',
+    'live aria task parent loop with auto QA',
+    '--auto-qa',
+  ]);
+  const status = runAria(['status', taskId]);
+  const statusJson = JSON.parse(status.stdout);
+  assert.equal(statusJson.actionLedger.eventCount >= 4, true, 'aria task status must expose action ledger events');
+  assert.equal(Boolean(statusJson.actionLedger.task), true, 'aria task status must expose task action-ledger projection');
+  assert.equal(statusJson.actionLedger.task.taskId, taskId, 'action ledger task projection must match active task');
+  assert.equal(typeof statusJson.actionLedger.latestEvent?.eventId, 'string', 'action ledger latest event missing');
+
+  const statePath = path.join(ariaHome, '.aria', 'cli-tasks', `${taskId}.json`);
+  assert.equal(existsSync(statePath), true, `missing state path: ${statePath}`);
+  const state = JSON.parse(readFileSync(statePath, 'utf8'));
+  assert.equal(state.schema, 'aria.cli_task.v2');
+  assert.ok(Array.isArray(state.taskConsumerReceipts) && state.taskConsumerReceipts.length >= 4, 'task consumer receipts must persist');
+  assert.ok(Array.isArray(state.phases?.[0]?.consumerReceipts) && state.phases[0].consumerReceipts.length >= 3, 'phase consumer receipts must persist');
+  assert.ok(state.requiredSkills.length >= 38, `required skills must include universal packet skills; observed=${state.requiredSkills.length}`);
+  assert.equal(state.forcedSkillLoad.skillExecutionMode, 'mechanical-receipt');
+  assert.equal(state.forcedSkillLoad.fullSkillBodiesInjected, false);
+  assert.ok(state.forcedSkillLoad.loadedCount >= 25, `loadedCount below floor: ${state.forcedSkillLoad.loadedCount}`);
+  assert.ok(state.forcedSkillLoad.activeRuntimeCount >= 16, `activeRuntimeCount below floor: ${state.forcedSkillLoad.activeRuntimeCount}`);
+  assert.ok(state.forcedSkillLoad.activePrimitiveCount >= 24, `activePrimitiveCount below floor: ${state.forcedSkillLoad.activePrimitiveCount}`);
+  assert.ok(state.forcedSkillLoad.activeMappingCount >= 24, `activeMappingCount below floor: ${state.forcedSkillLoad.activeMappingCount}`);
+  assert.equal(state.forcedSkillLoad.cognitiveRuntimeReceipts?.tadabbur?.stageCount, 12);
+  assert.equal(state.forcedSkillLoad.cognitiveRuntimeReceipts?.qiyas?.perspectiveCount, 15);
+  assert.equal(state.phases[0].status, 'completed');
+
+  const close = runAria([
+    'close',
+    taskId,
+    '--summary',
+    'phase consumer close command smoke finalized the task',
+    '--evidence',
+    'all phases completed and close gates passed',
+  ]);
+  const closeJson = JSON.parse(close.stdout);
+  assert.equal(closeJson.ok, true, 'aria task close must pass after all phases complete');
+  assert.equal(closeJson.status, 'completed', 'aria task close must mark task completed');
+  assert.ok(closeJson.forcedSkillLoad.requiredCount >= 50, `close summary requiredCount below floor: ${closeJson.forcedSkillLoad.requiredCount}`);
+  assert.ok(closeJson.forcedSkillLoad.loadedCount >= 50, `close summary loadedCount below floor: ${closeJson.forcedSkillLoad.loadedCount}`);
+  assert.ok(closeJson.forcedSkillLoad.firedSkillCount >= 50, `close summary firedSkillCount below floor: ${closeJson.forcedSkillLoad.firedSkillCount}`);
+  const closedState = JSON.parse(readFileSync(statePath, 'utf8'));
+  assert.equal(closedState.status, 'completed', 'closed task state must persist completed status');
+  assert.equal(closedState.activePhaseId, null, 'closed task must not retain activePhaseId');
+}
+
+process.stdout.write(`${JSON.stringify({
+  ok: true,
+  liveSmoke: process.env.ARIA_TASK_RUNNER_PHASE_CONSUMER_LIVE_SMOKE === '1',
+}, null, 2)}\n`);