@principles/core 1.73.0

package/dist/runtime-v2/__tests__/trajectory-store.test.js

@@ -0,0 +1,127 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { listCorrectionSamples, reviewCorrectionSample } from '../../trajectory-store.js';
+const mockPrepare = vi.fn();
+const mockClose = vi.fn();
+let shouldThrowOnOpen = false;
+vi.mock('better-sqlite3', () => {
+    return {
+        default: vi.fn(function () {
+            if (shouldThrowOnOpen) {
+                throw new Error('SQLITE_CANTOPEN: unable to open database file');
+            }
+            this.prepare = mockPrepare;
+            this.close = mockClose;
+        }),
+    };
+});
+describe('listCorrectionSamples', () => {
+    beforeEach(() => {
+        shouldThrowOnOpen = false;
+        mockPrepare.mockReset();
+        mockClose.mockReset();
+    });
+    it('returns empty array when DB cannot be opened', () => {
+        shouldThrowOnOpen = true;
+        const result = listCorrectionSamples('/fake/workspace');
+        expect(result).toEqual([]);
+    });
+    it('returns empty array when DB cannot be opened with custom status', () => {
+        shouldThrowOnOpen = true;
+        const result = listCorrectionSamples('/fake/workspace', 'approved');
+        expect(result).toEqual([]);
+    });
+    it('returns empty array when query throws (e.g. table missing)', () => {
+        mockPrepare.mockReturnValue({ all: () => { throw new Error('SQLITE_ERROR: no such table: correction_samples'); } });
+        const result = listCorrectionSamples('/fake/workspace');
+        expect(result).toEqual([]);
+        expect(mockClose).toHaveBeenCalled();
+    });
+    it('maps rows to CorrectionSampleRecord when query succeeds', () => {
+        mockPrepare.mockReturnValue({
+            all: () => [{
+                    sample_id: 's1',
+                    session_id: 'sess1',
+                    bad_assistant_turn_id: 1,
+                    user_correction_turn_id: 2,
+                    recovery_tool_span_json: '{"tool":"edit"}',
+                    diff_excerpt: 'old→new',
+                    principle_ids_json: '["p1"]',
+                    quality_score: 0.8,
+                    review_status: 'pending',
+                    export_mode: 'raw',
+                    created_at: '2026-01-01T00:00:00.000Z',
+                    updated_at: '2026-01-01T00:00:00.000Z',
+                }],
+        });
+        const result = listCorrectionSamples('/fake/workspace');
+        expect(result).toHaveLength(1);
+        expect(result[0]).toEqual({
+            sampleId: 's1',
+            sessionId: 'sess1',
+            badAssistantTurnId: 1,
+            userCorrectionTurnId: 2,
+            recoveryToolSpanJson: '{"tool":"edit"}',
+            diffExcerpt: 'old→new',
+            principleIdsJson: '["p1"]',
+            qualityScore: 0.8,
+            reviewStatus: 'pending',
+            exportMode: 'raw',
+            createdAt: '2026-01-01T00:00:00.000Z',
+            updatedAt: '2026-01-01T00:00:00.000Z',
+        });
+        expect(mockClose).toHaveBeenCalled();
+    });
+    it('passes status parameter to query', () => {
+        const mockAll = vi.fn().mockReturnValue([]);
+        mockPrepare.mockReturnValue({ all: mockAll });
+        listCorrectionSamples('/fake/workspace', 'rejected');
+        expect(mockPrepare).toHaveBeenCalledWith(expect.stringContaining('FROM correction_samples'));
+        expect(mockAll).toHaveBeenCalledWith('rejected');
+    });
+    it('handles null-ish row fields with defaults', () => {
+        mockPrepare.mockReturnValue({
+            all: () => [{
+                    sample_id: 's2',
+                    session_id: 'sess2',
+                    bad_assistant_turn_id: 3,
+                    user_correction_turn_id: 4,
+                    recovery_tool_span_json: null,
+                    diff_excerpt: null,
+                    principle_ids_json: null,
+                    quality_score: 0,
+                    review_status: 'pending',
+                    export_mode: 'redacted',
+                    created_at: '2026-01-01T00:00:00.000Z',
+                    updated_at: '2026-01-01T00:00:00.000Z',
+                }],
+        });
+        const [row] = listCorrectionSamples('/fake/workspace');
+        expect(row).toBeDefined();
+        if (!row)
+            return;
+        expect(row.recoveryToolSpanJson).toBe('');
+        expect(row.diffExcerpt).toBe('');
+        expect(row.principleIdsJson).toBe('[]');
+    });
+});
+describe('reviewCorrectionSample', () => {
+    beforeEach(() => {
+        shouldThrowOnOpen = false;
+        mockPrepare.mockReset();
+        mockClose.mockReset();
+    });
+    it('throws descriptive error when DB cannot be opened', () => {
+        shouldThrowOnOpen = true;
+        expect(() => {
+            reviewCorrectionSample('s1', 'approved', 'note', '/fake/workspace');
+        }).toThrow(/Database not found or cannot be opened/);
+    });
+    it('throws when sample not found (update changes=0)', () => {
+        mockPrepare.mockReturnValue({ run: () => ({ changes: 0 }) });
+        expect(() => {
+            reviewCorrectionSample('missing-id', 'approved', undefined, '/fake/workspace');
+        }).toThrow(/Sample not found: missing-id/);
+        expect(mockClose).toHaveBeenCalled();
+    });
+});
+//# sourceMappingURL=trajectory-store.test.js.map

package/dist/runtime-v2/__tests__/trajectory-store.test.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"trajectory-store.test.js","sourceRoot":"","sources":["../../../src/runtime-v2/__tests__/trajectory-store.test.ts"],"names":[],"mappings":"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"}

package/dist/runtime-v2/activation/__tests__/activation-dispatcher.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=activation-dispatcher.test.d.ts.map

package/dist/runtime-v2/activation/__tests__/activation-dispatcher.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"activation-dispatcher.test.d.ts","sourceRoot":"","sources":["../../../../src/runtime-v2/activation/__tests__/activation-dispatcher.test.ts"],"names":[],"mappings":""}

package/dist/runtime-v2/activation/__tests__/activation-dispatcher.test.js

@@ -0,0 +1,510 @@
+import { describe, it, expect } from 'vitest';
+import { ActivationDispatcher, PromptWriter, DeferArchiveWriter, MemoryActivationStateStore, MemoryArtifactReadModel, makeIdempotencyKey, isLowRiskChannel, getChannelRiskLevel, LOW_RISK_CHANNELS, HIGH_RISK_CHANNEL_MAP, MemoryApprovalQueueStore, AUTO_PROMOTION_CONFIDENCE_THRESHOLD, AUTO_PROMOTABLE_CHANNELS, } from '../index.js';
+function makePrincipleArtifact(overrides = {}) {
+    return {
+        artifactId: 'art-001',
+        artifactKind: 'principle',
+        sourceTaskId: 'task-001',
+        sourcePrincipleId: 'P_001',
+        lineageArtifactIds: [],
+        validationStatus: 'validated',
+        contentJson: JSON.stringify({ principleId: 'P_001', text: 'Test principle' }),
+        createdAt: '2026-01-01T00:00:00.000Z',
+        updatedAt: '2026-01-01T00:00:00.000Z',
+        ...overrides,
+    };
+}
+function makeDispatchInput(overrides = {}) {
+    return {
+        artifactId: 'art-001',
+        channel: 'prompt',
+        rolloutDecision: 'auto_activate',
+        actor: { kind: 'system', source: 'rollout_reviewer' },
+        now: '2026-05-17T00:00:00.000Z',
+        confirm: false,
+        ...overrides,
+    };
+}
+describe('ActivationDispatcher', () => {
+    function makeDispatcher() {
+        const stateStore = new MemoryActivationStateStore();
+        const artifactStore = new MemoryArtifactReadModel();
+        const promptWriter = new PromptWriter();
+        const archiveWriter = new DeferArchiveWriter();
+        const dispatcher = new ActivationDispatcher(artifactStore, stateStore, { writers: [promptWriter, archiveWriter] });
+        return { stateStore, artifactStore, dispatcher, promptWriter, archiveWriter };
+    }
+    it('low-risk prompt artifact dry-run → would_activate', async () => {
+        const { artifactStore, dispatcher } = makeDispatcher();
+        artifactStore.addArtifact(makePrincipleArtifact());
+        const result = await dispatcher.dispatch(makeDispatchInput({ channel: 'prompt', confirm: false }));
+        expect(result.decision).toBe('would_activate');
+        if (result.decision === 'would_activate') {
+            expect(result.activationId).toBe('act_prompt_P_001');
+            expect(result.action).toBe('prompt_activate');
+            expect(result.targetRef).toBe('ledger://P_001');
+        }
+    });
+    it('confirm → activated', async () => {
+        const { artifactStore, dispatcher } = makeDispatcher();
+        artifactStore.addArtifact(makePrincipleArtifact());
+        const result = await dispatcher.dispatch(makeDispatchInput({ channel: 'prompt', confirm: true }));
+        expect(result.decision).toBe('activated');
+        if (result.decision === 'activated') {
+            expect(result.activationId).toBe('act_prompt_P_001');
+            expect(result.action).toBe('prompt_activate');
+            expect(result.targetRef).toBe('ledger://P_001');
+        }
+    });
+    it('repeat confirm → already_activated', async () => {
+        const { artifactStore, dispatcher } = makeDispatcher();
+        artifactStore.addArtifact(makePrincipleArtifact());
+        await dispatcher.dispatch(makeDispatchInput({ channel: 'prompt', confirm: true }));
+        const result = await dispatcher.dispatch(makeDispatchInput({ channel: 'prompt', confirm: true }));
+        expect(result.decision).toBe('already_activated');
+        if (result.decision === 'already_activated') {
+            expect(result.activationId).toBe('act_prompt_P_001');
+        }
+    });
+    it('high-risk code_tool_hook → refused', async () => {
+        const { artifactStore, dispatcher } = makeDispatcher();
+        artifactStore.addArtifact(makePrincipleArtifact());
+        const result = await dispatcher.dispatch(makeDispatchInput({ channel: 'code_tool_hook' }));
+        expect(result.decision).toBe('refused');
+        if (result.decision === 'refused') {
+            expect(result.reason).toBe('requires_approval');
+            expect(result.riskLevel).toBe('high');
+        }
+    });
+    it('model_training → refused', async () => {
+        const { artifactStore, dispatcher } = makeDispatcher();
+        artifactStore.addArtifact(makePrincipleArtifact());
+        const result = await dispatcher.dispatch(makeDispatchInput({ channel: 'model_training' }));
+        expect(result.decision).toBe('refused');
+        if (result.decision === 'refused') {
+            expect(result.riskLevel).toBe('critical');
+        }
+    });
+    it('skill → refused', async () => {
+        const { artifactStore, dispatcher } = makeDispatcher();
+        artifactStore.addArtifact(makePrincipleArtifact());
+        const result = await dispatcher.dispatch(makeDispatchInput({ channel: 'skill' }));
+        expect(result.decision).toBe('refused');
+        if (result.decision === 'refused') {
+            expect(result.riskLevel).toBe('medium');
+        }
+    });
+    it('missing artifact → invalid_artifact', async () => {
+        const { dispatcher } = makeDispatcher();
+        const result = await dispatcher.dispatch(makeDispatchInput());
+        expect(result.decision).toBe('invalid_artifact');
+        if (result.decision === 'invalid_artifact') {
+            expect(result.reason).toBe('artifact_not_found');
+        }
+    });
+    it('malformed artifact → invalid_artifact', async () => {
+        const { artifactStore, dispatcher } = makeDispatcher();
+        artifactStore.addArtifact(makePrincipleArtifact({ artifactKind: undefined }));
+        const result = await dispatcher.dispatch(makeDispatchInput());
+        expect(result.decision).toBe('invalid_artifact');
+    });
+    it('dry-run does not write activation record', async () => {
+        const { artifactStore, stateStore, dispatcher } = makeDispatcher();
+        artifactStore.addArtifact(makePrincipleArtifact());
+        await dispatcher.dispatch(makeDispatchInput({ channel: 'prompt', confirm: false }));
+        const key = makeIdempotencyKey('art-001', 'prompt');
+        const status = await stateStore.getActivationStatus(key);
+        expect(status).toBeNull();
+    });
+    it('confirm writes only expected activation record', async () => {
+        const { artifactStore, stateStore, dispatcher } = makeDispatcher();
+        artifactStore.addArtifact(makePrincipleArtifact());
+        await dispatcher.dispatch(makeDispatchInput({ channel: 'prompt', confirm: true }));
+        const key = makeIdempotencyKey('art-001', 'prompt');
+        const status = await stateStore.getActivationStatus(key);
+        expect(status).not.toBeNull();
+        if (status) {
+            expect(status.activationId).toBe('act_prompt_P_001');
+            expect(status.action).toBe('prompt_activate');
+            expect(status.targetRef).toBe('ledger://P_001');
+        }
+    });
+    it('rolloutDecision = reject → refused', async () => {
+        const { artifactStore, dispatcher } = makeDispatcher();
+        artifactStore.addArtifact(makePrincipleArtifact());
+        const result = await dispatcher.dispatch(makeDispatchInput({ rolloutDecision: 'reject' }));
+        expect(result.decision).toBe('refused');
+        if (result.decision === 'refused') {
+            expect(result.reason).toBe('rollout_rejected');
+        }
+    });
+    it('rolloutDecision = require_approval → refused', async () => {
+        const { artifactStore, dispatcher } = makeDispatcher();
+        artifactStore.addArtifact(makePrincipleArtifact());
+        const result = await dispatcher.dispatch(makeDispatchInput({ rolloutDecision: 'require_approval' }));
+        expect(result.decision).toBe('refused');
+        if (result.decision === 'refused') {
+            expect(result.reason).toBe('requires_approval');
+        }
+    });
+    it('DB/read failure fail closed → refused', async () => {
+        const failingArtifactStore = new MemoryArtifactReadModel();
+        failingArtifactStore.getArtifactById = async () => { throw new Error('DB down'); };
+        const stateStore = new MemoryActivationStateStore();
+        const dispatcher = new ActivationDispatcher(failingArtifactStore, stateStore, { writers: [new PromptWriter(), new DeferArchiveWriter()] });
+        const result = await dispatcher.dispatch(makeDispatchInput());
+        expect(result.decision).toBe('refused');
+        if (result.decision === 'refused') {
+            expect(result.reason).toBe('artifact_read_failed');
+        }
+    });
+    it('defer_archive channel dry-run → would_activate', async () => {
+        const { artifactStore, dispatcher } = makeDispatcher();
+        artifactStore.addArtifact(makePrincipleArtifact());
+        const result = await dispatcher.dispatch(makeDispatchInput({ channel: 'defer_archive', confirm: false }));
+        expect(result.decision).toBe('would_activate');
+        if (result.decision === 'would_activate') {
+            expect(result.activationId).toBe('act_archive_P_001');
+            expect(result.action).toBe('defer_archive');
+            expect(result.targetRef).toBe('ledger://P_001#archived');
+        }
+    });
+    it('defer_archive confirm → activated', async () => {
+        const { artifactStore, dispatcher } = makeDispatcher();
+        artifactStore.addArtifact(makePrincipleArtifact());
+        const result = await dispatcher.dispatch(makeDispatchInput({ channel: 'defer_archive', confirm: true }));
+        expect(result.decision).toBe('activated');
+        if (result.decision === 'activated') {
+            expect(result.activationId).toBe('act_archive_P_001');
+            expect(result.targetRef).toBe('ledger://P_001#archived');
+        }
+    });
+    it('non-principle artifact → refused by writer canActivate', async () => {
+        const { artifactStore, dispatcher } = makeDispatcher();
+        artifactStore.addArtifact(makePrincipleArtifact({ artifactKind: 'rule' }));
+        const result = await dispatcher.dispatch(makeDispatchInput({ channel: 'prompt' }));
+        expect(result.decision).toBe('refused');
+        if (result.decision === 'refused') {
+            expect(result.reason).toContain('artifact_kind_not_principle');
+        }
+    });
+    it('artifact without principleId → invalid_artifact', async () => {
+        const { artifactStore, dispatcher } = makeDispatcher();
+        artifactStore.addArtifact(makePrincipleArtifact({
+            sourcePrincipleId: undefined,
+            contentJson: JSON.stringify({ text: 'No principle ID here' }),
+        }));
+        const result = await dispatcher.dispatch(makeDispatchInput({ channel: 'prompt' }));
+        expect(result.decision).toBe('invalid_artifact');
+        if (result.decision === 'invalid_artifact') {
+            expect(result.reason).toBe('no_principle_id');
+        }
+    });
+    it('pending validation artifact → refused by writer', async () => {
+        const { artifactStore, dispatcher } = makeDispatcher();
+        artifactStore.addArtifact(makePrincipleArtifact({ validationStatus: 'pending' }));
+        const result = await dispatcher.dispatch(makeDispatchInput({ channel: 'prompt' }));
+        expect(result.decision).toBe('refused');
+        if (result.decision === 'refused') {
+            expect(result.reason).toContain('artifact_validation_status_pending');
+        }
+    });
+    it('whitespace-only sourcePrincipleId → invalid_artifact', async () => {
+        const { artifactStore, dispatcher } = makeDispatcher();
+        artifactStore.addArtifact(makePrincipleArtifact({
+            sourcePrincipleId: '   ',
+            contentJson: JSON.stringify({ text: 'No principle ID here' }),
+        }));
+        const result = await dispatcher.dispatch(makeDispatchInput({ channel: 'prompt' }));
+        expect(result.decision).toBe('invalid_artifact');
+        if (result.decision === 'invalid_artifact') {
+            expect(result.reason).toBe('no_principle_id');
+        }
+    });
+    it('writer.activate throws → refused', async () => {
+        const { artifactStore } = makeDispatcher();
+        artifactStore.addArtifact(makePrincipleArtifact());
+        const throwingWriter = {
+            channel: 'prompt',
+            canActivate: async () => ({ ok: true, riskLevel: 'low' }),
+            activate: async () => { throw new Error('Writer crashed'); },
+        };
+        const stateStore = new MemoryActivationStateStore();
+        const throwDispatcher = new ActivationDispatcher({ getArtifactById: async (id) => id === 'art-001' ? makePrincipleArtifact() : null }, stateStore, { writers: [throwingWriter] });
+        const result = await throwDispatcher.dispatch(makeDispatchInput({ channel: 'prompt' }));
+        expect(result.decision).toBe('refused');
+        if (result.decision === 'refused') {
+            expect(result.reason).toBe('activation_write_failed');
+        }
+    });
+    // PRI-145: ApprovalQueue & Auto-Promotion
+    function makeDispatcherWithQueue() {
+        const stateStore = new MemoryActivationStateStore();
+        const artifactStore = new MemoryArtifactReadModel();
+        const approvalStore = new MemoryApprovalQueueStore();
+        const promptWriter = new PromptWriter();
+        const archiveWriter = new DeferArchiveWriter();
+        const dispatcher = new ActivationDispatcher(artifactStore, stateStore, { writers: [promptWriter, archiveWriter], approvalQueueStore: approvalStore });
+        return { stateStore, artifactStore, dispatcher, approvalStore };
+    }
+    it('skill with confidence 0.94 + queue store -> queued_for_approval', async () => {
+        const { artifactStore, dispatcher } = makeDispatcherWithQueue();
+        artifactStore.addArtifact(makePrincipleArtifact());
+        const result = await dispatcher.dispatch(makeDispatchInput({ channel: 'skill', confidence: 0.94 }));
+        expect(result.decision).toBe('queued_for_approval');
+        if (result.decision === 'queued_for_approval') {
+            expect(result.channel).toBe('skill');
+            expect(result.riskLevel).toBe('medium');
+            expect(result.approvalId).toBeTruthy();
+        }
+    });
+    it('code_tool_hook with queue store -> queued_for_approval', async () => {
+        const { artifactStore, dispatcher } = makeDispatcherWithQueue();
+        artifactStore.addArtifact(makePrincipleArtifact());
+        const result = await dispatcher.dispatch(makeDispatchInput({ channel: 'code_tool_hook', 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('model_training with queue store -> queued_for_approval', async () => {
+        const { artifactStore, dispatcher } = makeDispatcherWithQueue();
+        artifactStore.addArtifact(makePrincipleArtifact());
+        const result = await dispatcher.dispatch(makeDispatchInput({ channel: 'model_training', confidence: 0.99 }));
+        expect(result.decision).toBe('queued_for_approval');
+        if (result.decision === 'queued_for_approval') {
+            expect(result.channel).toBe('model_training');
+            expect(result.riskLevel).toBe('critical');
+        }
+    });
+    it('skill with low confidence -> queued_for_approval', async () => {
+        const { artifactStore, dispatcher } = makeDispatcherWithQueue();
+        artifactStore.addArtifact(makePrincipleArtifact());
+        const result = await dispatcher.dispatch(makeDispatchInput({ channel: 'skill', confidence: 0.90 }));
+        expect(result.decision).toBe('queued_for_approval');
+    });
+    it('skill with no confidence -> queued_for_approval', async () => {
+        const { artifactStore, dispatcher } = makeDispatcherWithQueue();
+        artifactStore.addArtifact(makePrincipleArtifact());
+        const result = await dispatcher.dispatch(makeDispatchInput({ channel: 'skill' }));
+        expect(result.decision).toBe('queued_for_approval');
+    });
+    it('skill with confidence 0.95 + queue store + writer -> would_activate (auto-promote dry-run)', async () => {
+        const skillWriter = {
+            channel: 'skill',
+            canActivate: async () => ({ ok: true, riskLevel: 'medium' }),
+            activate: async (input) => ({
+                activationId: 'act_skill_' + input.principleId,
+                action: 'skill_activate',
+                targetRef: 'skill://' + input.principleId,
+            }),
+        };
+        const stateStore = new MemoryActivationStateStore();
+        const artifactStore = new MemoryArtifactReadModel();
+        const approvalStore = new MemoryApprovalQueueStore();
+        artifactStore.addArtifact(makePrincipleArtifact());
+        const dispatcher = new ActivationDispatcher(artifactStore, stateStore, { writers: [skillWriter], approvalQueueStore: approvalStore });
+        const result = await dispatcher.dispatch(makeDispatchInput({ channel: 'skill', confidence: 0.95 }));
+        expect(result.decision).toBe('would_activate');
+        if (result.decision === 'would_activate') {
+            expect(result.activationId).toBe('act_skill_P_001');
+            expect(result.action).toBe('skill_activate');
+        }
+        // Verify nothing was queued
+        const pending = await approvalStore.listPending();
+        expect(pending).toHaveLength(0);
+    });
+    it('skill with confidence 0.96 + queue store + writer -> activated (auto-promote confirm)', async () => {
+        const skillWriter = {
+            channel: 'skill',
+            canActivate: async () => ({ ok: true, riskLevel: 'medium' }),
+            activate: async (input) => ({
+                activationId: 'act_skill_' + input.principleId,
+                action: 'skill_activate',
+                targetRef: 'skill://' + input.principleId,
+            }),
+        };
+        const stateStore = new MemoryActivationStateStore();
+        const artifactStore = new MemoryArtifactReadModel();
+        const approvalStore = new MemoryApprovalQueueStore();
+        artifactStore.addArtifact(makePrincipleArtifact());
+        const dispatcher = new ActivationDispatcher(artifactStore, stateStore, { writers: [skillWriter], approvalQueueStore: approvalStore });
+        const result = await dispatcher.dispatch(makeDispatchInput({ channel: 'skill', confidence: 0.96, confirm: true }));
+        expect(result.decision).toBe('activated');
+        if (result.decision === 'activated') {
+            expect(result.activationId).toBe('act_skill_P_001');
+        }
+        // Verify nothing was queued
+        const pending = await approvalStore.listPending();
+        expect(pending).toHaveLength(0);
+    });
+    // PRI-185: Context fields in queued approval records
+    it('queued approval record contains context fields', async () => {
+        const { artifactStore, dispatcher, approvalStore } = makeDispatcherWithQueue();
+        artifactStore.addArtifact(makePrincipleArtifact({
+            contentJson: JSON.stringify({ principleId: 'P_001', text: 'Always validate user input before processing' }),
+        }));
+        const result = await dispatcher.dispatch(makeDispatchInput({ channel: 'skill', confidence: 0.85, confirm: true }));
+        expect(result.decision).toBe('queued_for_approval');
+        const pending = await approvalStore.listPending();
+        expect(pending).toHaveLength(1);
+        const record = pending[0]; // eslint-disable-line @typescript-eslint/no-non-null-assertion
+        expect(record.summary).toContain('Always validate user input before processing');
+        expect(record.triggerReason).toContain('skill');
+        expect(record.triggerReason).toContain('medium');
+        expect(record.confidenceExplanation).toContain('85%');
+        expect(record.effectDescription).toContain('skill');
+        expect(record.rejectionEffect).toContain('skill');
+    });
+    it('queued approval record degrades gracefully with unparseable contentJson', async () => {
+        const { artifactStore, dispatcher, approvalStore } = makeDispatcherWithQueue();
+        artifactStore.addArtifact(makePrincipleArtifact({
+            contentJson: '{invalid json content',
+        }));
+        const result = await dispatcher.dispatch(makeDispatchInput({ channel: 'code_tool_hook', confirm: true }));
+        expect(result.decision).toBe('queued_for_approval');
+        const pending = await approvalStore.listPending();
+        expect(pending).toHaveLength(1);
+        const record = pending[0]; // eslint-disable-line @typescript-eslint/no-non-null-assertion
+        expect(record.summary).toContain('art-001');
+        expect(record.summary).not.toContain('{invalid');
+        expect(record.triggerReason).toContain('code_tool_hook');
+        expect(record.effectDescription).toContain('code tool hook');
+    });
+    it('approval store enqueue fails -> refused', async () => {
+        const failingStore = {
+            enqueue: async () => { throw new Error('DB down'); },
+            getById: async () => null,
+            listPending: async () => [],
+            approve: async () => ({ ok: false, error: 'not_found' }),
+            reject: async () => ({ ok: false, error: 'not_found' }),
+            listAll: async () => [],
+            countByStatus: async () => ({ pending: 0, approved: 0, rejected: 0, cancelled: 0 }),
+        };
+        const stateStore = new MemoryActivationStateStore();
+        const artifactStore = new MemoryArtifactReadModel();
+        artifactStore.addArtifact(makePrincipleArtifact());
+        const dispatcher = new ActivationDispatcher(artifactStore, stateStore, { writers: [new PromptWriter(), new DeferArchiveWriter()], approvalQueueStore: failingStore });
+        const result = await dispatcher.dispatch(makeDispatchInput({ channel: 'skill', confidence: 0.90, confirm: true }));
+        expect(result.decision).toBe('refused');
+        if (result.decision === 'refused') {
+            expect(result.reason).toBe('approval_enqueue_failed');
+        }
+    });
+});
+describe('PromptWriter', () => {
+    it('canActivate returns ok=true for principle artifact', async () => {
+        const writer = new PromptWriter();
+        const result = await writer.canActivate(makePrincipleArtifact());
+        expect(result.ok).toBe(true);
+        expect(result.riskLevel).toBe('low');
+    });
+    it('canActivate returns ok=false for non-principle artifact', async () => {
+        const writer = new PromptWriter();
+        const result = await writer.canActivate(makePrincipleArtifact({ artifactKind: 'rule' }));
+        expect(result.ok).toBe(false);
+    });
+    it('canActivate returns ok=false for pending validation artifact', async () => {
+        const writer = new PromptWriter();
+        const result = await writer.canActivate(makePrincipleArtifact({ validationStatus: 'pending' }));
+        expect(result.ok).toBe(false);
+        expect(result.reason).toContain('artifact_validation_status_pending');
+    });
+    it('activate returns correct activationId and targetRef', async () => {
+        const writer = new PromptWriter();
+        const result = await writer.activate({
+            artifactId: 'art-001',
+            channel: 'prompt',
+            principleId: 'P_001',
+            idempotencyKey: 'art-001::prompt',
+            now: '2026-05-17T00:00:00.000Z',
+        }, makePrincipleArtifact());
+        expect(result.activationId).toBe('act_prompt_P_001');
+        expect(result.action).toBe('prompt_activate');
+        expect(result.targetRef).toBe('ledger://P_001');
+    });
+});
+describe('DeferArchiveWriter', () => {
+    it('canActivate returns ok=true for principle artifact', async () => {
+        const writer = new DeferArchiveWriter();
+        const result = await writer.canActivate(makePrincipleArtifact());
+        expect(result.ok).toBe(true);
+    });
+    it('activate returns correct activationId and targetRef', async () => {
+        const writer = new DeferArchiveWriter();
+        const result = await writer.activate({
+            artifactId: 'art-001',
+            channel: 'defer_archive',
+            principleId: 'P_001',
+            idempotencyKey: 'art-001::defer_archive',
+            now: '2026-05-17T00:00:00.000Z',
+        }, makePrincipleArtifact());
+        expect(result.activationId).toBe('act_archive_P_001');
+        expect(result.action).toBe('defer_archive');
+        expect(result.targetRef).toBe('ledger://P_001#archived');
+    });
+});
+describe('extractPrincipleId', () => {
+    it('trims whitespace from sourcePrincipleId', async () => {
+        const writer = new PromptWriter();
+        const artifact = makePrincipleArtifact({ sourcePrincipleId: '  P_001  ' });
+        const result = await writer.canActivate(artifact);
+        expect(result.ok).toBe(true);
+    });
+    it('rejects whitespace-only sourcePrincipleId', async () => {
+        const writer = new PromptWriter();
+        const artifact = makePrincipleArtifact({
+            sourcePrincipleId: '   ',
+            contentJson: JSON.stringify({ text: 'No ID' }),
+        });
+        const result = await writer.canActivate(artifact);
+        expect(result.ok).toBe(false);
+        expect(result.reason).toBe('no_principle_id_in_artifact');
+    });
+    it('trims whitespace from contentJson principleId', async () => {
+        const writer = new PromptWriter();
+        const artifact = makePrincipleArtifact({
+            sourcePrincipleId: undefined,
+            contentJson: JSON.stringify({ principleId: '  P_002  ' }),
+        });
+        const result = await writer.canActivate(artifact);
+        expect(result.ok).toBe(true);
+    });
+});
+describe('activation type helpers', () => {
+    it('LOW_RISK_CHANNELS contains prompt and defer_archive', () => {
+        expect(LOW_RISK_CHANNELS).toContain('prompt');
+        expect(LOW_RISK_CHANNELS).toContain('defer_archive');
+        expect(LOW_RISK_CHANNELS.length).toBe(2);
+    });
+    it('isLowRiskChannel returns true for prompt and defer_archive', () => {
+        expect(isLowRiskChannel('prompt')).toBe(true);
+        expect(isLowRiskChannel('defer_archive')).toBe(true);
+        expect(isLowRiskChannel('code_tool_hook')).toBe(false);
+        expect(isLowRiskChannel('model_training')).toBe(false);
+        expect(isLowRiskChannel('skill')).toBe(false);
+    });
+    it('getChannelRiskLevel returns correct levels', () => {
+        expect(getChannelRiskLevel('prompt')).toBe('low');
+        expect(getChannelRiskLevel('defer_archive')).toBe('low');
+        expect(getChannelRiskLevel('skill')).toBe('medium');
+        expect(getChannelRiskLevel('code_tool_hook')).toBe('high');
+        expect(getChannelRiskLevel('model_training')).toBe('critical');
+    });
+    it('makeIdempotencyKey produces expected format', () => {
+        expect(makeIdempotencyKey('art-001', 'prompt')).toBe('art-001::prompt');
+    });
+    it('AUTO_PROMOTION_CONFIDENCE_THRESHOLD is 0.95', () => {
+        expect(AUTO_PROMOTION_CONFIDENCE_THRESHOLD).toBe(0.95);
+    });
+    it('AUTO_PROMOTABLE_CHANNELS contains only skill', () => {
+        expect(AUTO_PROMOTABLE_CHANNELS).toEqual(['skill']);
+    });
+    it('HIGH_RISK_CHANNEL_MAP has correct entries', () => {
+        expect(HIGH_RISK_CHANNEL_MAP.skill).toBe('medium');
+        expect(HIGH_RISK_CHANNEL_MAP.code_tool_hook).toBe('high');
+        expect(HIGH_RISK_CHANNEL_MAP.model_training).toBe('critical');
+    });
+});
+//# sourceMappingURL=activation-dispatcher.test.js.map