principles-disciple 1.127.0 → 1.129.0

package/tests/core/rule-host-unhealthy-visibility.test.ts

@@ -1,261 +0,0 @@
-/**
- * PRI-437 Slice 4: Approved compile failure is visible in EventLog, CLI and Console
- *
- * PURPOSE: Verify that when an approved rule fails to compile/load, the failure
- * is recorded in EventLog as an unhealthy event with reason and nextAction.
- * NOT just a logger.warn that's silently skipped.
- *
- * ERR risk mitigation:
- *   - ERR-002: degradation must include a reason (not silent logger.warn)
- *   - Observability: unhealthy state must be persisted and queryable
- *
- * Test approach:
- *   - Real SQLite activation with broken code (syntax error)
- *   - Real RuleHost.evaluate() (public interface)
- *   - Read real EventLog JSONL file to verify unhealthy record
- */
-import { describe, it, expect, beforeEach, afterEach } from 'vitest';
-import * as fs from 'fs';
-import * as os from 'os';
-import * as path from 'path';
-import { SqliteConnection, SqliteActivationStateStore } from '@principles/core/runtime-v2';
-import type { RuleHostInput } from '@principles/core/runtime-v2';
-import { RuleHost } from '../../src/core/rule-host.js';
-import { EventLogService } from '../../src/core/event-log.js';
-
-// ── Test helpers ───────────────────────────────────────────────────────────
-
-const RULE_ID_BROKEN = 'R_TEST_BROKEN_004';
-const ARTIFACT_ID_BROKEN = 'art-broken-004';
-const ACTIVATION_ID_BROKEN = `act_code_${RULE_ID_BROKEN}`;
-
-// Code with a syntax error that will cause compilation failure
-const BROKEN_CODE = `
-function evaluate(input, helpers) {
-  // Syntax error: unclosed brace
-  return { decision: 'block', matched: true, reason: 'broken'
-// Missing closing brace for function and return object
-var meta = { name: 'broken-rule', version: '1', ruleId: '${RULE_ID_BROKEN}', coversCondition: 'all' };
-`;
-
-let tempWorkspaceDir: string;
-let tempStateDir: string;
-let sqliteConn: SqliteConnection;
-
-function setupTempDirs(): void {
-  const baseTmp = os.tmpdir();
-  tempWorkspaceDir = fs.mkdtempSync(path.join(baseTmp, 'pd-rulehost-unhealthy-'));
-  tempStateDir = path.join(tempWorkspaceDir, '.principles');
-  fs.mkdirSync(tempStateDir, { recursive: true });
-}
-
-function insertRuleArtifact(): void {
-  const db = sqliteConn.getDb();
-  const now = new Date().toISOString();
-  const contentJson = JSON.stringify({
-    principleId: 'P_TEST_BROKEN_004',
-    ruleId: RULE_ID_BROKEN,
-    implementationCode: BROKEN_CODE,
-    goldenTrace: { traceId: 'trace-broken-004', cases: [], createdAt: now, version: 1 },
-    ruleHostGateDecision: 'accepted_shadow',
-    affectedTools: ['write_file'],
-    painReasonSummary: 'Test: broken code compilation',
-  });
-
-  db.prepare(`
-    INSERT INTO pi_artifacts (artifact_id, artifact_kind, source_task_id, source_principle_id, source_rule_id, lineage_artifact_ids, validation_status, content_json, created_at, updated_at)
-    VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
-  `).run(
-    ARTIFACT_ID_BROKEN,
-    'rule',
-    'task-broken-004',
-    'P_TEST_BROKEN_004',
-    RULE_ID_BROKEN,
-    '[]',
-    'validated',
-    contentJson,
-    now,
-    now,
-  );
-}
-
-async function insertActivation(): Promise<void> {
-  const store = new SqliteActivationStateStore(sqliteConn);
-  const now = new Date().toISOString();
-  await store.recordActivation({
-    activationId: ACTIVATION_ID_BROKEN,
-    idempotencyKey: `${ARTIFACT_ID_BROKEN}::code_tool_hook`,
-    artifactId: ARTIFACT_ID_BROKEN,
-    channel: 'code_tool_hook',
-    action: 'code_tool_hook_shadow_activate',
-    targetRef: `impl://${RULE_ID_BROKEN}`,
-    activatedAt: now,
-    deactivatedAt: null,
-  });
-}
-
-function makeInput(): RuleHostInput {
-  return {
-    action: {
-      toolName: 'write_file',
-      normalizedPath: '/etc/passwd',
-      paramsSummary: { path: '/etc/passwd' },
-    },
-    workspace: { isRiskPath: false, planStatus: 'NONE' as const, hasPlanFile: false },
-    session: { sessionId: 'test-session-unhealthy', currentGfi: 0, recentThinking: false },
-    evolution: { epTier: 1 },
-    derived: { estimatedLineChanges: 1, bashRisk: 'safe' as const },
-  };
-}
-
-function readTodayEvents(stateDir: string): string {
-  const today = new Date().toISOString().slice(0, 10);
-  const eventsFile = path.join(stateDir, 'logs', `events_${today}.jsonl`);
-  if (!fs.existsSync(eventsFile)) {
-    return '';
-  }
-  return fs.readFileSync(eventsFile, 'utf-8');
-}
-
-// ── Setup / Teardown ───────────────────────────────────────────────────────
-
-beforeEach(() => {
-  setupTempDirs();
-  EventLogService.disposeAll();
-  sqliteConn = new SqliteConnection(tempWorkspaceDir);
-  sqliteConn.getDb();
-});
-
-afterEach(() => {
-  EventLogService.disposeAll();
-  try { sqliteConn?.close(); } catch { /* best-effort */ }
-  try { fs.rmSync(tempWorkspaceDir, { recursive: true, force: true }); } catch { /* Windows */ }
-});
-
-// ── Slice 4: Compile failure visible in EventLog ───────────────────────────
-
-describe('PRI-437 Slice 4: Approved compile failure is visible in EventLog', () => {
-  it('broken code compilation → EventLog records rulehost_unhealthy with reason and nextAction', async () => {
-    insertRuleArtifact();
-    await insertActivation();
-
-    const warnCalls: string[] = [];
-    const spyLogger = {
-      warn: (message: string) => { warnCalls.push(message); },
-      error: () => {},
-      info: () => {},
-    };
-
-    const ruleHost = new RuleHost(tempStateDir, spyLogger, { workspaceDir: tempWorkspaceDir });
-
-    // Evaluate — should attempt to compile the broken code and fail
-    const result = ruleHost.evaluate(makeInput());
-
-    // Conservative degradation: undefined (no opinion)
-    expect(result).toBeUndefined();
-
-    // Flush EventLog to ensure events are written to disk
-    const eventLog = EventLogService.get(tempStateDir);
-    eventLog.flush();
-
-    // Read the EventLog JSONL file and verify unhealthy record exists
-    const eventsContent = readTodayEvents(tempStateDir);
-
-    // Must contain a rulehost_unhealthy event (NOT just logger.warn)
-    expect(eventsContent).toContain('rulehost_unhealthy');
-
-    // Structured validation: parse JSONL lines and find the unhealthy event
-    const lines = eventsContent.trim().split('\n').filter(l => l.trim());
-    const unhealthyEvents = lines
-      .map(line => { try { return JSON.parse(line); } catch { return null; } })
-      .filter(evt => evt?.type === 'rulehost_unhealthy');
-
-    expect(unhealthyEvents.length).toBeGreaterThanOrEqual(1);
-
-    // Verify the unhealthy event has all required fields in the same record
-    const unhealthy = unhealthyEvents[0];
-    expect(unhealthy.data.activationId).toBe(ACTIVATION_ID_BROKEN);
-    expect(unhealthy.data.ruleId).toBe(RULE_ID_BROKEN);
-    expect(typeof unhealthy.data.reason).toBe('string');
-    expect(unhealthy.data.reason.length).toBeGreaterThan(0);
-    expect(typeof unhealthy.data.nextAction).toBe('string');
-    expect(unhealthy.data.nextAction.length).toBeGreaterThan(0);
-  });
-
-  it('valid rule does NOT produce rulehost_unhealthy event', async () => {
-    // Insert a VALID rule (not broken)
-    const VALID_CODE = `
-function evaluate(input, helpers) {
-  var p = input.action.normalizedPath || '';
-  if (p.indexOf('/etc/') === 0) {
-    return { decision: 'block', matched: true, reason: 'valid block' };
-  }
-  return { decision: 'allow', matched: false, reason: 'not matched' };
-}
-var meta = { name: 'valid-rule', version: '1', ruleId: '${RULE_ID_BROKEN}', coversCondition: 'all' };
-`;
-
-    const db = sqliteConn.getDb();
-    const now = new Date().toISOString();
-    const contentJson = JSON.stringify({
-      principleId: 'P_TEST_VALID_004',
-      ruleId: RULE_ID_BROKEN,
-      implementationCode: VALID_CODE,
-      goldenTrace: { traceId: 'trace-valid-004', cases: [], createdAt: now, version: 1 },
-      ruleHostGateDecision: 'accepted_shadow',
-      affectedTools: ['write_file'],
-      painReasonSummary: 'Test: valid code',
-    });
-
-    db.prepare(`
-      INSERT INTO pi_artifacts (artifact_id, artifact_kind, source_task_id, source_principle_id, source_rule_id, lineage_artifact_ids, validation_status, content_json, created_at, updated_at)
-      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
-    `).run(
-      ARTIFACT_ID_BROKEN, 'rule', 'task-valid-004', 'P_TEST_VALID_004', RULE_ID_BROKEN,
-      '[]', 'validated', contentJson, now, now,
-    );
-
-    await insertActivation();
-
-    const ruleHost = new RuleHost(tempStateDir, { warn: () => {}, error: () => {}, info: () => {} }, { workspaceDir: tempWorkspaceDir });
-    const result = ruleHost.evaluate(makeInput());
-
-    // Valid rule should block (not undefined)
-    expect(result).toBeDefined();
-    expect(result?.decision).toBe('block');
-
-    // Flush and verify NO unhealthy event
-    const eventLog = EventLogService.get(tempStateDir);
-    eventLog.flush();
-
-    const eventsContent = readTodayEvents(tempStateDir);
-    expect(eventsContent).not.toContain('rulehost_unhealthy');
-  });
-
-  it('runtime-invalid result is persisted as rulehost_unhealthy and never executes', async () => {
-    const invalidResultCode = `
-function evaluate() {
-  return { decision: 'block', matched: 'yes', reason: 'invalid matched type' };
-}
-var meta = { name: 'invalid-result-rule', version: '1', ruleId: '${RULE_ID_BROKEN}', coversCondition: 'all' };
-`;
-    const now = new Date().toISOString();
-    sqliteConn.getDb().prepare(`
-      INSERT INTO pi_artifacts (artifact_id, artifact_kind, source_task_id, source_principle_id, source_rule_id, lineage_artifact_ids, validation_status, content_json, created_at, updated_at)
-      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
-    `).run(
-      ARTIFACT_ID_BROKEN, 'rule', 'task-invalid-result', 'P_TEST_INVALID_RESULT', RULE_ID_BROKEN,
-      '[]', 'validated', JSON.stringify({ ruleId: RULE_ID_BROKEN, implementationCode: invalidResultCode }), now, now,
-    );
-    await insertActivation();
-
-    const ruleHost = new RuleHost(tempStateDir, { warn: () => {} }, { workspaceDir: tempWorkspaceDir });
-    expect(ruleHost.evaluate(makeInput())).toBeUndefined();
-    EventLogService.get(tempStateDir).flush();
-
-    const events = readTodayEvents(tempStateDir);
-    expect(events).toContain('rulehost_unhealthy');
-    expect(events).toContain('invalid RuleHostResult');
-    expect(events).toContain(ACTIVATION_ID_BROKEN);
-  });
-});

package/tests/core/rule-host-validation.test.ts

@@ -1,315 +0,0 @@
-/**
- * PRI-437: Harden RuleHost execution validation, isolation and activation health
- *
- * TDD vertical slices:
- *   1. Malformed VM results never enforce and create unhealthy evidence
- *   2. Valid decisions work through public before-tool-call hook
- *   3. Infinite loop and memory allocation terminate without taking down host
- *   4. Approved compile failure is visible in health, CLI JSON and Console API
- *   5. Invalid tier/adversarial diagnostics cannot corrupt output
- *
- * Tests verify through public interfaces:
- *   - Real SQLite store (SqliteConnection + SqliteActivationStateStore)
- *   - Real RuleHost.evaluate()
- *   - No mocking of private internals
- *
- * ERR risk mitigation:
- *   - ERR-001: no `as` bypass at trust boundary — VM output validated as unknown
- *   - ERR-002: no catch-and-degrade — malformed results emit structured unhealthy evidence
- *   - ERR-013: Object.hasOwn for untrusted object key checks
- *   - ERR-024: validator wired into production path, not just demo/test
- */
-import { describe, it, expect, beforeEach, afterEach } from 'vitest';
-import * as fs from 'fs';
-import * as os from 'os';
-import * as path from 'path';
-import { SqliteConnection, SqliteActivationStateStore } from '@principles/core/runtime-v2';
-import type { RuleHostInput } from '@principles/core/runtime-v2';
-import { RuleHost } from '../../src/core/rule-host.js';
-
-// ── Test helpers (shared with rule-host-sqlite-source.test.ts pattern) ──────
-
-const RULE_ID = 'R_TEST_PRI437_001';
-const ARTIFACT_ID = 'art-pri437-001';
-const ACTIVATION_ID = `act_code_${RULE_ID}`;
-
-let tempWorkspaceDir: string;
-let tempStateDir: string;
-let sqliteConn: SqliteConnection;
-
-function setupTempDirs(): void {
-  const baseTmp = os.tmpdir();
-  tempWorkspaceDir = fs.mkdtempSync(path.join(baseTmp, 'pd-rulehost-pri437-'));
-  tempStateDir = path.join(tempWorkspaceDir, '.principles');
-  fs.mkdirSync(tempStateDir, { recursive: true });
-}
-
-function insertRuleArtifact(overrides?: {
-  artifactId?: string;
-  ruleId?: string;
-  contentJson?: string;
-  validationStatus?: string;
-  sourceTaskId?: string;
-}): void {
-  const artifactId = overrides?.artifactId ?? ARTIFACT_ID;
-  const ruleId = overrides?.ruleId ?? RULE_ID;
-  const validationStatus = overrides?.validationStatus ?? 'validated';
-  const sourceTaskId = overrides?.sourceTaskId ?? 'task-pri437-001';
-  const db = sqliteConn.getDb();
-  const now = new Date().toISOString();
-
-  const contentJson = overrides?.contentJson ?? JSON.stringify({
-    principleId: 'P_TEST_PRI437',
-    ruleId,
-    implementationCode: '',
-    goldenTrace: {
-      traceId: 'trace-pri437',
-      cases: [],
-      createdAt: now,
-      version: 1,
-    },
-    ruleHostGateDecision: 'accepted_shadow',
-    affectedTools: ['write_file'],
-    painReasonSummary: 'Test: PRI-437',
-  });
-
-  db.prepare(`
-    INSERT INTO pi_artifacts (artifact_id, artifact_kind, source_task_id, source_principle_id, source_rule_id, lineage_artifact_ids, validation_status, content_json, created_at, updated_at)
-    VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
-  `).run(
-    artifactId,
-    'rule',
-    sourceTaskId,
-    'P_TEST_PRI437',
-    ruleId,
-    '[]',
-    validationStatus,
-    contentJson,
-    now,
-    now,
-  );
-}
-
-async function insertCodeToolHookActivation(overrides?: {
-  activationId?: string;
-  artifactId?: string;
-  ruleId?: string;
-  deactivatedAt?: string | null;
-}): Promise<void> {
-  const activationId = overrides?.activationId ?? ACTIVATION_ID;
-  const artifactId = overrides?.artifactId ?? ARTIFACT_ID;
-  const ruleId = overrides?.ruleId ?? RULE_ID;
-  const store = new SqliteActivationStateStore(sqliteConn);
-  const now = new Date().toISOString();
-
-  await store.recordActivation({
-    activationId,
-    idempotencyKey: `${artifactId}::code_tool_hook`,
-    artifactId,
-    channel: 'code_tool_hook',
-    action: 'code_tool_hook_shadow_activate',
-    targetRef: `impl://${ruleId}`,
-    activatedAt: now,
-    deactivatedAt: overrides?.deactivatedAt ?? null,
-  });
-}
-
-function makeInput(normalizedPath: string): RuleHostInput {
-  return {
-    action: {
-      toolName: 'write_file',
-      normalizedPath,
-      paramsSummary: { path: normalizedPath },
-    },
-    workspace: {
-      isRiskPath: false,
-      planStatus: 'NONE',
-      hasPlanFile: false,
-    },
-    session: {
-      sessionId: 'test-session',
-      currentGfi: 0,
-      recentThinking: false,
-    },
-    evolution: {
-      epTier: 1,
-    },
-    derived: {
-      estimatedLineChanges: 1,
-      bashRisk: 'safe' as const,
-    },
-  };
-}
-
-function makeContentJson(ruleId: string, code: string): string {
-  return JSON.stringify({
-    principleId: 'P_TEST_PRI437',
-    ruleId,
-    implementationCode: code,
-    goldenTrace: {
-      traceId: 'trace-pri437',
-      cases: [],
-      createdAt: new Date().toISOString(),
-      version: 1,
-    },
-    ruleHostGateDecision: 'accepted_shadow',
-    affectedTools: ['write_file'],
-    painReasonSummary: 'Test: PRI-437',
-  });
-}
-
-// ── Setup / Teardown ───────────────────────────────────────────────────────
-
-beforeEach(() => {
-  setupTempDirs();
-  sqliteConn = new SqliteConnection(tempWorkspaceDir);
-  sqliteConn.getDb();
-});
-
-afterEach(() => {
-  try { sqliteConn?.close(); } catch { /* best-effort */ }
-  try { fs.rmSync(tempWorkspaceDir, { recursive: true, force: true }); } catch { /* Windows */ }
-});
-
-// ── Slice 1: Malformed VM results never enforce and create unhealthy evidence ─
-
-describe('PRI-437 Slice 1: Malformed VM results never enforce and create unhealthy evidence', () => {
-  it('malformed result with non-string reason does not enforce and emits unhealthy evidence', async () => {
-    // RuleCode returns { matched: true, decision: 'block', reason: 42 } — reason is a number, not a string
-    const MALFORMED_CODE = `
-function evaluate(input, helpers) {
-  return { matched: true, decision: 'block', reason: 42 };
-}
-var meta = { name: 'malformed-rule', version: '1', ruleId: '${RULE_ID}', coversCondition: 'all' };
-`;
-    insertRuleArtifact({ contentJson: makeContentJson(RULE_ID, MALFORMED_CODE) });
-    await insertCodeToolHookActivation();
-
-    const warnCalls: string[] = [];
-    const spyLogger: { warn: (_message: string) => void } = {
-      warn: (message: string) => { warnCalls.push(message); },
-    };
-
-    const ruleHost = new RuleHost(tempStateDir, spyLogger, { workspaceDir: tempWorkspaceDir });
-    const result = ruleHost.evaluate(makeInput('/etc/passwd'));
-
-    // Malformed result must NOT enforce — no block returned
-    expect(result).toBeUndefined();
-
-    // Unhealthy evidence must be emitted via logger.warn
-    expect(warnCalls.length).toBeGreaterThan(0);
-    const unhealthyWarn = warnCalls.find(m =>
-      m.toLowerCase().includes('invalid') ||
-      m.toLowerCase().includes('malformed') ||
-      m.toLowerCase().includes('unhealthy') ||
-      m.toLowerCase().includes('validation')
-    );
-    expect(unhealthyWarn).toBeDefined();
-  });
-
-  it('malformed result with non-boolean matched does not enforce and emits unhealthy evidence', async () => {
-    // RuleCode returns { matched: "yes", decision: 'block', reason: 'valid' } — matched is a string
-    const MALFORMED_CODE = `
-function evaluate(input, helpers) {
-  return { matched: "yes", decision: 'block', reason: 'Blocked: system directory' };
-}
-var meta = { name: 'malformed-matched', version: '1', ruleId: '${RULE_ID}', coversCondition: 'all' };
-`;
-    insertRuleArtifact({ contentJson: makeContentJson(RULE_ID, MALFORMED_CODE) });
-    await insertCodeToolHookActivation();
-
-    const warnCalls: string[] = [];
-    const spyLogger: { warn: (_message: string) => void } = {
-      warn: (message: string) => { warnCalls.push(message); },
-    };
-
-    const ruleHost = new RuleHost(tempStateDir, spyLogger, { workspaceDir: tempWorkspaceDir });
-    const result = ruleHost.evaluate(makeInput('/etc/passwd'));
-
-    expect(result).toBeUndefined();
-    expect(warnCalls.length).toBeGreaterThan(0);
-    const unhealthyWarn = warnCalls.find(m =>
-      m.toLowerCase().includes('invalid') ||
-      m.toLowerCase().includes('malformed') ||
-      m.toLowerCase().includes('unhealthy') ||
-      m.toLowerCase().includes('validation')
-    );
-    expect(unhealthyWarn).toBeDefined();
-  });
-
-  it('malformed result with invalid decision does not enforce and emits unhealthy evidence', async () => {
-    // RuleCode returns { matched: true, decision: 'execute', reason: 'valid' } — decision is not one of the four
-    const MALFORMED_CODE = `
-function evaluate(input, helpers) {
-  return { matched: true, decision: 'execute', reason: 'do it' };
-}
-var meta = { name: 'malformed-decision', version: '1', ruleId: '${RULE_ID}', coversCondition: 'all' };
-`;
-    insertRuleArtifact({ contentJson: makeContentJson(RULE_ID, MALFORMED_CODE) });
-    await insertCodeToolHookActivation();
-
-    const warnCalls: string[] = [];
-    const spyLogger: { warn: (_message: string) => void } = {
-      warn: (message: string) => { warnCalls.push(message); },
-    };
-
-    const ruleHost = new RuleHost(tempStateDir, spyLogger, { workspaceDir: tempWorkspaceDir });
-    const result = ruleHost.evaluate(makeInput('/etc/passwd'));
-
-    expect(result).toBeUndefined();
-    expect(warnCalls.length).toBeGreaterThan(0);
-    const unhealthyWarn = warnCalls.find(m =>
-      m.toLowerCase().includes('invalid') ||
-      m.toLowerCase().includes('malformed') ||
-      m.toLowerCase().includes('unhealthy') ||
-      m.toLowerCase().includes('validation')
-    );
-    expect(unhealthyWarn).toBeDefined();
-  });
-
-  it('null return from evaluate does not enforce and emits unhealthy evidence', async () => {
-    const MALFORMED_CODE = `
-function evaluate(input, helpers) {
-  return null;
-}
-var meta = { name: 'null-return', version: '1', ruleId: '${RULE_ID}', coversCondition: 'all' };
-`;
-    insertRuleArtifact({ contentJson: makeContentJson(RULE_ID, MALFORMED_CODE) });
-    await insertCodeToolHookActivation();
-
-    const warnCalls: string[] = [];
-    const spyLogger: { warn: (_message: string) => void } = {
-      warn: (message: string) => { warnCalls.push(message); },
-    };
-
-    const ruleHost = new RuleHost(tempStateDir, spyLogger, { workspaceDir: tempWorkspaceDir });
-    const result = ruleHost.evaluate(makeInput('/etc/passwd'));
-
-    expect(result).toBeUndefined();
-    expect(warnCalls.length).toBeGreaterThan(0);
-  });
-
-  it('valid block result still enforces correctly (no false positive rejection)', async () => {
-    const VALID_CODE = `
-function evaluate(input, helpers) {
-  var p = input.action.normalizedPath || '';
-  if (p.startsWith('/etc')) {
-    return { decision: 'block', matched: true, reason: 'Blocked: system directory' };
-  }
-  return { decision: 'allow', matched: false, reason: 'Not matched' };
-}
-var meta = { name: 'valid-rule', version: '1', ruleId: '${RULE_ID}', coversCondition: 'all' };
-`;
-    insertRuleArtifact({ contentJson: makeContentJson(RULE_ID, VALID_CODE) });
-    await insertCodeToolHookActivation();
-
-    const ruleHost = new RuleHost(tempStateDir, console, { workspaceDir: tempWorkspaceDir });
-    const result = ruleHost.evaluate(makeInput('/etc/passwd'));
-
-    expect(result).toBeDefined();
-    expect(result?.decision).toBe('block');
-    expect(result?.matched).toBe(true);
-    expect(result?.reason).toBe('Blocked: system directory');
-    expect(result?.ruleId).toBe(RULE_ID);
-  });
-});

package/tests/core/rule-implementation-runtime.test.ts

@@ -1,49 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import { loadRuleImplementationModule } from '../../src/core/rule-implementation-runtime.js';
-
-describe('rule-implementation-runtime', () => {
-  it('does not leak global mutations from loaded rule implementations into the host realm', () => {
-    delete (globalThis as Record<string, unknown>).__pdRuleHostLeak;
-
-    const moduleExports = loadRuleImplementationModule(
-      `
-      globalThis.__pdRuleHostLeak = 'sandbox-only';
-      export const meta = {
-        name: 'leak-check',
-        version: '1.0.0',
-        ruleId: 'R-LEAK',
-        coversCondition: 'host isolation'
-      };
-
-      export function evaluate() {
-        globalThis.__pdRuleHostLeak = 'still-sandboxed';
-        return {
-          decision: 'allow',
-          matched: false,
-          reason: 'ok'
-        };
-      }
-      `,
-      'rule-leak-check.js',
-    );
-
-    expect(typeof moduleExports.evaluate).toBe('function');
-    expect((globalThis as Record<string, unknown>).__pdRuleHostLeak).toBeUndefined();
-
-    (moduleExports.evaluate as () => unknown)();
-
-    expect((globalThis as Record<string, unknown>).__pdRuleHostLeak).toBeUndefined();
-  });
-
-  it('contains memory-exhausting evaluation in a resource-limited worker', () => {
-    const moduleExports = loadRuleImplementationModule(
-      `export function evaluate() {
-        const memoryBomb = new Array(100_000_000).fill('x');
-        return { decision: 'allow', matched: false, reason: String(memoryBomb.length) };
-      }`,
-      'rule-memory-limit.js',
-    );
-
-    expect(() => moduleExports.callEvaluate?.({}, {})).toThrow(/worker|memory|heap|timed out|exited without a valid result/i);
-  });
-});