@aria_asi/cli 0.2.39 → 0.2.41

package/scripts/aria-task-cheap-worker-dispatch.mjs

@@ -0,0 +1,234 @@
+#!/usr/bin/env node
+
+import { existsSync, mkdtempSync, readFileSync, writeFileSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import path from 'node:path';
+import { spawnSync } from 'node:child_process';
+
+function parseArgs(argv) {
+  const flags = {};
+  for (let index = 0; index < argv.length; index += 1) {
+    const arg = argv[index];
+    if (!arg.startsWith('--')) continue;
+    const eq = arg.indexOf('=');
+    if (eq >= 0) {
+      flags[arg.slice(2, eq)] = arg.slice(eq + 1);
+      continue;
+    }
+    const key = arg.slice(2);
+    const next = argv[index + 1];
+    if (next && !next.startsWith('--')) {
+      flags[key] = next;
+      index += 1;
+    } else {
+      flags[key] = true;
+    }
+  }
+  return flags;
+}
+
+function readStdin() {
+  try {
+    return readFileSync(0, 'utf8');
+  } catch {
+    return '';
+  }
+}
+
+function readPacket(flags) {
+  const packetPath = flags.packet || process.env.ARIA_TASK_WORKER_PACKET_PATH || '';
+  const raw = packetPath && existsSync(packetPath) ? readFileSync(packetPath, 'utf8') : readStdin();
+  if (!raw.trim()) throw new Error('worker dispatch requires packet JSON on stdin or --packet <path>');
+  const packet = JSON.parse(raw);
+  if (!packet || typeof packet !== 'object' || Array.isArray(packet)) throw new Error('worker packet must be a JSON object');
+  if (packet.schema !== 'aria.task_worker_packet.v1') throw new Error(`unexpected worker packet schema: ${packet.schema || '<missing>'}`);
+  return { packet, packetPath };
+}
+
+function extractJsonObject(text) {
+  const trimmed = String(text || '').trim();
+  if (!trimmed) throw new Error('worker command returned empty output');
+  try {
+    return JSON.parse(trimmed);
+  } catch {
+    const fenced = trimmed.match(/```(?:json)?\s*([\s\S]*?)```/i);
+    if (fenced) return JSON.parse(fenced[1].trim());
+    const start = trimmed.indexOf('{');
+    const end = trimmed.lastIndexOf('}');
+    if (start >= 0 && end > start) return JSON.parse(trimmed.slice(start, end + 1));
+    throw new Error('worker command did not return parseable JSON');
+  }
+}
+
+function shellQuote(value) {
+  return `'${String(value).replace(/'/g, "'\\''")}'`;
+}
+
+function buildPrompt(packet) {
+  return [
+    '# Aria Bounded Cheap Worker Packet',
+    '',
+    'You are the cheaper execution unit. Do implementation work only inside this packet. Do not do architecture planning, product scoping, broad refactors, deploys, secrets work, or phase completion.',
+    '',
+    'Authority split:',
+    '- Heavy planner / Codex / Aria owns architecture, plan quality, scope, acceptance, and final phase completion.',
+    '- You may make bounded edits only in allowedFiles.',
+    '- You must not touch forbiddenFiles.',
+    '- Aria will rerun verification and reject output that is out of scope.',
+    '- Do not run `aria task complete`.',
+    '',
+    'Required final response: return only JSON matching `aria.task_worker_output.v1`.',
+    '',
+    'Packet JSON:',
+    JSON.stringify(packet, null, 2),
+    '',
+    'Return JSON shape:',
+    JSON.stringify(packet.requiredReturnSchema || {
+      schema: 'aria.task_worker_output.v1',
+      taskId: packet.taskId,
+      phaseId: packet.phaseId,
+      executor: packet.executor,
+      changedFiles: [],
+      verification: { command: packet.verificationCommand, exitCode: 0, summary: '' },
+      summary: '',
+      evidence: '',
+      blockers: [],
+    }, null, 2),
+  ].join('\n');
+}
+
+function buildWorkerOutputSchema(packet) {
+  return {
+    type: 'object',
+    additionalProperties: true,
+    required: ['schema', 'taskId', 'phaseId', 'executor', 'changedFiles', 'verification', 'summary', 'evidence', 'blockers'],
+    properties: {
+      schema: { type: 'string', const: 'aria.task_worker_output.v1' },
+      taskId: { type: 'string', const: String(packet.taskId || '') },
+      phaseId: { type: 'string', const: String(packet.phaseId || '') },
+      executor: { type: 'string', const: String(packet.executor || '') },
+      changedFiles: { type: 'array', items: { type: 'string' } },
+      verification: {
+        type: 'object',
+        additionalProperties: true,
+        required: ['command', 'exitCode', 'summary'],
+        properties: {
+          command: { type: 'string' },
+          exitCode: { type: 'number' },
+          summary: { type: 'string' },
+        },
+      },
+      summary: { type: 'string' },
+      evidence: { type: 'string' },
+      blockers: { type: 'array', items: { type: 'string' } },
+    },
+  };
+}
+
+function validateWorkerOutputShape(workerOutput, packet) {
+  const gaps = [];
+  if (!workerOutput || typeof workerOutput !== 'object' || Array.isArray(workerOutput)) {
+    gaps.push('worker output must be a JSON object');
+    return gaps;
+  }
+  if (workerOutput.schema !== 'aria.task_worker_output.v1') gaps.push('schema must be aria.task_worker_output.v1');
+  if (workerOutput.taskId !== packet.taskId) gaps.push(`taskId mismatch: ${workerOutput.taskId || '<missing>'}`);
+  if (workerOutput.phaseId !== packet.phaseId) gaps.push(`phaseId mismatch: ${workerOutput.phaseId || '<missing>'}`);
+  if (workerOutput.executor !== packet.executor) gaps.push(`executor mismatch: ${workerOutput.executor || '<missing>'}`);
+  if (!Array.isArray(workerOutput.changedFiles)) gaps.push('changedFiles must be an array');
+  if (!workerOutput.verification || typeof workerOutput.verification !== 'object' || Array.isArray(workerOutput.verification)) {
+    gaps.push('verification must be an object');
+  } else {
+    if (typeof workerOutput.verification.command !== 'string') gaps.push('verification.command must be a string');
+    if (typeof workerOutput.verification.exitCode !== 'number') gaps.push('verification.exitCode must be a number');
+    if (typeof workerOutput.verification.summary !== 'string') gaps.push('verification.summary must be a string');
+  }
+  if (typeof workerOutput.summary !== 'string') gaps.push('summary must be a string');
+  if (typeof workerOutput.evidence !== 'string') gaps.push('evidence must be a string');
+  if (!Array.isArray(workerOutput.blockers)) gaps.push('blockers must be an array');
+  return gaps;
+}
+
+function substituteTemplate(template, values) {
+  return template
+    .replaceAll('{prompt}', shellQuote(values.prompt))
+    .replaceAll('{promptFile}', shellQuote(values.promptFile))
+    .replaceAll('{packet}', shellQuote(values.packetPath))
+    .replaceAll('{output}', shellQuote(values.outputPath))
+    .replaceAll('{outputSchema}', shellQuote(values.outputSchemaPath))
+    .replaceAll('{cwd}', shellQuote(values.cwd))
+    .replaceAll('{model}', shellQuote(values.model));
+}
+
+const flags = parseArgs(process.argv.slice(2));
+const { packet, packetPath } = readPacket(flags);
+const model = String(flags.model || process.env.ARIA_TASK_WORKER_MODEL || 'gpt-5.3-codex-spark');
+const outputPath = path.resolve(String(flags.out || process.env.ARIA_TASK_WORKER_OUTPUT_PATH || path.join(process.cwd(), `${packet.taskId}.${packet.phaseId}.${packet.executor}.worker-output.json`)));
+const cwd = String(packet.cwd || process.cwd());
+const prompt = buildPrompt(packet);
+const tempDir = mkdtempSync(path.join(tmpdir(), 'aria-cheap-worker-'));
+const promptFile = path.join(tempDir, 'prompt.md');
+const outputSchemaPath = path.join(tempDir, 'worker-output.schema.json');
+writeFileSync(promptFile, prompt + '\n', { mode: 0o600 });
+writeFileSync(outputSchemaPath, `${JSON.stringify(buildWorkerOutputSchema(packet), null, 2)}\n`, { mode: 0o600 });
+
+if (flags['print-prompt'] === true || flags['dry-run'] === true) {
+  console.log(JSON.stringify({
+    ok: true,
+    dryRun: true,
+    model,
+    cwd,
+    promptFile,
+    outputSchemaPath,
+    outputPath,
+    packetPath,
+  }, null, 2));
+  process.exit(0);
+}
+
+const commandTemplate = String(flags['command-template'] || process.env.ARIA_TASK_WORKER_COMMAND_TEMPLATE || '');
+const command = commandTemplate
+  ? substituteTemplate(commandTemplate, { prompt, promptFile, packetPath, outputPath, outputSchemaPath, cwd, model })
+  : `codex exec -m ${shellQuote(model)} -C ${shellQuote(cwd)} -s workspace-write --output-schema ${shellQuote(outputSchemaPath)} -o ${shellQuote(outputPath)} -`;
+
+const result = spawnSync('/bin/bash', ['-lc', command], {
+  cwd,
+  input: prompt,
+  encoding: 'utf8',
+  env: {
+    ...process.env,
+    ARIA_TASK_WORKER_PACKET_PATH: packetPath,
+    ARIA_TASK_WORKER_OUTPUT_PATH: outputPath,
+    ARIA_TASK_WORKER_MODEL: model,
+    ARIA_TASK_WORKER_EXECUTOR: String(packet.executor || ''),
+    ARIA_TASK_ID: String(packet.taskId || ''),
+    ARIA_TASK_PHASE_ID: String(packet.phaseId || ''),
+  },
+});
+
+if (result.status !== 0 || result.error) {
+  console.error(JSON.stringify({
+    ok: false,
+    command,
+    exitCode: result.status,
+    signal: result.signal || null,
+    error: result.error ? result.error.message : null,
+    stderr: String(result.stderr || '').slice(-4000),
+  }, null, 2));
+  process.exit(typeof result.status === 'number' && result.status !== 0 ? result.status : 1);
+}
+
+const rawOutput = existsSync(outputPath) ? readFileSync(outputPath, 'utf8') : String(result.stdout || '');
+const workerOutput = extractJsonObject(rawOutput);
+const shapeGaps = validateWorkerOutputShape(workerOutput, packet);
+if (shapeGaps.length) {
+  console.error(JSON.stringify({
+    ok: false,
+    error: 'worker command returned JSON with invalid aria.task_worker_output.v1 shape',
+    gaps: shapeGaps,
+    outputPath,
+  }, null, 2));
+  process.exit(1);
+}
+writeFileSync(outputPath, JSON.stringify(workerOutput, null, 2) + '\n', { mode: 0o600 });
+console.log(JSON.stringify(workerOutput, null, 2));

package/scripts/audit-of-audit-prior-tasks.mjs

@@ -0,0 +1,194 @@
+#!/usr/bin/env node
+// Audit-of-audit court for prior 2026-05-17 tasks (#50..#63) that landed
+// without explicit Tadabbur-12 + Qiyas-15 court. Layer C of the plan's
+// discipline contract is the authority: per-task, run the canonical kernel
+// against the artifact summary as observation, capture per-perspective verdicts,
+// surface findings as concern/reject rows. Reproducible / deterministic.
+
+import { evaluateWithKernel } from '../runtime-src/lib/evaluate-with-kernel.mjs';
+
+const PRIOR_TASKS = [
+  {
+    id: '#50',
+    title: 'G0: shared evaluateWithKernel helper (foundational)',
+    summary: 'Wired evaluate-with-kernel.mjs (114 lines, pure fn) at packages/aria-connector/runtime-src/lib/ + connector hook mirror. Vendored atlas kernel deterministic-cognitive-kernel.mjs under runtime-src/lib/kernel/ + hooks/lib/kernel/. check-kernel-sync.mjs gate matches vendor body sha256 to atlas. self-test-evaluate-with-kernel.mjs 9/9 pass.',
+    artifactKind: 'helper_wiring',
+    hasVerifyBlock: true,
+    completionShape: true,
+  },
+  {
+    id: '#51',
+    title: 'G1: behavioral guard via evaluateWithKernel',
+    summary: 'Wired callKernelGuard in aria-stop-gate.mjs:1858-1900 (now refactored into callKernelGuard helper). Joins OR block; violation entry carries decision/source_trust/action_class/cognition_mutated_output. Skipped when reflection block already present. Kill switch ARIA_KERNEL_GATE_DISABLE=1. Connector mirror byte-identical.',
+    artifactKind: 'gate_wiring',
+    hasVerifyBlock: true,
+    completionShape: true,
+  },
+  {
+    id: '#52',
+    title: 'G6: goal contract evaluation via evaluateWithKernel',
+    summary: 'Second kernel call at aria-stop-gate.mjs:1907-1941 with observation kind=goal_contract_eval. Only fires when continuationRequested. Joins OR block. Violation entry tagged mechanism_description vs goal_advancement. Connector mirror byte-identical.',
+    artifactKind: 'gate_wiring',
+    hasVerifyBlock: true,
+    completionShape: true,
+  },
+  {
+    id: '#53',
+    title: 'Phase 4/5 kernel consolidation audit',
+    summary: 'Audited end-phase-qa-autofire.mjs + project-boundary-cognition.mjs for canonical-kernel call vs inline duplicate Tadabbur/Qiyas logic. Result: not duplicates; end-phase is structural receipt producer with hardcoded ok; boundary is shape validator. No parity-scope migration needed. POST-PARITY enhancement tracked as Task #54.',
+    artifactKind: 'audit_only',
+    hasVerifyBlock: true,
+    completionShape: true,
+  },
+  {
+    id: '#54',
+    title: 'POST-PARITY: end-phase-qa-autofire kernel verdicts',
+    summary: 'Wired ARIA_KERNEL_QA_MODE env gate + KERNEL_QIYAS_CANONICAL/KERNEL_TADABBUR_CANONICAL maps + kernelQiyasRow/kernelTadabburRow helpers + buildKernelVerdict factory. Threaded kernelVerdict into receipt evidence. 2026-05-17: F2 discovered post-claim — display list was shifted by 1 vs kernel canonical at positions 1-13. F2 fix landed at 8 canonical sources via Task #64.',
+    artifactKind: 'helper_wiring_with_recurring_violation',
+    hasVerifyBlock: true,
+    completionShape: true,
+    knownDefect: 'F2: silent kernel-row label-shift, fixed post-claim only after owner audit-of-audit directive',
+  },
+  {
+    id: '#55',
+    title: 'Kernel taxonomy extension: output_emit classification branch',
+    summary: 'Atlas kernel deterministic-cognitive-kernel.mjs extended with OUTPUT_EMIT_FAILURE_CLASSES exported constant + classifyOutputEmit() helper + classify() branch for kind=output_emit/goal_contract_eval producing 5 action_class values + constrainOptions blocks per failure class. Re-vendored to runtime-src/hooks/lib mirrors. atlas-side body sha256=f1662b53.',
+    artifactKind: 'core_kernel_extension',
+    hasVerifyBlock: true,
+    completionShape: true,
+  },
+  {
+    id: '#56',
+    title: 'G1/G6 refactor: surface kernel options, not just decision',
+    summary: 'Extracted callKernelGuard shared helper in aria-stop-gate.mjs eliminating G1/G6 duplication. computeDecision maps failure classes to force_reauthor. buildRecoveryDirective surfaces class-specific rejection reason from kernel as workshop material for next-turn substrate. Computed sharedEmitAttrs from text once; reused across both guards.',
+    artifactKind: 'refactor_with_helper_extraction',
+    hasVerifyBlock: true,
+    completionShape: true,
+  },
+  {
+    id: '#57',
+    title: 'G1/G6 integration smoke test',
+    summary: 'Wrote packages/aria-connector/scripts/self-test-stop-gate-kernel-guards.mjs 7/7 pass: benign emit allow, env disable kill switch, claim_without_evidence force_reauthor, sycophancy_shape force_reauthor, mechanism_description force_reauthor, well-formed allow, deterministic receiptHash invariant.',
+    artifactKind: 'smoke_test',
+    hasVerifyBlock: true,
+    completionShape: true,
+  },
+  {
+    id: '#58',
+    title: 'Option C prereq: surface-parameterize runtime-client.mjs',
+    summary: 'Added ARIA_HOOK_SURFACE export to ops/claude-hooks/codex-native/lib/runtime-client.mjs. Routed inferActionLedgerProjectId + inferActionLedgerTaskId via the surface const. Connector mirror byte-identical.',
+    artifactKind: 'parameterize',
+    hasVerifyBlock: true,
+    completionShape: true,
+  },
+  {
+    id: '#59',
+    title: 'Option C follow-up: normalize surface labels across chains',
+    summary: 'Surface label pollution fix: replaced literal codex-* strings in action-ledger artifacts + source labels with `${ARIA_HOOK_SURFACE}` interpolation across aria-userprompt-submit / aria-pre-tool-use / aria-post-tool-use / aria-stop in codex-native chain. Batch import-injection trailing-comma bug fixed.',
+    artifactKind: 'label_normalization',
+    hasVerifyBlock: true,
+    completionShape: true,
+  },
+  {
+    id: '#60',
+    title: 'Option C next: cross-phase gate check using chained state',
+    summary: 'PostToolUse writes unacknowledgedToolFailures[] entry on tool error before saveTurnState. Stop hook reads + emits ACKNOWLEDGMENT_RX/COMPLETION_CLAIM_RX cross-phase gate at TOP of try block before !text short-circuit. self-test-cross-phase-tool-failure.mjs 5/5 pass.',
+    artifactKind: 'cross_phase_state_machine',
+    hasVerifyBlock: true,
+    completionShape: true,
+  },
+  {
+    id: '#61',
+    title: 'Kernel-into-coach: codex-native QA + goal-contract through atlas kernel',
+    summary: 'Codex-native runtime-client.mjs evaluateGoalContractOutput hoisted UNCONDITIONAL false-completion check before continuation gate; phase-gated goalQa.blockers consumption (only stop/stop_goal_contract phases). evaluateWithKernel adapter for hard-risk pre-tool with hasReleaseLang skip-gate.',
+    artifactKind: 'coach_kernel_integration',
+    hasVerifyBlock: true,
+    completionShape: true,
+  },
+  {
+    id: '#62',
+    title: 'QA audit + regression repair (session-wide)',
+    summary: 'Session-wide regression repair: 5+ smoke scripts at packages/aria-connector/scripts/ covering qa-exec, goal-contract, stop-gate, cross-phase, kernel-sync. Both regex-mode and kernel-mode self-tests pass.',
+    artifactKind: 'regression_repair',
+    hasVerifyBlock: true,
+    completionShape: true,
+  },
+  {
+    id: '#63',
+    title: 'Consolidate observation regexes + durable smoke files',
+    summary: 'Module-level shared regex constants extracted: OUTPUT_FALSE_COMPLETION_RX, OUTPUT_AGREEMENT_RX, OUTPUT_ADVANCE_LANG_RX, OUTPUT_OBSERVATION_EVIDENCE_RX, OUTPUT_CODE_CONTEXT_RX, OUTPUT_VERIFY_BLOCK_RX. extractEmitAttrs(source, opts) single source of truth for output-emit structured attrs. Concrete-pattern observation regexes only (exit 0, sha256, byte-identical, N/N pass).',
+    artifactKind: 'regex_consolidation',
+    hasVerifyBlock: true,
+    completionShape: true,
+  },
+];
+
+function runCourtOnTask(task) {
+  const text = `${task.title}. ${task.summary}`;
+  const attrs = {
+    hasCompletionLang: task.completionShape,
+    hasAdvanceLang: task.completionShape,
+    hasVerifyBlock: task.hasVerifyBlock,
+    evidenceAnchorCount: (text.match(/\b(?:7\/7|9\/9|5\/5|byte-identical|sha256|atlas-side|GREEN|PASS)\b/gi) || []).length,
+    lensCount: 0,
+    codeBlockCount: 0,
+    continuationRequested: false,
+    textLength: text.length,
+    backendPassed: true,
+    userSurfacePassed: true,
+    upstreamQaKernelOk: true,
+  };
+  return evaluateWithKernel({
+    surface: 'audit-of-audit-prior-tasks',
+    phase: 'phase_close',
+    observation: {
+      kind: 'output_emit',
+      source: `task-${task.id}`,
+      severity: 'low',
+      summary: text.slice(0, 1000),
+      attrs,
+    },
+    evidence: [{ kind: 'task_completion_claim', value: task.completionShape, source: task.id }],
+    predicate: 'task_completion_claim_carries_bounded_evidence',
+  });
+}
+
+const findings = [];
+let totalConcerns = 0, totalRejects = 0;
+
+console.log('# Audit-of-Audit: Tadabbur-12 + Qiyas-15 Court on Prior 2026-05-17 Tasks\n');
+
+for (const task of PRIOR_TASKS) {
+  const v = runCourtOnTask(task);
+  const qiyasRows = v?.qiyas?.rows || [];
+  const tadabburRows = v?.tadabbur?.rows || [];
+  const topOptionId = v?.topOption?.option_id;
+  const qiyasIssues = qiyasRows
+    .filter((r) => topOptionId ? r.option_id === topOptionId : true)
+    .filter((r) => r.verdict && r.verdict !== 'accepted');
+  const tadabburIssues = tadabburRows.filter((r) => r.mutation_type === 'option_rejected' || (r.mutation_type && r.mutation_type !== 'uncertainty_recorded'));
+  totalConcerns += qiyasIssues.filter((r) => r.verdict !== 'reject').length;
+  totalRejects += qiyasIssues.filter((r) => r.verdict === 'reject').length + tadabburIssues.filter((r) => r.mutation_type === 'option_rejected').length;
+  console.log(`## ${task.id} — ${task.title}`);
+  console.log(`   decision=${v.decision} action_class=${v.classification?.action_class} cog_mutated=${v.acceptance?.cognition_mutated_output}`);
+  if (task.knownDefect) console.log(`   KNOWN-DEFECT-LOG: ${task.knownDefect}`);
+  if (qiyasIssues.length > 0) {
+    console.log(`   Qiyas issues (${qiyasIssues.length}):`);
+    for (const r of qiyasIssues) console.log(`     - ${r.perspective}: ${r.verdict} — ${(r.reason || '').slice(0, 120)}`);
+  }
+  if (tadabburIssues.length > 0) {
+    console.log(`   Tadabbur stages emitting non-trivial mutations (${tadabburIssues.length}):`);
+    for (const r of tadabburIssues) console.log(`     - ${r.stage}: ${r.mutation_type} — ${(r.reason || '').slice(0, 120)}`);
+  }
+  if (qiyasIssues.length === 0 && tadabburIssues.length === 0) console.log('   Qiyas/Tadabbur: clean');
+  if (v.recoveryDirective && v.decision !== 'allow' && v.decision !== 'observe_only') {
+    console.log(`   Recovery directive: ${v.recoveryDirective.slice(0, 200)}`);
+    findings.push({ taskId: task.id, recovery: v.recoveryDirective });
+  }
+  console.log();
+}
+
+console.log('---');
+console.log(`Summary: ${PRIOR_TASKS.length} tasks audited, ${totalConcerns} concerns, ${totalRejects} rejects across all per-row verdicts.`);
+console.log(`Tasks requiring recovery action: ${findings.length}`);
+for (const f of findings) console.log(`  - ${f.taskId}`);

package/scripts/audit-of-audit-this-turn.mjs

@@ -0,0 +1,116 @@
+#!/usr/bin/env node
+// Layer C court for THIS turn's work (G5 statusline, F2-structural, parity-queue
+// closures). Per feedback_layer_c_court_before_claim_done.md: smoke pass is not
+// court pass. Runs the deterministic kernel against each artifact summary.
+
+import { evaluateWithKernel } from '../runtime-src/lib/evaluate-with-kernel.mjs';
+
+const THIS_TURN = [
+  {
+    id: '#44',
+    title: 'G5 statusline ticker in Claude settings.json',
+    summary: 'Added statusLine entry to ~/.claude/settings.json: command=node $HOME/rei-ai-brain/ops/claude-hooks/codex-native/aria-harness-ticker-sidecar.mjs --render-statusline, padding=0. JSON.parse() exit 0. Live render exit 0: Aria ready | skills 0 | saved 3 | lessons 444 | atlas #162 35.5kN | sentinel high 3 | latest evolution_candidate. Takes effect on next Claude Code session restart.',
+    artifactKind: 'settings_json_edit',
+  },
+  {
+    id: '#66',
+    title: 'F2-structural: import kernel canonical exports directly',
+    summary: 'Replaced hand-maintained KERNEL_QIYAS_CANONICAL + KERNEL_TADABBUR_CANONICAL arrays in end-phase-qa-autofire.mjs at 3 sites (ops + connector + live ~/.claude/hooks) with direct imports from evaluate-with-kernel.mjs re-exports of atlas vendored kernel. node --check exit 0 × 3 sites. Kernel-mode smoke confirms semantically-correct labels (Owner-Hamza-now:ok, Owner-Hamza-future:ok, operator-client:ok, investor-or-buyer:ok). Eliminates F2-class bug structurally — if atlas reorders, mappers follow automatically.',
+    artifactKind: 'structural_refactor',
+  },
+  {
+    id: '#42',
+    title: 'Phase 2 chained turn state in Claude native hooks',
+    summary: 'Closed via plan §10.5 architecture pivot. Verified codex-native parallel chain registered in settings.json: aria-pre-tool-use.mjs:43 uses loadTurnState, aria-post-tool-use.mjs:5/8/37/194 uses load+saveTurnState, aria-stop.mjs:9/10/56/99/145/171/575 uses both. Cross-phase tool-failure smoke 5/5 pass confirms chained state crosses tool boundaries.',
+    artifactKind: 'verification_closure',
+  },
+  {
+    id: '#43',
+    title: 'Phase 6 synchronous hive lifecycle per tool',
+    summary: 'Closed via codex-native chain. Verified recordHiveFileTouch + recordHiveSessionLifecycle at aria-pre-tool-use.mjs:16-17 and aria-post-tool-use.mjs:12-13,44-56. Both bounded via runtimePostBounded per hive-transport carve-out doctrine.',
+    artifactKind: 'verification_closure',
+  },
+  {
+    id: '#45',
+    title: 'Phase 8 goal contract evaluation in aria-stop-gate',
+    summary: 'Closed via plan §12 G6 (kernel-driven goal contract guard at aria-stop-gate.mjs:1907-1941) AND codex-native aria-stop.mjs:123,625 (evaluateGoalContractOutput). 7/7 stop-gate-kernel-guards smoke pass.',
+    artifactKind: 'verification_closure',
+  },
+  {
+    id: '#46',
+    title: 'codex-native chain registration question',
+    summary: 'Resolved by verification. All 4 codex-native hooks registered in ~/.claude/settings.json: UserPromptSubmit:53, PreToolUse:109, PostToolUse:157, Stop:210. Each fires with ARIA_HOOK_SURFACE=claude ARIA_KERNEL_QA_MODE=1 env.',
+    artifactKind: 'verification_closure',
+  },
+];
+
+function runCourt(task) {
+  const text = `${task.title}. ${task.summary}`;
+  const attrs = {
+    hasCompletionLang: /\b(?:done|completed|closed|landed|wired|fixed|shipped|verified)\b/i.test(text),
+    hasAdvanceLang: true,
+    hasVerifyBlock: /\b(?:smoke|exit\s*0|pass|verified|kernel-sync|9\/9|7\/7|5\/5|node --check)\b/i.test(text),
+    evidenceAnchorCount: (text.match(/\b(?:exit\s*0|node\s*--check|sha256|byte-identical|\d+\/\d+\s*pass|kernel-sync|line\s*\d+|smoke|self-test)\b/gi) || []).length,
+    lensCount: 0,
+    codeBlockCount: 0,
+    continuationRequested: false,
+    textLength: text.length,
+    backendPassed: true,
+    userSurfacePassed: true,
+    upstreamQaKernelOk: true,
+  };
+  return evaluateWithKernel({
+    surface: 'audit-of-audit-this-turn',
+    phase: 'phase_close',
+    observation: {
+      kind: 'output_emit',
+      source: `task-${task.id}`,
+      severity: 'low',
+      summary: text.slice(0, 1000),
+      attrs,
+    },
+    evidence: [
+      { kind: 'task_artifact_summary', value: task.summary.slice(0, 400), source: task.id },
+      { kind: 'artifact_class', value: task.artifactKind, source: task.id },
+    ],
+    predicate: 'turn_artifact_carries_concrete_verification_evidence',
+  });
+}
+
+console.log('# Layer C Court — This Turn (G5 + F2-structural + parity closures)\n');
+let totalRejects = 0;
+let totalForceReauthor = 0;
+const findings = [];
+
+for (const task of THIS_TURN) {
+  const v = runCourt(task);
+  const qiyas = v?.qiyas?.rows || [];
+  const tadabbur = v?.tadabbur?.rows || [];
+  const topId = v?.topOption?.option_id;
+  const qiyasRejects = qiyas.filter((r) => (!topId || r.option_id === topId) && r.verdict === 'reject');
+  const tadabburRejects = tadabbur.filter((r) => r.mutation_type === 'option_rejected');
+  totalRejects += qiyasRejects.length + tadabburRejects.length;
+  if (v.decision === 'force_reauthor' || v.decision === 'block') totalForceReauthor++;
+  console.log(`## ${task.id} — ${task.title}`);
+  console.log(`   decision=${v.decision}  action_class=${v.classification?.action_class}  cog_mutated=${v.acceptance?.cognition_mutated_output}`);
+  console.log(`   qiyas_15=${v.acceptance?.qiyas_15}  tadabbur_12=${v.acceptance?.tadabbur_12}`);
+  if (qiyasRejects.length > 0) {
+    console.log(`   QIYAS REJECTS (${qiyasRejects.length}):`);
+    for (const r of qiyasRejects) console.log(`     - ${r.perspective}: ${(r.reason || '').slice(0, 120)}`);
+    findings.push({ id: task.id, kind: 'qiyas_reject', rows: qiyasRejects });
+  }
+  if (tadabburRejects.length > 0) {
+    console.log(`   TADABBUR REJECTS (${tadabburRejects.length}):`);
+    for (const r of tadabburRejects) console.log(`     - ${r.stage}: ${(r.reason || '').slice(0, 120)}`);
+    findings.push({ id: task.id, kind: 'tadabbur_reject', rows: tadabburRejects });
+  }
+  if (qiyasRejects.length === 0 && tadabburRejects.length === 0) console.log('   Qiyas/Tadabbur: clean (no reject)');
+  console.log();
+}
+
+console.log('---');
+console.log(`Summary: ${THIS_TURN.length} closures audited.`);
+console.log(`Qiyas+Tadabbur rejects: ${totalRejects}`);
+console.log(`force_reauthor / block decisions: ${totalForceReauthor}`);
+console.log(`Findings requiring recovery action: ${findings.length}`);
+for (const f of findings) console.log(`  - ${f.id} (${f.kind})`);

package/scripts/bundle-sdk.mjs

@@ -123,18 +123,44 @@ if (!existsSync(SDK_DST)) {
   mkdirSync(SDK_DST, { recursive: true });
 }
 if (existsSync(RUNTIME_DST)) {
-  rmSync(RUNTIME_DST, { recursive: true, force: true });
+  removeTreeWithRetry(RUNTIME_DST);
 }
 mkdirSync(RUNTIME_DST, { recursive: true });
 
-function copyTree(srcDir, dstDir) {
+function removeTreeWithRetry(targetPath) {
+  let lastError = null;
+  for (let attempt = 1; attempt <= 5; attempt += 1) {
+    try {
+      rmSync(targetPath, {
+        recursive: true,
+        force: true,
+        maxRetries: 5,
+        retryDelay: 100,
+      });
+      if (!existsSync(targetPath)) return;
+    } catch (error) {
+      lastError = error;
+    }
+    Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, 100 * attempt);
+  }
+  if (lastError) throw lastError;
+  throw new Error(`[bundle-sdk] failed to remove ${targetPath}`);
+}
+
+function shouldSkipCopyEntry(name, options) {
+  if (!options.excludeTests) return false;
+  return name === '__tests__' || /\.test\.[cm]?[jt]s$/.test(name);
+}
+
+function copyTree(srcDir, dstDir, options = {}) {
   mkdirSync(dstDir, { recursive: true });
   for (const name of readdirSync(srcDir)) {
+    if (shouldSkipCopyEntry(name, options)) continue;
     const src = join(srcDir, name);
     const stat = statSync(src);
     const dst = join(dstDir, name);
     if (stat.isDirectory()) {
-      copyTree(src, dst);
+      copyTree(src, dst, options);
       continue;
     }
     copyFileSync(src, dst);
@@ -301,8 +327,8 @@ if (existsSync(DOCTRINE_TRIGGER_MAP_SRC)) {
   copyFileSync(DOCTRINE_TRIGGER_MAP_SRC, join(RUNTIME_DST, 'doctrine_trigger_map.json'));
 }
 if (existsSync(CONNECTOR_HOOKS_SRC)) {
-  copyTree(CONNECTOR_HOOKS_SRC, join(RUNTIME_DST, 'hooks'));
-  copyTree(CONNECTOR_HOOKS_SRC, join(DIST_ASSETS_DST, 'hooks'));
+  copyTree(CONNECTOR_HOOKS_SRC, join(RUNTIME_DST, 'hooks'), { excludeTests: true });
+  copyTree(CONNECTOR_HOOKS_SRC, join(DIST_ASSETS_DST, 'hooks'), { excludeTests: true });
 }
 if (existsSync(OPENCODE_PLUGINS_SRC)) {
   copyTree(OPENCODE_PLUGINS_SRC, join(DIST_ASSETS_DST, 'opencode-plugins'));