principles-disciple 1.127.0 → 1.129.0

package/tests/core/workspace-context-factory.test.ts

@@ -1,18 +0,0 @@
-import { describe, it, expect, vi } from 'vitest';
-import { createTestContext } from '../test-utils.js';
-import * as path from 'path';
-
-describe('WorkspaceContext Factory (Test Utils)', () => {
-    it('should create a test context with a temporary directory', () => {
-        const wctx = createTestContext();
-        
-        expect(wctx.workspaceDir).toContain('pd-test-');
-        expect(wctx.stateDir).toContain('.state');
-    });
-
-    it('should allow overriding workspaceDir', () => {
-        const customDir = path.resolve('/custom/test');
-        const wctx = createTestContext({ workspaceDir: customDir });
-        expect(wctx.workspaceDir).toBe(customDir);
-    });
-});

package/tests/core/workspace-context.test.ts

@@ -1,187 +0,0 @@
-import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
-import { WorkspaceContext } from '../../src/core/workspace-context.js';
-import * as fs from 'fs';
-import * as path from 'path';
-import * as principleTreeLedger from '../../src/core/principle-tree-ledger.js';
-
-vi.mock('fs');
-vi.mock('../../src/core/trajectory.js', () => ({
-    TrajectoryRegistry: {
-        get: vi.fn(() => ({
-            dispose: vi.fn(),
-        })),
-        use: vi.fn(),
-        dispose: vi.fn(),
-        clear: vi.fn(),
-    }
-}));
-vi.mock('../../src/core/principle-tree-ledger.js', () => ({
-    getPrincipleSubtree: vi.fn(),
-}));
-
-describe('WorkspaceContext', () => {
-    // Use path.resolve for cross-platform compatibility on Windows
-    const workspaceDir = path.resolve('/mock/workspace');
-    const stateDir = path.resolve('/mock/state');
-
-    beforeEach(() => {
-        vi.clearAllMocks();
-        WorkspaceContext.clearCache();
-    });
-
-    afterEach(() => {
-        vi.resetAllMocks();
-    });
-
-    it('should create an instance from hook context', () => {
-        const mockCtx = { workspaceDir, stateDir };
-        const wctx = WorkspaceContext.fromHookContext(mockCtx);
-        
-        expect(wctx.workspaceDir).toBe(workspaceDir);
-        expect(wctx.stateDir).toBe(stateDir);
-    });
-
-    it('should cache instances based on workspaceDir', () => {
-        const mockCtx1 = { workspaceDir, stateDir: path.resolve('/state1') };
-        const mockCtx2 = { workspaceDir, stateDir: path.resolve('/state2') };
-        
-        const wctx1 = WorkspaceContext.fromHookContext(mockCtx1);
-        const wctx2 = WorkspaceContext.fromHookContext(mockCtx2);
-        
-        expect(wctx1).toBe(wctx2);
-        expect(wctx1.stateDir).toBe(path.resolve('/state1'));
-    });
-
-    it('should use fallback workspace when workspaceDir is missing', () => {
-        const mockCtx = { stateDir };
-        const wctx = WorkspaceContext.fromHookContext(mockCtx);
-        expect(wctx).toBeDefined();
-        expect(wctx.workspaceDir).toBeDefined();
-    });
-
-    it('should resolve paths using PD_FILES keys', () => {
-        const mockCtx = { workspaceDir };
-        const wctx = WorkspaceContext.fromHookContext(mockCtx);
-        
-        // PROFILE is at .principles/PROFILE.json
-        expect(wctx.resolve('PROFILE')).toBe(path.join(workspaceDir, '.principles', 'PROFILE.json'));
-        // THINKING_OS is at .principles/THINKING_OS.md
-        expect(wctx.resolve('THINKING_OS')).toBe(path.join(workspaceDir, '.principles', 'THINKING_OS.md'));
-    });
-
-    it('should support explicit disposal from cache', () => {
-        const mockCtx = { workspaceDir };
-        const wctx1 = WorkspaceContext.fromHookContext(mockCtx);
-        
-        WorkspaceContext.dispose(workspaceDir);
-        
-        const wctx2 = WorkspaceContext.fromHookContext(mockCtx);
-        expect(wctx1).not.toBe(wctx2);
-    });
-
-    it('should allow invalidation of internal state', () => {
-        const mockCtx = { workspaceDir };
-        const wctx = WorkspaceContext.fromHookContext(mockCtx);
-        
-        expect(() => wctx.invalidate()).not.toThrow();
-    });
-
-    it('should lazy load ConfigService', () => {
-        const mockCtx = { workspaceDir };
-        const wctx = WorkspaceContext.fromHookContext(mockCtx);
-        
-        const config = wctx.config;
-        expect(config).toBeDefined();
-        expect(wctx.config).toBe(config); // Should be cached
-    });
-
-    it('should lazy load EventLog', () => {
-        const mockCtx = { workspaceDir };
-        const wctx = WorkspaceContext.fromHookContext(mockCtx);
-        
-        const eventLog = wctx.eventLog;
-        expect(eventLog).toBeDefined();
-        expect(wctx.eventLog).toBe(eventLog); // Should be cached
-    });
-
-    it('should pass trajectory settings from config into the registry', async () => {
-        const { TrajectoryRegistry } = await import('../../src/core/trajectory.js');
-        const mockCtx = { workspaceDir };
-        const wctx = WorkspaceContext.fromHookContext(mockCtx);
-
-        (wctx as any)._config = {
-            get: vi.fn((key: string) => {
-                if (key === 'trajectory.blob_inline_threshold_bytes') return 2048;
-                if (key === 'trajectory.busy_timeout_ms') return 1500;
-                if (key === 'trajectory.orphan_blob_grace_days') return 2;
-                return undefined;
-            }),
-        };
-
-        const trajectory = wctx.trajectory;
-        expect(trajectory).toBeDefined();
-        expect(TrajectoryRegistry.get).toHaveBeenCalledWith(workspaceDir, {
-            blobInlineThresholdBytes: 2048,
-            busyTimeoutMs: 1500,
-            orphanBlobGraceDays: 2,
-        });
-    });
-
-    it('should lazy load Dictionary service', () => {
-        const mockCtx = { workspaceDir };
-        const wctx = WorkspaceContext.fromHookContext(mockCtx);
-        
-        const dictionary = wctx.dictionary;
-        expect(dictionary).toBeDefined();
-        expect(wctx.dictionary).toBe(dictionary);
-    });
-
-    it('should cache a workspace-scoped principle tree ledger accessor', () => {
-        const mockCtx = { workspaceDir };
-        const wctx = WorkspaceContext.fromHookContext(mockCtx);
-
-        const principleTreeLedgerAccessor = (wctx as any).principleTreeLedger;
-
-        expect(principleTreeLedgerAccessor).toBeDefined();
-        expect((wctx as any).principleTreeLedger).toBe(principleTreeLedgerAccessor);
-        expect(typeof principleTreeLedgerAccessor.getPrincipleSubtree).toBe('function');
-    });
-
-    it('should retrieve active principle subtrees through the workspace boundary', () => {
-        const mockCtx = { workspaceDir, stateDir };
-        const wctx = WorkspaceContext.fromHookContext(mockCtx);
-        const activePrinciples = [
-            {
-                id: 'P-001',
-                trigger: 'delete',
-                contextTags: ['write'],
-                valueMetrics: undefined,
-            },
-        ];
-        const subtree = {
-            principle: { id: 'P-001', ruleIds: ['R-001'] },
-            rules: [
-                {
-                    rule: { id: 'R-001', implementationIds: ['IMPL-001'] },
-                    implementations: [{ id: 'IMPL-001', ruleId: 'R-001', type: 'prompt' }],
-                },
-            ],
-        };
-
-        vi.mocked(principleTreeLedger.getPrincipleSubtree).mockReturnValue(subtree as any);
-        (wctx as any)._evolutionReducer = {
-            getActivePrinciples: vi.fn().mockReturnValue(activePrinciples),
-        };
-
-        const activePrincipleSubtrees = (wctx as any).getActivePrincipleSubtrees();
-
-        expect((wctx as any)._evolutionReducer.getActivePrinciples).toHaveBeenCalled();
-        expect(principleTreeLedger.getPrincipleSubtree).toHaveBeenCalledWith(stateDir, 'P-001');
-        expect(activePrincipleSubtrees).toEqual([
-            {
-                principle: activePrinciples[0],
-                subtree,
-            },
-        ]);
-    });
-});

package/tests/core/workspace-guidance-migrator.test.ts

@@ -1,248 +0,0 @@
-import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
-import * as fs from 'fs';
-import * as path from 'path';
-import type { Dirent } from 'fs';
-import type { OpenClawPluginApi } from '../../src/openclaw-sdk.js';
-
-const mockFs = {
-  existsSync: vi.fn(),
-  readFileSync: vi.fn(),
-  writeFileSync: vi.fn(),
-  readdirSync: vi.fn(),
-};
-
-vi.mock('fs', () => mockFs);
-
-// Mock heavy core module to avoid slow re-imports and to control staleness detection
-const mockMigrateWorkspaceGuidance = vi.fn<(content: string, relativePath: string) => { changed: boolean; migrated: string }>();
-const mockContainsStalePlanMdGuidance = vi.fn<(content: string, relativePath: string) => boolean>();
-
-vi.mock('@principles/core/runtime-v2', () => ({
-  migrateWorkspaceGuidance: (...args: unknown[]) => mockMigrateWorkspaceGuidance(...(args as [string, string])),
-  containsStalePlanMdGuidance: (...args: unknown[]) => mockContainsStalePlanMdGuidance(...(args as [string, string])),
-}));
-
-const WORKSPACE_GUIDANCE_MIGRATOR_PATH = '../../src/core/workspace-guidance-migrator.js';
-
-describe('workspace-guidance-migrator', () => {
-  let migrateStaleWorkspaceGuidance: (api: OpenClawPluginApi, workspaceDir: string) => {
-    migratedFiles: string[];
-    skippedFiles: string[];
-    errors: { file: string; error: string }[];
-  };
-
-  const mockLogger = {
-    info: vi.fn(),
-    warn: vi.fn(),
-    error: vi.fn(),
-  };
-
-  const mockApi = {
-    logger: mockLogger,
-  } as unknown as OpenClawPluginApi;
-
-  beforeEach(async () => {
-    vi.clearAllMocks();
-    vi.resetModules();
-
-    mockFs.existsSync.mockReturnValue(true);
-    mockFs.readFileSync.mockReturnValue('');
-    mockFs.writeFileSync.mockReturnValue(undefined);
-    mockFs.readdirSync.mockReturnValue([]);
-
-    // Default: content is NOT stale
-    mockContainsStalePlanMdGuidance.mockReturnValue(false);
-    mockMigrateWorkspaceGuidance.mockImplementation((content: string) => ({
-      changed: false,
-      migrated: content,
-    }));
-
-    const module = await import(WORKSPACE_GUIDANCE_MIGRATOR_PATH);
-    migrateStaleWorkspaceGuidance = module.migrateStaleWorkspaceGuidance;
-  });
-
-  afterEach(() => {
-    vi.restoreAllMocks();
-  });
-
-  describe('migrateStaleWorkspaceGuidance', () => {
-    it('skips files that do not exist', () => {
-      mockFs.existsSync.mockReturnValue(false);
-
-      const result = migrateStaleWorkspaceGuidance(mockApi, '/workspace');
-
-      expect(result.migratedFiles).toEqual([]);
-      expect(result.skippedFiles).toEqual([]);
-      expect(result.errors).toEqual([]);
-    });
-
-    it('skips files with no stale guidance', () => {
-      mockFs.existsSync.mockReturnValue(true);
-      mockFs.readFileSync.mockReturnValue('# Clean AGENTS.md\nNo stale references here.');
-      // Default: containsStalePlanMdGuidance returns false
-
-      const result = migrateStaleWorkspaceGuidance(mockApi, '/workspace');
-
-      expect(result.migratedFiles).toEqual([]);
-      expect(result.skippedFiles.length).toBeGreaterThan(0);
-      expect(result.errors).toEqual([]);
-    });
-
-    it('migrates AGENTS.md with stale guidance', () => {
-      mockFs.existsSync.mockReturnValue(true);
-      mockFs.readFileSync.mockReturnValue(
-        '# Agent Instructions\nPhysical interception ensures safety.',
-      );
-      // First call (AGENTS.md) is stale, second (MEMORY.md) is not
-      mockContainsStalePlanMdGuidance
-        .mockReturnValueOnce(true)
-        .mockReturnValueOnce(false);
-      mockMigrateWorkspaceGuidance.mockImplementation((content: string) => ({
-        changed: true,
-        migrated: content.replace('Physical interception', 'MIGRATED'),
-      }));
-
-      const result = migrateStaleWorkspaceGuidance(mockApi, '/workspace');
-
-      expect(result.migratedFiles.some(f => f.includes('AGENTS.md'))).toBe(true);
-      expect(result.skippedFiles.some(f => f.includes('MEMORY.md'))).toBe(true);
-    });
-
-    it('creates backup before migration', () => {
-      mockFs.existsSync.mockReturnValue(true);
-      mockFs.readFileSync.mockReturnValue(
-        '# Agent Instructions\nPhysical interception ensures safety.',
-      );
-      mockContainsStalePlanMdGuidance.mockReturnValue(true);
-      mockMigrateWorkspaceGuidance.mockImplementation((content: string) => ({
-        changed: true,
-        migrated: content.replace('Physical interception', 'MIGRATED'),
-      }));
-
-      migrateStaleWorkspaceGuidance(mockApi, '/workspace');
-
-      const backupCalls = mockFs.writeFileSync.mock.calls.filter(
-        (call: unknown[]) => String(call[0]).includes('.pre-pri286.bak'),
-      );
-      expect(backupCalls.length).toBeGreaterThan(0);
-    });
-
-    it('logs migration progress', () => {
-      mockFs.existsSync.mockReturnValue(true);
-      mockFs.readFileSync.mockReturnValue(
-        '# Agent Instructions\nPhysical interception ensures safety.',
-      );
-      mockContainsStalePlanMdGuidance.mockReturnValue(true);
-      mockMigrateWorkspaceGuidance.mockImplementation((content: string) => ({
-        changed: true,
-        migrated: content.replace('Physical interception', 'MIGRATED'),
-      }));
-
-      migrateStaleWorkspaceGuidance(mockApi, '/workspace');
-
-      expect(mockLogger.info).toHaveBeenCalledWith(
-        expect.stringContaining('[PD:GuidanceMigration]'),
-      );
-    });
-
-    it('handles read errors gracefully', () => {
-      mockFs.existsSync.mockReturnValue(true);
-      mockFs.readFileSync.mockImplementation(() => {
-        throw new Error('Read error');
-      });
-
-      const result = migrateStaleWorkspaceGuidance(mockApi, '/workspace');
-
-      expect(result.errors.length).toBeGreaterThan(0);
-      expect(result.errors[0].error).toContain('Failed to read file content');
-    });
-
-    it('handles write errors and restores original', () => {
-      const originalContent = '# Agent Instructions\nPhysical interception ensures safety.';
-      mockFs.existsSync.mockReturnValue(true);
-      mockFs.readFileSync.mockReturnValue(originalContent);
-      mockContainsStalePlanMdGuidance.mockReturnValue(true);
-      mockMigrateWorkspaceGuidance.mockImplementation((content: string) => ({
-        changed: true,
-        migrated: content.replace('Physical interception', 'MIGRATED'),
-      }));
-
-      let callCount = 0;
-      mockFs.writeFileSync.mockImplementation((path: string, content: string) => {
-        callCount++;
-        if (path.includes('.pre-pri286.bak')) return;
-        if (callCount === 2) {
-          expect(content).toBe(originalContent);
-          return;
-        }
-        throw new Error('Write error');
-      });
-
-      const result = migrateStaleWorkspaceGuidance(mockApi, '/workspace');
-
-      expect(result.errors.length).toBeGreaterThan(0);
-      expect(callCount).toBeGreaterThanOrEqual(2);
-    });
-
-    it('skips non-guidance files', () => {
-      mockFs.existsSync.mockReturnValue(true);
-      mockFs.readFileSync.mockReturnValue('# Random Content\nNo guidance here.');
-
-      const result = migrateStaleWorkspaceGuidance(mockApi, '/workspace');
-
-      expect(result.migratedFiles).toEqual([]);
-    });
-
-    it('discovers skill files in .principles/skills directory', () => {
-      const skillsPattern = path.join('.principles', 'skills');
-      mockFs.existsSync.mockImplementation((p: string) => {
-        if (String(p).includes(skillsPattern)) return true;
-        return false;
-      });
-      mockFs.readdirSync.mockReturnValue([
-        { isDirectory: () => true, name: 'admin' },
-        { isDirectory: () => true, name: 'reflection' },
-      ] as Dirent[]);
-      mockFs.readFileSync.mockReturnValue(
-        'Ensure `PLAN.md` contains `## Target Files` heading.',
-      );
-      mockContainsStalePlanMdGuidance.mockReturnValue(true);
-      mockMigrateWorkspaceGuidance.mockImplementation((content: string) => ({
-        changed: true,
-        migrated: content.replace('## Target Files', '## Targets'),
-      }));
-
-      const result = migrateStaleWorkspaceGuidance(mockApi, '/workspace');
-
-      expect(result.migratedFiles.length).toBeGreaterThan(0);
-    });
-
-    it('handles empty workspace directory', () => {
-      mockFs.existsSync.mockReturnValue(false);
-
-      const result = migrateStaleWorkspaceGuidance(mockApi, '/workspace');
-
-      expect(result.migratedFiles).toEqual([]);
-      expect(result.skippedFiles).toEqual([]);
-      expect(result.errors).toEqual([]);
-    });
-
-    it('handles skills directory read error gracefully', () => {
-      const skillsPattern = path.join('.principles', 'skills');
-      mockFs.existsSync.mockImplementation((p: string) => {
-        if (String(p).includes(skillsPattern)) return true;
-        return false;
-      });
-      mockFs.readdirSync.mockImplementation(() => {
-        throw new Error('Directory read error');
-      });
-      mockFs.readFileSync.mockReturnValue(
-        '# Agent Instructions\nPhysical interception ensures safety.',
-      );
-
-      const result = migrateStaleWorkspaceGuidance(mockApi, '/workspace');
-
-      expect(result.errors.length).toBeGreaterThan(0);
-    });
-  });
-});

package/tests/core-anti-growth.test.ts

@@ -1,182 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import * as fs from 'fs';
-import * as path from 'path';
-
-// ── PRI-212: Plugin core anti-growth architecture guard ─────────────────────
-//
-// Prevents new unclassified files from being added to packages/openclaw-plugin/src/core/
-// without explicit allowlisting. New pure domain logic MUST go to @principles/core.
-//
-// Baseline from PRI-211 inventory (2026-05-21).
-// Reference: docs/reviews/plugin-core-inventory-2026-05.md
-//
-// How to add a new file:
-//   1. Is it pure domain logic? → add to @principles/core, NOT here
-//   2. Is it a plugin I/O adapter/binding? → add to PLUGIN_IO_FILES
-//      with a comment explaining why it belongs in plugin core
-//   3. NEVER add to/from FROZEN_LEGACY (ADR-0005) — those must NOT be modified
-
-describe('PRI-212 plugin core anti-growth guard', () => {
-  // Category 1: Frozen Legacy (ADR-0005) — deleted in PRI-230
-  const FROZEN_LEGACY = [
-  ] as const;
-
-  // Category 2: Pure domain logic with zero I/O imports — should migrate to @principles/core
-  const ZERO_IMPORT_CANDIDATES = [
-    'trajectory-types.ts',
-    'profile.ts',
-    'pd-task-types.ts',
-    'evolution-types.ts',
-    'empathy-types.ts',
-    'correction-types.ts',
-    'principle-injection.ts',
-    'principle-compiler/template-generator.ts',
-  ] as const;
-
-  // Categories 3-5: Plugin I/O adapters, Do Not Move, I/O boundary
-  const PLUGIN_IO_FILES = [
-    // Thin adapter candidates
-    'local-worker-routing.ts',
-    'principle-internalization/principle-lifecycle-service.ts',
-    'principle-tree-ledger-adapter.ts',
-    'principle-compiler/ledger-registrar.ts',
-    'principle-compiler/code-validator.ts',
-    'pd-task-service.ts',
-    'principle-internalization/lifecycle-read-model.ts',
-    'principle-internalization/filesystem-lifecycle-datasource.ts',
-    'config-service.ts',
-    'principle-compiler/index.ts',
-    'principle-internalization/lifecycle-refresh.ts',
-    // Do Not Move
-    'event-log.ts',
-    'schema/schema-definitions.ts',
-    'path-resolver.ts',
-    'init.ts',
-    'workspace-context.ts',
-    'reflection/reflection-context.ts',
-    'bootstrap-rules.ts',
-    'schema/migration-runner.ts',
-    'rule-host.ts',
-    'principle-training-state.ts',
-    'pain-diagnostic-gate.ts',
-    'hygiene/tracker.ts',
-    'schema/migrations/002-init-central.ts',
-    'paths.ts',
-    'schema/migrations/004-add-thinking-and-gfi.ts',
-    'schema/migrations/003-init-workflow.ts',
-    'workspace-dir-validation.ts',
-    'rule-implementation-runtime.ts',
-    'detection-service.ts',
-    'schema/migrations/index.ts',
-    'dictionary-service.ts',
-    'schema/index.ts',
-    'schema/db-types.ts',
-    'rule-host-types.ts',
-    'rule-host-helpers.ts',
-    'schema/migrations/001-init-trajectory.ts',
-    // I/O boundary
-    'trajectory.ts',
-    'evolution-reducer.ts',
-    'promotion-gate.ts',
-    'model-training-registry.ts',
-    'focus-history.ts',
-    'model-deployment-registry.ts',
-    'replay-engine.ts',
-    'external-training-contract.ts',
-    'shadow-observation-registry.ts',
-    'control-ui-db.ts',
-    'thinking-models.ts',
-    'pd-task-reconciler.ts',
-    'correction-cue-learner.ts',
-    'principle-compiler/compiler.ts',
-    'pain.ts',
-    'config.ts',
-    'code-implementation-storage.ts',
-    'observability.ts',
-    'workflow-funnel-loader.ts',
-    'dictionary.ts',
-    'thinking-os-parser.ts',
-    'system-logger.ts',
-    'detection-funnel.ts',
-    'risk-calculator.ts',
-    'migration.ts',
-    'file-store.ts',
-    'pd-task-store.ts',
-    'evolution-migration.ts',
-    'empathy-keyword-matcher.ts',
-    'session-tracker.ts',
-    'principle-tree-ledger.ts',
-    'evolution-logger.ts',
-    'evolution-engine.ts',
-    'runtime-v2-prompt-activation-reader.ts',
-    'workspace-guidance-migrator.ts',
-    'surface-guard.ts',
-    'pd-config-loader.ts',
-    'config-health.ts',  // PRI-346: conversation access check extracted to avoid circular imports
-  ] as const;
-
-  // Category 6: Test files
-  const KNOWN_TEST_FILES = [
-    '__tests__/focus-history.test.ts',
-    'principle-compiler/__tests__/compiler-replay-gate.test.ts',
-  ] as const;
-
-  const ALL_KNOWN = [
-    ...FROZEN_LEGACY,
-    ...ZERO_IMPORT_CANDIDATES,
-    ...PLUGIN_IO_FILES,
-    ...KNOWN_TEST_FILES,
-  ];
-
-  function enumerateFiles(dir: string, prefix = ''): string[] {
-    const entries = fs.readdirSync(dir, { withFileTypes: true });
-    const files: string[] = [];
-    for (const entry of entries) {
-      const relPath = prefix ? `${prefix}/${entry.name}` : entry.name;
-      const fullPath = path.resolve(dir, entry.name);
-      if (entry.isDirectory()) {
-        files.push(...enumerateFiles(fullPath, relPath));
-      } else if (entry.name.endsWith('.ts')) {
-        files.push(relPath.replace(/\\/g, '/'));
-      }
-    }
-    return files;
-  }
-
-  it('no new unclassified files in plugin core', () => {
-    const coreDir = path.resolve(__dirname, '../src/core');
-    const actualFiles = enumerateFiles(coreDir).sort();
-    const expectedFiles = [...ALL_KNOWN].sort();
-
-    const actualSet = new Set(actualFiles);
-    const knownSet = new Set(expectedFiles);
-
-    const unknownFiles = actualFiles.filter((f) => !knownSet.has(f));
-    const missingFiles = expectedFiles.filter((f) => !actualSet.has(f));
-
-    expect(unknownFiles, [
-      `\nUnclassified files detected in packages/openclaw-plugin/src/core/:`,
-      ...unknownFiles.map((f) => `  + ${f}`),
-      ``,
-      `New pure domain logic MUST go to @principles/core (packages/principles-core/).`,
-      `Plugin I/O adapter additions must be explicitly allowlisted in`,
-      `packages/openclaw-plugin/tests/core-anti-growth.test.ts`,
-      `ADR-0005 frozen files must NOT be modified.`,
-      `Reference: docs/reviews/plugin-core-inventory-2026-05.md (PRI-211)`,
-    ].join('\n')).toEqual([]);
-
-    expect(missingFiles, [
-      `\nBaseline files missing from packages/openclaw-plugin/src/core/:`,
-      ...missingFiles.map((f) => `  - ${f}`),
-      ``,
-      `Missing baseline files may indicate:`,
-      `  - File was moved or deleted (update inventory if intentional)`,
-      `  - Stale-main rollback (ERR-012): rebase on latest origin/main`,
-      `  - File was renamed (update inventory with new name)`,
-    ].join('\n')).toEqual([]);
-  });
-
-  it('zero-import candidates are tracked for migration awareness', () => {
-    expect(ZERO_IMPORT_CANDIDATES.length).toBeGreaterThan(0);
-  });
-});