principles-disciple 1.83.0 → 1.84.0

package/tests/evolution-worker-slimming.test.ts

@@ -0,0 +1,323 @@
+/**
+ * PRI-294: Split EvolutionWorker-era services into MVP hook adapters.
+ *
+ * Tests prove:
+ * 1. All guardHook/guardService surface IDs in index.ts exist in the registry.
+ * 2. CorrectionObserver starts independently of EvolutionWorker.
+ * 3. Core hooks are enabled; non-core hooks are disabled by default.
+ * 4. EvolutionWorker-era prompt injection has been removed.
+ * 5. EvolutionWorker service is NOT registered via api.registerService.
+ *
+ * ERR-024: dead validators/services must not appear as protection if not wired.
+ * ERR-025: tests must exercise production hook/service paths.
+ * ERR-027: registry/docs must match actual runtime surface.
+ */
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import * as fs from 'fs';
+import * as path from 'path';
+import * as os from 'os';
+import * as yaml from 'js-yaml';
+import { PLUGIN_SURFACE_REGISTRY, computeEffectiveFlags, DEFAULT_FEATURE_FLAGS } from '@principles/core/runtime-v2';
+
+// ── Helpers ──
+
+function createTempWorkspace(): string {
+  const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'pd-slimming-'));
+  fs.mkdirSync(path.join(dir, '.pd'), { recursive: true });
+  fs.mkdirSync(path.join(dir, '.state'), { recursive: true });
+  return dir;
+}
+
+function writeFeatureFlags(workspaceDir: string, flags: Record<string, unknown>): void {
+  const configPath = path.join(workspaceDir, '.pd', 'feature-flags.yaml');
+  const content = yaml.dump(flags, { schema: yaml.JSON_SCHEMA });
+  fs.writeFileSync(configPath, content, 'utf8');
+}
+
+function createMockLogger() {
+  return {
+    info: vi.fn(),
+    warn: vi.fn(),
+    error: vi.fn(),
+    debug: vi.fn(),
+  };
+}
+
+// Mock dependencies for service start tests
+vi.mock('../src/core/dictionary-service.js', () => ({
+  DictionaryService: { get: vi.fn(() => ({ flush: vi.fn() })) },
+}));
+
+vi.mock('../src/core/session-tracker.js', () => ({
+  initPersistence: vi.fn(),
+  flushAllSessions: vi.fn(),
+  listSessions: vi.fn(() => []),
+}));
+
+vi.mock('../src/core/workspace-context.js', () => {
+  const mockCtx = {
+    stateDir: '',
+    workspaceDir: '',
+    config: { get: vi.fn() },
+    eventLog: { recordHookExecution: vi.fn() },
+    dictionary: { flush: vi.fn() },
+    resolve: vi.fn((key: string) => `/mock/${key}`),
+    trajectory: null,
+  };
+  return {
+    WorkspaceContext: {
+      fromHookContext: vi.fn(() => mockCtx),
+      clearCache: vi.fn(),
+    },
+  };
+});
+
+// Import after mocks
+import { loadFeatureFlagFromWorkspace, shouldStartEvolutionWorker, shouldStartCorrectionObserver } from '../src/index.js';
+import { CorrectionObserverService } from '../src/service/correction-observer-service.js';
+
+// ── 1. Surface Registry Coverage Audit ──
+
+describe('PRI-294: Surface registry coverage audit', () => {
+  // Surface IDs actually used in index.ts guardHook/guardService calls
+  const USED_SURFACE_IDS = [
+    'hook:before_prompt_build',
+    'hook:before_tool_call',
+    'hook:after_tool_call',
+    'hook:llm_output',
+    'hook:after_tool_call.trajectory',
+    'hook:llm_output.trajectory',
+    'hook:subagent_spawning',
+    'hook:subagent_ended',
+    'hook:before_reset',
+    'hook:before_compaction',
+    'hook:after_compaction',
+    // Services registered via guardService
+    'service:correction-observer',
+    'service:trajectory',
+    'service:pd-task',
+    'service:central-sync',
+  ];
+
+  for (const surfaceId of USED_SURFACE_IDS) {
+    it(`used surface '${surfaceId}' exists in registry`, () => {
+      const entry = PLUGIN_SURFACE_REGISTRY.find(s => s.id === surfaceId);
+      expect(entry).toBeDefined();
+      expect(entry!.id).toBe(surfaceId);
+    });
+  }
+
+  it('all used surface IDs are accounted for (no orphan surfaces)', () => {
+    const registeredIds = new Set(PLUGIN_SURFACE_REGISTRY.map(s => s.id));
+    const usedButNotRegistered = USED_SURFACE_IDS.filter(id => !registeredIds.has(id));
+    expect(usedButNotRegistered).toEqual([]);
+  });
+
+  it('registry has no unexpected surfaces beyond what index.ts uses', () => {
+    const usedSet = new Set(USED_SURFACE_IDS);
+    // These are used but not directly via guardHook/guardService in the main hook path
+    const additionallyRegistered = [
+      'service:evolution-worker',  // Previously registered, now removed per PRI-294
+      'startup:workspace-init',
+      'startup:evolution-worker',
+      'startup:correction-observer',
+    ];
+    const allowedIds = new Set([...usedSet, ...additionallyRegistered]);
+    const unaccounted = PLUGIN_SURFACE_REGISTRY
+      .map(s => s.id)
+      .filter(id => !allowedIds.has(id));
+    // Unaccounted surfaces should be empty — every registry entry must trace to a caller
+    expect(unaccounted).toEqual([]);
+  });
+});
+
+// ── 2. CorrectionObserver Independence ──
+
+describe('PRI-294: CorrectionObserver independence from EvolutionWorker', () => {
+  let workspaceDir: string;
+
+  beforeEach(() => {
+    workspaceDir = createTempWorkspace();
+    CorrectionObserverService.stop?.({ logger: createMockLogger() });
+  });
+
+  afterEach(() => {
+    CorrectionObserverService.stop?.({ logger: createMockLogger() });
+    try {
+      fs.rmSync(workspaceDir, { recursive: true, force: true });
+    } catch {
+      // best-effort
+    }
+  });
+
+  it('CorrectionObserver starts when EvolutionWorker is disabled (default)', () => {
+    const logger = createMockLogger();
+
+    // Verify EvolutionWorker is disabled
+    const ewGate = shouldStartEvolutionWorker(workspaceDir, logger);
+    expect(ewGate.shouldStart).toBe(false);
+
+    // Verify CorrectionObserver is enabled
+    const coGate = shouldStartCorrectionObserver(workspaceDir, logger);
+    expect(coGate.shouldStart).toBe(true);
+    expect(coGate.disabledInfo).toBeNull();
+  });
+
+  it('CorrectionObserver starts when EvolutionWorker is explicitly enabled', () => {
+    writeFeatureFlags(workspaceDir, {
+      evolution_worker: { enabled: true },
+    });
+    const logger = createMockLogger();
+
+    const ewGate = shouldStartEvolutionWorker(workspaceDir, logger);
+    expect(ewGate.shouldStart).toBe(true);
+
+    const coGate = shouldStartCorrectionObserver(workspaceDir, logger);
+    expect(coGate.shouldStart).toBe(true);
+  });
+
+  it('CorrectionObserver can be independently disabled', () => {
+    writeFeatureFlags(workspaceDir, {
+      correction_observer: { enabled: false },
+    });
+    const logger = createMockLogger();
+
+    const coGate = shouldStartCorrectionObserver(workspaceDir, logger);
+    expect(coGate.shouldStart).toBe(false);
+    expect(coGate.disabledInfo).not.toBeNull();
+  });
+});
+
+// ── 3. Core vs Non-Core Surface Defaults ──
+
+describe('PRI-294: MVP core hooks enabled, non-core disabled', () => {
+  const CORE_HOOKS = [
+    'hook:before_prompt_build',
+    'hook:before_tool_call',
+    'hook:after_tool_call',
+    'hook:llm_output',
+  ];
+
+  const QUIET_HOOKS = [
+    'hook:after_tool_call.trajectory',
+    'hook:llm_output.trajectory',
+    'hook:subagent_spawning',
+    'hook:subagent_ended',
+    'hook:before_reset',
+    'hook:before_compaction',
+    'hook:after_compaction',
+  ];
+
+  for (const surfaceId of CORE_HOOKS) {
+    it(`core hook '${surfaceId}' is enabled by default`, () => {
+      const entry = PLUGIN_SURFACE_REGISTRY.find(s => s.id === surfaceId);
+      expect(entry).toBeDefined();
+      expect(entry!.category).toBe('core');
+      expect(entry!.enabledByDefault).toBe(true);
+    });
+  }
+
+  for (const surfaceId of QUIET_HOOKS) {
+    it(`quiet hook '${surfaceId}' is disabled by default`, () => {
+      const entry = PLUGIN_SURFACE_REGISTRY.find(s => s.id === surfaceId);
+      expect(entry).toBeDefined();
+      expect(entry!.category).toBe('quiet');
+      expect(entry!.enabledByDefault).toBe(false);
+    });
+  }
+
+  it('CorrectionObserver service surface is core and enabled', () => {
+    const entry = PLUGIN_SURFACE_REGISTRY.find(s => s.id === 'service:correction-observer');
+    expect(entry).toBeDefined();
+    expect(entry!.category).toBe('core');
+    expect(entry!.enabledByDefault).toBe(true);
+  });
+
+  it('EvolutionWorker service surface is quiet and disabled', () => {
+    const entry = PLUGIN_SURFACE_REGISTRY.find(s => s.id === 'service:evolution-worker');
+    expect(entry).toBeDefined();
+    expect(entry!.category).toBe('quiet');
+    expect(entry!.enabledByDefault).toBe(false);
+    expect(entry!.disabledReason).toBeDefined();
+  });
+
+  it('all disabled surfaces have disabledReason (ERR-002 observability)', () => {
+    const disabledWithoutReason = PLUGIN_SURFACE_REGISTRY.filter(
+      s => !s.enabledByDefault && s.category !== 'core' && !s.disabledReason,
+    );
+    expect(disabledWithoutReason).toEqual([]);
+  });
+});
+
+// ── 4. EvolutionWorker-era prompt injection removed ──
+
+describe('PRI-294: EvolutionWorker-era prompt injection removed', () => {
+  it('prompt.ts does not inject EVOLUTION_WORKER key into agent prompt', async () => {
+    const promptPath = path.resolve(__dirname, '../src/hooks/prompt.ts');
+    const src = fs.readFileSync(promptPath, 'utf-8');
+    // Check that the EVOLUTION_WORKER PathResolver key is not injected into
+    // the prependSystemContext template string (the runtime prompt).
+    // Comments referencing EVOLUTION_WORKER for documentation are fine.
+    // Match: inside template literal interpolation that resolves EVOLUTION_WORKER
+    expect(src).not.toMatch(/\$\{.*EVOLUTION_WORKER.*\}/);
+    // Also check no template literal contains "PathResolver key: EVOLUTION_WORKER"
+    expect(src).not.toContain('PathResolver key: EVOLUTION_WORKER');
+  });
+
+  it('prompt.ts does not inject INTERNAL SYSTEM LAYOUT section into prompt', async () => {
+    const promptPath = path.resolve(__dirname, '../src/hooks/prompt.ts');
+    const src = fs.readFileSync(promptPath, 'utf-8');
+    // The INTERNAL SYSTEM LAYOUT section was EvolutionWorker-era injection.
+    // Verify the actual rendered section header is gone — only comments should remain.
+    // Remove all single-line comments, then check no INTERNAL SYSTEM LAYOUT in code.
+    const withoutComments = src.replace(/\/\/.*$/gm, '');
+    expect(withoutComments).not.toContain('INTERNAL SYSTEM LAYOUT');
+  });
+});
+
+// ── 5. EvolutionWorker NOT registered via api.registerService ──
+
+describe('PRI-294: EvolutionWorker not registered as service', () => {
+  it('index.ts does not register EvolutionWorker via api.registerService', async () => {
+    const indexPath = path.resolve(__dirname, '../src/index.ts');
+    const src = fs.readFileSync(indexPath, 'utf-8');
+    // Should NOT have guardService('service:evolution-worker', ...)
+    expect(src).not.toMatch(/guardService\(\s*['"]service:evolution-worker['"]/);
+  });
+
+  it('index.ts does not pre-assign EvolutionWorkerService.api outside gate', async () => {
+    const indexPath = path.resolve(__dirname, '../src/index.ts');
+    const src = fs.readFileSync(indexPath, 'utf-8');
+    // The only EvolutionWorkerService.api assignment should be inside the gate
+    const apiAssignments = src.match(/EvolutionWorkerService\.api\s*=\s*api/g) ?? [];
+    // Should be exactly one: inside the shouldStartEvolutionWorker gate
+    expect(apiAssignments.length).toBe(1);
+  });
+});
+
+// ── 6. Feature flag registry completeness ──
+
+describe('PRI-294: Feature flag registry matches surface registry', () => {
+  it('evolution_worker flag exists in DEFAULT_FEATURE_FLAGS as quiet+disabled', () => {
+    const flag = DEFAULT_FEATURE_FLAGS.find(f => f.id === 'evolution_worker');
+    expect(flag).toBeDefined();
+    expect(flag!.category).toBe('quiet');
+    expect(flag!.enabled).toBe(false);
+  });
+
+  it('correction_observer flag exists in DEFAULT_FEATURE_FLAGS', () => {
+    const flag = DEFAULT_FEATURE_FLAGS.find(f => f.id === 'correction_observer');
+    expect(flag).toBeDefined();
+    expect(flag!.enabled).toBe(true);
+  });
+
+  it('nocturnal and idle_trigger are gone flags', () => {
+    const nocturnal = DEFAULT_FEATURE_FLAGS.find(f => f.id === 'nocturnal');
+    expect(nocturnal).toBeDefined();
+    expect(nocturnal!.category).toBe('gone');
+
+    const idle = DEFAULT_FEATURE_FLAGS.find(f => f.id === 'idle_trigger');
+    expect(idle).toBeDefined();
+    expect(idle!.category).toBe('gone');
+  });
+});

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

@@ -7,36 +7,44 @@ const INDEX_TS = fs.readFileSync(
   'utf-8',
 );
 
+const WORKSPACE_RESOLVER_TS = fs.readFileSync(
+  path.resolve(__dirname, '../src/utils/workspace-resolver.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('no stale HOOK_WORKSPACE_RESOLUTION_NEXT_ACTION constant remains', () => {
+    const constantMatch = INDEX_TS.match(/HOOK_WORKSPACE_RESOLUTION_NEXT_ACTION/);
+    expect(constantMatch).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('resolveHookWorkspaceDir failure result includes PD canonical config in nextAction', () => {
+    const nextActionMatch = WORKSPACE_RESOLVER_TS.match(
+      /nextAction:\s*'([^']+)'/s,
+    );
+    expect(nextActionMatch).not.toBeNull();
+    const nextAction = nextActionMatch![1];
+    expect(nextAction).toContain('PD_WORKSPACE_DIR');
+    expect(nextAction).toContain('principles-disciple.json');
   });
 
-  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('all hook failure paths use resolveHookWorkspaceDir with structured nextAction', () => {
+    const hookUsages = INDEX_TS.match(/resolveHookWorkspaceDir\(/g);
+    expect(hookUsages).not.toBeNull();
+    expect(hookUsages!.length).toBeGreaterThanOrEqual(6);
+
+    const wsResultOkChecks = INDEX_TS.match(/!wsResult\.ok/g);
+    expect(wsResultOkChecks).not.toBeNull();
+    expect(wsResultOkChecks!.length).toBeGreaterThanOrEqual(6);
+
+    const nextActionRefs = INDEX_TS.match(/wsResult\.nextAction/g);
+    expect(nextActionRefs).not.toBeNull();
+    expect(nextActionRefs!.length).toBeGreaterThanOrEqual(6);
   });
 
-  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);
-    }
+  it('resolveHookWorkspaceDir failure result has reason and nextAction fields', () => {
+    expect(WORKSPACE_RESOLVER_TS).toContain("reason: 'workspace_dir_unresolvable'");
+    expect(WORKSPACE_RESOLVER_TS).toContain('nextAction:');
+    expect(WORKSPACE_RESOLVER_TS).toContain('PD_WORKSPACE_DIR');
   });
 });

package/tests/integration/mvp-surface-registry-guard.test.ts

@@ -200,12 +200,21 @@ describe('MVP Surface Registry Guard (PRI-289)', () => {
       expect(unclassified).toEqual([]);
     });
 
-    it('total service registrations match expected count', () => {
+    it('registered service IDs match expected MVP set', () => {
+      // Quiet/disabled services (e.g. evolution-worker per PRI-294) exist in the
+      // registry but are NOT registered via guardService in index.ts.
       const source = read('packages/openclaw-plugin/src/index.ts');
       const registrations = extractServiceRegistrations(source);
 
-      const registryServiceCount = PLUGIN_SURFACE_REGISTRY.filter(s => s.kind === 'service').length;
-      expect(registrations.length).toBe(registryServiceCount);
+      const registeredIds = registrations.map(r => r.surfaceId).sort();
+      const expectedIds = [
+        'service:central-sync',
+        'service:correction-observer',
+        'service:pd-task',
+        'service:trajectory',
+      ].sort();
+
+      expect(registeredIds).toEqual(expectedIds);
     });
   });