create-principles-disciple 1.92.0 → 1.94.0

package/core/dist/prompt-builder/model-config.js

@@ -0,0 +1,84 @@
+/**
+ * Model configuration validation and resolution.
+ *
+ * Pure logic — no I/O, no side effects (except optional logger callback).
+ *
+ * Extracted from openclaw-plugin/src/hooks/prompt.ts (PRI-444) so that model
+ * config validation can be unit-tested in core without mocking plugin I/O.
+ */
+const MODEL_PATTERN = /^[a-zA-Z0-9][a-zA-Z0-9-]*[a-zA-Z0-9]\/[a-zA-Z0-9._-]+$/;
+function describeModelConfigType(value) {
+    if (value === null)
+        return 'null';
+    if (Array.isArray(value))
+        return 'array';
+    return typeof value;
+}
+/**
+ * Validate model format: must be "provider/model".
+ *
+ * provider: e.g., "openai", "anthropic" — the API provider name
+ * model: e.g., "gpt-4", "claude-3-opus" — the specific model name
+ */
+export function isValidModelFormat(model) {
+    return MODEL_PATTERN.test(model);
+}
+/**
+ * Resolve model configuration for OpenClaw agents, supporting string and object formats.
+ *
+ * @param modelConfig - Model config: string (e.g. "provider/model") or { primary, fallbacks } object
+ * @param logger - Optional logger for validation warnings
+ * @returns Resolved model string, or null if config is missing/invalid
+ */
+export function resolveModelFromConfig(modelConfig, logger) {
+    if (modelConfig === null || modelConfig === undefined) {
+        logger?.warn?.(`[PD:Prompt] Missing model config.`);
+        return null;
+    }
+    // Case 1: modelConfig is a string like "provider/model"
+    if (typeof modelConfig === 'string') {
+        const trimmed = modelConfig.trim();
+        if (!trimmed) {
+            logger?.warn?.(`[PD:Prompt] Empty model string.`);
+            return null;
+        }
+        if (!isValidModelFormat(trimmed)) {
+            logger?.warn?.(`[PD:Prompt] Invalid model format: "${trimmed}". Expected "provider/model" format.`);
+            return null;
+        }
+        return trimmed;
+    }
+    // Case 2: modelConfig is an object { primary, fallbacks } like { primary: "provider/model", fallbacks: [...] }
+    if (typeof modelConfig === 'object' && modelConfig !== null && !Array.isArray(modelConfig)) {
+        if (Object.hasOwn(modelConfig, 'primary')) {
+            const primaryDescriptor = Object.getOwnPropertyDescriptor(modelConfig, 'primary');
+            if (!primaryDescriptor)
+                return null;
+            const primary = primaryDescriptor.value;
+            if (typeof primary !== 'string') {
+                logger?.warn?.(`[PD:Prompt] Invalid primary model type: ${describeModelConfigType(primary)}. Expected string.`);
+                return null;
+            }
+            const trimmed = primary.trim();
+            if (!trimmed) {
+                logger?.warn?.(`[PD:Prompt] Empty primary model string.`);
+                return null;
+            }
+            if (!isValidModelFormat(trimmed)) {
+                logger?.warn?.(`[PD:Prompt] Invalid primary model format: "${trimmed}". Expected "provider/model" format.`);
+                return null;
+            }
+            return trimmed;
+        }
+        logger?.warn?.(`[PD:Prompt] Missing primary model in object config.`);
+        return null;
+    }
+    // Case 3: Array format not supported
+    if (Array.isArray(modelConfig)) {
+        logger?.warn?.(`[PD:Prompt] Array model config not supported. Expected "provider/model" string or { primary: "..." } object.`);
+        return null;
+    }
+    logger?.warn?.(`[PD:Prompt] Unsupported model config type: ${describeModelConfigType(modelConfig)}.`);
+    return null;
+}
+//# sourceMappingURL=model-config.js.map

package/core/dist/prompt-builder/model-config.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"model-config.js","sourceRoot":"","sources":["../../src/prompt-builder/model-config.ts"],"names":[],"mappings":"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"}

package/core/dist/prompt-builder/xml-escape.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Escape special XML characters in a string.
+ *
+ * Pure logic — no I/O, no side effects.
+ *
+ * Used by prompt injection to safely embed user/principle text into XML-style
+ * prompt markers (e.g. `<directive id="...">...</directive>`). Also accepted
+ * as a callback by `trimToBudget` and `renderPrinciplesToDirectives` in
+ * `runtime-v2/activation/prompt-activation-reader-contract.ts`.
+ */
+export declare function escapeXml(input: string): string;
+//# sourceMappingURL=xml-escape.d.ts.map

package/core/dist/prompt-builder/xml-escape.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"xml-escape.d.ts","sourceRoot":"","sources":["../../src/prompt-builder/xml-escape.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AACH,wBAAgB,SAAS,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAO/C"}

package/core/dist/prompt-builder/xml-escape.js

@@ -0,0 +1,19 @@
+/**
+ * Escape special XML characters in a string.
+ *
+ * Pure logic — no I/O, no side effects.
+ *
+ * Used by prompt injection to safely embed user/principle text into XML-style
+ * prompt markers (e.g. `<directive id="...">...</directive>`). Also accepted
+ * as a callback by `trimToBudget` and `renderPrinciplesToDirectives` in
+ * `runtime-v2/activation/prompt-activation-reader-contract.ts`.
+ */
+export function escapeXml(input) {
+    return input
+        .replace(/&/g, '&amp;')
+        .replace(/</g, '&lt;')
+        .replace(/>/g, '&gt;')
+        .replace(/"/g, '&quot;')
+        .replace(/'/g, '&apos;');
+}
+//# sourceMappingURL=xml-escape.js.map

package/core/dist/prompt-builder/xml-escape.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"xml-escape.js","sourceRoot":"","sources":["../../src/prompt-builder/xml-escape.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AACH,MAAM,UAAU,SAAS,CAAC,KAAa;IACrC,OAAO,KAAK;SACT,OAAO,CAAC,IAAI,EAAE,OAAO,CAAC;SACtB,OAAO,CAAC,IAAI,EAAE,MAAM,CAAC;SACrB,OAAO,CAAC,IAAI,EAAE,MAAM,CAAC;SACrB,OAAO,CAAC,IAAI,EAAE,QAAQ,CAAC;SACvB,OAAO,CAAC,IAAI,EAAE,QAAQ,CAAC,CAAC;AAC7B,CAAC"}

package/core/dist/runtime-v2/__tests__/architecture-regression.test.js

@@ -5,6 +5,8 @@
  * Add entries here whenever a new service/read-model boundary is established.
  */
 import { describe, it, expect, beforeAll } from 'vitest';
+import * as fsSync from 'fs';
+import * as pathSync from 'path';
 // ── Source-file existence ──────────────────────────────────────────────────
 const REQUIRED_SOURCE_FILES = [
     'pain-to-principle-service.ts',
@@ -193,6 +195,12 @@ const REQUIRED_SOURCE_FILES = [
     'activation/approval-completion-service.ts',
     // PRI-431: L2 principle reader (pure logic, extracted from pd-cli + plugin duplicates)
     'build-l2-principle-reader.ts',
+    // PRI-446: pure logic migrated from openclaw-plugin into core
+    'evidence-triage/observation-resolver.ts',
+    'pain-gate/pain-diagnostic-gate-policy.ts',
+    'pain-gate/index.ts',
+    'detection/detection-funnel-policy.ts',
+    'detection/index.ts',
 ];
 // ── PRI-212: Plugin core anti-growth guard ────────────────────────────────────
 //
@@ -245,6 +253,9 @@ const KNOWN_PLUGIN_CORE_FILES = new Set([
     'schema/migration-runner.ts',
     'rule-host.ts',
     'principle-training-state.ts',
+    // PRI-446: now a thin adapter delegating pure decision logic to
+    // runtime-v2/pain-gate/pain-diagnostic-gate-policy.ts. Kept here because it
+    // owns the cooldown Map + SystemLogger + Date.now side effects.
     'pain-diagnostic-gate.ts',
     'hygiene/tracker.ts',
     'schema/migrations/002-init-central.ts',
@@ -287,6 +298,9 @@ const KNOWN_PLUGIN_CORE_FILES = new Set([
     'dictionary.ts',
     'thinking-os-parser.ts',
     'system-logger.ts',
+    // PRI-446: now a thin shell wiring DetectionFunnelCore (core runtime-v2/detection)
+    // with crypto.createHash + PainDictionary. Kept here because it owns the
+    // crypto + dictionary I/O boundary.
     'detection-funnel.ts',
     'risk-calculator.ts',
     'migration.ts',
@@ -359,6 +373,9 @@ describe('PRI-212 plugin core anti-growth guard', () => {
         // model-training-registry.ts, model-deployment-registry.ts,
         // shadow-observation-registry.ts (98 → 93)
         // PRI-449: Removed external-training-contract.ts (93 → 92)
+        // PRI-446: pain-diagnostic-gate.ts and detection-funnel.ts remain at 92 —
+        // they are now thin adapters delegating pure logic to core, but still live
+        // in plugin src/core/ and own I/O side effects, so they stay classified.
         expect(KNOWN_PLUGIN_CORE_FILES.size).toBe(92);
     });
 });
@@ -595,6 +612,30 @@ describe('PRI-42 internalization boundary', () => {
             expect(src).not.toContain('../../../openclaw-plugin');
         }
     });
+    it('PRI-446: pain-gate has zero openclaw-plugin imports', async () => {
+        const { existsSync, readdirSync, readFileSync } = await import('node:fs');
+        const { resolve, join } = await import('node:path');
+        const dir = resolve(__dirname, '..', 'pain-gate');
+        expect(existsSync(dir)).toBe(true);
+        const files = readdirSync(dir).filter((f) => f.endsWith('.ts') && !f.endsWith('.test.ts'));
+        for (const file of files) {
+            const src = readFileSync(join(dir, file), 'utf-8');
+            expect(src).not.toContain('openclaw-plugin');
+            expect(src).not.toContain('../../../openclaw-plugin');
+        }
+    });
+    it('PRI-446: detection has zero openclaw-plugin imports', async () => {
+        const { existsSync, readdirSync, readFileSync } = await import('node:fs');
+        const { resolve, join } = await import('node:path');
+        const dir = resolve(__dirname, '..', 'detection');
+        expect(existsSync(dir)).toBe(true);
+        const files = readdirSync(dir).filter((f) => f.endsWith('.ts') && !f.endsWith('.test.ts'));
+        for (const file of files) {
+            const src = readFileSync(join(dir, file), 'utf-8');
+            expect(src).not.toContain('openclaw-plugin');
+            expect(src).not.toContain('../../../openclaw-plugin');
+        }
+    });
     it('plugin does not re-define RuleHost contract types locally', async () => {
         const { existsSync, readFileSync } = await import('node:fs');
         const { resolve } = await import('node:path');
@@ -1596,6 +1637,16 @@ describe('PRI-75/PRI-74/PRI-81 prompt-builder core boundary', () => {
         // Must NOT have the old multi-line fallback block with attitudeDirective interpolation
         expect(src).not.toMatch(/## 【CONTEXT SECTIONS】\n\n\[WARNING: Context sections stripped/);
     });
+    it('plugin prompt-helpers.ts imports escapeXml from core, not reimplemented', async () => {
+        const { readFileSync } = await import('node:fs');
+        const { resolve } = await import('node:path');
+        const src = readFileSync(resolve(__dirname, '../../../../openclaw-plugin/src/hooks/prompt-helpers.ts'), 'utf-8');
+        // Must import escapeXml from core
+        expect(src).toContain('@principles/core/prompt-builder');
+        expect(src).toMatch(/import\s*\{[^}]*escapeXml[^}]*\}\s*from\s*['"]@principles\/core\/prompt-builder['"]/);
+        // Must NOT reimplement escapeXml inline
+        expect(src).not.toMatch(/\b(function\s+escapeXml\s*\(|const\s+escapeXml\s*=\s*(?:async\s*)?(?:\([^)]*\)|[a-zA-Z_$][\w$]*)\s*=>)/);
+    });
     it('plugin empathy-keyword-matcher.ts is a thin adapter (re-exports from core)', async () => {
         const { readFileSync } = await import('node:fs');
         const { resolve } = await import('node:path');
@@ -1753,6 +1804,19 @@ describe('PRI-111 ArtificerRunner boundary', () => {
         expect(src).toContain('ArtificerRuleOutputSchema');
     });
 });
+// ── PRI-458: PhilosopherRunner barrel boundary (MVP-Quiet) ─────────────────────
+describe('PRI-458 PhilosopherRunner barrel boundary', () => {
+    it('BARREL_EXPORTS: internalization/index.ts does NOT export PhilosopherRunner (PRI-458 MVP-Quiet)', async () => {
+        // PRI-458: PhilosopherRunner is de-surfaced from the internal barrel (MVP-Quiet).
+        // It remains in runtime-v2/index.ts (public barrel) because rulehost-pipeline-runner.ts
+        // imports it from there (EP-02 exception).
+        const { readFileSync } = await import('node:fs');
+        const { resolve } = await import('node:path');
+        const src = readFileSync(resolve(__dirname, '..', 'internalization', 'index.ts'), 'utf-8');
+        expect(src).not.toContain("from './philosopher-runner.js'");
+        expect(src).not.toContain("from './philosopher-output.js'");
+    });
+});
 // ── PRI-EVAL: EvaluatorRunner boundary guards ──────────────────────────────────
 describe('PRI-EVAL EvaluatorRunner boundary', () => {
     it('evaluator source files exist in internalization directory', async () => {
@@ -1793,13 +1857,17 @@ describe('PRI-EVAL EvaluatorRunner boundary', () => {
         expect(src).not.toContain('node:fs');
         expect(src).not.toContain('node:cron');
     });
-    it('BARREL_EXPORTS: internalization/index.ts exports EvaluatorRunner and EvaluatorOutput', async () => {
+    it('BARREL_EXPORTS: internalization/index.ts does NOT export EvaluatorRunner (PRI-458 MVP-Quiet)', async () => {
+        // PRI-458: EvaluatorRunner is de-surfaced from the internal barrel (MVP-Quiet).
+        // It remains in runtime-v2/index.ts (public barrel) because rulehost-pipeline-runner.ts
+        // imports it from there (EP-02 exception). These negative assertions lock the boundary:
+        // if someone re-aggregates the evaluator exports into this barrel, the test will fail.
         const { readFileSync } = await import('node:fs');
         const { resolve } = await import('node:path');
         const src = readFileSync(resolve(__dirname, '..', 'internalization', 'index.ts'), 'utf-8');
-        expect(src).toContain('EvaluatorRunner');
-        expect(src).toContain('EvaluatorOutput');
-        expect(src).toContain('DefaultEvaluatorValidator');
+        expect(src).not.toContain("from './evaluator-runner.js'");
+        expect(src).not.toContain("from './evaluator-output.js'");
+        expect(src).not.toContain("from './evaluator-prompt-builder.js'");
     });
     it('SCHEMA_REGISTRY: pi-ai-runtime-adapter.ts registers evaluator-output-v1 schema', async () => {
         const { readFileSync } = await import('node:fs');
@@ -1849,13 +1917,16 @@ describe('PRI-RR RolloutReviewerRunner boundary', () => {
         expect(src).not.toContain('node:fs');
         expect(src).not.toContain('node:cron');
     });
-    it('BARREL_EXPORTS: internalization/index.ts exports RolloutReviewerRunner and RolloutReviewerOutput', async () => {
+    it('BARREL_EXPORTS: internalization/index.ts does NOT export RolloutReviewerRunner (PRI-458 MVP-Quiet)', async () => {
+        // PRI-458: RolloutReviewerRunner is de-surfaced from the internal barrel (MVP-Quiet).
+        // It remains in runtime-v2/index.ts (public barrel) because runtime-internalization-run-once.ts
+        // imports it from there and package.json has no deep import path available (EP-02 exception).
         const { readFileSync } = await import('node:fs');
         const { resolve } = await import('node:path');
         const src = readFileSync(resolve(__dirname, '..', 'internalization', 'index.ts'), 'utf-8');
-        expect(src).toContain('RolloutReviewerRunner');
-        expect(src).toContain('RolloutReviewerOutput');
-        expect(src).toContain('DefaultRolloutReviewerValidator');
+        expect(src).not.toContain("from './rollout-reviewer-runner.js'");
+        expect(src).not.toContain("from './rollout-reviewer-output.js'");
+        expect(src).not.toContain("from './rollout-reviewer-prompt-builder.js'");
     });
     it('SCHEMA_REGISTRY: pi-ai-runtime-adapter.ts registers rollout-reviewer-output-v1 schema', async () => {
         const { readFileSync } = await import('node:fs');
@@ -2125,12 +2196,14 @@ describe('PRI-117 Nocturnal god-class freeze', () => {
             expect(src).not.toContain('invokeStubScribe');
         }
     });
-    it('RUNTIME_V2_USES_PEER_RUNNERS: DreamerRunner/PhilosopherRunner/ScribeRunner are the canonical entry points', async () => {
+    it('RUNTIME_V2_USES_PEER_RUNNERS: DreamerRunner/ScribeRunner/ArtificerRunner are the canonical MVP-Core entry points', async () => {
+        // PRI-458: narrowed to MVP-Core runners only. PhilosopherRunner (MVP-Quiet)
+        // remains in runtime-v2/index.ts for rulehost-pipeline-runner.ts compatibility
+        // but is no longer asserted as a canonical entry point.
         const { readFileSync } = await import('node:fs');
         const { resolve } = await import('node:path');
         const src = readFileSync(resolve(__dirname, '..', 'index.ts'), 'utf-8');
         expect(src).toContain('DreamerRunner');
-        expect(src).toContain('PhilosopherRunner');
         expect(src).toContain('ScribeRunner');
         expect(src).toContain('ArtificerRunner');
     });
@@ -2427,7 +2500,8 @@ describe('PRI-139 L1 Hard Cap & LRU Eviction', () => {
     it('LedgerPrinciple includes lastTriggeredAt field', async () => {
         const { readFileSync } = await import('node:fs');
         const { resolve } = await import('node:path');
-        const src = readFileSync(resolve(__dirname, '..', '..', 'principle-tree-ledger.ts'), 'utf-8');
+        // PRI-443: type moved to pure module
+        const src = readFileSync(resolve(__dirname, '..', 'types', 'ledger-store.ts'), 'utf-8');
         expect(src).toContain('lastTriggeredAt');
     });
     it('PruningHealthSummary includes activeL1Count and l1Cap fields', async () => {
@@ -2875,7 +2949,7 @@ describe('PRI-225: No unsafe type assertions on untrusted metadata arrays', () =
 // ── PRI-239: Feature flag registry architecture boundary ──────────────────
 //
 // Core: packages/principles-core/src/runtime-v2/feature-flags/feature-flag-contract.ts
-// I/O Loader: packages/pd-cli/src/services/feature-flag-loader.ts
+// I/O Loader: packages/pd-cli/src/services/pd-config-loader.ts (PRI-460: replaced feature-flag-loader.ts)
 // CLI Command: packages/pd-cli/src/commands/runtime-features.ts
 // Consumption: packages/pd-cli/src/commands/runtime-canary.ts (GFI check)
 describe('PRI-239: Feature flag registry architecture boundary', () => {
@@ -2897,10 +2971,10 @@ describe('PRI-239: Feature flag registry architecture boundary', () => {
         expect(src).not.toContain('InternalizationOrchestrator');
         expect(src).not.toContain('SqliteConnection');
     });
-    it('IO_LOADER_OUTSIDE_CORE: I/O loader exists at pd-cli/src/services/feature-flag-loader.ts', async () => {
+    it('IO_LOADER_OUTSIDE_CORE: I/O loader exists at pd-cli/src/services/pd-config-loader.ts', async () => {
         const { existsSync } = await import('node:fs');
         const { resolve } = await import('node:path');
-        expect(existsSync(resolve(__dirname, '../../../../pd-cli/src/services/feature-flag-loader.ts'))).toBe(true);
+        expect(existsSync(resolve(__dirname, '../../../../pd-cli/src/services/pd-config-loader.ts'))).toBe(true);
     });
     it('CLI_COMMAND_OUTSIDE_CORE: CLI command exists at pd-cli/src/commands/runtime-features.ts', async () => {
         const { existsSync } = await import('node:fs');
@@ -2915,12 +2989,12 @@ describe('PRI-239: Feature flag registry architecture boundary', () => {
         expect(src).not.toContain('nocturnal-arbiter');
         expect(src).not.toContain('nocturnal-service');
     });
-    it('CONSUMPTION_WIRED: runtime-canary.ts imports feature flag loader', async () => {
+    it('CONSUMPTION_WIRED: runtime-canary.ts imports canonical PD config loader', async () => {
         const { readFileSync } = await import('node:fs');
         const { resolve } = await import('node:path');
         const src = readFileSync(resolve(__dirname, '../../../../pd-cli/src/commands/runtime-canary.ts'), 'utf-8');
-        expect(src).toContain('feature-flag-loader');
-        expect(src).toContain('loadEffectiveFeatureFlags');
+        expect(src).toContain('pd-config-loader');
+        expect(src).toContain('loadPdConfig');
     });
 });
 describe('PRI-304: PD-Owned Config Contract barrel exports and purity', () => {
@@ -3022,11 +3096,18 @@ describe('PRI-416: type single-ownership guards', () => {
     });
     it('HybridLedgerStore is defined exactly once in core/src/', () => {
         const hits = findDefinitions(/export\s+interface\s+HybridLedgerStore\s*\{/);
-        expect(hits).toEqual(['principle-tree-ledger.ts']);
+        expect(hits).toEqual(['runtime-v2/types/ledger-store.ts']);
     });
-    it('atomicWriteFileSync is defined exactly once in core/src/', () => {
+    it('atomicWriteFileSync is NOT exported from any core/src/ file (PRI-443 Phase 4)', () => {
+        // After PRI-443 Phase 4, atomicWriteFileSync is inlined as a PRIVATE helper
+        // inside principle-tree-ledger.ts. It must NOT be exported from core.
         const hits = findDefinitions(/export\s+function\s+atomicWriteFileSync\s*\(/);
-        expect(hits).toEqual(['io.ts']);
+        expect(hits).toEqual([]);
+    });
+    it('atomicWriteFileSync is defined exactly once as a private function in principle-tree-ledger.ts (PRI-443 Phase 4)', () => {
+        // The function is now a private (non-exported) helper inlined in principle-tree-ledger.ts
+        const hits = findDefinitions(/function\s+atomicWriteFileSync\s*\(/);
+        expect(hits).toEqual(['principle-tree-ledger.ts']);
     });
 });
 // ── PRI-416: Barrel Cap Guards ────────────────────────────────────────────────
@@ -3054,4 +3135,168 @@ describe('PRI-416: barrel cap guards', () => {
         expect(exportLines.length).toBeLessThanOrEqual(BARREL_MAX_EXPORT_LINES);
     });
 });
+// ── PRI-443: Pure module boundary guards ──────────────────────────────────────
+//
+// Phases 1-3 extracted pure types/codecs/schema out of I/O modules. These guards
+// ensure those pure modules never regress to importing fs/path, and that the
+// runtime-v2 barrel never re-exports I/O functions from principle-tree-ledger.
+describe('PRI-443: pure module boundary guards', () => {
+    const FORBIDDEN_PURE_IMPORTS = [
+        "from 'fs'",
+        'from "fs"',
+        "from 'node:fs'",
+        'from "node:fs"',
+        "from 'path'",
+        'from "path"',
+        "from 'node:path'",
+        'from "node:path"',
+    ];
+    async function readSrc(relPath) {
+        const fsMod = await import('fs'); // eslint-disable-line @typescript-eslint/consistent-type-imports
+        const pathMod = await import('path'); // eslint-disable-line @typescript-eslint/consistent-type-imports
+        const full = pathMod.resolve(__dirname, '..', relPath);
+        return fsMod.readFileSync(full, 'utf-8');
+    }
+    it('runtime-v2/types/ledger-store.ts has zero fs/path imports (pure types module)', async () => {
+        const src = await readSrc('types/ledger-store.ts');
+        for (const pat of FORBIDDEN_PURE_IMPORTS) {
+            expect(src).not.toContain(pat);
+        }
+    });
+    it('runtime-v2/principle-tree/ledger-codec.ts has zero fs/path imports (pure codec module)', async () => {
+        const src = await readSrc('principle-tree/ledger-codec.ts');
+        for (const pat of FORBIDDEN_PURE_IMPORTS) {
+            expect(src).not.toContain(pat);
+        }
+    });
+    it('runtime-v2/types/pain-signal.ts has zero fs/path imports (pure schema module)', async () => {
+        const src = await readSrc('types/pain-signal.ts');
+        for (const pat of FORBIDDEN_PURE_IMPORTS) {
+            expect(src).not.toContain(pat);
+        }
+    });
+    it('runtime-v2/index.ts barrel does NOT export I/O functions from principle-tree-ledger', async () => {
+        const src = await readSrc('index.ts');
+        // I/O functions must not be re-exported through the pure-types barrel.
+        expect(src).not.toMatch(/export\s+\{[^}]*\bloadLedger\b[^}]*\}\s*from\s*['"]\.\.\/principle-tree-ledger/);
+        expect(src).not.toMatch(/export\s+\{[^}]*\bsaveLedger\b[^}]*\}\s*from\s*['"]\.\.\/principle-tree-ledger/);
+        expect(src).not.toMatch(/export\s+\{[^}]*\bgetLedgerFilePathPublic\b[^}]*\}\s*from\s*['"]\.\.\/principle-tree-ledger/);
+        expect(src).not.toMatch(/export\s+\{[^}]*\bupdatePrinciple\b[^}]*\}\s*from\s*['"]\.\.\/principle-tree-ledger/);
+        expect(src).not.toMatch(/export\s+\{[^}]*\batomicWriteFileSync\b[^}]*\}\s*from\s*['"]\.\.\/principle-tree-ledger/);
+    });
+    it('runtime-v2/index.ts barrel re-exports LedgerTreeStore type from pure types module, not from principle-tree-ledger', async () => {
+        const src = await readSrc('index.ts');
+        // The type must come from the pure types module (./types/ledger-store.js),
+        // NOT from the I/O module (../principle-tree-ledger.js).
+        expect(src).toMatch(/export\s+type\s+\{\s*LedgerTreeStore\s*\}\s*from\s*['"]\.\/types\/ledger-store\.js['"]/);
+        expect(src).not.toMatch(/export\s+type\s+\{\s*LedgerTreeStore\s*\}\s*from\s*['"]\.\.\/principle-tree-ledger\.js['"]/);
+    });
+});
+// ── PRI-450: Core I/O whitelist guard ──────────────────────────────────────────
+//
+// Scans all production (.ts, non-test) files under packages/principles-core/src/
+// for fs/path imports and verifies they match an explicit whitelist. Any new file
+// that needs I/O must be added to ALLOWED_IO_FILES here — otherwise CI fails.
+// This forces developers to explain "why does this file need I/O?" in their PR.
+describe('PRI-450: core I/O whitelist guard', () => {
+    // Whitelist of production files allowed to import fs/path.
+    // Paths are relative to packages/principles-core/src/.
+    const ALLOWED_IO_FILES = new Set([
+        'principle-tree-ledger.ts',
+        'evolution-store.ts',
+        'trajectory-store.ts',
+        'workflow-funnel-loader.ts',
+        'runtime-v2/store/sqlite-connection.ts',
+        'runtime-v2/store/runtime-state-manager.ts',
+        'runtime-v2/adapter/openclaw-cli-runtime-adapter.ts',
+        'runtime-v2/candidate-audit.ts',
+        'runtime-v2/pain-signal-observability.ts',
+        'runtime-v2/internalization-chain-integrity-read-model.ts',
+        'runtime-v2/internalization-integrity-remediation.ts',
+        'runtime-v2/operator-health-read-model.ts',
+        'runtime-v2/pain-chain-read-model.ts',
+        'runtime-v2/pruning-read-model.ts',
+        'runtime-v2/pruning-review-log.ts',
+        'runtime-v2/schema-conformance-read-model.ts',
+    ]);
+    // Extract all import module paths from source code.
+    // Handles: import ... from 'mod', import 'mod' (side-effect), and multiline imports.
+    // Reuses the same pattern proven in the PRI-215 extractImportModulePaths helper.
+    function extractImportPaths(src) {
+        const paths = [];
+        for (const m of src.matchAll(/import\s+[\s\S]*?from\s+['"]([^'"]+)['"]/g)) {
+            if (m[1] != null)
+                paths.push(m[1]);
+        }
+        for (const m of src.matchAll(/import\s+['"]([^'"]+)['"]/g)) {
+            if (m[1] != null && !paths.includes(m[1]))
+                paths.push(m[1]);
+        }
+        return paths;
+    }
+    // Check if any import path references fs or path (including sub-paths like fs/promises).
+    function importsFsOrPath(src) {
+        const paths = extractImportPaths(src);
+        return paths.some((p) => p === 'fs' || p.startsWith('fs/') ||
+            p === 'node:fs' || p.startsWith('node:fs/') ||
+            p === 'path' || p.startsWith('path/') ||
+            p === 'node:path' || p.startsWith('node:path/'));
+    }
+    function collectTsFiles(dir, acc) {
+        const entries = fsSync.readdirSync(dir, { withFileTypes: true });
+        for (const entry of entries) {
+            const fullPath = pathSync.join(dir, entry.name);
+            if (entry.isDirectory()) {
+                collectTsFiles(fullPath, acc);
+            }
+            else if (entry.isFile() &&
+                entry.name.endsWith('.ts') &&
+                !entry.name.endsWith('.test.ts') &&
+                !entry.name.endsWith('.spec.ts')) {
+                acc.push(fullPath);
+            }
+        }
+    }
+    it('core/src/ production files: only whitelisted files import fs/path', () => {
+        const coreSrcDir = pathSync.resolve(__dirname, '..', '..');
+        const allFiles = [];
+        collectTsFiles(coreSrcDir, allFiles);
+        const violations = [];
+        for (const filePath of allFiles) {
+            const content = fsSync.readFileSync(filePath, 'utf-8');
+            if (importsFsOrPath(content)) {
+                const relPath = pathSync.relative(coreSrcDir, filePath).replace(/\\/g, '/');
+                if (!ALLOWED_IO_FILES.has(relPath)) {
+                    violations.push(relPath);
+                }
+            }
+        }
+        expect(violations).toEqual([]);
+    });
+    it('ALLOWED_IO_FILES whitelist entries all exist on disk', () => {
+        const coreSrcDir = pathSync.resolve(__dirname, '..', '..');
+        const missing = [];
+        for (const relPath of ALLOWED_IO_FILES) {
+            const fullPath = pathSync.join(coreSrcDir, ...relPath.split('/'));
+            if (!fsSync.existsSync(fullPath)) {
+                missing.push(relPath);
+            }
+        }
+        expect(missing).toEqual([]);
+    });
+    it('importsFsOrPath detects sub-path imports (fs/promises) and side-effect imports', () => {
+        // Sub-path import
+        expect(importsFsOrPath(`import { mkdir } from 'node:fs/promises';`)).toBe(true);
+        expect(importsFsOrPath(`import { posix } from 'path/posix';`)).toBe(true);
+        // Side-effect import
+        expect(importsFsOrPath(`import 'fs';`)).toBe(true);
+        expect(importsFsOrPath(`import "node:path";`)).toBe(true);
+        // Standard import
+        expect(importsFsOrPath(`import * as fs from 'fs';`)).toBe(true);
+        expect(importsFsOrPath(`import { resolve } from 'node:path';`)).toBe(true);
+        // Non-fs/path imports
+        expect(importsFsOrPath(`import { foo } from 'bar';`)).toBe(false);
+        expect(importsFsOrPath(``)).toBe(false);
+    });
+});
 //# sourceMappingURL=architecture-regression.test.js.map