@aria_asi/cli 0.2.26 → 0.2.30

package/dist/assets/hooks/test-aria-preturn-memory-gate.mjs

@@ -0,0 +1,245 @@
+#!/usr/bin/env node
+// Test: aria-preturn-memory-gate.mjs — Enforcement Layer #49
+//
+// Runs the hook as a child process with simulated stdin events.
+// Asserts correct output shape for both the block and allow paths.
+//
+// Usage:  node hooks/test-aria-preturn-memory-gate.mjs
+// Exit code: 0 = all assertions passed, 1 = failure
+
+import { spawnSync, execSync } from 'node:child_process';
+import { writeFileSync, mkdirSync, existsSync, unlinkSync, readFileSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import * as path from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const HERE = path.dirname(fileURLToPath(import.meta.url));
+const HOOK = path.join(HERE, 'aria-preturn-memory-gate.mjs');
+const HOME = process.env.HOME || '/tmp';
+const CLAUDE_DIR = `${HOME}/.claude`;
+const SESSION_ID = `test-preturn-${Date.now()}`;
+
+// ── Helpers ────────────────────────────────────────────────────────────
+
+let passed = 0;
+let failed = 0;
+
+function assert(label, condition, actual) {
+  if (condition) {
+    console.log(`  PASS  ${label}`);
+    passed++;
+  } else {
+    console.error(`  FAIL  ${label}`);
+    if (actual !== undefined) console.error(`        got: ${JSON.stringify(actual)}`);
+    failed++;
+  }
+}
+
+function turnStatePath(sid) {
+  const safe = String(sid).replace(/[^a-zA-Z0-9_-]/g, '_');
+  return `${CLAUDE_DIR}/aria-turn-state-${safe}.json`;
+}
+
+function cleanTurnState(sid) {
+  const p = turnStatePath(sid);
+  if (existsSync(p)) unlinkSync(p);
+}
+
+function buildEvent(overrides = {}) {
+  return {
+    tool_name: 'Bash',
+    tool_input: { command: 'ls .' },
+    session_id: SESSION_ID,
+    transcript_path: null,
+    ...overrides,
+  };
+}
+
+function buildTranscriptWith(lines, filePath) {
+  const dir = path.dirname(filePath);
+  if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
+  writeFileSync(filePath, lines.map((l) => JSON.stringify(l)).join('\n') + '\n', 'utf-8');
+}
+
+function runHook(eventObj, env = {}) {
+  const result = spawnSync('node', [HOOK], {
+    input: JSON.stringify(eventObj),
+    encoding: 'utf-8',
+    env: { ...process.env, HOME, ...env },
+  });
+  let parsed = null;
+  try { parsed = JSON.parse(result.stdout.trim()); } catch { /* non-JSON stdout */ }
+  return { exitCode: result.status, stdout: result.stdout, stderr: result.stderr, parsed };
+}
+
+// ── Setup ──────────────────────────────────────────────────────────────
+
+if (!existsSync(CLAUDE_DIR)) mkdirSync(CLAUDE_DIR, { recursive: true });
+
+// ── Test 1: no transcript → gate fires, block + recovery payload ───────
+console.log('\nTest 1: no transcript (no context signals) → block with recovery');
+{
+  cleanTurnState(SESSION_ID);
+  const event = buildEvent({ transcript_path: null });
+  const { exitCode, parsed } = runHook(event);
+
+  assert('exit code is 2 (block)', exitCode === 2, exitCode);
+  assert('decision is "block"', parsed?.decision === 'block', parsed?.decision);
+  assert('reason is a non-empty string', typeof parsed?.reason === 'string' && parsed.reason.length > 0, parsed?.reason);
+  assert(
+    'hookSpecificOutput.recovery.action is "run_context_loader"',
+    parsed?.hookSpecificOutput?.recovery?.action === 'run_context_loader',
+    parsed?.hookSpecificOutput?.recovery?.action,
+  );
+  assert(
+    'hookSpecificOutput.recovery.target is session ID',
+    parsed?.hookSpecificOutput?.recovery?.target === SESSION_ID,
+    parsed?.hookSpecificOutput?.recovery?.target,
+  );
+  assert(
+    'hookSpecificOutput.recovery.expectedContext includes "harness_packet"',
+    Array.isArray(parsed?.hookSpecificOutput?.recovery?.expectedContext) &&
+      parsed.hookSpecificOutput.recovery.expectedContext.includes('harness_packet'),
+    parsed?.hookSpecificOutput?.recovery?.expectedContext,
+  );
+  assert(
+    'hookSpecificOutput.recovery.expectedContext includes "memory_files"',
+    Array.isArray(parsed?.hookSpecificOutput?.recovery?.expectedContext) &&
+      parsed.hookSpecificOutput.recovery.expectedContext.includes('memory_files'),
+    parsed?.hookSpecificOutput?.recovery?.expectedContext,
+  );
+  assert(
+    'hookSpecificOutput.recovery.expectedContext includes "binding_plan"',
+    Array.isArray(parsed?.hookSpecificOutput?.recovery?.expectedContext) &&
+      parsed.hookSpecificOutput.recovery.expectedContext.includes('binding_plan'),
+    parsed?.hookSpecificOutput?.recovery?.expectedContext,
+  );
+}
+
+// ── Test 2: transcript WITH all three signals → allow ─────────────────
+console.log('\nTest 2: transcript with all three context signals → allow');
+{
+  cleanTurnState(SESSION_ID);
+  const transcriptFile = path.join(tmpdir(), `test-transcript-preturn-${Date.now()}.jsonl`);
+
+  const assistantTextWithAllSignals = [
+    '🔐 Aria Harness — Session Packet loaded for turn.',
+    '[ARIA_DIRECTION] Proceed with implementation of Phase 8 research-first context injection.',
+    '<cognition>',
+    '  nur: Current task is implementing the pre-turn memory gate per feedback_no_graceful_degradation.md and project_aria_as_controller_inversion.md.',
+    '  mizan: Risk is that blocking without recovery creates dead-letter state. Soft-gate pattern resolves this.',
+    '  hikma: feedback_no_flag_without_fix.md requires inline fix for any discovery.',
+    '  tafakkur: The gate must deduplicate within 60s to prevent orchestrator retry loops.',
+    '</cognition>',
+  ].join('\n');
+
+  buildTranscriptWith(
+    [
+      {
+        role: 'user',
+        message: {
+          role: 'user',
+          content: [{ type: 'text', text: 'Implement phase 8.' }],
+        },
+      },
+      {
+        role: 'assistant',
+        message: {
+          role: 'assistant',
+          content: [{ type: 'text', text: assistantTextWithAllSignals }],
+        },
+      },
+    ],
+    transcriptFile,
+  );
+
+  const event = buildEvent({ transcript_path: transcriptFile });
+  const { exitCode, parsed } = runHook(event);
+
+  assert('exit code is 0 (allow)', exitCode === 0, exitCode);
+  assert('no block decision in stdout (stdout is empty or non-block)', !parsed || parsed.decision !== 'block', parsed?.decision);
+
+  // Cleanup
+  try { unlinkSync(transcriptFile); } catch {}
+}
+
+// ── Test 3: deduplication — gate already fired within 60s → skip ───────
+console.log('\nTest 3: gate already fired this turn (< 60s ago) → skip (exit 0)');
+{
+  // Pre-write a turn-state showing the gate fired 5 seconds ago
+  const statePath = turnStatePath(SESSION_ID);
+  writeFileSync(statePath, JSON.stringify({ lastTurnGateFiredAt: Date.now() - 5000, lastDecision: 'block', signals: {} }), 'utf-8');
+
+  const event = buildEvent({ transcript_path: null });
+  const { exitCode } = runHook(event);
+
+  assert('exit code is 0 (dedup skip — no re-fire within 60s)', exitCode === 0, exitCode);
+
+  cleanTurnState(SESSION_ID);
+}
+
+// ── Test 4: non-action tool (Read) → gate skips entirely ───────────────
+console.log('\nTest 4: non-action tool (Read) → gate skips (exit 0)');
+{
+  cleanTurnState(SESSION_ID);
+  const event = buildEvent({ tool_name: 'Read', transcript_path: null });
+  const { exitCode } = runHook(event);
+  assert('exit code is 0 (ungated read tool)', exitCode === 0, exitCode);
+}
+
+// ── Test 5: REMOVED 2026-04-27 — env-var kill-switch stripped per Hamza
+//    directive ("those should've been my choice to give you to turn off
+//    not free for you to access"). Gates are unconditional from the gated
+//    process. Disable = remove hook entry from ~/.claude/settings.json.
+
+// ── Test 6: only ONE signal present → still blocks ────────────────────
+console.log('\nTest 6: only harness packet signal (missing direction + memory ref) → block');
+{
+  cleanTurnState(SESSION_ID);
+  const transcriptFile = path.join(tmpdir(), `test-transcript-preturn-partial-${Date.now()}.jsonl`);
+
+  const assistantTextPartial = '🔐 Aria Harness — partial context only. No direction. No memory refs.';
+
+  buildTranscriptWith(
+    [
+      {
+        role: 'user',
+        message: {
+          role: 'user',
+          content: [{ type: 'text', text: 'Do the thing.' }],
+        },
+      },
+      {
+        role: 'assistant',
+        message: {
+          role: 'assistant',
+          content: [{ type: 'text', text: assistantTextPartial }],
+        },
+      },
+    ],
+    transcriptFile,
+  );
+
+  const event = buildEvent({ transcript_path: transcriptFile });
+  const { exitCode, parsed } = runHook(event);
+
+  assert('exit code is 2 (block on partial signals)', exitCode === 2, exitCode);
+  assert('decision is "block"', parsed?.decision === 'block', parsed?.decision);
+  assert(
+    'reason mentions missing aria_direction',
+    typeof parsed?.reason === 'string' && parsed.reason.includes('aria_direction'),
+    parsed?.reason?.slice(0, 200),
+  );
+
+  try { unlinkSync(transcriptFile); } catch {}
+  cleanTurnState(SESSION_ID);
+}
+
+// ── Summary ────────────────────────────────────────────────────────────
+console.log(`\n${passed + failed} tests: ${passed} passed, ${failed} failed`);
+if (failed > 0) {
+  process.exit(1);
+} else {
+  console.log('All assertions passed.');
+  process.exit(0);
+}

package/dist/assets/hooks/test-tier-lens-labeling.mjs

@@ -0,0 +1,399 @@
+#!/usr/bin/env node
+// Smoke test: Phase 11 #59 — tier-aware lens labeling
+//
+// Verifies that aria-pre-tool-gate.mjs and aria-stop-gate.mjs:
+//   1. Show canonical Arabic lens names (nur, mizan, etc.) when the harness
+//      packet has isHamza/hamza=true (OWNER tier).
+//   2. Show neutral generic labels (perception, balance, etc.) when the
+//      harness packet is client-surface (CLIENT tier).
+//   3. Gate enforcement (block on insufficient cognition) fires in both
+//      tiers — label swap does not change gate substance.
+//
+// Usage: node hooks/test-tier-lens-labeling.mjs
+// Exit:  0 = all assertions passed, 1 = failure
+
+import { spawnSync } from 'node:child_process';
+import { writeFileSync, mkdirSync, existsSync, unlinkSync, readFileSync } from 'node:fs';
+import * as path from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const HERE = path.dirname(fileURLToPath(import.meta.url));
+const PRE_TOOL_HOOK = path.join(HERE, 'aria-pre-tool-gate.mjs');
+const STOP_HOOK = path.join(HERE, 'aria-stop-gate.mjs');
+const HOME = process.env.HOME || '/tmp';
+const CLAUDE_DIR = `${HOME}/.claude`;
+const PACKET_PATH = `${CLAUDE_DIR}/.aria-harness-last-packet.json`;
+
+// ── Canonical vs generic label sets ────────────────────────────────────────
+const CANONICAL = ['nur', 'mizan', 'hikma', 'tafakkur', 'tadabbur', 'ilham', 'wahi', 'firasah'];
+const GENERIC   = ['perception', 'balance', 'wisdom', 'reflection', 'foresight', 'insight', 'revelation', 'discernment'];
+
+// ── Assertion helpers ───────────────────────────────────────────────────────
+let passed = 0;
+let failed = 0;
+
+function assert(label, condition, detail) {
+  if (condition) {
+    console.log(`  PASS  ${label}`);
+    passed++;
+  } else {
+    console.error(`  FAIL  ${label}`);
+    if (detail !== undefined) console.error(`        detail: ${String(detail).slice(0, 300)}`);
+    failed++;
+  }
+}
+
+// ── Packet helpers ──────────────────────────────────────────────────────────
+// Save/restore the real packet so running this test doesn't corrupt live state.
+let originalPacketContent = null;
+
+function savePacket() {
+  try {
+    if (existsSync(PACKET_PATH)) {
+      originalPacketContent = readFileSync(PACKET_PATH, 'utf8');
+    } else {
+      originalPacketContent = null;
+    }
+  } catch { originalPacketContent = null; }
+}
+
+function restorePacket() {
+  try {
+    if (originalPacketContent !== null) {
+      writeFileSync(PACKET_PATH, originalPacketContent);
+    } else if (existsSync(PACKET_PATH)) {
+      unlinkSync(PACKET_PATH);
+    }
+  } catch {}
+}
+
+function writeOwnerPacket() {
+  // contractGate.signals.hamza === true → OWNER tier
+  const packet = {
+    ok: true,
+    stage: 'preflight',
+    harness: 'surface=platform:hamza group:false hamza:true',
+    contractGate: {
+      signals: { hamza: true },
+    },
+  };
+  if (!existsSync(CLAUDE_DIR)) mkdirSync(CLAUDE_DIR, { recursive: true });
+  writeFileSync(PACKET_PATH, JSON.stringify(packet));
+}
+
+function writeClientPacket() {
+  // contractGate.signals.hamza === "false" (string) → CLIENT tier
+  const packet = {
+    ok: true,
+    stage: 'preflight',
+    harness: 'surface=platform:client group:false hamza:false',
+    contractGate: {
+      signals: { hamza: 'false' },
+    },
+  };
+  if (!existsSync(CLAUDE_DIR)) mkdirSync(CLAUDE_DIR, { recursive: true });
+  writeFileSync(PACKET_PATH, JSON.stringify(packet));
+}
+
+// ── Transcript helpers ──────────────────────────────────────────────────────
+// Write a minimal transcript where the most recent assistant turn has NO
+// cognition block — triggering a block decision.
+function writeEmptyTranscript(transcriptPath) {
+  const entries = [
+    // User message
+    JSON.stringify({
+      message: { role: 'user', content: [{ type: 'text', text: 'Run a build command' }] },
+    }),
+    // Assistant text with no cognition
+    JSON.stringify({
+      message: {
+        role: 'assistant',
+        content: [{ type: 'text', text: 'I will run the build.' }],
+      },
+    }),
+  ];
+  writeFileSync(transcriptPath, entries.join('\n'));
+}
+
+// Write a transcript with a Stop-gate-triggering assistant response (long,
+// decision-signal, but no cognition).
+function writeNoCognitionStopTranscript(transcriptPath) {
+  const longText = 'I recommend shipping this feature immediately because the test suite is green and the build passed. Let me proceed with the deployment now. ' +
+    'The plan is as follows: first we build, then we deploy, then we verify. I would suggest we move forward without delay.';
+  const entries = [
+    JSON.stringify({
+      message: { role: 'user', content: [{ type: 'text', text: 'Should I ship?' }] },
+    }),
+    JSON.stringify({
+      message: {
+        role: 'assistant',
+        content: [{ type: 'text', text: longText }],
+      },
+    }),
+  ];
+  writeFileSync(transcriptPath, entries.join('\n'));
+}
+
+// ── Run hook helpers ────────────────────────────────────────────────────────
+// Use a non-destructive but non-trivial command that skips the verify path
+// and goes straight to cognition-missing, where lens labels appear.
+function runPreToolGate(transcriptPath, command = 'npm run build --workspace=packages/aria-connector') {
+  const event = JSON.stringify({
+    tool_name: 'Bash',
+    tool_input: { command },
+    transcript_path: transcriptPath,
+    session_id: `test-tier-${Date.now()}`,
+  });
+  return spawnSync(process.execPath, [PRE_TOOL_HOOK], {
+    input: event,
+    encoding: 'utf8',
+    timeout: 10000,
+    env: {
+      ...process.env,
+      HOME,
+      ARIA_COGNITION_PUSH: 'off',   // silence network push
+      ARIA_HARNESS_TOKEN: '',        // no outbound harness calls
+      ARIA_BINDING_ENABLED: 'false', // disable binding gate — isolate cognition test
+    },
+  });
+}
+
+function runStopGate(transcriptPath) {
+  const event = JSON.stringify({
+    tool_name: 'Stop',
+    transcript_path: transcriptPath,
+    session_id: `test-tier-${Date.now()}`,
+  });
+  return spawnSync(process.execPath, [STOP_HOOK], {
+    input: event,
+    encoding: 'utf8',
+    timeout: 15000,
+    env: {
+      ...process.env,
+      HOME,
+      ARIA_COGNITION_PUSH: 'off',
+      ARIA_HARNESS_TOKEN: '',
+    },
+  });
+}
+
+// ── Test utilities ──────────────────────────────────────────────────────────
+const tmpTranscript = `/tmp/test-tier-transcript-${Date.now()}.jsonl`;
+const tmpTranscriptStop = `/tmp/test-tier-stop-transcript-${Date.now()}.jsonl`;
+
+function cleanup() {
+  [tmpTranscript, tmpTranscriptStop].forEach((p) => {
+    try { if (existsSync(p)) unlinkSync(p); } catch {}
+  });
+  restorePacket();
+}
+
+// ── Suite ───────────────────────────────────────────────────────────────────
+
+console.log('\n=== Phase 11 #59 — Tier-aware lens labeling smoke tests ===\n');
+
+// Save existing packet so we can restore after test run.
+savePacket();
+
+// ── Test 1: pre-tool-gate, OWNER tier → canonical labels in block reason ──
+console.log('Test 1: aria-pre-tool-gate — OWNER tier shows canonical lens names');
+{
+  writeOwnerPacket();
+  writeEmptyTranscript(tmpTranscript);
+  const result = runPreToolGate(tmpTranscript);
+
+  // Gate should block (exit 2) — no cognition in transcript
+  assert(
+    'T1: gate blocks (exit 2)',
+    result.status === 2,
+    `exit=${result.status} stderr=${result.stderr?.slice(0, 200)}`,
+  );
+
+  let blockReason = '';
+  try {
+    const parsed = JSON.parse(result.stdout);
+    blockReason = parsed.reason || '';
+  } catch {
+    blockReason = result.stdout || '';
+  }
+
+  // Must mention at least one canonical label
+  const hasCanonical = CANONICAL.some((name) => blockReason.includes(`${name}:`));
+  assert(
+    'T1: block reason mentions canonical label (e.g. nur:)',
+    hasCanonical,
+    blockReason.slice(0, 400),
+  );
+
+  // Must NOT mention generic labels — no IP exposure for owner
+  // (owner should only see canonical; absence of generic is nice-to-verify
+  // but not a hard requirement since some generic words may appear in prose)
+  // Instead check the first lens label is canonical not generic:
+  const firstCanonicalIdx = blockReason.indexOf(`${CANONICAL[0]}:`);
+  const firstGenericIdx = blockReason.indexOf(`${GENERIC[0]}:`);
+  assert(
+    'T1: first lens label is canonical (nur:), not generic (perception:)',
+    firstCanonicalIdx >= 0 && (firstGenericIdx < 0 || firstCanonicalIdx < firstGenericIdx),
+    `firstCanonicalIdx=${firstCanonicalIdx} firstGenericIdx=${firstGenericIdx}`,
+  );
+}
+
+// ── Test 2: pre-tool-gate, CLIENT tier → generic labels in block reason ──
+console.log('\nTest 2: aria-pre-tool-gate — CLIENT tier shows generic lens labels');
+{
+  writeClientPacket();
+  writeEmptyTranscript(tmpTranscript);
+  const result = runPreToolGate(tmpTranscript);
+
+  assert(
+    'T2: gate blocks (exit 2)',
+    result.status === 2,
+    `exit=${result.status} stderr=${result.stderr?.slice(0, 200)}`,
+  );
+
+  let blockReason = '';
+  try {
+    const parsed = JSON.parse(result.stdout);
+    blockReason = parsed.reason || '';
+  } catch {
+    blockReason = result.stdout || '';
+  }
+
+  // Must mention at least one generic label
+  const hasGeneric = GENERIC.some((name) => blockReason.includes(`${name}:`));
+  assert(
+    'T2: block reason mentions generic label (e.g. perception:)',
+    hasGeneric,
+    blockReason.slice(0, 400),
+  );
+
+  // Must NOT expose canonical Arabic names
+  const exposesCanonical = CANONICAL.some((name) =>
+    blockReason.includes(`${name}:`),
+  );
+  assert(
+    'T2: block reason does NOT expose canonical Arabic lens names',
+    !exposesCanonical,
+    `canonical leak: ${CANONICAL.filter((n) => blockReason.includes(`${n}:`)).join(', ')} in: ${blockReason.slice(0, 300)}`,
+  );
+
+  // Check doctrine memory filename is neutralized (no feedback_no_flag_without_fix.md for client)
+  const noDocFileLeak = !blockReason.includes('feedback_no_flag_without_fix.md');
+  // (This specific file only appears in discovery-unresolved path; just verify
+  // that the block reason itself also neutralizes EIGHT_LENS_DOCTRINE references if any)
+  // For this test we just assert the generic label set is present.
+  assert(
+    'T2: first generic label (perception:) appears in block reason',
+    blockReason.includes(`${GENERIC[0]}:`),
+    blockReason.slice(0, 400),
+  );
+}
+
+// ── Test 3: stop-gate, OWNER tier → canonical labels ──
+console.log('\nTest 3: aria-stop-gate — OWNER tier shows canonical lens names');
+{
+  writeOwnerPacket();
+  writeNoCognitionStopTranscript(tmpTranscriptStop);
+  const result = runStopGate(tmpTranscriptStop);
+
+  assert(
+    'T3: stop-gate blocks (exit 2)',
+    result.status === 2,
+    `exit=${result.status} stderr=${result.stderr?.slice(0, 200)}`,
+  );
+
+  let blockReason = '';
+  try {
+    const parsed = JSON.parse(result.stdout);
+    blockReason = parsed.reason || '';
+  } catch {
+    blockReason = result.stdout || '';
+  }
+
+  const hasCanonical = CANONICAL.some((name) => blockReason.includes(`${name}:`));
+  assert(
+    'T3: stop-gate block reason mentions canonical label',
+    hasCanonical,
+    blockReason.slice(0, 400),
+  );
+}
+
+// ── Test 4: stop-gate, CLIENT tier → generic labels, no canonical leak ──
+console.log('\nTest 4: aria-stop-gate — CLIENT tier shows generic labels, no canonical leak');
+{
+  writeClientPacket();
+  writeNoCognitionStopTranscript(tmpTranscriptStop);
+  const result = runStopGate(tmpTranscriptStop);
+
+  assert(
+    'T4: stop-gate blocks (exit 2)',
+    result.status === 2,
+    `exit=${result.status} stderr=${result.stderr?.slice(0, 200)}`,
+  );
+
+  let blockReason = '';
+  try {
+    const parsed = JSON.parse(result.stdout);
+    blockReason = parsed.reason || '';
+  } catch {
+    blockReason = result.stdout || '';
+  }
+
+  const hasGeneric = GENERIC.some((name) => blockReason.includes(`${name}:`));
+  assert(
+    'T4: stop-gate block reason mentions generic label',
+    hasGeneric,
+    blockReason.slice(0, 400),
+  );
+
+  const exposesCanonical = CANONICAL.some((name) => blockReason.includes(`${name}:`));
+  assert(
+    'T4: stop-gate block reason does NOT expose canonical lens names',
+    !exposesCanonical,
+    `canonical leak: ${CANONICAL.filter((n) => blockReason.includes(`${n}:`)).join(', ')}`,
+  );
+}
+
+// ── Test 5: packet missing → defaults to CLIENT tier (fail-safe) ──────────
+console.log('\nTest 5: missing packet cache → defaults to CLIENT tier (fail-safe)');
+{
+  // Remove the packet cache
+  try { unlinkSync(PACKET_PATH); } catch {}
+  writeEmptyTranscript(tmpTranscript);
+  const result = runPreToolGate(tmpTranscript);
+
+  assert(
+    'T5: gate blocks (exit 2) with no packet',
+    result.status === 2,
+    `exit=${result.status}`,
+  );
+
+  let blockReason = '';
+  try {
+    const parsed = JSON.parse(result.stdout);
+    blockReason = parsed.reason || '';
+  } catch {
+    blockReason = result.stdout || '';
+  }
+
+  // With no packet, should default to generic (client-safe fail direction)
+  const hasGeneric = GENERIC.some((name) => blockReason.includes(`${name}:`));
+  const exposesCanonical = CANONICAL.some((name) => blockReason.includes(`${name}:`));
+  assert(
+    'T5: defaults to generic labels when packet is absent',
+    hasGeneric && !exposesCanonical,
+    `generic=${hasGeneric} canonicalLeak=${exposesCanonical} reason=${blockReason.slice(0, 300)}`,
+  );
+}
+
+// ── Summary ─────────────────────────────────────────────────────────────────
+cleanup();
+console.log(`\n${'─'.repeat(60)}`);
+console.log(`Results: ${passed} passed, ${failed} failed`);
+if (failed > 0) {
+  console.error('\nSome tests FAILED — see FAIL lines above.');
+  process.exit(1);
+} else {
+  console.log('\nAll tests PASSED.');
+  process.exit(0);
+}