principles-disciple 1.79.0 → 1.81.0

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

@@ -0,0 +1,201 @@
+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);
+
+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([]);
+
+    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.');
+
+      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.',
+      );
+
+      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.',
+      );
+
+      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.',
+      );
+
+      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);
+
+      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', () => {
+      mockFs.existsSync.mockImplementation((p: string) => {
+        if (String(p).includes('.principles/skills')) 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.',
+      );
+
+      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', () => {
+      mockFs.existsSync.mockImplementation((p: string) => {
+        if (String(p).includes('.principles/skills')) 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/service/correction-observer-service.test.ts

@@ -0,0 +1,331 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+import * as fs from 'fs';
+import * as os from 'os';
+import * as path from 'path';
+import { WorkspaceContext } from '../../src/core/workspace-context.js';
+
+const mockLearner = {
+  getStore: vi.fn(() => ({ keywords: [{ term: 'wrong', weight: 0.5, hitCount: 3, truePositiveCount: 1, falsePositiveCount: 2 }] })),
+};
+
+const mockDb = {
+  listRecentSessions: vi.fn(() => [{ sessionId: 'session-1' }]),
+  listUserTurnsForSession: vi.fn(() => [{ rawExcerpt: 'User said wrong input', correctionDetected: true, correctionCue: 'wrong' }]),
+};
+
+const mockOptimizationService = {
+  buildTrajectoryHistory: vi.fn(async () => [
+    { sessionId: 'session-1', timestamp: 'now', term: 'wrong', userMessage: '' }
+  ]),
+  applyResult: vi.fn(),
+};
+
+vi.mock('../../src/core/correction-cue-learner.js', () => ({
+  CorrectionCueLearner: { get: vi.fn(() => mockLearner) },
+}));
+
+vi.mock('../../src/core/trajectory.js', () => ({
+  TrajectoryRegistry: {
+    get: vi.fn(() => mockDb),
+    clear: vi.fn(),
+  },
+}));
+
+vi.mock('../../src/service/keyword-optimization-service.js', () => ({
+  KeywordOptimizationService: { get: vi.fn(() => mockOptimizationService) },
+}));
+
+const mockDispatch = vi.fn().mockResolvedValue({
+  updated: true,
+  summary: 'Keyword store optimized',
+  updates: { wrong: { action: 'update', weight: 0.4, reasoning: 'slightly high FP' } }
+});
+
+const mockRegister = vi.fn();
+
+vi.mock('@principles/core/runtime-v2', () => {
+  return {
+    WorkflowFunnelLoader: class {
+      getFunnel = vi.fn(() => ({
+        policy: {
+          runtimeKind: 'pi-ai',
+          provider: 'anthropic',
+          model: 'anthropic/claude-3-5-sonnet',
+          apiKeyEnv: 'ANTHROPIC_API_KEY',
+          timeoutMs: 30000,
+        }
+      }));
+    },
+    PiAiRuntimeAdapter: class {},
+    CorrectionObserver: class {},
+    AgentScheduler: class {
+      register = mockRegister;
+      dispatch = mockDispatch;
+    }
+  };
+});
+
+import { CorrectionObserverService, runCorrectionObserverCycle } from '../../src/service/correction-observer-service.js';
+import { safeRmDir } from '../test-utils.js';
+
+describe('CorrectionObserverService — Independent Service (PRI-293)', () => {
+  beforeEach(() => {
+    vi.useFakeTimers();
+    vi.clearAllMocks();
+  });
+
+  afterEach(() => {
+    vi.useRealTimers();
+    CorrectionObserverService.stop?.({} as any);
+  });
+
+  it('has correct service id', () => {
+    expect(CorrectionObserverService.id).toBe('principles-correction-observer');
+  });
+
+  it('starts and schedules periodic cycles', async () => {
+    const workspaceDir = fs.mkdtempSync(path.join(os.tmpdir(), 'pd-corr-obs-'));
+    const stateDir = path.join(workspaceDir, '.state');
+    fs.mkdirSync(stateDir, { recursive: true });
+
+    const logger = { info: vi.fn(), warn: vi.fn(), error: vi.fn(), debug: vi.fn() };
+
+    try {
+      CorrectionObserverService.start({
+        workspaceDir,
+        stateDir,
+        logger,
+        config: { get: () => undefined },
+      } as any);
+
+      expect(logger.info).toHaveBeenCalledWith(
+        expect.stringContaining('[PD:CorrectionObserver] Starting')
+      );
+
+      await vi.advanceTimersByTimeAsync(10_000);
+      for (let i = 0; i < 20; i++) {
+        await Promise.resolve();
+      }
+
+      expect(mockRegister).toHaveBeenCalled();
+      expect(mockDispatch).toHaveBeenCalledWith('correction-observer', expect.objectContaining({
+        parentSessionId: 'correction-observer-service',
+        workspaceDir,
+        recentMessages: ['User said wrong input'],
+      }));
+
+      expect(mockOptimizationService.applyResult).toHaveBeenCalledWith(expect.objectContaining({
+        updated: true,
+        summary: 'Keyword store optimized',
+      }));
+    } finally {
+      CorrectionObserverService.stop?.({} as any);
+      safeRmDir(workspaceDir);
+    }
+  });
+
+  it('stops cleanly and cancels pending timer', () => {
+    const workspaceDir = fs.mkdtempSync(path.join(os.tmpdir(), 'pd-corr-obs-stop-'));
+    const stateDir = path.join(workspaceDir, '.state');
+    fs.mkdirSync(stateDir, { recursive: true });
+
+    const logger = { info: vi.fn(), warn: vi.fn(), error: vi.fn(), debug: vi.fn() };
+
+    try {
+      CorrectionObserverService.start({
+        workspaceDir,
+        stateDir,
+        logger,
+        config: { get: () => undefined },
+      } as any);
+
+      CorrectionObserverService.stop?.({} as any);
+
+      vi.advanceTimersByTime(30_000);
+
+      expect(mockDispatch).not.toHaveBeenCalled();
+    } finally {
+      safeRmDir(workspaceDir);
+    }
+  });
+
+  it('does not reschedule after stop during active cycle (P2 fix)', async () => {
+    const workspaceDir = fs.mkdtempSync(path.join(os.tmpdir(), 'pd-corr-obs-race-'));
+    const stateDir = path.join(workspaceDir, '.state');
+    fs.mkdirSync(stateDir, { recursive: true });
+
+    const logger = { info: vi.fn(), warn: vi.fn(), error: vi.fn(), debug: vi.fn() };
+
+    let cycleResolve: () => void;
+    const cyclePromise = new Promise<void>(r => { cycleResolve = r; });
+    mockDispatch.mockImplementationOnce(async () => {
+      cycleResolve!();
+      return { updated: false, summary: 'in-flight' };
+    });
+
+    try {
+      CorrectionObserverService.start({
+        workspaceDir,
+        stateDir,
+        logger,
+        config: { get: () => undefined },
+      } as any);
+
+      await vi.advanceTimersByTimeAsync(10_000);
+      await cyclePromise;
+
+      CorrectionObserverService.stop?.({} as any);
+
+      vi.advanceTimersByTime(15 * 60 * 1000 * 2);
+
+      expect(mockDispatch).toHaveBeenCalledTimes(1);
+    } finally {
+      CorrectionObserverService.stop?.({} as any);
+      safeRmDir(workspaceDir);
+    }
+  });
+
+  it('logs structured reason when workspaceDir is missing (ERR-002)', () => {
+    const logger = { info: vi.fn(), warn: vi.fn(), error: vi.fn(), debug: vi.fn() };
+
+    CorrectionObserverService.start({
+      workspaceDir: undefined as any,
+      logger,
+      config: { get: () => undefined },
+    } as any);
+
+    expect(logger.warn).toHaveBeenCalledWith(
+      expect.stringContaining('workspaceDir not found')
+    );
+  });
+
+  it('double start same workspace only dispatches one loop (P1 fix)', async () => {
+    const workspaceDir = fs.mkdtempSync(path.join(os.tmpdir(), 'pd-corr-dbl-'));
+    const stateDir = path.join(workspaceDir, '.state');
+    fs.mkdirSync(stateDir, { recursive: true });
+
+    const logger1 = { info: vi.fn(), warn: vi.fn(), error: vi.fn(), debug: vi.fn() };
+    const logger2 = { info: vi.fn(), warn: vi.fn(), error: vi.fn(), debug: vi.fn() };
+
+    try {
+      CorrectionObserverService.start({
+        workspaceDir,
+        stateDir,
+        logger: logger1,
+        config: { get: () => undefined },
+      } as any);
+
+      CorrectionObserverService.start({
+        workspaceDir,
+        stateDir,
+        logger: logger2,
+        config: { get: () => undefined },
+      } as any);
+
+      expect(logger2.info).toHaveBeenCalledWith(
+        expect.stringContaining('Already started')
+      );
+
+      await vi.advanceTimersByTimeAsync(10_000);
+      for (let i = 0; i < 20; i++) {
+        await Promise.resolve();
+      }
+
+      expect(mockDispatch).toHaveBeenCalledTimes(1);
+    } finally {
+      CorrectionObserverService.stop?.({} as any);
+      safeRmDir(workspaceDir);
+    }
+  });
+
+  it('stop after double start cancels all timers and allows clean restart', async () => {
+    const workspaceDir = fs.mkdtempSync(path.join(os.tmpdir(), 'pd-corr-stopdbl-'));
+    const stateDir = path.join(workspaceDir, '.state');
+    fs.mkdirSync(stateDir, { recursive: true });
+
+    const logger = { info: vi.fn(), warn: vi.fn(), error: vi.fn(), debug: vi.fn() };
+
+    try {
+      CorrectionObserverService.start({
+        workspaceDir,
+        stateDir,
+        logger,
+        config: { get: () => undefined },
+      } as any);
+
+      CorrectionObserverService.start({
+        workspaceDir,
+        stateDir,
+        logger,
+        config: { get: () => undefined },
+      } as any);
+
+      CorrectionObserverService.stop?.({} as any);
+
+      vi.advanceTimersByTime(30_000);
+
+      expect(mockDispatch).not.toHaveBeenCalled();
+
+      CorrectionObserverService.start({
+        workspaceDir,
+        stateDir,
+        logger,
+        config: { get: () => undefined },
+      } as any);
+
+      expect(logger.info).toHaveBeenCalledWith(
+        expect.stringContaining('[PD:CorrectionObserver] Starting')
+      );
+    } finally {
+      CorrectionObserverService.stop?.({} as any);
+      safeRmDir(workspaceDir);
+    }
+  });
+});
+
+describe('runCorrectionObserverCycle — Independent Execution', () => {
+  it('skips cycle when no recent sessions exist', async () => {
+    const workspaceDir = fs.mkdtempSync(path.join(os.tmpdir(), 'pd-corr-cycle-'));
+    const stateDir = path.join(workspaceDir, '.state');
+    fs.mkdirSync(stateDir, { recursive: true });
+
+    const wctx = WorkspaceContext.fromHookContext({ workspaceDir });
+    const logger = { info: vi.fn(), warn: vi.fn(), error: vi.fn(), debug: vi.fn() };
+
+    mockDb.listRecentSessions.mockReturnValueOnce([]);
+
+    try {
+      await runCorrectionObserverCycle(wctx, logger as any);
+
+      expect(logger.info).toHaveBeenCalledWith(
+        expect.stringContaining('No recent sessions found')
+      );
+      expect(mockDispatch).not.toHaveBeenCalled();
+    } finally {
+      safeRmDir(workspaceDir);
+    }
+  });
+
+  it('logs structured error on cycle failure (ERR-002)', async () => {
+    const workspaceDir = fs.mkdtempSync(path.join(os.tmpdir(), 'pd-corr-err-'));
+    const stateDir = path.join(workspaceDir, '.state');
+    fs.mkdirSync(stateDir, { recursive: true });
+
+    const wctx = WorkspaceContext.fromHookContext({ workspaceDir });
+    const logger = { info: vi.fn(), warn: vi.fn(), error: vi.fn(), debug: vi.fn() };
+
+    mockDb.listRecentSessions.mockImplementationOnce(() => {
+      throw new Error('DB connection failed');
+    });
+
+    try {
+      await runCorrectionObserverCycle(wctx, logger as any);
+
+      expect(logger.warn).toHaveBeenCalledWith(
+        expect.stringContaining('Correction observer cycle failed')
+      );
+    } finally {
+      safeRmDir(workspaceDir);
+    }
+  });
+});