@aria_asi/cli 0.2.39 → 0.2.41

package/scripts/self-test-live-codex-posttool-packet-smoke.mjs

@@ -0,0 +1,111 @@
+#!/usr/bin/env node
+import assert from 'node:assert/strict';
+import { spawnSync } from 'node:child_process';
+import { pathToFileURL } from 'node:url';
+
+const runtimeClient = await import(pathToFileURL('/home/hamzaibrahim1/.codex/hooks/lib/runtime-client.mjs'));
+
+const {
+  buildTurnSubstratePacket,
+  writeTurnSubstratePacket,
+  saveTurnState,
+  loadTurnState,
+} = runtimeClient;
+
+const firedSkillIds = Array.from({ length: 26 }, (_, index) => `skill-${index + 1}`);
+const threadId = `phase70-posttool-${Date.now()}`;
+const producerSessionId = `codex:${threadId}:producer`;
+const consumerSessionId = `codex:${threadId}:consumer`;
+const hiveThreadId = `codex:${threadId}`;
+const forcedSkillLoad = {
+  loadedSkillIds: firedSkillIds,
+  skillExecutionReceipt: { firedSkillIds },
+};
+
+const producerState = {
+  sessionId: producerSessionId,
+  hiveThreadId,
+  traceId: `trace-${threadId}`,
+  userText: 'continue corpus-to-runtime wiring with post-tool correction-first QA',
+  readiness: {
+    status: 'ready',
+    currentPhase: 'ready',
+    progress: 100,
+  },
+  forcedSkillLoad,
+  requiredSkills: firedSkillIds,
+  preReceiptId: `pre-${threadId}`,
+};
+
+const packet = buildTurnSubstratePacket({
+  sessionId: producerSessionId,
+  event: { thread_id: threadId, turn_id: 'producer' },
+  state: producerState,
+  phase: 'pre_prompt_ready',
+  action: 'bind_packet',
+  text: producerState.userText,
+});
+
+const writeResult = writeTurnSubstratePacket(packet, {
+  sessionId: producerSessionId,
+  event: { thread_id: threadId, turn_id: 'producer' },
+  state: producerState,
+});
+assert.equal(writeResult.ok, true, 'producer packet write succeeds');
+
+saveTurnState(consumerSessionId, {
+  sessionId: consumerSessionId,
+  hiveThreadId,
+  traceId: `trace-${threadId}`,
+  userText: producerState.userText,
+  preReceiptId: `pre-${threadId}`,
+  forcedSkillLoad,
+  requiredSkills: firedSkillIds,
+});
+
+const event = {
+  thread_id: threadId,
+  turn_id: 'consumer',
+  tool_name: 'functions.exec_command',
+  tool_input: {
+    cmd: 'node --check packages/aria-connector/hooks/codex-native/lib/runtime-client.mjs',
+  },
+  tool_response: {
+    status: 0,
+    stdout: 'exit 0',
+    stderr: '',
+  },
+};
+
+const postTool = spawnSync('node', ['/home/hamzaibrahim1/.codex/hooks/aria-post-tool-use.mjs'], {
+  input: JSON.stringify(event),
+  encoding: 'utf8',
+  env: {
+    ...process.env,
+    ARIA_REMOTE_COACH_ENABLED: '0',
+  },
+});
+
+assert.equal(postTool.status, 0, `posttool hook exits 0: stdout=${postTool.stdout} stderr=${postTool.stderr}`);
+assert.equal(postTool.stdout.trim(), '', 'posttool hook did not emit a block payload');
+
+const consumerState = loadTurnState(consumerSessionId);
+assert.equal(consumerState.turnSubstratePacket?.schema, 'aria.turn_substrate_packet.v1', 'consumer state has turn packet');
+assert.equal(consumerState.turnPacketConsumerReceipt?.schema, 'aria.turn_packet_consumer_receipt.v1', 'posttool records consumer receipt');
+assert.equal(consumerState.turnPacketConsumerReceipt?.phase, 'post_tool', 'consumer receipt records post_tool phase');
+assert.notEqual(consumerState.turnSubstrateQaKernel?.hardBlock, true, 'consumer posttool QA kernel did not hard-block');
+assert.ok(
+  ['pass', 'repair'].includes(consumerState.turnSubstrateQaKernel?.decision),
+  `consumer QA decision is pass or repair, got ${consumerState.turnSubstrateQaKernel?.decision}`,
+);
+assert.ok(Array.isArray(consumerState.toolOutputs) && consumerState.toolOutputs.length > 0, 'posttool stores observed tool output');
+
+console.log(JSON.stringify({
+  ok: true,
+  checked: [
+    'live posttool hook consumes canonical turn packet',
+    'posttool records packet consumer receipt',
+    'posttool stores observed result before QA continuation',
+    'QA kernel state persisted to consumer turn',
+  ],
+}, null, 2));

package/scripts/self-test-live-codex-pretool-packet-smoke.mjs

@@ -0,0 +1,101 @@
+#!/usr/bin/env node
+import assert from 'node:assert/strict';
+import { spawnSync } from 'node:child_process';
+import { pathToFileURL } from 'node:url';
+
+const runtimeClient = await import(pathToFileURL('/home/hamzaibrahim1/.codex/hooks/lib/runtime-client.mjs'));
+
+const {
+  buildTurnSubstratePacket,
+  writeTurnSubstratePacket,
+  saveTurnState,
+  loadTurnState,
+} = runtimeClient;
+
+const firedSkillIds = Array.from({ length: 26 }, (_, index) => `skill-${index + 1}`);
+const threadId = `phase69-pretool-${Date.now()}`;
+const producerSessionId = `codex:${threadId}:producer`;
+const consumerSessionId = `codex:${threadId}:consumer`;
+const hiveThreadId = `codex:${threadId}`;
+const forcedSkillLoad = {
+  loadedSkillIds: firedSkillIds,
+  skillExecutionReceipt: { firedSkillIds },
+};
+
+const producerState = {
+  sessionId: producerSessionId,
+  hiveThreadId,
+  traceId: `trace-${threadId}`,
+  userText: 'continue corpus-to-runtime wiring with recovery-first QA',
+  readiness: {
+    status: 'ready',
+    currentPhase: 'ready',
+    progress: 100,
+  },
+  forcedSkillLoad,
+  requiredSkills: firedSkillIds,
+  preReceiptId: `pre-${threadId}`,
+};
+
+const packet = buildTurnSubstratePacket({
+  sessionId: producerSessionId,
+  event: { thread_id: threadId, turn_id: 'producer' },
+  state: producerState,
+  phase: 'pre_prompt_ready',
+  action: 'bind_packet',
+  text: producerState.userText,
+});
+
+const writeResult = writeTurnSubstratePacket(packet, {
+  sessionId: producerSessionId,
+  event: { thread_id: threadId, turn_id: 'producer' },
+  state: producerState,
+});
+assert.equal(writeResult.ok, true, 'producer packet write succeeds');
+
+saveTurnState(consumerSessionId, {
+  sessionId: consumerSessionId,
+  hiveThreadId,
+  traceId: `trace-${threadId}`,
+  userText: producerState.userText,
+  preReceiptId: `pre-${threadId}`,
+  requiredSkills: firedSkillIds,
+});
+
+const event = {
+  thread_id: threadId,
+  turn_id: 'consumer',
+  tool_name: 'Read',
+  tool_input: {
+    file_path: 'packages/aria-connector/src/connectors/codex.ts',
+  },
+};
+
+const preTool = spawnSync('node', ['/home/hamzaibrahim1/.codex/hooks/aria-pre-tool-use.mjs'], {
+  input: JSON.stringify(event),
+  encoding: 'utf8',
+  env: {
+    ...process.env,
+    ARIA_REMOTE_COACH_ENABLED: '0',
+  },
+});
+
+assert.equal(preTool.status, 0, `pretool hook exits 0: stdout=${preTool.stdout} stderr=${preTool.stderr}`);
+assert.equal(preTool.stdout.trim(), '', 'pretool hook did not emit a block payload');
+
+const consumerState = loadTurnState(consumerSessionId);
+assert.equal(consumerState.turnSubstratePacket?.schema, 'aria.turn_substrate_packet.v1', 'consumer state has turn packet');
+assert.notEqual(consumerState.turnSubstrateQaKernel?.hardBlock, true, 'consumer pretool QA kernel did not hard-block');
+assert.ok(
+  ['pass', 'repair'].includes(consumerState.turnSubstrateQaKernel?.decision),
+  `consumer QA decision is pass or repair, got ${consumerState.turnSubstrateQaKernel?.decision}`,
+);
+
+console.log(JSON.stringify({
+  ok: true,
+  checked: [
+    'live pretool hook consumes canonical turn packet',
+    'cross-turn readiness split-brain does not hard-block read tool',
+    'QA kernel state persisted to consumer turn',
+  ],
+}, null, 2));

package/scripts/self-test-live-codex-stop-qa-kernel-smoke.mjs

@@ -0,0 +1,43 @@
+#!/usr/bin/env node
+import assert from 'node:assert/strict';
+import { spawnSync } from 'node:child_process';
+
+function runStop(event) {
+  return spawnSync('node', ['/home/hamzaibrahim1/.codex/hooks/aria-stop.mjs'], {
+    encoding: 'utf8',
+    env: {
+      ...process.env,
+      ARIA_HOOK_EVENT_JSON: JSON.stringify(event),
+      ARIA_REMOTE_COACH_ENABLED: '0',
+      ARIA_RUNTIME_URL: 'http://127.0.0.1:9',
+    },
+  });
+}
+
+const lowRisk = runStop({
+  thread_id: `phase69-stop-low-${Date.now()}`,
+  turn_id: 'stop',
+  last_assistant_message: 'Bounded status: packet QA local checks passed; runtime stop smoke remains pending evidence.',
+});
+
+assert.equal(lowRisk.status, 0, `low-risk stop exits 0: stdout=${lowRisk.stdout} stderr=${lowRisk.stderr}`);
+assert.deepEqual(JSON.parse(lowRisk.stdout), { continue: true }, 'low-risk runtime failure becomes continue with recorded QA packet');
+
+const hardRisk = runStop({
+  thread_id: `phase69-stop-hard-${Date.now()}`,
+  turn_id: 'stop',
+  last_assistant_message: 'This is production ready and verified for release to users.',
+});
+
+assert.equal(hardRisk.status, 0, `hard-risk stop exits 0 with block JSON: stderr=${hardRisk.stderr}`);
+const hardPayload = JSON.parse(hardRisk.stdout);
+assert.equal(hardPayload.decision, 'block', 'hard-risk stop emits block decision');
+assert.match(hardPayload.reason, /hard-risk/i, 'hard-risk block names hard-risk QA path');
+
+console.log(JSON.stringify({
+  ok: true,
+  checked: [
+    'low-risk runtime stop exception records QA and continues',
+    'hard-risk runtime stop exception blocks',
+  ],
+}, null, 2));

package/scripts/self-test-live-wrapper-substrate-inventory.mjs

@@ -0,0 +1,149 @@
+#!/usr/bin/env node
+
+import assert from 'node:assert/strict';
+import { createHash } from 'node:crypto';
+import { existsSync, readFileSync } from 'node:fs';
+import { homedir } from 'node:os';
+import path from 'node:path';
+
+const HOME = process.env.HOME || homedir();
+const repoRoot = path.resolve(import.meta.dirname, '..', '..', '..');
+
+function sha256(text) {
+  return createHash('sha256').update(String(text)).digest('hex');
+}
+
+function readRequired(filePath) {
+  assert.equal(existsSync(filePath), true, `required live path missing: ${filePath}`);
+  return readFileSync(filePath, 'utf8');
+}
+
+function checkMarkers(label, filePath, markers) {
+  const text = readRequired(filePath);
+  const missing = markers.filter((marker) => !text.includes(marker));
+  return {
+    label,
+    path: filePath,
+    ok: missing.length === 0,
+    missing,
+    sha256: sha256(text),
+  };
+}
+
+const checks = [
+  checkMarkers('codex config managed hooks', path.join(HOME, '.codex', 'config.toml'), [
+    'BEGIN ARIA MANAGED HOOKS',
+    'aria-userprompt-submit.mjs',
+    'aria-pre-tool-use.mjs',
+    'aria-post-tool-use.mjs',
+    'aria-stop.mjs',
+  ]),
+  checkMarkers('codex wrapper async universal packet', path.join(HOME, '.aria', 'wrappers', 'codex'), [
+    'ARIA_UNIVERSAL_TURN_PACKET_SCRIPT="$HOME/.aria/runtime/hooks/aria-universal-turn-packet.mjs"',
+    'aria_codex_start_async_bootstrap',
+    'ARIA_SURFACE_ID="codex"',
+    'ARIA_TURN_USER_TEXT="$*"',
+  ]),
+  checkMarkers('codex live userprompt hook', path.join(HOME, '.codex', 'hooks', 'aria-userprompt-submit.mjs'), [
+    'updateTaskProjectLedger',
+    'recordCodexActionEvent',
+    'publishCodexActionEventToRuntime',
+    'buildTurnSubstratePacket',
+    'universalTurnPacket: true',
+    "skillExecutionMode: 'mechanical-receipt'",
+  ]),
+  checkMarkers('codex live runtime client validator', path.join(HOME, '.codex', 'hooks', 'lib', 'runtime-client.mjs'), [
+    'ARIA_CODEX_UNIVERSAL_RUNTIME_FLOOR',
+    'ARIA_CODEX_UNIVERSAL_PRIMITIVE_FLOOR',
+    'ARIA_CODEX_UNIVERSAL_MAPPING_FLOOR',
+    'universalTurnPacketGaps',
+    'universal Hive observer/source topology receipt missing or failed',
+  ]),
+  checkMarkers('mounted runtime universal packet hook', path.join(HOME, '.aria', 'runtime', 'hooks', 'aria-universal-turn-packet.mjs'), [
+    'SKILL_FLOOR = 50',
+    'RUNTIME_FLOOR = 16',
+    'PRIMITIVE_FLOOR = 24',
+    'MAPPING_FLOOR = 24',
+    "skillExecutionMode: 'mechanical-receipt'",
+    'hive_observer_source_topology_missing_or_under_floor',
+    'schema: \'aria.universal_turn_packet.live_entrypoint.v1\'',
+  ]),
+  checkMarkers('claude settings userprompt universal packet', path.join(HOME, '.claude', 'settings.json'), [
+    'ARIA_SURFACE_ID=claude-code HOOK_EVENT_NAME=UserPromptSubmit node $HOME/.claude/hooks/aria-universal-turn-packet.mjs',
+    'aria-hive-wal-consumer.mjs',
+    'aria-first-class-coach.mjs',
+    'aria-pre-tool-gate.mjs',
+  ]),
+  checkMarkers('claude live universal packet hook', path.join(HOME, '.claude', 'hooks', 'aria-universal-turn-packet.mjs'), [
+    'SKILL_FLOOR = 50',
+    'RUNTIME_FLOOR = 16',
+    "skillExecutionMode: 'mechanical-receipt'",
+    'ARIA_CLAUDE_HOOK_MODE',
+    'native provider execution continues',
+  ]),
+  checkMarkers('opencode config plugins', path.join(HOME, '.opencode', 'config.json'), [
+    'harness-context',
+    'harness-gate',
+    'harness-stop',
+  ]),
+  checkMarkers('opencode live universal packet hook', path.join(HOME, '.opencode', 'hooks', 'aria-universal-turn-packet.mjs'), [
+    'SKILL_FLOOR = 50',
+    'RUNTIME_FLOOR = 16',
+    "skillExecutionMode: 'mechanical-receipt'",
+    'ARIA_OPENCODE_HOOK_MODE',
+  ]),
+  checkMarkers('opencode live harness context plugin', path.join(HOME, '.opencode', 'plugins', 'harness-context', 'index.js'), [
+    'UNIVERSAL_TURN_PACKET_SCRIPT',
+    "ARIA_SURFACE_ID: 'opencode'",
+    "ARIA_UNIVERSAL_TURN_PACKET_CONTEXT: '1'",
+    'ctx.system?.prepend',
+  ]),
+  checkMarkers('repo codex connector install path', path.join(repoRoot, 'packages', 'aria-connector', 'src', 'connectors', 'codex.ts'), [
+    'aria-userprompt-submit.mjs',
+    'aria-pre-tool-use.mjs',
+    'aria-post-tool-use.mjs',
+    'aria-stop.mjs',
+  ]),
+  checkMarkers('repo claude connector install path', path.join(repoRoot, 'packages', 'aria-connector', 'src', 'connectors', 'claude-code.ts'), [
+    'aria-universal-turn-packet.mjs',
+    'UserPromptSubmit',
+    'Building Aria universal turn packet...',
+  ]),
+  checkMarkers('repo opencode connector install path', path.join(repoRoot, 'packages', 'aria-connector', 'src', 'connectors', 'opencode.ts'), [
+    'harness-context',
+    'aria-universal-turn-packet.mjs',
+    '.opencode',
+  ]),
+  checkMarkers('repo shell connector wrapper path', path.join(repoRoot, 'packages', 'aria-connector', 'src', 'connectors', 'shell.ts'), [
+    'buildUniversalTurnPacketExecBlock',
+    'ARIA_UNIVERSAL_TURN_PACKET_SCRIPT="$HOME/.aria/runtime/hooks/aria-universal-turn-packet.mjs"',
+    "if (toolName === 'codex') return 'codex';",
+    "if (toolName === 'claude') return 'claude-code';",
+    "if (toolName === 'opencode') return 'opencode';",
+  ]),
+  checkMarkers('repo runtime prompt builder', path.join(repoRoot, 'packages', 'aria-connector', 'runtime-src', 'service.mjs'), [
+    'POST /build-system-prompt',
+    'buildMechanicalSkillActivationBlock',
+    'substrateKernelExecution',
+    'ARIA MECHANICAL SKILL EXECUTION RECEIPT',
+    'buildHiveObserverSourceTopologyReceipt',
+  ]),
+];
+
+const gaps = checks.flatMap((check) => check.ok
+  ? []
+  : check.missing.map((marker) => `${check.label} missing marker ${marker}`));
+
+assert.deepEqual(gaps, [], gaps.join('\n'));
+
+console.log(JSON.stringify({
+  ok: true,
+  test: 'live-wrapper-substrate-inventory',
+  checkedCount: checks.length,
+  checked: checks.map(({ label, path: checkedPath, sha256: hash }) => ({
+    label,
+    path: checkedPath,
+    sha256: hash,
+  })),
+  predicate: 'Codex, Claude Code, OpenCode, shell wrappers, live installed hooks, connector installers, and runtime prompt builder all expose a universal mechanical substrate packet path before provider execution.',
+}, null, 2));

package/scripts/self-test-local-main-sync-script.mjs

@@ -0,0 +1,47 @@
+#!/usr/bin/env node
+import { readFileSync } from 'node:fs';
+import { dirname, resolve } from 'node:path';
+import { spawnSync } from 'node:child_process';
+import { fileURLToPath } from 'node:url';
+
+const here = dirname(fileURLToPath(import.meta.url));
+const repoRoot = resolve(here, '..', '..', '..');
+const scriptPath = resolve(here, 'sync-local-main-on-task-complete.mjs');
+const source = readFileSync(scriptPath, 'utf8');
+
+const failures = [];
+
+function assert(condition, message) {
+  if (!condition) failures.push(message);
+}
+
+const syntax = spawnSync('node', ['--check', scriptPath], {
+  cwd: repoRoot,
+  encoding: 'utf8',
+});
+assert(syntax.status === 0, `sync script node --check failed: ${syntax.stderr || syntax.stdout}`);
+
+const help = spawnSync('node', [scriptPath, '--help'], {
+  cwd: repoRoot,
+  encoding: 'utf8',
+});
+assert(help.status === 0, `sync script --help failed: ${help.stderr || help.stdout}`);
+assert(help.stdout.includes('never fetches, pulls, or rebases'), 'help must state the no-fetch/no-pull/no-rebase contract');
+
+assert(source.includes("git(repo, ['ls-remote'"), 'sync script must inspect remote heads without fetching');
+assert(source.includes("git(repo, ['worktree', 'list', '--porcelain']"), 'sync script must inspect local worktrees before choosing a main worktree');
+assert(source.includes("['worktree', 'add', '--detach'"), 'sync script dry-run must use a detached worktree instead of re-checking out main');
+assert(!source.includes("['fetch'"), 'sync script must not call git fetch');
+assert(!source.includes("['pull'"), 'sync script must not call git pull');
+assert(!source.includes("['rebase'"), 'sync script must not call git rebase');
+assert(source.includes('backupRef'), 'sync script must create a remote backup ref before push');
+assert(source.includes('npm --prefix packages/aria-connector run check:release'), 'sync script must default to release QA before push');
+assert(source.includes('--skip-qa'), 'sync script must require an explicit operator flag to skip QA');
+
+if (failures.length > 0) {
+  console.error('[self-test-local-main-sync-script] FAIL');
+  for (const failure of failures) console.error(`- ${failure}`);
+  process.exit(1);
+}
+
+console.log('[self-test-local-main-sync-script] OK - local-main sync script is push-only and QA-bound');