principles-disciple 1.72.0 → 1.74.0

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

@@ -0,0 +1,191 @@
+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',
+    'pain-signal.ts',
+    'pd-task-types.ts',
+    'evolution-types.ts',
+    'telemetry-event.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-tree-migration.ts',
+    'principle-internalization/principle-lifecycle-service.ts',
+    'principle-tree-ledger-adapter.ts',
+    'principle-compiler/ledger-registrar.ts',
+    'principle-compiler/code-validator.ts',
+    'principle-injector.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',
+    'workspace-dir-service.ts',
+    'paths.ts',
+    'schema/migrations/004-add-thinking-and-gfi.ts',
+    'evolution-hook.ts',
+    'storage-adapter.ts',
+    'schema/migrations/003-init-workflow.ts',
+    'workspace-dir-validation.ts',
+    'pain-signal-adapter.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',
+    'training-program.ts',
+    'replay-engine.ts',
+    'external-training-contract.ts',
+    'merge-gate-audit.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',
+    'pain-context-extractor.ts',
+    'config.ts',
+    'code-implementation-storage.ts',
+    'observability.ts',
+    'file-storage-adapter.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',
+    'pain-lifecycle.ts',
+    'session-tracker.ts',
+    'principle-tree-ledger.ts',
+    'evolution-logger.ts',
+    'evolution-engine.ts',
+    'runtime-v2-prompt-activation-reader.ts',
+  ] 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);
+  });
+});

package/tests/hook-workspace-nextaction-contract.test.ts

@@ -0,0 +1,42 @@
+import { describe, it, expect } from 'vitest';
+import * as fs from 'fs';
+import * as path from 'path';
+
+const INDEX_TS = fs.readFileSync(
+  path.resolve(__dirname, '../src/index.ts'),
+  'utf-8',
+);
+
+describe('Hook workspace resolution NextAction contract', () => {
+  const FORBIDDEN_NEXT_ACTION_PATTERNS = [
+    /PD_WORKSPACE_DIR/,
+    /principles-disciple\.json/,
+  ];
+
+  it('does not claim PD_WORKSPACE_DIR env var as recovery in NextAction', () => {
+    const matches = INDEX_TS.match(/NextAction:[^`]*PD_WORKSPACE_DIR/g);
+    expect(matches).toBeNull();
+  });
+
+  it('does not claim principles-disciple.json as recovery in NextAction', () => {
+    const matches = INDEX_TS.match(/NextAction:[^`]*principles-disciple\.json/g);
+    expect(matches).toBeNull();
+  });
+
+  it('all hook failure NextActions reference canonical workspace migration', () => {
+    const nextActionLines = INDEX_TS.match(/NextAction: \${HOOK_WORKSPACE_RESOLUTION_NEXT_ACTION}/g);
+    expect(nextActionLines).not.toBeNull();
+    expect(nextActionLines!.length).toBeGreaterThanOrEqual(7);
+  });
+
+  it('HOOK_WORKSPACE_RESOLUTION_NEXT_ACTION constant exists and does not contain forbidden patterns', () => {
+    const constantMatch = INDEX_TS.match(
+      /const HOOK_WORKSPACE_RESOLUTION_NEXT_ACTION\s*=\s*'([^']+)'/,
+    );
+    expect(constantMatch).not.toBeNull();
+    const constantValue = constantMatch![1];
+    for (const pattern of FORBIDDEN_NEXT_ACTION_PATTERNS) {
+      expect(pattern.test(constantValue)).toBe(false);
+    }
+  });
+});

package/tests/hooks/confirm-first-removal.test.ts

@@ -0,0 +1,188 @@
+/**
+ * PRI-286: Verify confirm-first gate has been fully removed from live paths.
+ *
+ * These tests prove that:
+ * 1. The confirm-first-gate module no longer exists as an importable live module
+ * 2. gate.ts does not call any confirm-first function
+ * 3. prompt.ts does not import any confirm-first function
+ * 4. gate-block-helper does not output confirm-first specific block messages
+ * 5. confirm_first_gate does not appear in DEFAULT_FEATURE_FLAGS
+ * 6. Default PD installation does not block mutating tools due to PLAN.md absence
+ * 7. PLAN.md is not a canonical PD path (paths.ts, path-resolver.ts, env.ts, migration.ts)
+ * 8. confirm-first event types and state store are fully deleted
+ */
+
+import { describe, it, expect } from 'vitest';
+import fs from 'fs';
+import path from 'path';
+
+// __dirname = packages/openclaw-plugin/tests/hooks → go up 4 to monorepo root
+// (hooks → tests → openclaw-plugin → packages → monorepo-root)
+const ROOT = path.resolve(__dirname, '..', '..', '..', '..');
+
+describe('PRI-286: Confirm-first gate removal verification', () => {
+  it('confirm-first-gate.ts source file has been deleted', () => {
+    const gatePath = path.join(ROOT, 'packages/openclaw-plugin/src/core/confirm-first-gate.ts');
+    expect(fs.existsSync(gatePath)).toBe(false);
+  });
+
+  it('gate.ts does not import from confirm-first-gate', async () => {
+    const gateSource = fs.readFileSync(
+      path.join(ROOT, 'packages/openclaw-plugin/src/hooks/gate.ts'),
+      'utf8',
+    );
+    expect(gateSource).not.toContain('confirm-first-gate');
+    expect(gateSource).not.toContain('evaluateConfirmFirstGateSync');
+    expect(gateSource).not.toContain('confirm-first');
+  });
+
+  it('prompt.ts does not import from confirm-first-gate', async () => {
+    const promptSource = fs.readFileSync(
+      path.join(ROOT, 'packages/openclaw-plugin/src/hooks/prompt.ts'),
+      'utf8',
+    );
+    expect(promptSource).not.toContain('confirm-first-gate');
+    expect(promptSource).not.toContain('detectApprovalMarker');
+    expect(promptSource).not.toContain('setConfirmFirstDirective');
+    expect(promptSource).not.toContain('setConfirmFirstApproval');
+    expect(promptSource).not.toContain('hydrateFromStore');
+    expect(promptSource).not.toContain('pruneStoreStaleRows');
+    expect(promptSource).not.toContain('setConfirmFirstStore');
+    expect(promptSource).not.toContain('resetConfirmFirst');
+    expect(promptSource).not.toContain('setConfirmFirstGateEnabled');
+    expect(promptSource).not.toContain('SqliteConfirmFirstStateStore');
+    expect(promptSource).not.toContain('confirm_first_gate');
+  });
+
+  it('gate-block-helper does not have confirm-first specific branch', () => {
+    const helperSource = fs.readFileSync(
+      path.join(ROOT, 'packages/openclaw-plugin/src/hooks/gate-block-helper.ts'),
+      'utf8',
+    );
+    expect(helperSource).not.toContain('confirm-first-gate');
+    expect(helperSource).not.toContain('Confirm-First Gate Blocked');
+    expect(helperSource).not.toContain('confirm-first behavioral directive');
+  });
+
+  it('confirm_first_gate is not in DEFAULT_FEATURE_FLAGS', async () => {
+    const { DEFAULT_FEATURE_FLAGS } = await import('@principles/core/runtime-v2');
+    const ids = DEFAULT_FEATURE_FLAGS.map((f: { id: string }) => f.id);
+    expect(ids).not.toContain('confirm_first_gate');
+  });
+
+  it('no PLAN.md physical interception language in AGENTS.md templates', () => {
+    const templateDirs = [
+      path.join(ROOT, 'packages/openclaw-plugin/templates'),
+      path.join(ROOT, 'packages/create-principles-disciple/templates'),
+      path.join(ROOT, 'packages/create-principles-disciple/plugin/templates'),
+    ];
+
+    for (const dir of templateDirs) {
+      if (!fs.existsSync(dir)) continue;
+      const agentsFiles = findFiles(dir, 'AGENTS.md');
+      for (const file of agentsFiles) {
+        const content = fs.readFileSync(file, 'utf8');
+        // Must NOT contain physical interception language
+        expect(content, `${file} should not contain physical interception`).not.toContain('Physical interception');
+        expect(content, `${file} should not contain 物理拦截`).not.toContain('物理拦截');
+        expect(content, `${file} should not contain Single source of truth.*PLAN`).not.toMatch(/Single source of truth.*PLAN/i);
+      }
+    }
+  });
+
+  it('no mandatory PLAN.md STATUS:READY in THINKING_OS templates', () => {
+    const templateDirs = [
+      path.join(ROOT, 'packages/openclaw-plugin/templates'),
+      path.join(ROOT, 'packages/create-principles-disciple/templates'),
+      path.join(ROOT, 'packages/create-principles-disciple/plugin/templates'),
+    ];
+
+    for (const dir of templateDirs) {
+      if (!fs.existsSync(dir)) continue;
+      const thinkingFiles = findFiles(dir, 'THINKING_OS.md');
+      for (const file of thinkingFiles) {
+        const content = fs.readFileSync(file, 'utf8');
+        expect(content, `${file} should not require PLAN.md status: READY`).not.toContain('PLAN.md` (status: READY)');
+        expect(content, `${file} should not require PLAN.md（状态：READY）`).not.toContain('PLAN.md`（状态：READY）');
+      }
+    }
+  });
+
+  // ── Round 2: Canonical PLAN.md path removal ──
+
+  it('paths.ts does not contain PLAN: entry', () => {
+    const source = fs.readFileSync(
+      path.join(ROOT, 'packages/openclaw-plugin/src/core/paths.ts'),
+      'utf8',
+    );
+    expect(source).not.toMatch(/PLAN:\s*'PLAN\.md'/);
+  });
+
+  it('path-resolver.ts does not contain PLAN key', () => {
+    const source = fs.readFileSync(
+      path.join(ROOT, 'packages/openclaw-plugin/src/core/path-resolver.ts'),
+      'utf8',
+    );
+    expect(source).not.toContain("'PLAN':");
+    expect(source).not.toContain('"PLAN":');
+  });
+
+  it('env.ts CORE_FILES does not contain PLAN.md', () => {
+    const source = fs.readFileSync(
+      path.join(ROOT, 'packages/create-principles-disciple/src/utils/env.ts'),
+      'utf8',
+    );
+    // Match 'PLAN.md' inside the CORE_FILES array — should not exist
+    expect(source).not.toMatch(/CORE_FILES\s*=\s*\[[\s\S]*?'PLAN\.md'/);
+  });
+
+  it('migration.ts does not migrate docs/PLAN.md', () => {
+    const source = fs.readFileSync(
+      path.join(ROOT, 'packages/openclaw-plugin/src/core/migration.ts'),
+      'utf8',
+    );
+    expect(source).not.toContain("'PLAN.md'");
+    expect(source).not.toContain("newKey: 'PLAN'");
+  });
+
+  // ── Round 2: Event type and state store full deletion ──
+
+  it('event-types.ts does not contain runtime_v2_confirm_first_gate', () => {
+    const source = fs.readFileSync(
+      path.join(ROOT, 'packages/principles-core/src/runtime-v2/types/event-types.ts'),
+      'utf8',
+    );
+    expect(source).not.toContain('runtime_v2_confirm_first_gate');
+    expect(source).not.toContain('RuntimeV2ConfirmFirstGate');
+  });
+
+  it('confirm-first state store source has been deleted', () => {
+    const storePath = path.join(
+      ROOT, 'packages/principles-core/src/runtime-v2/activation/sqlite-confirm-first-state-store.ts',
+    );
+    expect(fs.existsSync(storePath)).toBe(false);
+  });
+
+  it('confirm-first state store test has been deleted', () => {
+    const testPath = path.join(
+      ROOT, 'packages/principles-core/src/runtime-v2/__tests__/sqlite-confirm-first-state-store.test.ts',
+    );
+    expect(fs.existsSync(testPath)).toBe(false);
+  });
+});
+
+function findFiles(dir: string, filename: string): string[] {
+  const results: string[] = [];
+  function walk(d: string): void {
+    for (const entry of fs.readdirSync(d, { withFileTypes: true })) {
+      const full = path.join(d, entry.name);
+      if (entry.isDirectory()) {
+        walk(full);
+      } else if (entry.name === filename) {
+        results.push(full);
+      }
+    }
+  }
+  walk(dir);
+  return results;
+}