@principles/core 1.287.1 → 1.287.2

package/dist/runtime-v2/activation/writers/__tests__/rule-host-writer.test.js

@@ -1,1144 +0,0 @@
-import { describe, it, expect, vi } from 'vitest';
-const SUCCESSFUL_SANDBOX_RESULT = {
-    success: true,
-    failedCases: [],
-    executionTimeMs: 10,
-    forbiddenPatternViolations: [],
-};
-function makeGoldenTrace() {
-    return {
-        traceId: 'gt-001',
-        sourcePainId: 'pain-001',
-        cases: [
-            {
-                caseId: 'case-001',
-                kind: 'negative',
-                toolName: 'edit_file',
-                params: { path: '/etc/passwd' },
-                expectedDecision: 'block',
-            },
-            {
-                caseId: 'case-002',
-                kind: 'positive',
-                toolName: 'edit_file',
-                params: { path: '/project/src/safe.ts' },
-                expectedDecision: 'allow',
-            },
-        ],
-        createdAt: '2026-05-17T00:00:00.000Z',
-        version: 1,
-    };
-}
-function makeRuleArtifact(overrides = {}) {
-    const goldenTrace = makeGoldenTrace();
-    return {
-        artifactId: 'art-rule-001',
-        artifactKind: 'rule',
-        sourceTaskId: 'task-001',
-        sourcePrincipleId: 'P_001',
-        sourceRuleId: 'R_001',
-        lineageArtifactIds: [],
-        validationStatus: 'validated',
-        contentJson: JSON.stringify({
-            implementationCode: 'function evaluate(input, helpers) { return { decision: "block", matched: true, reason: "test" }; }',
-            goldenTrace,
-            ruleHostGateDecision: 'accepted_shadow',
-            affectedTools: ['read_file'],
-        }),
-        createdAt: '2026-05-17T00:00:00.000Z',
-        updatedAt: '2026-05-17T00:00:00.000Z',
-        ...overrides,
-    };
-}
-function makeWriterInput(overrides = {}) {
-    return {
-        artifactId: 'art-rule-001',
-        channel: 'code_tool_hook',
-        principleId: 'P_001',
-        idempotencyKey: 'art-rule-001::code_tool_hook',
-        now: '2026-05-17T00:00:00.000Z',
-        ...overrides,
-    };
-}
-function makeGateDeps(overrideResult) {
-    const defaultResult = {
-        decision: 'accepted_shadow',
-        applicationMode: 'shadow',
-        sandboxResult: SUCCESSFUL_SANDBOX_RESULT,
-        reasons: [],
-        ...overrideResult,
-    };
-    return {
-        evaluateInSandbox: vi.fn().mockReturnValue(defaultResult.sandboxResult),
-    };
-}
-describe('RuleHostWriter', () => {
-    async function importWriter() {
-        const { RuleHostWriter } = await import('../rule-host-writer.js');
-        return { RuleHostWriter };
-    }
-    it('accepts valid code_tool_hook artifact in shadow mode', async () => {
-        const { RuleHostWriter } = await importWriter();
-        const writer = new RuleHostWriter({ gateDeps: makeGateDeps() });
-        const result = await writer.canActivate(makeRuleArtifact());
-        expect(result.ok).toBe(true);
-        expect(result.riskLevel).toBe('high');
-    });
-    it('rejects non-rule artifact', async () => {
-        const { RuleHostWriter } = await importWriter();
-        const writer = new RuleHostWriter({ gateDeps: makeGateDeps() });
-        const result = await writer.canActivate(makeRuleArtifact({ artifactKind: 'principle' }));
-        expect(result.ok).toBe(false);
-        expect(result.reason).toContain('artifact_kind_not_rule');
-    });
-    it('rejects artifact without code/implementation payload', async () => {
-        const { RuleHostWriter } = await importWriter();
-        const writer = new RuleHostWriter({ gateDeps: makeGateDeps() });
-        const artifact = makeRuleArtifact({
-            contentJson: JSON.stringify({ goldenTrace: makeGoldenTrace() }),
-        });
-        const result = await writer.canActivate(artifact);
-        expect(result.ok).toBe(false);
-        expect(result.reason).toContain('no_implementation_code');
-    });
-    it('rejects artifact without GoldenTrace/replay evidence', async () => {
-        const { RuleHostWriter } = await importWriter();
-        const writer = new RuleHostWriter({ gateDeps: makeGateDeps() });
-        const artifact = makeRuleArtifact({
-            contentJson: JSON.stringify({
-                implementationCode: 'function evaluate() {}',
-            }),
-        });
-        const result = await writer.canActivate(artifact);
-        expect(result.ok).toBe(false);
-        expect(result.reason).toContain('no_golden_trace');
-    });
-    it.each([
-        { affectedTools: [], reason: 'rulecode_scope_empty' },
-        { affectedTools: ['*'], reason: 'rulecode_scope_wildcard_forbidden' },
-        { affectedTools: ['rulecode_deactivate'], reason: 'rulecode_scope_protected_capability' },
-    ])('rejects unsafe generated scope before shadow: $reason', async ({ affectedTools, reason }) => {
-        const { RuleHostWriter } = await importWriter();
-        const base = makeRuleArtifact();
-        const content = JSON.parse(base.contentJson);
-        if (typeof content !== 'object' || content === null || Array.isArray(content))
-            throw new Error('fixture content malformed');
-        const writer = new RuleHostWriter({ gateDeps: makeGateDeps() });
-        await expect(writer.canActivate({ ...base, contentJson: JSON.stringify({ ...content, affectedTools }) })).resolves.toMatchObject({ ok: false, reason });
-    });
-    it('rejects when RefinerRuleHostGate decision is not accepted_shadow', async () => {
-        const { RuleHostWriter } = await importWriter();
-        const gateDeps = makeGateDeps();
-        const writer = new RuleHostWriter({ gateDeps });
-        const artifact = makeRuleArtifact({
-            contentJson: JSON.stringify({
-                implementationCode: 'function evaluate() {}',
-                goldenTrace: makeGoldenTrace(),
-                ruleHostGateDecision: 'rejected_validation_failed',
-            }),
-        });
-        const result = await writer.canActivate(artifact);
-        expect(result.ok).toBe(false);
-        expect(result.reason).toContain('gate_decision_not_accepted_shadow');
-    });
-    // Regression for issue #1337: a legacy artifact (stored gate decision
-    // accepted_shadow under the pre-2026-06-20 contract) whose code violates
-    // the tightened RuleHostResult return shape must fail canActivate with the
-    // gate's field-level reasons attached — not the opaque bare decision
-    // suffix the owner previously saw (EP-03 / rc-9-no-silent-fallback).
-    it('surfaces field-level gate failure reasons on return-shape rejection (issue #1337)', async () => {
-        const { RuleHostWriter } = await importWriter();
-        // Use the REAL sandbox wrapper + gate chain (static return-shape check →
-        // __return_shape__ validation_failed → rejected_validation_failed), not a
-        // mock, so the refusal reason is exercised along the production path
-        // (EP-02 / EP-09). evaluateCode is never reached: the static check
-        // short-circuits before VM execution.
-        const { evaluateInRefinerSandbox } = await import('../../../internalization/refiner-sandbox-wrapper.js');
-        const gateDeps = {
-            evaluateInSandbox: (code, trace, opts) => 
-            // Stub satisfies ReplayEvaluateFn but is never reached: the static
-            // return-shape check short-circuits before VM execution.
-            evaluateInRefinerSandbox(code, trace, {
-                ...opts,
-                evaluateCode: () => ({ decision: 'allow', matched: false, reason: 'unreachable' }),
-            }),
-        };
-        const writer = new RuleHostWriter({ gateDeps });
-        // Mirrors the real legacy artifact pi-art-rule-rule-real-diagnosis-first-490a7eb9:
-        // returns missing decision/reason fields.
-        const legacyCode = [
-            'function evaluate(input, helpers) {',
-            '  if (!input.action) { return { matched: false }; }',
-            '  return { matched: true, decision: "allow" };',
-            '}',
-        ].join('\n');
-        const artifact = makeRuleArtifact({
-            contentJson: JSON.stringify({
-                implementationCode: legacyCode,
-                goldenTrace: makeGoldenTrace(),
-                ruleHostGateDecision: 'accepted_shadow',
-            }),
-        });
-        const result = await writer.canActivate(artifact);
-        expect(result.ok).toBe(false);
-        expect(result.reason).toContain('gate_decision_not_accepted_shadow:rejected_validation_failed');
-        expect(result.reason).toContain('return statement missing required field(s): decision, reason');
-        expect(result.reason).toContain('return statement missing required field(s): reason');
-    });
-    // Bounded enrichment: the same slice(0, 3) convention as extractGoldenTrace
-    // — a pathological artifact with many violations must not blow up the
-    // refusal reason unboundedly.
-    it('bounds gate failure reasons surfaced in the refusal (issue #1337)', async () => {
-        const { RuleHostWriter } = await importWriter();
-        const failedCases = Array.from({ length: 5 }, (_, i) => ({
-            caseId: `case-r${i + 1}`,
-            errorType: 'validation_failed',
-            message: `marker-r${i + 1}`,
-        }));
-        const gateDeps = {
-            evaluateInSandbox: vi.fn().mockReturnValue({
-                success: false,
-                failedCases,
-                executionTimeMs: 1,
-                forbiddenPatternViolations: [],
-            }),
-        };
-        const writer = new RuleHostWriter({ gateDeps });
-        const artifact = makeRuleArtifact();
-        const result = await writer.canActivate(artifact);
-        expect(result.ok).toBe(false);
-        expect(result.reason).toContain('gate_decision_not_accepted_shadow:rejected_validation_failed');
-        expect(result.reason).toContain('case-r3');
-        expect(result.reason).not.toContain('case-r4');
-    });
-    // PRI-489: Owner approval creates a SHADOW activation first. The only
-    // shadow -> live transition is `pd activation promote --activation-id ...
-    // --confirm` (SqliteActivationStateStore.promoteActivation). Live blocking
-    // must never happen immediately after approval — that was the seed-MVP
-    // release blocker this test now guards against.
-    it('returns shadow activation action after owner approval (shadow-first)', async () => {
-        const { RuleHostWriter } = await importWriter();
-        const writer = new RuleHostWriter({ gateDeps: makeGateDeps() });
-        const artifact = makeRuleArtifact();
-        const result = await writer.activate(makeWriterInput(), artifact);
-        expect(result.action).toBe('code_tool_hook_shadow_activate');
-        expect(result.targetRef).toContain('R_001');
-    });
-    it('never returns live activation action directly after owner approval', async () => {
-        const { RuleHostWriter } = await importWriter();
-        const writer = new RuleHostWriter({ gateDeps: makeGateDeps() });
-        const artifact = makeRuleArtifact();
-        const result = await writer.activate(makeWriterInput(), artifact);
-        // Shadow-first: live must only appear after an explicit promote, never
-        // straight from the writer. This assertion uniquely identifies the
-        // shadow-first contract (ERR-088: assert the specific action value).
-        expect(result.action).not.toContain('live');
-        expect(result.action).toContain('shadow');
-    });
-    it('returns correct activationId format', async () => {
-        const { RuleHostWriter } = await importWriter();
-        const writer = new RuleHostWriter({ gateDeps: makeGateDeps() });
-        const artifact = makeRuleArtifact();
-        const result = await writer.activate(makeWriterInput(), artifact);
-        expect(result.activationId).toBe('act_code_R_001');
-    });
-    it('rejects artifact with empty GoldenTrace cases', async () => {
-        const { RuleHostWriter } = await importWriter();
-        const writer = new RuleHostWriter({ gateDeps: makeGateDeps() });
-        const emptyTrace = { ...makeGoldenTrace(), cases: [] };
-        const artifact = makeRuleArtifact({
-            contentJson: JSON.stringify({
-                implementationCode: 'function evaluate() {}',
-                goldenTrace: emptyTrace,
-            }),
-        });
-        const result = await writer.canActivate(artifact);
-        expect(result.ok).toBe(false);
-        // Empty cases is a schema violation (missing required positive/negative
-        // cases), not a missing trace. The canonical validator surfaces the
-        // specific schema error rather than masking it as 'no_golden_trace'.
-        expect(result.reason).toContain('golden_trace_schema_invalid');
-        expect(result.reason).toMatch(/cases|positive|negative/);
-    });
-    it('rejects artifact with unparseable contentJson', async () => {
-        const { RuleHostWriter } = await importWriter();
-        const writer = new RuleHostWriter({ gateDeps: makeGateDeps() });
-        const artifact = makeRuleArtifact({ contentJson: '{not valid json' });
-        const result = await writer.canActivate(artifact);
-        expect(result.ok).toBe(false);
-        expect(result.reason).toContain('content_json_parse_failed');
-    });
-    it('returns critical riskLevel for write/edit tools', async () => {
-        const { RuleHostWriter } = await importWriter();
-        const writer = new RuleHostWriter({ gateDeps: makeGateDeps() });
-        const artifact = makeRuleArtifact({
-            contentJson: JSON.stringify({
-                implementationCode: 'function evaluate() {}',
-                goldenTrace: makeGoldenTrace(),
-                ruleHostGateDecision: 'accepted_shadow',
-                affectedTools: ['edit_file', 'write_file', 'bash'],
-            }),
-        });
-        const result = await writer.canActivate(artifact);
-        expect(result.ok).toBe(true);
-        expect(result.riskLevel).toBe('critical');
-    });
-    it('returns high riskLevel for read-only tools', async () => {
-        const { RuleHostWriter } = await importWriter();
-        const writer = new RuleHostWriter({ gateDeps: makeGateDeps() });
-        const artifact = makeRuleArtifact({
-            contentJson: JSON.stringify({
-                implementationCode: 'function evaluate() {}',
-                goldenTrace: makeGoldenTrace(),
-                ruleHostGateDecision: 'accepted_shadow',
-                affectedTools: ['read_file', 'grep'],
-            }),
-        });
-        const result = await writer.canActivate(artifact);
-        expect(result.ok).toBe(true);
-        expect(result.riskLevel).toBe('high');
-    });
-    it('uses sourceRuleId from artifact for activationId', async () => {
-        const { RuleHostWriter } = await importWriter();
-        const writer = new RuleHostWriter({ gateDeps: makeGateDeps() });
-        const artifact = makeRuleArtifact({ sourceRuleId: 'R_CUSTOM_42' });
-        const result = await writer.activate(makeWriterInput(), artifact);
-        expect(result.activationId).toBe('act_code_R_CUSTOM_42');
-        expect(result.targetRef).toBe('impl://R_CUSTOM_42');
-    });
-    it('falls back to principleId when sourceRuleId is missing', async () => {
-        const { RuleHostWriter } = await importWriter();
-        const writer = new RuleHostWriter({ gateDeps: makeGateDeps() });
-        const artifact = makeRuleArtifact({ sourceRuleId: undefined });
-        const result = await writer.activate(makeWriterInput(), artifact);
-        expect(result.activationId).toBe('act_code_P_001');
-    });
-    it('rejects artifact where goldenTrace is not a valid object', async () => {
-        const { RuleHostWriter } = await importWriter();
-        const writer = new RuleHostWriter({ gateDeps: makeGateDeps() });
-        const artifact = makeRuleArtifact({
-            contentJson: JSON.stringify({
-                implementationCode: 'function evaluate() {}',
-                goldenTrace: 'not_an_object',
-            }),
-        });
-        const result = await writer.canActivate(artifact);
-        expect(result.ok).toBe(false);
-        expect(result.reason).toContain('no_golden_trace');
-    });
-    // Regression: artifact with illegal expectedDecision value (e.g. "requireApproval",
-    // which is a RuleHostDecision runtime enum, not a GoldenTraceDecision test expectation)
-    // must be rejected at the schema validation layer with a clear, actionable reason —
-    // NOT passed through to the sandbox where it fails with an opaque
-    // "gate_decision_not_accepted_shadow:rejected_validation_failed" error.
-    // See ERR-001/ERR-005 (rc-1/rc-2): previously extractGoldenTrace() used
-    // `as unknown as GoldenTrace` to bypass schema validation.
-    it('rejects artifact with illegal expectedDecision (requireApproval) before sandbox, with clear reason', async () => {
-        const { RuleHostWriter } = await importWriter();
-        const gateDeps = makeGateDeps();
-        const writer = new RuleHostWriter({ gateDeps });
-        // Include a valid positive case so the ONLY schema failure is the illegal
-        // expectedDecision — isolating the test to the exact regression scenario
-        // rather than also tripping "missing positive case".
-        const badTrace = {
-            ...makeGoldenTrace(),
-            cases: [
-                {
-                    caseId: 'case-bad',
-                    kind: 'negative',
-                    toolName: 'write_file',
-                    params: { path: '/etc/passwd' },
-                    // Illegal: requireApproval is a RuleHostDecision, not a GoldenTraceDecision.
-                    // Legal values are: allow | block | propose_correction.
-                    expectedDecision: 'requireApproval',
-                },
-                {
-                    caseId: 'case-pos-valid',
-                    kind: 'positive',
-                    toolName: 'write_file',
-                    params: { path: '/project/src/safe.ts' },
-                    expectedDecision: 'allow',
-                },
-            ],
-        };
-        const artifact = makeRuleArtifact({
-            contentJson: JSON.stringify({
-                implementationCode: 'function evaluate() { return { decision: "requireApproval", matched: true, reason: "test" }; }',
-                goldenTrace: badTrace,
-                ruleHostGateDecision: 'accepted_shadow',
-            }),
-        });
-        const result = await writer.canActivate(artifact);
-        expect(result.ok).toBe(false);
-        // Must surface the schema violation clearly, not the opaque sandbox error.
-        expect(result.reason).toContain('golden_trace_schema_invalid');
-        expect(result.reason).not.toContain('gate_decision_not_accepted_shadow');
-        // The reason should point at the offending field so the owner knows what to fix.
-        expect(result.reason).toMatch(/expectedDecision|requireApproval|allow.*block.*propose_correction/);
-        // The rejection must happen BEFORE the sandbox is invoked — proving the
-        // schema guard is the defense, not the sandbox's validation_failed path.
-        expect(gateDeps.evaluateInSandbox).not.toHaveBeenCalled();
-    });
-    it('rejects artifact where implementationCode is not a string', async () => {
-        const { RuleHostWriter } = await importWriter();
-        const writer = new RuleHostWriter({ gateDeps: makeGateDeps() });
-        const artifact = makeRuleArtifact({
-            contentJson: JSON.stringify({
-                implementationCode: 42,
-                goldenTrace: makeGoldenTrace(),
-            }),
-        });
-        const result = await writer.canActivate(artifact);
-        expect(result.ok).toBe(false);
-        expect(result.reason).toContain('no_implementation_code');
-    });
-    it('rejects affectedTools empty array because empty scope must not match all', async () => {
-        const { RuleHostWriter } = await importWriter();
-        const writer = new RuleHostWriter({ gateDeps: makeGateDeps() });
-        const artifact = makeRuleArtifact({
-            contentJson: JSON.stringify({
-                implementationCode: 'function evaluate() {}',
-                goldenTrace: makeGoldenTrace(),
-                ruleHostGateDecision: 'accepted_shadow',
-                affectedTools: [],
-            }),
-        });
-        const result = await writer.canActivate(artifact);
-        expect(result.ok).toBe(false);
-        expect(result.reason).toBe('rulecode_scope_empty');
-        expect(result.riskLevel).toBe('high');
-    });
-    it('returns critical riskLevel for tools containing destructive prefixes (substring match)', async () => {
-        const { RuleHostWriter } = await importWriter();
-        const writer = new RuleHostWriter({ gateDeps: makeGateDeps() });
-        const artifact = makeRuleArtifact({
-            contentJson: JSON.stringify({
-                implementationCode: 'function evaluate() {}',
-                goldenTrace: makeGoldenTrace(),
-                ruleHostGateDecision: 'accepted_shadow',
-                affectedTools: ['my-edit-wrapper', 'pre-write-hook', 'post-delete-callback'],
-            }),
-        });
-        const result = await writer.canActivate(artifact);
-        expect(result.ok).toBe(true);
-        expect(result.riskLevel).toBe('critical');
-    });
-    it('returns high riskLevel for mixed tools where none contain destructive prefixes', async () => {
-        const { RuleHostWriter } = await importWriter();
-        const writer = new RuleHostWriter({ gateDeps: makeGateDeps() });
-        const artifact = makeRuleArtifact({
-            contentJson: JSON.stringify({
-                implementationCode: 'function evaluate() {}',
-                goldenTrace: makeGoldenTrace(),
-                ruleHostGateDecision: 'accepted_shadow',
-                affectedTools: ['search', 'grep', 'list_files'],
-            }),
-        });
-        const result = await writer.canActivate(artifact);
-        expect(result.ok).toBe(true);
-        expect(result.riskLevel).toBe('high');
-    });
-    it('rejects affectedTools containing no valid explicit tool names', async () => {
-        const { RuleHostWriter } = await importWriter();
-        const writer = new RuleHostWriter({ gateDeps: makeGateDeps() });
-        const artifact = makeRuleArtifact({
-            contentJson: JSON.stringify({
-                implementationCode: 'function evaluate() {}',
-                goldenTrace: makeGoldenTrace(),
-                ruleHostGateDecision: 'accepted_shadow',
-                affectedTools: [123, null, undefined, {}],
-            }),
-        });
-        const result = await writer.canActivate(artifact);
-        expect(result.ok).toBe(false);
-        expect(result.reason).toBe('rulecode_scope_empty');
-        expect(result.riskLevel).toBe('high');
-    });
-    it('rejects artifact with pending validationStatus', async () => {
-        const { RuleHostWriter } = await importWriter();
-        const writer = new RuleHostWriter({ gateDeps: makeGateDeps() });
-        const artifact = makeRuleArtifact({
-            validationStatus: 'pending',
-        });
-        const result = await writer.canActivate(artifact);
-        expect(result.ok).toBe(false);
-        expect(result.reason).toContain('artifact_validation_status_pending');
-    });
-    it('rejects artifact with rejected validationStatus', async () => {
-        const { RuleHostWriter } = await importWriter();
-        const writer = new RuleHostWriter({ gateDeps: makeGateDeps() });
-        const artifact = makeRuleArtifact({
-            validationStatus: 'rejected',
-        });
-        const result = await writer.canActivate(artifact);
-        expect(result.ok).toBe(false);
-        expect(result.reason).toContain('artifact_validation_status_rejected');
-    });
-});
-describe('RuleHostWriter.canActivate — PRI-484 rulecode_context_v2 gating', () => {
-    async function importWriter() {
-        const { RuleHostWriter } = await import('../rule-host-writer.js');
-        return { RuleHostWriter };
-    }
-    /** Build a v2-declaring artifact (requiresContextVersion: 2 in contentJson).
-     *  PRI-490: v2 artifacts MUST carry evidenceRefs (preserved verbatim from
-     *  BehaviorExamplePack) — the fixture includes a valid evidenceRefs array
-     *  so the existing "accepts v2 when flag ON" test continues to pass once
-     *  the v2 evidenceRefs requirement is enforced by validateV2SeedRuleContent. */
-    function makeV2Artifact() {
-        const goldenTrace = makeGoldenTrace();
-        return {
-            artifactId: 'art-rule-v2-001',
-            artifactKind: 'rule',
-            sourceTaskId: 'task-v2-001',
-            sourcePrincipleId: 'P_v2',
-            sourceRuleId: 'R_v2',
-            lineageArtifactIds: [],
-            validationStatus: 'validated',
-            contentJson: JSON.stringify({
-                implementationCode: 'function evaluate(input, helpers) { return { decision: "allow", matched: false, reason: "v2 rule" }; }',
-                goldenTrace,
-                ruleHostGateDecision: 'accepted_shadow',
-                affectedTools: ['read_file'],
-                requiresContextVersion: 2,
-                evidenceRefs: ['pain:1', 'tool_call:abc'],
-            }),
-            createdAt: '2026-06-27T00:00:00.000Z',
-            updatedAt: '2026-06-27T00:00:00.000Z',
-        };
-    }
-    it('rejects v2 artifact when rulecode_context_v2 flag is OFF (default, no probe)', async () => {
-        const { RuleHostWriter } = await importWriter();
-        // No featureFlagProbe provided — defaults to "all flags off" (safe default
-        // for quiet-category flags per PRI-239).
-        const writer = new RuleHostWriter({ gateDeps: makeGateDeps() });
-        const result = await writer.canActivate(makeV2Artifact());
-        expect(result.ok).toBe(false);
-        expect(result.reason).toContain('rulecode_context_v2_disabled');
-    });
-    it('rejects v2 artifact when featureFlagProbe reports rulecode_context_v2=false', async () => {
-        const { RuleHostWriter } = await importWriter();
-        const writer = new RuleHostWriter({
-            gateDeps: makeGateDeps(),
-            featureFlagProbe: (_flagId) => false,
-        });
-        const result = await writer.canActivate(makeV2Artifact());
-        expect(result.ok).toBe(false);
-        expect(result.reason).toContain('rulecode_context_v2_disabled');
-    });
-    it('accepts v2 artifact when featureFlagProbe reports rulecode_context_v2=true', async () => {
-        const { RuleHostWriter } = await importWriter();
-        const writer = new RuleHostWriter({
-            gateDeps: makeGateDeps(),
-            featureFlagProbe: (flagId) => flagId === 'rulecode_context_v2',
-        });
-        const result = await writer.canActivate(makeV2Artifact());
-        expect(result.ok).toBe(true);
-    });
-    it('accepts v1 artifact (no requiresContextVersion) regardless of flag state', async () => {
-        const { RuleHostWriter } = await importWriter();
-        // Flag OFF — v1 artifact must still pass.
-        const writerOff = new RuleHostWriter({ gateDeps: makeGateDeps() });
-        const resultOff = await writerOff.canActivate(makeRuleArtifact());
-        expect(resultOff.ok).toBe(true);
-        // Flag ON — v1 artifact still passes (flag doesn't affect v1).
-        const writerOn = new RuleHostWriter({
-            gateDeps: makeGateDeps(),
-            featureFlagProbe: () => true,
-        });
-        const resultOn = await writerOn.canActivate(makeRuleArtifact());
-        expect(resultOn.ok).toBe(true);
-    });
-    it('does not invoke the sandbox when rejecting v2 artifact with flag OFF', async () => {
-        const { RuleHostWriter } = await importWriter();
-        const gateDeps = makeGateDeps();
-        const writer = new RuleHostWriter({ gateDeps });
-        await writer.canActivate(makeV2Artifact());
-        expect(gateDeps.evaluateInSandbox).not.toHaveBeenCalled();
-    });
-    it.each([
-        { label: 'numeric 1', value: 1 },
-        { label: 'numeric 3', value: 3 },
-        { label: 'string "2" (not strict-equal to 2)', value: '2' },
-        { label: 'null', value: null },
-        { label: 'boolean true', value: true },
-    ])('rejects declared context versions other than 2 ($label)', async ({ value }) => {
-        const { RuleHostWriter } = await importWriter();
-        const writer = new RuleHostWriter({ gateDeps: makeGateDeps() });
-        const artifact = makeRuleArtifact({
-            contentJson: JSON.stringify({
-                implementationCode: 'function evaluate(input, helpers) { return { decision: "block", matched: true, reason: "x" }; }',
-                goldenTrace: makeGoldenTrace(),
-                ruleHostGateDecision: 'accepted_shadow',
-                affectedTools: ['read_file'],
-                requiresContextVersion: value,
-            }),
-        });
-        const result = await writer.canActivate(artifact);
-        expect(result).toEqual({
-            ok: false,
-            reason: 'unsupported_context_version',
-            riskLevel: 'high',
-        });
-    });
-});
-describe('RuleHostWriter.canActivate — PRI-490 v2 seed rule allow/block-only + evidenceRefs', () => {
-    async function importWriter() {
-        const { RuleHostWriter } = await import('../rule-host-writer.js');
-        return { RuleHostWriter };
-    }
-    /** Build a v2 artifact with full overrides applied to its contentJson. */
-    function makeV2ArtifactWithContent(contentOverrides = {}) {
-        const goldenTrace = makeGoldenTrace();
-        const baseContent = {
-            implementationCode: 'function evaluate(input, helpers) { return { decision: "allow", matched: false, reason: "v2 rule" }; }',
-            goldenTrace,
-            ruleHostGateDecision: 'accepted_shadow',
-            affectedTools: ['read_file'],
-            requiresContextVersion: 2,
-            evidenceRefs: ['pain:1', 'tool_call:abc'],
-            ...contentOverrides,
-        };
-        return {
-            artifactId: 'art-rule-v2-pri490',
-            artifactKind: 'rule',
-            sourceTaskId: 'task-v2-pri490',
-            sourcePrincipleId: 'P_v2_490',
-            sourceRuleId: 'R_v2_490',
-            lineageArtifactIds: [],
-            validationStatus: 'validated',
-            contentJson: JSON.stringify(baseContent),
-            createdAt: '2026-06-30T00:00:00.000Z',
-            updatedAt: '2026-06-30T00:00:00.000Z',
-        };
-    }
-    it('rejects v2 artifact with propose_correction in goldenTraceCases (PRI-490)', async () => {
-        const { RuleHostWriter } = await importWriter();
-        const writer = new RuleHostWriter({
-            gateDeps: makeGateDeps(),
-            featureFlagProbe: (flagId) => flagId === 'rulecode_context_v2',
-        });
-        // Build a v2 artifact whose negative case expects propose_correction.
-        // This is structurally valid (goldenTrace validator accepts it for v1)
-        // but forbidden for v2 seed rules per PRI-490.
-        const badTrace = {
-            ...makeGoldenTrace(),
-            cases: [
-                {
-                    caseId: 'case-propose',
-                    kind: 'negative',
-                    toolName: 'write_file',
-                    params: { path: '/etc/passwd' },
-                    expectedDecision: 'propose_correction',
-                    expectedProposedParams: { path: '/safe/path' },
-                    expectedApplicationMode: 'shadow',
-                },
-                {
-                    caseId: 'case-allow',
-                    kind: 'positive',
-                    toolName: 'write_file',
-                    params: { path: '/project/src/safe.ts' },
-                    expectedDecision: 'allow',
-                },
-            ],
-        };
-        const artifact = makeV2ArtifactWithContent({ goldenTrace: badTrace });
-        const result = await writer.canActivate(artifact);
-        expect(result.ok).toBe(false);
-        // PRI-490: rejection reason must surface the forbidden decision so the
-        // owner knows exactly what to fix (ERR-088: assert the specific reason,
-        // not just `result.ok === false`).
-        expect(result.reason).toContain('v2_seed_rule_forbidden_decision');
-        expect(result.reason).toContain('propose_correction');
-    });
-    it('rejects v2 artifact missing evidenceRefs (PRI-490)', async () => {
-        const { RuleHostWriter } = await importWriter();
-        const writer = new RuleHostWriter({
-            gateDeps: makeGateDeps(),
-            featureFlagProbe: (flagId) => flagId === 'rulecode_context_v2',
-        });
-        // v2 artifact without evidenceRefs field — should be rejected.
-        const artifact = makeV2ArtifactWithContent({});
-        const parsed = JSON.parse(artifact.contentJson);
-        delete parsed.evidenceRefs;
-        artifact.contentJson = JSON.stringify(parsed);
-        const result = await writer.canActivate(artifact);
-        expect(result.ok).toBe(false);
-        expect(result.reason).toContain('v2_seed_rule_missing_evidence_refs');
-    });
-    it('rejects v2 artifact with empty evidenceRefs array (PRI-490)', async () => {
-        const { RuleHostWriter } = await importWriter();
-        const writer = new RuleHostWriter({
-            gateDeps: makeGateDeps(),
-            featureFlagProbe: (flagId) => flagId === 'rulecode_context_v2',
-        });
-        const artifact = makeV2ArtifactWithContent({ evidenceRefs: [] });
-        const result = await writer.canActivate(artifact);
-        expect(result.ok).toBe(false);
-        expect(result.reason).toContain('v2_seed_rule_invalid_evidence_refs');
-    });
-    it('rejects v2 artifact with non-string evidenceRefs entries (PRI-490)', async () => {
-        const { RuleHostWriter } = await importWriter();
-        const writer = new RuleHostWriter({
-            gateDeps: makeGateDeps(),
-            featureFlagProbe: (flagId) => flagId === 'rulecode_context_v2',
-        });
-        const artifact = makeV2ArtifactWithContent({ evidenceRefs: ['pain:1', 42, null] });
-        const result = await writer.canActivate(artifact);
-        expect(result.ok).toBe(false);
-        expect(result.reason).toContain('v2_seed_rule_invalid_evidence_refs');
-    });
-    it('rejects v2 artifact with whitespace-only evidenceRefs entries (PRI-490)', async () => {
-        const { RuleHostWriter } = await importWriter();
-        const writer = new RuleHostWriter({
-            gateDeps: makeGateDeps(),
-            featureFlagProbe: (flagId) => flagId === 'rulecode_context_v2',
-        });
-        const artifact = makeV2ArtifactWithContent({ evidenceRefs: ['pain:1', '   '] });
-        const result = await writer.canActivate(artifact);
-        expect(result.ok).toBe(false);
-        expect(result.reason).toContain('v2_seed_rule_invalid_evidence_refs');
-    });
-    it('does NOT invoke sandbox when rejecting v2 artifact with propose_correction (defense before sandbox)', async () => {
-        const { RuleHostWriter } = await importWriter();
-        const gateDeps = makeGateDeps();
-        const writer = new RuleHostWriter({
-            gateDeps,
-            featureFlagProbe: (flagId) => flagId === 'rulecode_context_v2',
-        });
-        const badTrace = {
-            ...makeGoldenTrace(),
-            cases: [
-                {
-                    caseId: 'case-propose',
-                    kind: 'negative',
-                    toolName: 'write_file',
-                    params: { path: '/etc/passwd' },
-                    expectedDecision: 'propose_correction',
-                    expectedProposedParams: { path: '/safe/path' },
-                    expectedApplicationMode: 'shadow',
-                },
-                {
-                    caseId: 'case-allow',
-                    kind: 'positive',
-                    toolName: 'write_file',
-                    params: { path: '/safe' },
-                    expectedDecision: 'allow',
-                },
-            ],
-        };
-        const artifact = makeV2ArtifactWithContent({ goldenTrace: badTrace });
-        await writer.canActivate(artifact);
-        expect(gateDeps.evaluateInSandbox).not.toHaveBeenCalled();
-    });
-    it('accepts valid v2 artifact with allow/block-only + evidenceRefs (PRI-490 happy path)', async () => {
-        const { RuleHostWriter } = await importWriter();
-        const writer = new RuleHostWriter({
-            gateDeps: makeGateDeps(),
-            featureFlagProbe: (flagId) => flagId === 'rulecode_context_v2',
-        });
-        // makeV2ArtifactWithContent() defaults to a valid v2 artifact.
-        const result = await writer.canActivate(makeV2ArtifactWithContent());
-        expect(result.ok).toBe(true);
-    });
-    it('does not run v2 content checks on v1 artifacts (v1 behavior unchanged)', async () => {
-        const { RuleHostWriter } = await importWriter();
-        // No featureFlagProbe — v1 path must still pass.
-        const writer = new RuleHostWriter({ gateDeps: makeGateDeps() });
-        // v1 artifact with propose_correction is allowed (v1 contract unchanged).
-        const v1TraceWithPropose = {
-            ...makeGoldenTrace(),
-            cases: [
-                {
-                    caseId: 'case-propose-v1',
-                    kind: 'negative',
-                    toolName: 'write_file',
-                    params: { path: '/etc/passwd' },
-                    expectedDecision: 'propose_correction',
-                    expectedProposedParams: { path: '/safe' },
-                    expectedApplicationMode: 'shadow',
-                },
-                {
-                    caseId: 'case-allow-v1',
-                    kind: 'positive',
-                    toolName: 'write_file',
-                    params: { path: '/safe' },
-                    expectedDecision: 'allow',
-                },
-            ],
-        };
-        const artifact = makeRuleArtifact({
-            contentJson: JSON.stringify({
-                implementationCode: 'function evaluate() {}',
-                goldenTrace: v1TraceWithPropose,
-                ruleHostGateDecision: 'accepted_shadow',
-                affectedTools: ['read_file'],
-                // Note: no requiresContextVersion, no evidenceRefs — v1 path.
-            }),
-        });
-        const result = await writer.canActivate(artifact);
-        expect(result.ok).toBe(true);
-    });
-});
-describe('RuleHostWriter.buildApprovalContext', () => {
-    async function importWriter() {
-        const { RuleHostWriter } = await import('../rule-host-writer.js');
-        return { RuleHostWriter };
-    }
-    it('happy path: generates all 5 approval context fields from artifact metadata', async () => {
-        const { RuleHostWriter } = await importWriter();
-        const writer = new RuleHostWriter({ gateDeps: makeGateDeps() });
-        const artifact = makeRuleArtifact();
-        const input = makeWriterInput();
-        const ctx = writer.buildApprovalContext(input, artifact);
-        expect(ctx.summary).toBeTruthy();
-        expect(ctx.summary).toContain('R_001');
-        expect(ctx.triggerReason).toBeTruthy();
-        expect(ctx.confidenceExplanation).toBeTruthy();
-        expect(ctx.effectDescription).toBeTruthy();
-        expect(ctx.rejectionEffect).toBeTruthy();
-        expect(ctx.rejectionEffect).toContain('not be activated');
-    });
-    it('includes affectedTools in effectDescription when available', async () => {
-        const { RuleHostWriter } = await importWriter();
-        const writer = new RuleHostWriter({ gateDeps: makeGateDeps() });
-        const artifact = makeRuleArtifact({
-            contentJson: JSON.stringify({
-                implementationCode: 'function evaluate() {}',
-                goldenTrace: makeGoldenTrace(),
-                ruleHostGateDecision: 'accepted_shadow',
-                affectedTools: ['edit_file', 'bash'],
-            }),
-        });
-        const ctx = writer.buildApprovalContext(makeWriterInput(), artifact);
-        expect(ctx.effectDescription).toContain('edit_file');
-        expect(ctx.effectDescription).toContain('bash');
-    });
-    // PRI-490 — evidence refs must be surfaced in approval context so the owner
-    // has provenance context during approval review. Surfaced only when the
-    // artifact carries a valid evidenceRefs array.
-    it('surfaces evidenceRefs in effectDescription when present (PRI-490)', async () => {
-        const { RuleHostWriter } = await importWriter();
-        const writer = new RuleHostWriter({ gateDeps: makeGateDeps() });
-        const artifact = makeRuleArtifact({
-            contentJson: JSON.stringify({
-                implementationCode: 'function evaluate() {}',
-                goldenTrace: makeGoldenTrace(),
-                ruleHostGateDecision: 'accepted_shadow',
-                affectedTools: ['edit_file'],
-                evidenceRefs: ['pain:42', 'tool_call:def'],
-            }),
-        });
-        const ctx = writer.buildApprovalContext(makeWriterInput(), artifact);
-        expect(ctx.effectDescription).toContain('pain:42');
-        expect(ctx.effectDescription).toContain('tool_call:def');
-    });
-    it('does not surface evidenceRefs clause when absent (PRI-490)', async () => {
-        const { RuleHostWriter } = await importWriter();
-        const writer = new RuleHostWriter({ gateDeps: makeGateDeps() });
-        const artifact = makeRuleArtifact({
-            contentJson: JSON.stringify({
-                implementationCode: 'function evaluate() {}',
-                goldenTrace: makeGoldenTrace(),
-                ruleHostGateDecision: 'accepted_shadow',
-                affectedTools: ['edit_file'],
-                // No evidenceRefs field — effectDescription must not surface an
-                // evidence clause.
-            }),
-        });
-        const ctx = writer.buildApprovalContext(makeWriterInput(), artifact);
-        expect(ctx.effectDescription).not.toContain('Evidence backing');
-        expect(ctx.effectDescription).toContain('edit_file');
-    });
-    it('has stable fallback for effectDescription when affectedTools is missing', async () => {
-        const { RuleHostWriter } = await importWriter();
-        const writer = new RuleHostWriter({ gateDeps: makeGateDeps() });
-        const artifact = makeRuleArtifact({
-            contentJson: JSON.stringify({
-                implementationCode: 'function evaluate() {}',
-                goldenTrace: makeGoldenTrace(),
-                ruleHostGateDecision: 'accepted_shadow',
-            }),
-        });
-        const ctx = writer.buildApprovalContext(makeWriterInput(), artifact);
-        expect(ctx.effectDescription).toBeTruthy();
-        expect(ctx.effectDescription).not.toContain('undefined');
-    });
-    it('has stable fallback for triggerReason when painReasonSummary is missing', async () => {
-        const { RuleHostWriter } = await importWriter();
-        const writer = new RuleHostWriter({ gateDeps: makeGateDeps() });
-        const artifact = makeRuleArtifact();
-        const ctx = writer.buildApprovalContext(makeWriterInput(), artifact);
-        expect(ctx.triggerReason).toBeTruthy();
-        expect(ctx.triggerReason).not.toContain('undefined');
-        expect(ctx.triggerReason).not.toContain('null');
-    });
-    it('uses painReasonSummary from contentJson for triggerReason when available', async () => {
-        const { RuleHostWriter } = await importWriter();
-        const writer = new RuleHostWriter({ gateDeps: makeGateDeps() });
-        const artifact = makeRuleArtifact({
-            contentJson: JSON.stringify({
-                implementationCode: 'function evaluate() {}',
-                goldenTrace: makeGoldenTrace(),
-                ruleHostGateDecision: 'accepted_shadow',
-                affectedTools: ['read_file'],
-                painReasonSummary: 'Detected repeated dangerous git force push errors',
-            }),
-        });
-        const ctx = writer.buildApprovalContext(makeWriterInput(), artifact);
-        expect(ctx.triggerReason).toContain('git force push');
-    });
-    it('formats confidence as percentage when confidence is provided', async () => {
-        const { RuleHostWriter } = await importWriter();
-        const writer = new RuleHostWriter({ gateDeps: makeGateDeps() });
-        const artifact = makeRuleArtifact();
-        const input = makeWriterInput();
-        const ctx = writer.buildApprovalContext(input, artifact, 0.92);
-        expect(ctx.confidenceExplanation).toContain('92%');
-        expect(ctx.confidenceExplanation).not.toContain('unavailable');
-    });
-    it('has stable fallback when confidence is undefined', async () => {
-        const { RuleHostWriter } = await importWriter();
-        const writer = new RuleHostWriter({ gateDeps: makeGateDeps() });
-        const artifact = makeRuleArtifact();
-        const ctx = writer.buildApprovalContext(makeWriterInput(), artifact);
-        expect(ctx.confidenceExplanation).toBeTruthy();
-        expect(ctx.confidenceExplanation).not.toContain('undefined');
-        expect(ctx.confidenceExplanation).not.toContain('null');
-    });
-    it('rejectionEffect is a fixed template for code_tool_hook', async () => {
-        const { RuleHostWriter } = await importWriter();
-        const writer = new RuleHostWriter({ gateDeps: makeGateDeps() });
-        const artifact = makeRuleArtifact();
-        const ctx = writer.buildApprovalContext(makeWriterInput(), artifact);
-        expect(ctx.rejectionEffect).toBe('The rule will not be activated. Current tool calls will continue unchanged.');
-    });
-    it('uses sourceRuleId for summary when available', async () => {
-        const { RuleHostWriter } = await importWriter();
-        const writer = new RuleHostWriter({ gateDeps: makeGateDeps() });
-        const artifact = makeRuleArtifact({ sourceRuleId: 'R_git_force_push' });
-        const ctx = writer.buildApprovalContext(makeWriterInput(), artifact);
-        expect(ctx.summary).toContain('R_git_force_push');
-        expect(ctx.summary).toContain('code_tool_hook');
-    });
-    it('falls back to artifactId for summary when sourceRuleId is missing', async () => {
-        const { RuleHostWriter } = await importWriter();
-        const writer = new RuleHostWriter({ gateDeps: makeGateDeps() });
-        const artifact = makeRuleArtifact({
-            sourceRuleId: undefined,
-            artifactId: 'art-rule-no-source',
-        });
-        const ctx = writer.buildApprovalContext(makeWriterInput(), artifact);
-        expect(ctx.summary).toContain('art-rule-no-source');
-        expect(ctx.summary).not.toContain('undefined');
-    });
-    it('fields contain no undefined/null text', async () => {
-        const { RuleHostWriter } = await importWriter();
-        const writer = new RuleHostWriter({ gateDeps: makeGateDeps() });
-        const artifact = makeRuleArtifact({
-            sourceRuleId: undefined,
-            contentJson: JSON.stringify({
-                implementationCode: 'function evaluate() {}',
-                goldenTrace: makeGoldenTrace(),
-                ruleHostGateDecision: 'accepted_shadow',
-            }),
-        });
-        const ctx = writer.buildApprovalContext(makeWriterInput(), artifact);
-        for (const value of Object.values(ctx)) {
-            expect(value).not.toContain('undefined');
-            expect(value).not.toContain('null');
-        }
-    });
-    it('falls back for NaN confidence', async () => {
-        const { RuleHostWriter } = await importWriter();
-        const writer = new RuleHostWriter({ gateDeps: makeGateDeps() });
-        const artifact = makeRuleArtifact();
-        const ctx = writer.buildApprovalContext(makeWriterInput(), artifact, NaN);
-        expect(ctx.confidenceExplanation).toContain('unavailable');
-        expect(ctx.confidenceExplanation).not.toContain('NaN');
-    });
-    it('falls back for Infinity confidence', async () => {
-        const { RuleHostWriter } = await importWriter();
-        const writer = new RuleHostWriter({ gateDeps: makeGateDeps() });
-        const artifact = makeRuleArtifact();
-        const ctx = writer.buildApprovalContext(makeWriterInput(), artifact, Infinity);
-        expect(ctx.confidenceExplanation).toContain('unavailable');
-        expect(ctx.confidenceExplanation).not.toContain('Infinity');
-    });
-    it('falls back for out-of-range confidence (>1)', async () => {
-        const { RuleHostWriter } = await importWriter();
-        const writer = new RuleHostWriter({ gateDeps: makeGateDeps() });
-        const artifact = makeRuleArtifact();
-        const ctx = writer.buildApprovalContext(makeWriterInput(), artifact, 1.5);
-        expect(ctx.confidenceExplanation).toContain('unavailable');
-    });
-});
-describe('RuleHostWriter dispatcher integration', () => {
-    it('ActivationDispatcher routes code_tool_hook to RuleHostWriter', async () => {
-        const { RuleHostWriter } = await import('../rule-host-writer.js');
-        const { ActivationDispatcher, MemoryActivationStateStore, MemoryArtifactReadModel, MemoryApprovalQueueStore, } = await import('../../index.js');
-        const gateDeps = makeGateDeps();
-        const ruleHostWriter = new RuleHostWriter({ gateDeps });
-        const stateStore = new MemoryActivationStateStore();
-        const artifactStore = new MemoryArtifactReadModel();
-        const approvalStore = new MemoryApprovalQueueStore();
-        const dispatcher = new ActivationDispatcher(artifactStore, stateStore, { writers: [ruleHostWriter], approvalQueueStore: approvalStore });
-        const artifact = makeRuleArtifact();
-        artifactStore.addArtifact(artifact);
-        const result = await dispatcher.dispatch({
-            artifactId: 'art-rule-001',
-            channel: 'code_tool_hook',
-            rolloutDecision: 'require_approval',
-            actor: { kind: 'system', source: 'rollout_reviewer' },
-            now: '2026-05-17T00:00:00.000Z',
-            confirm: true,
-        });
-        expect(result.decision).toBe('queued_for_approval');
-        if (result.decision === 'queued_for_approval') {
-            expect(result.channel).toBe('code_tool_hook');
-            expect(result.riskLevel).toBe('high');
-        }
-    });
-    it('code_tool_hook with auto_activate still goes to approval queue (forced)', async () => {
-        const { RuleHostWriter } = await import('../rule-host-writer.js');
-        const { ActivationDispatcher, MemoryActivationStateStore, MemoryArtifactReadModel, MemoryApprovalQueueStore, } = await import('../../index.js');
-        const gateDeps = makeGateDeps();
-        const ruleHostWriter = new RuleHostWriter({ gateDeps });
-        const stateStore = new MemoryActivationStateStore();
-        const artifactStore = new MemoryArtifactReadModel();
-        const approvalStore = new MemoryApprovalQueueStore();
-        const dispatcher = new ActivationDispatcher(artifactStore, stateStore, { writers: [ruleHostWriter], approvalQueueStore: approvalStore });
-        const artifact = makeRuleArtifact();
-        artifactStore.addArtifact(artifact);
-        const result = await dispatcher.dispatch({
-            artifactId: 'art-rule-001',
-            channel: 'code_tool_hook',
-            rolloutDecision: 'auto_activate',
-            actor: { kind: 'system', source: 'rollout_reviewer' },
-            now: '2026-05-17T00:00:00.000Z',
-            confirm: true,
-            confidence: 0.99,
-        });
-        expect(result.decision).toBe('queued_for_approval');
-        if (result.decision === 'queued_for_approval') {
-            expect(result.channel).toBe('code_tool_hook');
-            expect(result.riskLevel).toBe('high');
-        }
-    });
-    it('stored approval record has RuleHost-specific context fields (not generic)', async () => {
-        const { RuleHostWriter } = await import('../rule-host-writer.js');
-        const { ActivationDispatcher, MemoryActivationStateStore, MemoryArtifactReadModel, MemoryApprovalQueueStore, } = await import('../../index.js');
-        const gateDeps = makeGateDeps();
-        const ruleHostWriter = new RuleHostWriter({ gateDeps });
-        const stateStore = new MemoryActivationStateStore();
-        const artifactStore = new MemoryArtifactReadModel();
-        const approvalStore = new MemoryApprovalQueueStore();
-        const dispatcher = new ActivationDispatcher(artifactStore, stateStore, { writers: [ruleHostWriter], approvalQueueStore: approvalStore });
-        const artifact = makeRuleArtifact();
-        artifactStore.addArtifact(artifact);
-        await dispatcher.dispatch({
-            artifactId: 'art-rule-001',
-            channel: 'code_tool_hook',
-            rolloutDecision: 'require_approval',
-            actor: { kind: 'system', source: 'rollout_reviewer' },
-            now: '2026-05-17T00:00:00.000Z',
-            confirm: true,
-            confidence: 0.88,
-        });
-        const record = await approvalStore.getById('apr_code_tool_hook_art-rule-001');
-        expect(record).not.toBeNull();
-        if (!record)
-            return;
-        expect(record.summary).toContain('R_001');
-        expect(record.triggerReason).toBeTruthy();
-        expect(record.confidenceExplanation).toContain('88%');
-        expect(record.effectDescription).toContain('read_file');
-        expect(record.rejectionEffect).toContain('not be activated');
-    });
-    it('refuses to enqueue malformed RuleHost artifact (no implementation code)', async () => {
-        const { RuleHostWriter } = await import('../rule-host-writer.js');
-        const { ActivationDispatcher, MemoryActivationStateStore, MemoryArtifactReadModel, MemoryApprovalQueueStore, } = await import('../../index.js');
-        const gateDeps = makeGateDeps();
-        const ruleHostWriter = new RuleHostWriter({ gateDeps });
-        const stateStore = new MemoryActivationStateStore();
-        const artifactStore = new MemoryArtifactReadModel();
-        const approvalStore = new MemoryApprovalQueueStore();
-        const dispatcher = new ActivationDispatcher(artifactStore, stateStore, { writers: [ruleHostWriter], approvalQueueStore: approvalStore });
-        const malformedArtifact = makeRuleArtifact({
-            contentJson: JSON.stringify({ goldenTrace: makeGoldenTrace() }),
-        });
-        artifactStore.addArtifact(malformedArtifact);
-        const result = await dispatcher.dispatch({
-            artifactId: 'art-rule-001',
-            channel: 'code_tool_hook',
-            rolloutDecision: 'require_approval',
-            actor: { kind: 'system', source: 'rollout_reviewer' },
-            now: '2026-05-17T00:00:00.000Z',
-            confirm: true,
-        });
-        expect(result.decision).toBe('refused');
-        const record = await approvalStore.getById('apr_code_tool_hook_art-rule-001');
-        expect(record).toBeNull();
-    });
-    it('refuses to enqueue when gate decision is not accepted_shadow', async () => {
-        const { RuleHostWriter } = await import('../rule-host-writer.js');
-        const { ActivationDispatcher, MemoryActivationStateStore, MemoryArtifactReadModel, MemoryApprovalQueueStore, } = await import('../../index.js');
-        const gateDeps = makeGateDeps();
-        const ruleHostWriter = new RuleHostWriter({ gateDeps });
-        const stateStore = new MemoryActivationStateStore();
-        const artifactStore = new MemoryArtifactReadModel();
-        const approvalStore = new MemoryApprovalQueueStore();
-        const dispatcher = new ActivationDispatcher(artifactStore, stateStore, { writers: [ruleHostWriter], approvalQueueStore: approvalStore });
-        const gateFailedArtifact = makeRuleArtifact({
-            contentJson: JSON.stringify({
-                implementationCode: 'function evaluate() {}',
-                goldenTrace: makeGoldenTrace(),
-                ruleHostGateDecision: 'rejected_validation_failed',
-            }),
-        });
-        artifactStore.addArtifact(gateFailedArtifact);
-        const result = await dispatcher.dispatch({
-            artifactId: 'art-rule-001',
-            channel: 'code_tool_hook',
-            rolloutDecision: 'require_approval',
-            actor: { kind: 'system', source: 'rollout_reviewer' },
-            now: '2026-05-17T00:00:00.000Z',
-            confirm: true,
-        });
-        expect(result.decision).toBe('refused');
-        const record = await approvalStore.getById('apr_code_tool_hook_art-rule-001');
-        expect(record).toBeNull();
-    });
-});
-describe('legacy-signature RuleCode anti-regression (2026-08-19 validator hardening)', () => {
-    it('rejects an old-signature evaluate(toolName, params) rule at the activation boundary via the REAL gate deps', async () => {
-        const { RuleHostWriter } = await import('../rule-host-writer.js');
-        const { createProductionGateDeps } = await import('../../production-gate-deps.js');
-        // Old demo-pipeline signature: treats arg0 as a toolName string and arg1
-        // as a params record. Called with the canonical (input, helpers) contract
-        // it throws (params.path is undefined -> TypeError), which the replay
-        // gate must classify as rejected_runtime_error — never activatable.
-        const legacySignatureCode = [
-            'function evaluate(toolName, params) {',
-            '  if (params.path.indexOf("/etc") === 0) {',
-            '    return { decision: "block", matched: true, reason: "legacy demo rule" };',
-            '  }',
-            '  return { decision: "allow", matched: false, reason: "legacy demo rule" };',
-            '}',
-            'var meta = { name: "legacy-demo", version: "1", ruleId: "R_LEGACY", coversCondition: "all" };',
-        ].join('\n');
-        const artifact = makeRuleArtifact({
-            contentJson: JSON.stringify({
-                implementationCode: legacySignatureCode,
-                goldenTrace: makeGoldenTrace(),
-                ruleHostGateDecision: 'accepted_shadow',
-                affectedTools: ['write_file'],
-            }),
-        });
-        const writer = new RuleHostWriter({ gateDeps: createProductionGateDeps() });
-        const result = await writer.canActivate(artifact);
-        expect(result.ok).toBe(false);
-        expect(result.reason).toContain('gate_decision_not_accepted_shadow:rejected_runtime_error');
-    });
-});
-//# sourceMappingURL=rule-host-writer.test.js.map