principles-disciple 1.83.0 → 1.83.1

package/openclaw.plugin.json

@@ -2,7 +2,7 @@
   "id": "principles-disciple",
   "name": "Principles Disciple",
   "description": "Evolutionary programming agent framework with strategic guardrails and reflection loops.",
-  "version": "1.83.0",
+  "version": "1.83.1",
   "activation": {
     "onCapabilities": [
       "hook"

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "principles-disciple",
-  "version": "1.83.0",
+  "version": "1.83.1",
   "description": "Native OpenClaw plugin for Principles Disciple",
   "type": "module",
   "main": "./dist/bundle.js",

package/src/hooks/prompt.ts

@@ -192,7 +192,7 @@ export function loadContextInjectionConfig(workspaceDir: string): ContextInjecti
     const raw = cachedReadFile(profilePath);
     if (raw) {
       const profile = JSON.parse(raw);
-      if (profile.contextInjection) {
+      if (profile && typeof profile === 'object' && profile.contextInjection && typeof profile.contextInjection === 'object') {
         const contextInjection = profile.contextInjection as Partial<ContextInjectionConfig>;
         return {
           ...defaultContextConfig,
@@ -360,6 +360,9 @@ export async function handleBeforePromptBuild(
   }
 
   // ──── 1. prependSystemContext: Minimal Agent Identity ────
+  // EvolutionWorker-era INTERNAL SYSTEM LAYOUT removed per PRI-294.
+  // The EVOLUTION_WORKER PathResolver key and system layout reference are
+  // not MVP-Core; agents discover what they need via tool calls.
   prependSystemContext = `## 【AGENT IDENTITY】
 
 You are a **self-evolving AI agent** powered by Principles Disciple.
@@ -377,10 +380,6 @@ You are a **self-evolving AI agent** powered by Principles Disciple.
 - Use the current session for the normal user reply.
 - Use sessions_send for cross-session messaging.
 - Use agents_list / sessions_list for peer-agent or peer-session orchestration.
-
-## 🔧 INTERNAL SYSTEM LAYOUT
-- Your core plugin logic is rooted at: ${PathResolver.getExtensionRoot() || 'EXTENSION_ROOT (unresolved)'}
-- If you need self-inspection, prioritize the worker entry pointed by PathResolver key: EVOLUTION_WORKER
 `;
 
   // ──── 2. Empathy Observer Spawn (async sidecar)

package/src/index.ts

@@ -563,11 +563,12 @@ const plugin = {
       return handleAfterCompaction(event, { ...ctx, workspaceDir });
     }));
 
-    // ── Service: Background Evolution Worker ──
+    // ── Service Registration (surface-guarded) ──
+    // PRI-294: EvolutionWorker service registration removed — it starts via
+    // before_prompt_build hook gate, not via api.registerService. The surface
+    // guard already prevents registration when disabled (enabledByDefault=false).
+    // Dead pre-assignment of EvolutionWorkerService.api removed.
     try {
-      EvolutionWorkerService.api = api;
-      const guardedEvolutionWorker = guardService('service:evolution-worker', EvolutionWorkerService, api.logger);
-      if (guardedEvolutionWorker) api.registerService(guardedEvolutionWorker);
       const guardedCorrectionObserver = guardService('service:correction-observer', CorrectionObserverService, api.logger);
       if (guardedCorrectionObserver) api.registerService(guardedCorrectionObserver);
       const guardedTrajectory = guardService('service:trajectory', TrajectoryService, api.logger);

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

@@ -13,6 +13,15 @@ const mockFs = {
 
 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', () => {
@@ -41,6 +50,13 @@ describe('workspace-guidance-migrator', () => {
     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;
   });
@@ -63,6 +79,7 @@ describe('workspace-guidance-migrator', () => {
     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');
 
@@ -76,6 +93,14 @@ describe('workspace-guidance-migrator', () => {
       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');
 
@@ -88,6 +113,11 @@ describe('workspace-guidance-migrator', () => {
       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');
 
@@ -102,6 +132,11 @@ describe('workspace-guidance-migrator', () => {
       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');
 
@@ -126,6 +161,11 @@ describe('workspace-guidance-migrator', () => {
       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) => {
@@ -154,8 +194,9 @@ describe('workspace-guidance-migrator', () => {
     });
 
     it('discovers skill files in .principles/skills directory', () => {
+      const skillsPattern = path.join('.principles', 'skills');
       mockFs.existsSync.mockImplementation((p: string) => {
-        if (String(p).includes('.principles/skills')) return true;
+        if (String(p).includes(skillsPattern)) return true;
         return false;
       });
       mockFs.readdirSync.mockReturnValue([
@@ -165,6 +206,11 @@ describe('workspace-guidance-migrator', () => {
       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');
 
@@ -182,8 +228,9 @@ describe('workspace-guidance-migrator', () => {
     });
 
     it('handles skills directory read error gracefully', () => {
+      const skillsPattern = path.join('.principles', 'skills');
       mockFs.existsSync.mockImplementation((p: string) => {
-        if (String(p).includes('.principles/skills')) return true;
+        if (String(p).includes(skillsPattern)) return true;
         return false;
       });
       mockFs.readdirSync.mockImplementation(() => {

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/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);
     });
   });