create-principles-disciple 1.104.0 → 1.104.2

package/plugin/dist/core/rule-host.js

@@ -1,554 +0,0 @@
-/**
- * Rule Host — Constrained execution layer for active code implementations
- *
- * PURPOSE: Load active code implementations from the SQLite activations table
- * (code_tool_hook channel), execute them in a constrained node:vm context,
- * and merge their decisions.
- *
- * ARCHITECTURE (PRI-436):
- *   - SQLite is the SOLE production source of active RuleCode
- *   - No filesystem ledger or implementation asset reads occur during evaluation
- *   - Constructor takes stateDir for API compatibility (no longer used for impl loading)
- *   - workspaceDir enables reading code_tool_hook activations from SQLite
- *   - evaluate(input) loads active code implementations and runs them
- *   - Each implementation executes in an isolated vm context with minimal helpers
- *   - Decision merge: block short-circuits, requireApproval collects, allow is implicit
- *
- * SECURITY CONSTRAINTS (T-12-01, T-12-04):
- *   - Candidate code loads through a dedicated vm context, not the host realm
- *   - No importModuleDynamically callback
- *   - Helpers are a frozen object — implementations cannot modify the helper surface
- *
- * CONSERVATIVE DEGRADATION (T-12-02, D-08):
- *   - On ANY host error (load failure, eval error, vm error): return undefined
- *   - Never throw, never bypass downstream gates (Progressive Gate, Edit Verification)
- */
-import { createRuleHostHelpers } from '@principles/core/runtime-v2';
-import { mergeDecisions } from '@principles/core/runtime-v2';
-import { validateRuleHostResult } from '@principles/core/runtime-v2';
-import { SqliteConnection } from '@principles/core/runtime-v2';
-import { loadRuleImplementationModule } from './rule-implementation-runtime.js';
-import { EventLogService } from './event-log.js';
-/**
- * Type guard for RuleHostMeta from untrusted module exports.
- * Validates all four required string fields (EP-01: no `as` bypass at trust boundary).
- */
-function isRuleHostMeta(value) {
-    if (!value || typeof value !== 'object' || Array.isArray(value)) {
-        return false;
-    }
-    const v = value;
-    return (typeof v['name'] === 'string' &&
-        typeof v['version'] === 'string' &&
-        typeof v['ruleId'] === 'string' &&
-        typeof v['coversCondition'] === 'string');
-}
-export class RuleHost {
-    stateDir;
-    logger;
-    workspaceDir;
-    implementationSources = new Map();
-    activationFingerprint = null;
-    cachedImplementations = [];
-    /**
-     * PRI-491: Cached skipped activations from the last load. Returned alongside
-     * cachedImplementations on fingerprint hit so evaluateDetailed can surface
-     * them without re-scanning SQLite.
-     */
-    cachedSkipped = [];
-    sqliteConnection = null;
-    /**
-     * R2-RH-002: Guards the "armed but empty" warn so it fires at most once per
-     * RuleHost instance. Without this, the 0-rules path (workspaceDir missing OR
-     * zero active code_tool_hook activations) returns [] silently on every
-     * evaluation — an observability gap (rc-9-no-silent-fallback). The warn is
-     * NOT a degradation fallback (RuleHost correctly has no opinion when empty);
-     * it makes the empty-armed state visible so operators can investigate why
-     * no live rules are loaded.
-     */
-    emptyLoadWarnEmitted = false;
-    constructor(stateDir, logger = console, options) {
-        this.stateDir = stateDir;
-        this.logger = logger;
-        this.workspaceDir = options?.workspaceDir ?? null;
-    }
-    /**
-     * Update the logger sink on a cached RuleHost instance.
-     *
-     * WorkspaceContext caches the RuleHost singleton, but each gate call may
-     * pass a request-level logger. Without this update, warn/unhealthy logs
-     * would forever go to the first logger sink, making the new path hard to
-     * debug.
-     */
-    updateLogger(logger) {
-        this.logger = logger;
-    }
-    /**
-     * Evaluate the input against all active code implementations.
-     *
-     * Returns:
-     *   - undefined when no active code implementations exist (no opinion)
-     *   - undefined when all implementations return allow or matched=false
-     *   - { decision: 'block', ... } when any implementation returns block (short-circuits)
-     *   - { decision: 'requireApproval', ... } when any implementation returns requireApproval
-     */
-    evaluate(input) {
-        return this.evaluateDetailed(input).liveDecision;
-    }
-    dispose() {
-        this.sqliteConnection?.close();
-        this.sqliteConnection = null;
-        this.cachedImplementations = [];
-        this.cachedSkipped = [];
-        this.activationFingerprint = null;
-        this.implementationSources.clear();
-        this.emptyLoadWarnEmitted = false;
-    }
-    evaluateDetailed(input) {
-        try {
-            const { loaded: activeImpls, skipped } = this._loadActiveCodeImplementations(input.context?.version === 2);
-            const liveImpls = activeImpls.filter((impl) => impl.activationMode === 'live');
-            const shadowImpls = activeImpls.filter((impl) => impl.activationMode === 'shadow');
-            const shadowDecisions = [];
-            for (const impl of shadowImpls) {
-                try {
-                    const result = impl.evaluate(input);
-                    shadowDecisions.push({ ...result, activationId: impl.activationId });
-                }
-                catch (evalError) {
-                    const reason = `evaluation failed: ${String(evalError)}`;
-                    this.logger.warn?.(`[RuleHost] Shadow implementation ${impl.implId} ${reason}`);
-                    const source = this.implementationSources.get(impl.implId);
-                    if (source) {
-                        this._recordUnhealthy(source.activationId, source.artifactId, source.ruleId, reason, 'Fix the RuleCode runtime error or return shape, then re-activate the rule');
-                    }
-                }
-            }
-            const liveDecision = mergeDecisions(liveImpls, input, {
-                warn: this.logger.warn,
-                onImplementationUnhealthy: (impl, reason) => {
-                    const source = this.implementationSources.get(impl.implId);
-                    if (!source) {
-                        this.logger.warn?.(`[RuleHost] No source mapping for implId=${impl.implId}, cannot record unhealthy event`);
-                        return;
-                    }
-                    this._recordUnhealthy(source.activationId, source.artifactId, source.ruleId, reason, 'Fix the RuleCode runtime error or return shape, then re-activate the rule');
-                },
-            });
-            return { liveDecision, shadowDecisions, skippedActivations: skipped };
-        }
-        catch (hostError) {
-            // Conservative degradation: log and return undefined (D-08)
-            this.logger.warn?.(`[RuleHost] Host evaluation failed, degrading conservatively: ${String(hostError)}`);
-            return { liveDecision: undefined, shadowDecisions: [], skippedActivations: [] };
-        }
-    }
-    /**
-     * Load active code implementations from the SQLite activations table.
-     *
-     * PRI-436: SQLite is the SOLE production source. The filesystem ledger
-     * (principle-tree-ledger) and implementation asset paths have been deleted.
-     * No fallback, no dual-source, no deprecated adapter.
-     *
-     * Source: activations table (code_tool_hook channel, deactivated_at IS NULL)
-     *   → JOIN pi_artifacts for content_json → extract implementationCode → compile
-     */
-    _loadActiveCodeImplementations(supportsContextV2) {
-        if (!this.workspaceDir) {
-            this._emitEmptyLoadWarn('workspaceDir not configured — RuleHost cannot load active code_tool_hook rules', 'Provide workspaceDir when constructing RuleHost (required for code_tool_hook channel)');
-            return { loaded: [], skipped: [] };
-        }
-        try {
-            const { loaded, skipped } = this._loadFromActivationsTable(this.workspaceDir, supportsContextV2);
-            if (loaded.length === 0) {
-                this._emitEmptyLoadWarn('armed but empty — 0 active code_tool_hook activations loaded (RuleHost will not block or require approval)', 'If this is unexpected, run `pd activation list --channel code_tool_hook` to inspect activations, or `pd activation promote --activation-id <id> --confirm` to enable a live rule');
-            }
-            return { loaded, skipped };
-        }
-        catch (activationError) {
-            this.logger.warn?.(`[RuleHost] Failed to load code_tool_hook activations: ${String(activationError)}`);
-            return { loaded: [], skipped: [] };
-        }
-    }
-    /**
-     * R2-RH-002: Emit the "armed but empty" warn at most once per RuleHost
-     * instance. The warn is cached via `emptyLoadWarnEmitted` so repeated
-     * evaluations (which all hit the empty path) do not spam the log.
-     *
-     * This is an observability signal, NOT a degradation fallback — RuleHost
-     * correctly returns "no opinion" when there are no active rules. The warn
-     * makes the empty state visible so operators can distinguish "RuleHost is
-     * working but has no rules" from "RuleHost is broken" (rc-9-no-silent-fallback).
-     */
-    _emitEmptyLoadWarn(reason, nextAction) {
-        if (this.emptyLoadWarnEmitted)
-            return;
-        this.emptyLoadWarnEmitted = true;
-        this.logger.warn?.(`[RuleHost] ${reason}. ` +
-            `nextAction=${nextAction}`);
-    }
-    /**
-     * Load active code implementations from the activations table (code_tool_hook channel).
-     *
-     * For each activation record:
-     *   1. Query the pi_artifacts table for the artifact content
-     *   2. Parse content_json to extract implementationCode (treated as unknown, EP-01)
-     *   3. Compile via loadRuleImplementationModule (isolated vm context)
-     *
-     * PRI-436 invariant: at most one active activation per rule (target_ref).
-     * Duplicate active activations for the same target_ref are ALL skipped
-     * (zero executions) and emit structured unhealthy evidence via logger.warn
-     * (Runtime Contract Rule 9: graceful degradation includes a reason).
-     *
-     * All data from SQLite is treated as unknown and validated before use.
-     */
-    _loadFromActivationsTable(workspaceDir, supportsContextV2) {
-        const sqliteConn = this.sqliteConnection ?? new SqliteConnection(workspaceDir);
-        this.sqliteConnection = sqliteConn;
-        {
-            const db = sqliteConn.getDb();
-            const rows = db.prepare(`
-        SELECT a.activation_id, a.artifact_id, a.target_ref, a.action,
-               p.content_json, p.source_rule_id, p.source_principle_id
-        FROM activations a
-        JOIN pi_artifacts p ON a.artifact_id = p.artifact_id
-        WHERE a.channel = 'code_tool_hook' AND a.deactivated_at IS NULL
-        ORDER BY a.activated_at ASC
-      `).all();
-            if (!Array.isArray(rows)) {
-                this.logger.warn?.('[RuleHost] Activations table query returned non-array, skipping');
-                return { loaded: [], skipped: [] };
-            }
-            const fingerprintParts = [supportsContextV2 ? 'context-v2' : 'context-v1'];
-            for (const row of rows) {
-                if (!row || typeof row !== 'object' || Array.isArray(row))
-                    continue;
-                const record = row;
-                fingerprintParts.push([
-                    record['activation_id'], record['artifact_id'], record['target_ref'], record['action'], record['content_json'], record['source_rule_id'], record['source_principle_id'],
-                ].map((value) => typeof value === 'string' ? value : '').join('\u0001'));
-            }
-            const fingerprint = fingerprintParts.join('\u0002');
-            if (fingerprint === this.activationFingerprint) {
-                return { loaded: [...this.cachedImplementations], skipped: [...this.cachedSkipped] };
-            }
-            this.implementationSources.clear();
-            // PRI-436: Group active rows by target_ref to detect duplicates.
-            // At most one active activation per rule (target_ref) is allowed.
-            // Duplicate groups are skipped entirely (zero executions) and emit
-            // structured unhealthy evidence. Non-duplicate rows proceed to compilation.
-            const rowsByTargetRef = new Map();
-            for (const row of rows) {
-                if (!row || typeof row !== 'object') {
-                    continue;
-                }
-                const r = row;
-                const targetRef = typeof r['target_ref'] === 'string' ? r['target_ref'] : '';
-                const activationId = typeof r['activation_id'] === 'string' ? r['activation_id'] : '';
-                if (!targetRef) {
-                    this.logger.warn?.(`[RuleHost] Activation ${activationId}: missing target_ref, skipping`);
-                    continue;
-                }
-                const group = rowsByTargetRef.get(targetRef);
-                if (group) {
-                    group.push(r);
-                }
-                else {
-                    rowsByTargetRef.set(targetRef, [r]);
-                }
-            }
-            // Emit structured unhealthy evidence for duplicate groups; collect valid (non-duplicate) rows.
-            // PRI-497: duplicate activations are ALSO pushed to the `skipped` array
-            // so callers (gate.ts, CLI, Console) can observe them via
-            // skippedActivations — not just via rulehost_unhealthy event log.
-            // Both paths are populated (rc-9-no-silent-fallback): event log for
-            // telemetry, skipped array for structured caller-facing observability.
-            const validRows = [];
-            const skipped = [];
-            for (const [targetRef, group] of rowsByTargetRef) {
-                if (group.length > 1) {
-                    const activationIds = [];
-                    const artifactIds = [];
-                    for (const r of group) {
-                        if (typeof r['activation_id'] === 'string')
-                            activationIds.push(r['activation_id']);
-                        if (typeof r['artifact_id'] === 'string')
-                            artifactIds.push(r['artifact_id']);
-                    }
-                    this.logger.warn?.(`[RuleHost] Duplicate active activations detected — skipping all executions for this rule. ` +
-                        `targetRef=${targetRef} count=${group.length} ` +
-                        `activationIds=[${activationIds.join(', ')}] ` +
-                        `artifactIds=[${artifactIds.join(', ')}] ` +
-                        `reason=at most one active activation per rule is allowed ` +
-                        `nextAction=deactivate all but one activation for this target_ref`);
-                    for (const r of group) {
-                        const activationId = typeof r['activation_id'] === 'string' ? r['activation_id'] : '';
-                        const artifactId = typeof r['artifact_id'] === 'string' ? r['artifact_id'] : '';
-                        if (activationId && artifactId) {
-                            this._recordUnhealthy(activationId, artifactId, targetRef, `duplicate active activation for target_ref ${targetRef}`, 'Deactivate all but one activation for this target_ref');
-                            // PRI-497: also surface in skippedActivations for caller observability
-                            skipped.push({
-                                activationId,
-                                ruleId: targetRef,
-                                mode: 'live',
-                                reason: 'duplicate_active_activation',
-                                nextAction: 'Deactivate all but one activation for this target_ref',
-                            });
-                        }
-                    }
-                }
-                else {
-                    const row = group[0];
-                    if (row)
-                        validRows.push(row);
-                }
-            }
-            const loaded = [];
-            for (const r of validRows) {
-                const activationId = typeof r['activation_id'] === 'string' ? r['activation_id'] : '';
-                const artifactId = typeof r['artifact_id'] === 'string' ? r['artifact_id'] : '';
-                const contentJson = typeof r['content_json'] === 'string' ? r['content_json'] : '';
-                const sourceRuleId = typeof r['source_rule_id'] === 'string' ? r['source_rule_id'] : null;
-                // R2-RH-004: Extract source_principle_id from pi_artifacts (DB lineage field).
-                // Previously this column was never SELECTed, so principleId was always
-                // derived from meta.ruleId (a rule ID, not a principle ID) — violating
-                // rc-6-lineage-consistency. Downstream gate.ts:135/164 recorded the
-                // wrong principleId in eventLog.recordRuleEnforced().
-                const sourcePrincipleId = typeof r['source_principle_id'] === 'string' ? r['source_principle_id'] : null;
-                const action = typeof r['action'] === 'string' ? r['action'] : '';
-                if (!activationId || !artifactId || !contentJson) {
-                    this.logger.warn?.(`[RuleHost] Activation row missing required fields, skipping`);
-                    continue;
-                }
-                const activationMode = action === 'code_tool_hook_shadow_activate'
-                    ? 'shadow'
-                    : action === 'code_tool_hook_live_activate'
-                        ? 'live'
-                        : null;
-                if (!activationMode) {
-                    const reason = `unsupported action: ${action || '(missing)'}`;
-                    const nextAction = 'Deactivate and recreate the activation through RuleHostWriter with action code_tool_hook_shadow_activate or code_tool_hook_live_activate';
-                    this.logger.warn?.(`[RuleHost] Activation ${activationId}: ${reason}, skipping. nextAction=${nextAction}`);
-                    const skipRecord = {
-                        activationId,
-                        ruleId: sourceRuleId ?? artifactId,
-                        reason,
-                        nextAction,
-                    };
-                    skipped.push(skipRecord);
-                    this._recordSkipped(activationId, artifactId, sourceRuleId ?? artifactId, undefined, reason, nextAction);
-                    continue;
-                }
-                if (activationMode === 'shadow') {
-                    // PRI-489 (seed-MVP readiness): shadow activations are
-                    // observation-only and do NOT enter mergeDecisions (no block /
-                    // requireApproval). Owner approval creates a shadow activation
-                    // first; the only shadow -> live transition is `pd activation
-                    // promote --activation-id ... --confirm` (atomic action rewrite
-                    // in SqliteActivationStateStore.promoteActivation). Surface a
-                    // structured reason + nextAction so the degradation is observable
-                    // (rc-9-no-silent-fallback), not silent. Fires once per
-                    // fingerprint change (cached), not per evaluation.
-                    this.logger.warn?.(`[RuleHost] Activation ${activationId}: loaded in shadow (observation-only) mode; ` +
-                        'it will NOT block or require approval (shadowDecisions only). ' +
-                        `nextAction=run \`pd activation promote --activation-id ${activationId} --confirm\` to enable live blocking, ` +
-                        'or leave as-is for shadow observation.');
-                }
-                try {
-                    const content = JSON.parse(contentJson);
-                    if (!content || typeof content !== 'object' || Array.isArray(content)) {
-                        const reason = 'content_json is not a valid object';
-                        const nextAction = 'Regenerate the rule artifact with valid JSON content_json';
-                        this.logger.warn?.(`[RuleHost] Activation ${activationId}: ${reason}, skipping. nextAction=${nextAction}`);
-                        skipped.push({
-                            activationId,
-                            ruleId: sourceRuleId ?? artifactId,
-                            mode: activationMode,
-                            reason,
-                            nextAction,
-                        });
-                        this._recordSkipped(activationId, artifactId, sourceRuleId ?? artifactId, activationMode, reason, nextAction);
-                        continue;
-                    }
-                    const contentObj = content;
-                    if (Object.hasOwn(contentObj, 'requiresContextVersion')) {
-                        if (contentObj['requiresContextVersion'] !== 2) {
-                            const reason = `unsupported context version: ${String(contentObj['requiresContextVersion'])}`;
-                            const nextAction = 'Regenerate the rule artifact with requiresContextVersion: 2 or omit the field for v1';
-                            this.logger.warn?.(`[RuleHost] Activation ${activationId}: ${reason}, skipping. nextAction=${nextAction}`);
-                            skipped.push({
-                                activationId,
-                                ruleId: typeof contentObj['ruleId'] === 'string' ? contentObj['ruleId'] : (sourceRuleId ?? artifactId),
-                                mode: activationMode,
-                                reason,
-                                nextAction,
-                            });
-                            this._recordSkipped(activationId, artifactId, typeof contentObj['ruleId'] === 'string' ? contentObj['ruleId'] : (sourceRuleId ?? artifactId), activationMode, reason, nextAction);
-                            continue;
-                        }
-                        if (!supportsContextV2) {
-                            const reason = 'suspended_by_flag: rulecode_context_v2 is disabled or unavailable';
-                            const nextAction = 'Enable rulecode_context_v2 with valid config, or deactivate this activation';
-                            this.logger.warn?.(`[RuleHost] Activation ${activationId}: ${reason}, skipping. nextAction=${nextAction}`);
-                            skipped.push({
-                                activationId,
-                                ruleId: typeof contentObj['ruleId'] === 'string' ? contentObj['ruleId'] : (sourceRuleId ?? artifactId),
-                                mode: activationMode,
-                                reason,
-                                nextAction,
-                            });
-                            this._recordSkipped(activationId, artifactId, typeof contentObj['ruleId'] === 'string' ? contentObj['ruleId'] : (sourceRuleId ?? artifactId), activationMode, reason, nextAction);
-                            continue;
-                        }
-                    }
-                    const implementationCode = contentObj['implementationCode'];
-                    if (typeof implementationCode !== 'string' || implementationCode.length === 0) {
-                        const reason = 'no implementationCode in artifact';
-                        const nextAction = 'Regenerate the rule artifact with a non-empty implementationCode field';
-                        this.logger.warn?.(`[RuleHost] Activation ${activationId}: ${reason}, skipping. nextAction=${nextAction}`);
-                        skipped.push({
-                            activationId,
-                            ruleId: typeof contentObj['ruleId'] === 'string' ? contentObj['ruleId'] : (sourceRuleId ?? artifactId),
-                            mode: activationMode,
-                            reason,
-                            nextAction,
-                        });
-                        this._recordSkipped(activationId, artifactId, typeof contentObj['ruleId'] === 'string' ? contentObj['ruleId'] : (sourceRuleId ?? artifactId), activationMode, reason, nextAction);
-                        continue;
-                    }
-                    const ruleId = typeof contentObj['ruleId'] === 'string'
-                        ? contentObj['ruleId']
-                        : (sourceRuleId ?? artifactId);
-                    // R2-RH-004: Extract principleId from artifact content_json.
-                    // Previously this field was never read, so result.principleId was
-                    // always set to meta.ruleId (a rule ID) — violating
-                    // rc-6-lineage-consistency. Precedence: contentJson.principleId
-                    // (artifact payload) → pi_artifacts.source_principle_id (DB lineage)
-                    // → meta.ruleId (rule ID fallback) → ruleId (last resort).
-                    const contentPrincipleId = typeof contentObj['principleId'] === 'string'
-                        ? contentObj['principleId']
-                        : null;
-                    const implId = `act-impl-${activationId}`;
-                    const moduleExports = loadRuleImplementationModule(implementationCode, implId);
-                    if (!moduleExports || typeof moduleExports.callEvaluate !== 'function') {
-                        const reason = 'compiled module has no evaluate function';
-                        this.logger.warn?.(`[RuleHost] Activation ${activationId}: ${reason}, skipping`);
-                        this._recordUnhealthy(activationId, artifactId, ruleId, reason, 'Fix the RuleCode to export an evaluate(input, helpers) function, then re-activate');
-                        continue;
-                    }
-                    const fallbackMeta = {
-                        name: implId,
-                        version: '1',
-                        ruleId,
-                        coversCondition: 'all',
-                    };
-                    const meta = isRuleHostMeta(moduleExports.meta)
-                        ? moduleExports.meta
-                        : fallbackMeta;
-                    // PRI-437: Use callEvaluate (vm-context-bounded) instead of raw evaluate.
-                    // callEvaluate runs the invocation INSIDE the vm context with a time
-                    // boundary, terminating infinite loops and excessive computation.
-                    const boundedCallEvaluate = moduleExports.callEvaluate;
-                    this.implementationSources.set(implId, { activationId, artifactId, ruleId });
-                    loaded.push({
-                        implId,
-                        ruleId,
-                        meta,
-                        activationId,
-                        activationMode,
-                        evaluate: (input) => {
-                            const frozenHelpers = createRuleHostHelpers(input);
-                            // PRI-437: Execute inside vm context with timeout boundary.
-                            const rawResult = boundedCallEvaluate(input, frozenHelpers);
-                            const validation = validateRuleHostResult(rawResult);
-                            if (!validation.valid) {
-                                throw new Error(`[RuleHost] Activation ${activationId} returned invalid RuleHostResult: ${validation.errors.join('; ')}`);
-                            }
-                            const result = rawResult;
-                            if (result.matched && (result.decision === 'block' || result.decision === 'requireApproval')) {
-                                result.ruleId = ruleId;
-                                // R2-RH-004: principleId precedence — contentJson.principleId
-                                // (artifact payload) → source_principle_id (DB lineage) →
-                                // meta.ruleId (rule ID fallback) → ruleId (last resort).
-                                // Previously this was `meta.ruleId ?? ruleId`, which always
-                                // resolved to a rule ID (never a principle ID) because
-                                // isRuleHostMeta guarantees meta.ruleId is a non-empty string.
-                                result.principleId = contentPrincipleId ?? sourcePrincipleId ?? meta.ruleId ?? ruleId;
-                            }
-                            return result;
-                        },
-                    });
-                }
-                catch (loadError) {
-                    const reason = `compilation failed: ${String(loadError)}`;
-                    this.logger.warn?.(`[RuleHost] Failed to load activation ${activationId}: ${reason}`);
-                    // ruleId is declared inside the try block and may not be assigned yet;
-                    // fall back to sourceRuleId or artifactId (both available in scope)
-                    this._recordUnhealthy(activationId, artifactId, sourceRuleId ?? artifactId, reason, 'Fix the RuleCode syntax/compilation error, then re-activate the rule');
-                }
-            }
-            this.activationFingerprint = fingerprint;
-            this.cachedImplementations = loaded;
-            this.cachedSkipped = skipped;
-            return { loaded, skipped };
-        }
-    }
-    /**
-     * PRI-437: Record an unhealthy activation state to EventLog.
-     *
-     * This makes compile/load failures visible to CLI (pd runtime health) and
-     * Console API — NOT just a logger.warn that's silently skipped.
-     *
-     * ERR-002: degradation includes a reason and nextAction (not silent).
-     * Failures in EventLog recording are caught and logged (never throw).
-     */
-    _recordUnhealthy(activationId, artifactId, ruleId, reason, nextAction) {
-        try {
-            // Pass undefined as logger: RuleHostLogger only has warn(), but EventLog
-            // calls this.logger.error() without optional chaining. Passing the
-            // RuleHostLogger directly would cause TypeError if EventLog tried to
-            // log an internal error. EventLog's logger is optional; RuleHost already
-            // logs its own warnings for the unhealthy event.
-            const eventLog = EventLogService.get(this.stateDir);
-            eventLog.recordRuleHostUnhealthy({
-                activationId,
-                artifactId,
-                ruleId,
-                reason,
-                nextAction,
-            });
-        }
-        catch (recordError) {
-            // EventLog recording must never break RuleHost evaluation
-            this.logger.warn?.(`[RuleHost] Failed to record unhealthy event for activation ${activationId}: ${String(recordError)}`);
-        }
-    }
-    /**
-     * PRI-491: Record a skipped activation to EventLog.
-     *
-     * Unlike _recordUnhealthy (compile/load failures), skipped activations have
-     * a configuration/flag reason — the RuleCode itself may be valid, but the
-     * runtime chose not to execute it (flag-off v2, unsupported context version,
-     * unsupported action, content_json not object, no implementationCode).
-     *
-     * ERR-002: degradation includes a reason and nextAction (rc-9-no-silent-fallback).
-     * Failures in EventLog recording are caught and logged (never throw).
-     */
-    _recordSkipped(activationId, artifactId, ruleId, mode, reason, nextAction) {
-        try {
-            const eventLog = EventLogService.get(this.stateDir);
-            eventLog.recordRuleHostSkipped({
-                activationId,
-                artifactId,
-                ruleId,
-                mode,
-                reason,
-                nextAction,
-            });
-        }
-        catch (recordError) {
-            // EventLog recording must never break RuleHost evaluation
-            this.logger.warn?.(`[RuleHost] Failed to record skipped event for activation ${activationId}: ${String(recordError)}`);
-        }
-    }
-}

package/plugin/dist/core/rule-implementation-runtime.js

@@ -1,112 +0,0 @@
-import { nodeVm } from '../utils/node-vm-polyfill.js';
-import { spawnSync } from 'node:child_process';
-/** Timeout (ms) for compiling RuleCode (defining evaluate + meta). */
-const COMPILE_TIMEOUT_MS = 1000;
-/** Timeout (ms) for executing evaluate(input, helpers) inside the vm. */
-const EVALUATE_PROCESS_TIMEOUT_MS = 3000;
-const EVALUATE_PROCESS_OUTPUT_BYTES = 1024 * 1024;
-const EVALUATION_PROCESS_SOURCE = String.raw `
-const vm = require('node:vm');
-try {
-  const workerData = JSON.parse(require('node:fs').readFileSync(0, 'utf8'));
-  const context = vm.createContext(Object.create(null));
-  new vm.Script(workerData.source, { filename: workerData.filename }).runInContext(context, { timeout: 1000 });
-  const input = workerData.input;
-  const helpers = Object.freeze({
-    isRiskPath: () => input.workspace.isRiskPath,
-    getToolName: () => input.action.toolName,
-    getEstimatedLineChanges: () => input.derived.estimatedLineChanges,
-    getBashRisk: () => input.derived.bashRisk,
-    hasPlanFile: () => input.workspace.hasPlanFile,
-    getPlanStatus: () => input.workspace.planStatus,
-    getEpTier: () => input.evolution.epTier,
-  });
-  context.__pdCallInput = input;
-  context.__pdCallHelpers = helpers;
-  const result = new vm.Script('__pdRuleModule.evaluate(__pdCallInput, __pdCallHelpers)', { filename: workerData.filename + '.call' })
-    .runInContext(context, { timeout: 1000 });
-  process.stdout.write(JSON.stringify({ ok: true, result }));
-} catch (error) {
-  process.stdout.write(JSON.stringify({ ok: false, error: String(error) }));
-  process.exitCode = 1;
-}
-`;
-function normalizeImplementationSource(sourceCode) {
-    const withoutExports = sourceCode
-        .replace(/export\s+const\s+meta\s*=/, 'const meta =')
-        .replace(/export\s+function\s+evaluate\s*\(/, 'function evaluate(');
-    return `${withoutExports}
-globalThis.__pdRuleModule = {
-  meta: typeof meta === 'undefined' ? undefined : meta,
-  evaluate: typeof evaluate === 'undefined' ? undefined : evaluate,
-};`;
-}
-function isRecord(value) {
-    return typeof value === 'object' && value !== null && !Array.isArray(value);
-}
-export function loadRuleImplementationModule(sourceCode, filename) {
-    const context = nodeVm.createContext(Object.create(null));
-    const script = new nodeVm.Script(normalizeImplementationSource(sourceCode), {
-        filename,
-    });
-    // Compile phase: define evaluate + meta (timeout-bounded)
-    script.runInContext(context, {
-        timeout: COMPILE_TIMEOUT_MS,
-        displayErrors: true,
-    });
-    const moduleExports = context.__pdRuleModule;
-    // Note: keep __pdRuleModule on the context so callEvaluate can reference it.
-    // We do NOT delete it here — it's needed for subsequent evaluate calls.
-    const hasEvaluate = typeof moduleExports?.evaluate === 'function';
-    const meta = moduleExports?.meta;
-    if (!hasEvaluate) {
-        // No evaluate function — return early with no callEvaluate
-        return { meta, evaluate: moduleExports?.evaluate };
-    }
-    // PRI-437: Create a context-aware caller that runs evaluate INSIDE the vm
-    // context with a time boundary. This terminates infinite loops and
-    // excessive computation that would otherwise hang the host process.
-    //
-    // The callEvaluate function:
-    //   1. Sets input and helpers as context globals (sandboxed)
-    //   2. Compiles a tiny call script
-    //   3. Runs it in the context with EVALUATE_TIMEOUT_MS
-    //   4. Cleans up globals
-    //   5. Returns the raw result (validation happens in the caller)
-    const normalizedSource = normalizeImplementationSource(sourceCode);
-    const callEvaluate = (input, _helpers) => {
-        const child = spawnSync(process.execPath, [
-            '--max-old-space-size=32',
-            '-e',
-            EVALUATION_PROCESS_SOURCE,
-        ], {
-            input: JSON.stringify({ source: normalizedSource, filename, input }),
-            encoding: 'utf8',
-            timeout: EVALUATE_PROCESS_TIMEOUT_MS,
-            maxBuffer: EVALUATE_PROCESS_OUTPUT_BYTES,
-            windowsHide: true,
-        });
-        if (child.error) {
-            throw new Error(`RuleCode process failed: ${child.error.message}`);
-        }
-        let parsed;
-        try {
-            parsed = JSON.parse(child.stdout);
-        }
-        catch {
-            const stderr = child.stderr.trim().slice(0, 500);
-            throw new Error(`RuleCode process exited without a valid result${stderr ? `: ${stderr}` : ''}`);
-        }
-        if (!isRecord(parsed) || !Object.hasOwn(parsed, 'ok') || parsed['ok'] !== true || !Object.hasOwn(parsed, 'result')) {
-            const reason = isRecord(parsed) && Object.hasOwn(parsed, 'error') && typeof parsed['error'] === 'string'
-                ? parsed['error'] : 'RuleCode process failed';
-            throw new Error(reason);
-        }
-        return parsed['result'];
-    };
-    return {
-        meta,
-        evaluate: moduleExports?.evaluate,
-        callEvaluate,
-    };
-}