principles-disciple 1.72.0 → 1.74.0

package/tests/index.test.ts

@@ -1,9 +1,102 @@
 import { describe, it, expect } from 'vitest';
 import plugin from '../src/index';
+import type { PluginCommandDefinition, OpenClawPluginApi, PluginCommandContext } from '../src/openclaw-sdk.js';
+
+function createMockApi(): { registeredCommands: PluginCommandDefinition[]; api: OpenClawPluginApi } {
+  const registeredCommands: PluginCommandDefinition[] = [];
+  const api: OpenClawPluginApi = {
+    rootDir: '/mock',
+    pluginConfig: { language: 'en' },
+    logger: {
+      debug: () => {},
+      info: () => {},
+      warn: () => {},
+      error: () => {},
+    },
+    config: {},
+    registerCommand: (cmd: PluginCommandDefinition) => {
+      registeredCommands.push(cmd);
+    },
+    registerService: () => {},
+    registerTool: () => {},
+    registerHttpRoute: () => {},
+    on: () => {},
+  };
+  return { registeredCommands, api };
+}
 
 describe('OpenClaw Plugin Scaffolding', () => {
   it('should export a valid register function', () => {
     expect(plugin).toBeDefined();
     expect(typeof plugin.register).toBe('function');
   });
-});
+});
+
+describe('Command Registration', () => {
+  it('registers /pd-pain with acceptsArgs: true', () => {
+    const { registeredCommands, api } = createMockApi();
+    plugin.register(api);
+
+    const pdPain = registeredCommands.find((c) => c.name === 'pd-pain');
+    expect(pdPain).toBeDefined();
+    expect(pdPain!.acceptsArgs).toBe(true);
+  });
+
+  it('registers /pd-pain handler as async (always returns Promise)', async () => {
+    const { registeredCommands, api } = createMockApi();
+    plugin.register(api);
+
+    const pdPain = registeredCommands.find((c) => c.name === 'pd-pain');
+    expect(pdPain).toBeDefined();
+
+    const ctx: PluginCommandContext = {
+      sessionId: 'session-123',
+      sessionKey: 'sk-123',
+      args: 'test pain reason',
+      config: { workspaceDir: '/mock', language: 'en' },
+    };
+
+    const result = pdPain!.handler(ctx);
+    expect(result).toBeInstanceOf(Promise);
+    await result;
+  });
+
+  it('returns error result when workspace resolution fails', async () => {
+    const { registeredCommands, api } = createMockApi();
+    plugin.register(api);
+
+    const pdPain = registeredCommands.find((c) => c.name === 'pd-pain');
+    expect(pdPain).toBeDefined();
+
+    const ctx: PluginCommandContext = {
+      sessionId: '',
+      sessionKey: '',
+      args: 'test pain reason',
+      config: { language: 'en' },
+    };
+
+    const result = await pdPain!.handler(ctx);
+    expect(result).toBeDefined();
+    expect(result.text).toBeDefined();
+  });
+
+  it('passes workspaceDir to handler even when ctx.config is undefined', async () => {
+    const { registeredCommands, api } = createMockApi();
+    plugin.register(api);
+
+    const pdPain = registeredCommands.find((c) => c.name === 'pd-pain');
+    expect(pdPain).toBeDefined();
+
+    const ctx: PluginCommandContext = {
+      sessionId: 'session-123',
+      sessionKey: 'sk-123',
+      workspaceDir: '/mock/workspace',
+      args: 'test pain reason',
+    };
+
+    const result = await pdPain!.handler(ctx);
+    expect(result).toBeDefined();
+    expect(result.text).toBeDefined();
+    expect(ctx.workspaceDir).toBe('/mock/workspace');
+  });
+});

package/tests/integration/auto-entry-gate.test.ts

@@ -0,0 +1,248 @@
+/**
+ * Auto-Entry Gate Integration Tests
+ *
+ * Verifies that the PainDiagnosticGate → emitPainDetectedEvent → PainSignalBridge
+ * path behaves correctly under various conditions.
+ *
+ * TC1: Trivial tool failure → no diagnosis (GFI below threshold)
+ * TC2: Repeated failures → diagnosis triggered
+ * TC3: High GFI event → enters Runtime V2
+ * TC4: Gate rejection → structured log with gfi, reason, threshold
+ */
+
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import * as fs from 'fs';
+import * as path from 'path';
+import { handleAfterToolCall } from '../../src/hooks/pain.js';
+import { WorkspaceContext } from '../../src/core/workspace-context.js';
+import { EventLogService } from '../../src/core/event-log.js';
+import { resetPainDiagnosticGateForTest, evaluatePainDiagnosticGate } from '../../src/core/pain-diagnostic-gate.js';
+import * as ioUtils from '../../src/utils/io.js';
+
+vi.mock('fs');
+vi.mock('../../src/utils/io.js');
+vi.mock('../../src/core/evolution-engine.js', () => ({
+  recordEvolutionSuccess: vi.fn(),
+  recordEvolutionFailure: vi.fn(),
+}));
+vi.mock('../../src/core/evolution-logger.js', () => ({
+  createTraceId: vi.fn(() => 'trace-123'),
+  getEvolutionLogger: vi.fn(() => ({
+    logPainDetected: vi.fn(),
+  })),
+}));
+
+const mockEmitSync = vi.fn();
+const mockRecordProbationFeedback = vi.fn();
+const mockUpdatePrincipleValueMetrics = vi.fn();
+
+describe('Auto-Entry Gate Integration', () => {
+  const workspaceDir = '/mock/workspace';
+  const mockEventLog = {
+    recordToolCall: vi.fn(),
+    recordPainSignal: vi.fn(),
+  };
+  const mockConfig = {
+    get: vi.fn().mockReturnValue(30),
+  };
+
+  const mockWctx = {
+    workspaceDir,
+    stateDir: '/mock/state',
+    config: mockConfig,
+    eventLog: mockEventLog,
+    trajectory: {
+      recordToolCall: vi.fn(),
+      recordPainEvent: vi.fn(),
+    },
+    principleTreeLedger: {
+      updatePrincipleValueMetrics: mockUpdatePrincipleValueMetrics,
+    },
+    evolutionReducer: {
+      emitSync: mockEmitSync,
+      recordProbationFeedback: mockRecordProbationFeedback,
+      getPrincipleById: vi.fn().mockReturnValue(null),
+      getActivePrinciples: vi.fn().mockReturnValue([]),
+    },
+    resolve: vi.fn().mockImplementation((key) => {
+      if (key === 'PROFILE') return path.join(workspaceDir, '.principles', 'PROFILE.json');
+      return '';
+    }),
+  };
+
+  beforeEach(() => {
+    vi.clearAllMocks();
+    mockEmitSync.mockReset();
+    mockRecordProbationFeedback.mockReset();
+    mockUpdatePrincipleValueMetrics.mockReset();
+    vi.spyOn(WorkspaceContext, 'fromHookContext').mockReturnValue(mockWctx as any);
+    vi.spyOn(EventLogService, 'get').mockReturnValue(mockEventLog as any);
+    vi.spyOn(fs, 'existsSync').mockReturnValue(false);
+    resetPainDiagnosticGateForTest();
+  });
+
+  afterEach(() => {
+    vi.restoreAllMocks();
+  });
+
+  // ── TC1: Trivial tool failure → no diagnosis ─────────────────────────
+
+  it('TC1: trivial tool failure does not trigger diagnosis (GFI below threshold)', () => {
+    const mockCtx = { workspaceDir, sessionId: 's-tc1', api: { logger: {} } };
+    const mockEvent = {
+      toolName: 'write',
+      params: { file_path: 'src/utils.ts' },
+      error: 'Permission denied',
+      result: { exitCode: 1 },
+    };
+
+    vi.mocked(ioUtils.normalizePath).mockReturnValue('src/utils.ts');
+    vi.mocked(ioUtils.isRisky).mockReturnValue(false);
+
+    handleAfterToolCall(mockEvent as any, mockCtx as any);
+
+    // No pain_detected event should be emitted
+    expect(mockEmitSync).not.toHaveBeenCalled();
+    expect(mockEventLog.recordPainSignal).not.toHaveBeenCalled();
+    expect(mockWctx.trajectory.recordPainEvent).not.toHaveBeenCalled();
+  });
+
+  // ── TC2: Repeated failures → diagnosis triggered ──────────────────────
+
+  it('TC2: repeated same-file write failures trigger diagnosis', () => {
+    const mockCtx = { workspaceDir, sessionId: 's-tc2', api: { logger: {} } };
+    const mockEvent = {
+      toolName: 'write',
+      params: { file_path: 'src/main.ts' },
+      error: 'EACCES: permission denied',
+      result: { exitCode: 1 },
+    };
+
+    vi.mocked(ioUtils.normalizePath).mockReturnValue('src/main.ts');
+    vi.mocked(ioUtils.isRisky).mockReturnValue(false);
+
+    // First failure — accumulates GFI, does not emit
+    handleAfterToolCall(mockEvent as any, mockCtx as any);
+    expect(mockEmitSync).not.toHaveBeenCalled();
+
+    // Second failure — repeated, should emit
+    handleAfterToolCall(mockEvent as any, mockCtx as any);
+
+    expect(mockEmitSync).toHaveBeenCalledWith(
+      expect.objectContaining({
+        type: 'pain_detected',
+        data: expect.objectContaining({
+          painType: 'tool_failure',
+          source: 'write',
+          reason: expect.stringContaining('diagnosticGate=high_gfi'),
+        }),
+      }),
+    );
+  });
+
+  // ── TC3: High GFI event → enters Runtime V2 ───────────────────────────
+
+  it('TC3: high GFI event enters Runtime V2 via PainDiagnosticGate', () => {
+    const decision = evaluatePainDiagnosticGate({
+      source: 'tool_failure',
+      score: 60,
+      currentGfi: 80,
+      consecutiveErrors: 3,
+      sessionId: 's-tc3',
+    });
+
+    expect(decision).toMatchObject({
+      shouldDiagnose: true,
+      reason: 'high_gfi',
+    });
+    expect(decision.detail).toContain('GFI');
+  });
+
+  it('TC3: risky high-score operation enters Runtime V2', () => {
+    const decision = evaluatePainDiagnosticGate({
+      source: 'tool_failure',
+      score: 75,
+      currentGfi: 0,
+      isRisky: true,
+      sessionId: 's-tc3-risky',
+    });
+
+    expect(decision).toMatchObject({
+      shouldDiagnose: true,
+      reason: 'risky_high_score',
+    });
+  });
+
+  // ── TC4: Gate rejection structured log ─────────────────────────────────
+
+  it('TC4: gate rejection produces structured detail with gfi and reason', () => {
+    const decision = evaluatePainDiagnosticGate({
+      source: 'tool_failure',
+      score: 50,
+      currentGfi: 32,
+      consecutiveErrors: 1,
+      sessionId: 's-tc4',
+    });
+
+    expect(decision).toMatchObject({
+      shouldDiagnose: false,
+      reason: 'below_gate',
+    });
+
+    // The detail string contains score and gfi
+    expect(decision.detail).toContain('score=50');
+    expect(decision.detail).toContain('gfi=32');
+  });
+
+  it('TC4: gate rejection on low-signal subagent error', () => {
+    const decision = evaluatePainDiagnosticGate({
+      source: 'subagent_error',
+      score: 30,
+      currentGfi: 0,
+      sessionId: 's-tc4-subagent',
+    });
+
+    expect(decision).toMatchObject({
+      shouldDiagnose: false,
+      reason: 'below_gate',
+    });
+  });
+
+  // ── Manual pain bypasses gate ──────────────────────────────────────────
+
+  it('manual pain always bypasses gate (except cooldown)', () => {
+    const decision = evaluatePainDiagnosticGate({
+      source: 'manual',
+      score: 1,
+      currentGfi: 0,
+      sessionId: 's-manual',
+    });
+
+    expect(decision).toMatchObject({
+      shouldDiagnose: true,
+      reason: 'manual',
+    });
+  });
+
+  // ── Cooldown deduplication ─────────────────────────────────────────────
+
+  it('cooldown prevents duplicate diagnosis within window', () => {
+    const input = {
+      source: 'tool_failure',
+      score: 50,
+      currentGfi: 80,
+      sessionId: 's-cooldown',
+      errorHash: 'same-error',
+      nowMs: 1_000,
+    };
+
+    const first = evaluatePainDiagnosticGate(input);
+    expect(first.shouldDiagnose).toBe(true);
+
+    const second = evaluatePainDiagnosticGate({ ...input, nowMs: 2_000 });
+    expect(second).toMatchObject({
+      shouldDiagnose: false,
+      reason: 'cooldown',
+    });
+  });
+});

package/tests/integration/internalization-trigger-guard.test.ts

@@ -0,0 +1,69 @@
+/**
+ * Internalization Trigger Adapter - Integration Guards (PRI-63)
+ *
+ * Verifies plugin-level architecture constraints:
+ * - adapter does not import nocturnal-trinity / runTrinity
+ * - adapter does not write .pain_flag or subagent_workflows
+ * - wake() is read-only (no mutating store calls)
+ * - adapter reuses TaskRecord/PITaskRecord (no second task model)
+ */
+
+import { describe, it, expect } from 'vitest';
+import { readFileSync } from 'fs';
+import { resolve } from 'path';
+import type { TaskRecord } from '@principles/core/runtime-v2';
+
+describe('Internalization Trigger Adapter — Integration Guards', () => {
+  const adapterSrc = () =>
+    readFileSync(
+      resolve(__dirname, '../../src/service/internalization-trigger-adapter.ts'),
+      'utf8',
+    );
+
+  it('adapter source does not import nocturnal-trinity', () => {
+    expect(adapterSrc()).not.toContain('nocturnal-trinity');
+  });
+
+  it('adapter source does not import runTrinity or runTrinityAsync', () => {
+    const src = adapterSrc();
+    expect(src).not.toContain('runTrinity');
+    expect(src).not.toContain('runTrinityAsync');
+  });
+
+  it('adapter source does not import Dreamer/Philosopher/Scribe executors', () => {
+    const src = adapterSrc();
+    expect(src).not.toContain("from 'dreamer'");
+    expect(src).not.toContain("from 'philosopher'");
+    expect(src).not.toContain("from 'scribe'");
+    expect(src).not.toContain("from 'artificer'");
+  });
+
+  it('adapter source does not call PDRuntimeAdapter', () => {
+    expect(adapterSrc()).not.toContain('PDRuntimeAdapter');
+  });
+
+  it('adapter source does not write .pain_flag', () => {
+    const src = adapterSrc();
+    expect(src).not.toContain('.pain_flag');
+    expect(src).not.toContain('pain_flag');
+  });
+
+  it('adapter source does not write subagent_workflows', () => {
+    const src = adapterSrc();
+    expect(src).not.toContain('subagent_workflows');
+  });
+
+  it('adapter imports TaskRecord type from @principles/core/runtime-v2', () => {
+    expect(adapterSrc()).toContain('TaskRecord');
+    expect(adapterSrc()).toContain('@principles/core/runtime-v2');
+  });
+
+  it('adapter source does not use node:fs/node:path directly (provider abstraction)', () => {
+    const src = adapterSrc();
+    // node:fs and node:path should not appear in adapter source
+    expect(src).not.toContain("from 'node:fs'");
+    expect(src).not.toContain('from "node:fs"');
+    expect(src).not.toContain("from 'node:path'");
+    expect(src).not.toContain('from "node:path"');
+  });
+});

package/tests/integration/m8-legacy-paths.test.ts

@@ -0,0 +1,63 @@
+import { describe, test, expect } from 'vitest';
+import * as fs from 'fs';
+import * as path from 'path';
+
+const ROOT = path.join(__dirname, '../../../..');
+
+function readFile(relativePath: string): string {
+  return fs.readFileSync(path.join(ROOT, relativePath), 'utf-8');
+}
+
+describe('M8: Legacy diagnostician/cron/subagent paths disabled', () => {
+  test('does NOT register createWritePainFlagTool', () => {
+    const index = readFile('packages/openclaw-plugin/src/index.ts');
+    expect(index).not.toMatch(/createWritePainFlagTool/);
+  });
+
+  test('does NOT have empathy-optimizer in BUILTIN_PD_TASKS', () => {
+    const content = readFile('packages/openclaw-plugin/src/core/pd-task-types.ts');
+    expect(content).not.toMatch(/empathy-optimizer/);
+  });
+
+  test('does NOT have empathy-optimizer case in buildTaskPrompt', () => {
+    const content = readFile('packages/openclaw-plugin/src/core/pd-task-reconciler.ts');
+    expect(content).not.toMatch(/case 'empathy-optimizer'/);
+  });
+
+  test('does NOT have EmpathyObserverWorkflowManager in prompt.ts active code', () => {
+    const content = readFile('packages/openclaw-plugin/src/hooks/prompt.ts');
+    // Only check for actual usage (not comments)
+    const uncommented = content.replace(/\/\/.*$/mg, '').replace(/\/\*[\s\S]*?\*\//g, '');
+    expect(uncommented).not.toMatch(/EmpathyObserverWorkflowManager/);
+  });
+
+  test('does NOT have EmpathyObserverWorkflowManager import in subagent.ts', () => {
+    const content = readFile('packages/openclaw-plugin/src/hooks/subagent.ts');
+    expect(content).not.toMatch(/EmpathyObserverWorkflowManager/);
+  });
+
+  test('does NOT have empathy-observer case in subagent.ts active code', () => {
+    const content = readFile('packages/openclaw-plugin/src/hooks/subagent.ts');
+    const uncommented = content.replace(/\/\/.*$/mg, '');
+    expect(uncommented).not.toMatch(/empathy-observer/);
+  });
+
+  test('PD task reconciliation does NOT create PD Empathy Optimizer cron job', () => {
+    const content = readFile('packages/openclaw-plugin/src/core/pd-task-types.ts');
+    // BUILTIN_PD_TASKS should be empty array
+    const match = content.match(/BUILTIN_PD_TASKS\s*:\s*PDTaskSpec\[\]\s*=\s*\[\s*\]/);
+    expect(match).not.toBeNull();
+  });
+
+  test('pain signal calls PainSignalBridge.emit via evolutionReducer', () => {
+    const content = readFile('packages/openclaw-plugin/src/hooks/pain.ts');
+    expect(content).toMatch(/emitPainDetectedEvent/);
+    expect(content).toMatch(/evolutionReducer\.emitSync/);
+  });
+
+  test('empathy keyword matcher is still functional (kept capability)', () => {
+    const content = readFile('packages/openclaw-plugin/src/core/empathy-keyword-matcher.ts');
+    expect(content).toMatch(/matchEmpathyKeywords/);
+    expect(content).toMatch(/loadKeywordStore/);
+  });
+});

package/tests/integration/runtime-v2-pain-guard.test.ts

@@ -0,0 +1,125 @@
+import { describe, expect, it } from 'vitest';
+import * as fs from 'fs';
+import * as path from 'path';
+
+// Find repo root by walking up from cwd until we find .git
+function findRepoRoot(cwd: string): string {
+  let dir = cwd;
+  while (dir !== path.dirname(dir)) {
+    if (fs.existsSync(path.join(dir, '.git'))) {
+      return dir;
+    }
+    dir = path.dirname(dir);
+  }
+  return cwd;
+}
+
+const repoRoot = findRepoRoot(process.cwd());
+
+function read(relativePath: string): string {
+  return fs.readFileSync(path.join(repoRoot, relativePath), 'utf8');
+}
+
+function listSourceFiles(dir: string): string[] {
+  const absDir = path.join(repoRoot, dir);
+  const result: string[] = [];
+  for (const entry of fs.readdirSync(absDir, { withFileTypes: true })) {
+    const absPath = path.join(absDir, entry.name);
+    const relPath = path.relative(repoRoot, absPath).replace(/\\/g, '/');
+    if (entry.isDirectory()) {
+      result.push(...listSourceFiles(relPath));
+    } else if (entry.isFile() && relPath.endsWith('.ts')) {
+      result.push(relPath);
+    }
+  }
+  return result;
+}
+
+describe('Runtime V2 pain entrypoint guard', () => {
+  it('does not keep active pain flag writer APIs in openclaw-plugin/src', () => {
+    const offenders = listSourceFiles('packages/openclaw-plugin/src')
+      .filter((file) => read(file).match(/\b(writePainFlag|recordAndWritePainFlag)\b/));
+
+    expect(offenders).toEqual([]);
+  });
+
+  it('does not actively write .pain_flag from openclaw-plugin/src', () => {
+    const writePatterns = [
+      /writeFileSync\s*\([^)]*painFlagPath/s,
+      /appendFileSync\s*\([^)]*painFlagPath/s,
+      /atomicWriteFileSync\s*\([^)]*painFlagPath/s,
+      /createWriteStream\s*\([^)]*painFlagPath/s,
+    ];
+    const offenders = listSourceFiles('packages/openclaw-plugin/src')
+      .filter((file) => writePatterns.some((pattern) => pattern.test(read(file))));
+
+    expect(offenders).toEqual([]);
+  });
+
+  it('pd pain record enters PainToPrincipleService directly', () => {
+    const source = read('packages/pd-cli/src/commands/pain-record.ts');
+
+    expect(source).toMatch(/PainToPrincipleService/);
+    expect(source).toMatch(/service\.recordPain/);
+    expect(source).not.toMatch(/createPainSignalBridge/);
+    expect(source).not.toMatch(/\.pain_flag|PAIN_FLAG|writePainFlag/);
+  });
+
+  it('after_tool_call failure emits Runtime V2 pain event instead of writing .pain_flag', () => {
+    const source = read('packages/openclaw-plugin/src/hooks/pain.ts');
+
+    expect(source).toMatch(/emitPainDetectedEvent\(wctx,\s*\{/);
+    expect(source).toMatch(/type:\s*'pain_detected'/);
+    expect(source).toMatch(/PainToPrincipleService/);
+    // Verify it calls createPainToPrincipleService (the factory function inside pain.ts)
+    expect(source).toMatch(/createPainToPrincipleService\(/);
+    // Verify it does NOT call createPainSignalBridge (legacy factory)
+    expect(source).not.toMatch(/createPainSignalBridge\(/);
+    expect(source).not.toMatch(/writePainFlag|recordAndWritePainFlag/);
+    expect(source).not.toMatch(/writeFileSync\s*\([^)]*painFlagPath/s);
+    expect(source).not.toMatch(/atomicWriteFileSync\s*\([^)]*painFlagPath/s);
+  });
+
+  // PRI-29: emitPainDetectedEvent → PainToPrincipleService service contract guards
+  it('pain.ts constructs PainToPrincipleService with workspaceDir and stateDir from wctx', () => {
+    const source = read('packages/openclaw-plugin/src/hooks/pain.ts');
+
+    // Must construct PrincipleTreeLedgerAdapter with wctx.stateDir
+    expect(source).toMatch(/new PrincipleTreeLedgerAdapter\(\{\s*stateDir:\s*wctx\.stateDir\s*\}\)/);
+
+    // Must construct PainToPrincipleService with wctx properties
+    expect(source).toMatch(/new PainToPrincipleService\(\{/);
+    expect(source).toMatch(/workspaceDir:\s*wctx\.workspaceDir/);
+    expect(source).toMatch(/stateDir:\s*wctx\.stateDir/);
+    expect(source).toMatch(/owner:\s*['"]openclaw-plugin['"]/);
+    expect(source).toMatch(/autoIntakeEnabled:\s*true/);
+  });
+
+  it('pain.ts passes recordObservability: true to service.recordPain', () => {
+    const source = read('packages/openclaw-plugin/src/hooks/pain.ts');
+
+    expect(source).toMatch(/recordObservability:\s*true/);
+  });
+
+  it('pain.ts logs PAIN_SERVICE_FAILED for failed status with failureCategory', () => {
+    const source = read('packages/openclaw-plugin/src/hooks/pain.ts');
+
+    expect(source).toMatch(/PAIN_SERVICE_FAILED/);
+    // Must include failureCategory in the log payload
+    expect(source).toMatch(/failureCategory:\s*result\.failureCategory/);
+  });
+
+  it('pain.ts logs PAIN_SERVICE_SKIPPED for skipped status', () => {
+    const source = read('packages/openclaw-plugin/src/hooks/pain.ts');
+
+    expect(source).toMatch(/PAIN_SERVICE_SKIPPED/);
+  });
+
+  it('pain.ts logs PAIN_SERVICE_ERROR for exceptions', () => {
+    const source = read('packages/openclaw-plugin/src/hooks/pain.ts');
+
+    expect(source).toMatch(/PAIN_SERVICE_ERROR/);
+    // Must include "recordPain threw" in the error message
+    expect(source).toMatch(/recordPain threw:/);
+  });
+});