principles-disciple 1.8.0 → 1.8.2

package/tests/commands/nocturnal-review.test.ts

@@ -0,0 +1,448 @@
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import * as fs from 'fs';
+import * as path from 'path';
+import * as os from 'os';
+import { handleNocturnalReviewCommand } from '../../src/commands/nocturnal-review.js';
+import type { PluginCommandContext } from '../../src/openclaw-sdk.js';
+import {
+  registerSample,
+  updateReviewStatus,
+  getDatasetRecord,
+} from '../../src/core/nocturnal-dataset.js';
+import type { NocturnalArtifact } from '../../src/core/nocturnal-arbiter.js';
+
+// ---------------------------------------------------------------------------
+// Fixtures
+// ---------------------------------------------------------------------------
+
+function makeArtifact(overrides: Partial<NocturnalArtifact> = {}): NocturnalArtifact {
+  return {
+    artifactId: 'a1b2c3d4-e5f6-7890-abcd-ef1234567890',
+    sessionId: 'session-abc123',
+    principleId: 'T-08',
+    sourceSnapshotRef: 'snapshot-2026-03-27-001',
+    badDecision: 'After bash command failed, immediately retried without diagnosing',
+    betterDecision: 'Check the error message before retrying',
+    rationale: 'Diagnosing failures prevents repeated failures and respects cost of each attempt',
+    createdAt: '2026-03-27T12:00:00.000Z',
+    ...overrides,
+  };
+}
+
+function makeTmpDir(): string {
+  return fs.mkdtempSync(path.join(os.tmpdir(), 'pd-nocturnal-review-test-'));
+}
+
+function rmdir(dir: string): void {
+  try {
+    if (fs.existsSync(dir)) {
+      fs.rmSync(dir, { recursive: true, force: true });
+    }
+  } catch {
+    // Ignore
+  }
+}
+
+function makeCtx(workspaceDir: string, args = ''): PluginCommandContext {
+  return {
+    config: { workspaceDir, language: 'en' },
+    args,
+  } as unknown as PluginCommandContext;
+}
+
+function setupSample(
+  workspaceDir: string,
+  artifactId: string,
+  family: string | null = 'gpt-4'
+): { fingerprint: string; artifactPath: string } {
+  const artifact = makeArtifact({ artifactId });
+  const artifactPath = path.join(
+    workspaceDir,
+    '.state',
+    'nocturnal',
+    'samples',
+    `${artifactId}.json`
+  );
+  fs.mkdirSync(path.dirname(artifactPath), { recursive: true });
+  fs.writeFileSync(artifactPath, JSON.stringify({ ...artifact, status: 'approved' }), 'utf-8');
+  const result = registerSample(workspaceDir, artifact, artifactPath, family);
+  return { fingerprint: result.record.sampleFingerprint, artifactPath };
+}
+
+// ---------------------------------------------------------------------------
+// Tests: list
+// ---------------------------------------------------------------------------
+
+describe('NocturnalReviewCommand list', () => {
+  let tmpDir: string;
+
+  beforeEach(() => {
+    tmpDir = makeTmpDir();
+  });
+
+  afterEach(() => {
+    rmdir(tmpDir);
+  });
+
+  it('shows pending samples', () => {
+    const { fingerprint } = setupSample(tmpDir, 'art-pending-list');
+
+    const result = handleNocturnalReviewCommand(makeCtx(tmpDir, 'list'));
+
+    expect(result.text).toContain('pending_review');
+    expect(result.text).toContain(fingerprint.substring(0, 16));
+  });
+
+  it('shows empty when no pending samples', () => {
+    const { fingerprint } = setupSample(tmpDir, 'art-approved-list');
+    updateReviewStatus(tmpDir, fingerprint, 'approved_for_training', 'Approved');
+
+    const result = handleNocturnalReviewCommand(makeCtx(tmpDir, 'list'));
+
+    expect(result.text).toContain('No pending');
+  });
+});
+
+// ---------------------------------------------------------------------------
+// Tests: approve
+// ---------------------------------------------------------------------------
+
+describe('NocturnalReviewCommand approve', () => {
+  let tmpDir: string;
+
+  beforeEach(() => {
+    tmpDir = makeTmpDir();
+  });
+
+  afterEach(() => {
+    rmdir(tmpDir);
+  });
+
+  it('approves a pending sample', () => {
+    const { fingerprint } = setupSample(tmpDir, 'art-approve-test');
+
+    const result = handleNocturnalReviewCommand(
+      makeCtx(tmpDir, `approve ${fingerprint} Looks good for training`)
+    );
+
+    expect(result.text).toContain('approved for training');
+    const record = getDatasetRecord(tmpDir, fingerprint);
+    expect(record?.reviewStatus).toBe('approved_for_training');
+    expect(record?.reviewReason).toBe('Looks good for training');
+  });
+
+  it('approves with default reason if not provided', () => {
+    const { fingerprint } = setupSample(tmpDir, 'art-approve-default');
+
+    const result = handleNocturnalReviewCommand(
+      makeCtx(tmpDir, `approve ${fingerprint}`)
+    );
+
+    expect(result.text).toContain('approved for training');
+    const record = getDatasetRecord(tmpDir, fingerprint);
+    expect(record?.reviewStatus).toBe('approved_for_training');
+    expect(record?.reviewReason).toBeTruthy();
+  });
+
+  it('rejects already approved sample', () => {
+    const { fingerprint } = setupSample(tmpDir, 'art-already-approved');
+    updateReviewStatus(tmpDir, fingerprint, 'approved_for_training', 'Already approved');
+
+    const result = handleNocturnalReviewCommand(
+      makeCtx(tmpDir, `approve ${fingerprint}`)
+    );
+
+    expect(result.text).toContain('already approved');
+  });
+
+  it('rejects rejected sample without reset', () => {
+    const { fingerprint } = setupSample(tmpDir, 'art-already-rejected');
+    updateReviewStatus(tmpDir, fingerprint, 'rejected', 'Rejected');
+
+    const result = handleNocturnalReviewCommand(
+      makeCtx(tmpDir, `approve ${fingerprint}`)
+    );
+
+    expect(result.text).toContain('rejected');
+  });
+
+  it('rejects superseded sample', () => {
+    const { fingerprint } = setupSample(tmpDir, 'art-superseded');
+    updateReviewStatus(tmpDir, fingerprint, 'approved_for_training', 'Approved');
+    updateReviewStatus(tmpDir, fingerprint, 'superseded', 'Superseded by better');
+
+    const result = handleNocturnalReviewCommand(
+      makeCtx(tmpDir, `approve ${fingerprint}`)
+    );
+
+    expect(result.text).toContain('superseded');
+  });
+
+  it('returns error for unknown fingerprint', () => {
+    const result = handleNocturnalReviewCommand(
+      makeCtx(tmpDir, 'approve unknown-fingerprint')
+    );
+
+    expect(result.text).toContain('not found');
+  });
+
+  it('returns error when missing fingerprint', () => {
+    const result = handleNocturnalReviewCommand(makeCtx(tmpDir, 'approve'));
+
+    expect(result.text).toContain('Usage');
+  });
+});
+
+// ---------------------------------------------------------------------------
+// Tests: reject
+// ---------------------------------------------------------------------------
+
+describe('NocturnalReviewCommand reject', () => {
+  let tmpDir: string;
+
+  beforeEach(() => {
+    tmpDir = makeTmpDir();
+  });
+
+  afterEach(() => {
+    rmdir(tmpDir);
+  });
+
+  it('rejects a pending sample', () => {
+    const { fingerprint } = setupSample(tmpDir, 'art-reject-test');
+
+    const result = handleNocturnalReviewCommand(
+      makeCtx(tmpDir, `reject ${fingerprint} Not suitable for training`)
+    );
+
+    expect(result.text).toContain('rejected');
+    const record = getDatasetRecord(tmpDir, fingerprint);
+    expect(record?.reviewStatus).toBe('rejected');
+    expect(record?.reviewReason).toBe('Not suitable for training');
+  });
+
+  it('rejects with default reason if not provided', () => {
+    const { fingerprint } = setupSample(tmpDir, 'art-reject-default');
+
+    const result = handleNocturnalReviewCommand(
+      makeCtx(tmpDir, `reject ${fingerprint}`)
+    );
+
+    expect(result.text).toContain('rejected');
+    const record = getDatasetRecord(tmpDir, fingerprint);
+    expect(record?.reviewStatus).toBe('rejected');
+  });
+
+  it('rejects already rejected sample', () => {
+    const { fingerprint } = setupSample(tmpDir, 'art-already-rejected');
+    updateReviewStatus(tmpDir, fingerprint, 'rejected', 'Already rejected');
+
+    const result = handleNocturnalReviewCommand(
+      makeCtx(tmpDir, `reject ${fingerprint}`)
+    );
+
+    expect(result.text).toContain('already rejected');
+  });
+
+  it('rejects superseded sample', () => {
+    const { fingerprint } = setupSample(tmpDir, 'art-superseded-reject');
+    updateReviewStatus(tmpDir, fingerprint, 'approved_for_training', 'Approved');
+    updateReviewStatus(tmpDir, fingerprint, 'superseded', 'Superseded');
+
+    const result = handleNocturnalReviewCommand(
+      makeCtx(tmpDir, `reject ${fingerprint}`)
+    );
+
+    expect(result.text).toContain('superseded');
+  });
+
+  it('returns error for unknown fingerprint', () => {
+    const result = handleNocturnalReviewCommand(
+      makeCtx(tmpDir, 'reject unknown-fingerprint')
+    );
+
+    expect(result.text).toContain('not found');
+  });
+});
+
+// ---------------------------------------------------------------------------
+// Tests: show
+// ---------------------------------------------------------------------------
+
+describe('NocturnalReviewCommand show', () => {
+  let tmpDir: string;
+
+  beforeEach(() => {
+    tmpDir = makeTmpDir();
+  });
+
+  afterEach(() => {
+    rmdir(tmpDir);
+  });
+
+  it('shows sample details', () => {
+    const { fingerprint } = setupSample(tmpDir, 'art-show-test');
+
+    const result = handleNocturnalReviewCommand(
+      makeCtx(tmpDir, `show ${fingerprint}`)
+    );
+
+    expect(result.text).toContain(fingerprint.substring(0, 16));
+    expect(result.text).toContain('T-08');
+    expect(result.text).toContain('session-abc123');
+  });
+
+  it('returns error for unknown fingerprint', () => {
+    const result = handleNocturnalReviewCommand(
+      makeCtx(tmpDir, 'show unknown-fingerprint')
+    );
+
+    expect(result.text).toContain('not found');
+  });
+
+  it('returns error when missing fingerprint', () => {
+    const result = handleNocturnalReviewCommand(makeCtx(tmpDir, 'show'));
+
+    expect(result.text).toContain('Usage');
+  });
+});
+
+// ---------------------------------------------------------------------------
+// Tests: set-family
+// ---------------------------------------------------------------------------
+
+describe('NocturnalReviewCommand set-family', () => {
+  let tmpDir: string;
+
+  beforeEach(() => {
+    tmpDir = makeTmpDir();
+  });
+
+  afterEach(() => {
+    rmdir(tmpDir);
+  });
+
+  it('sets target model family', () => {
+    const { fingerprint } = setupSample(tmpDir, 'art-family-test', null);
+
+    const result = handleNocturnalReviewCommand(
+      makeCtx(tmpDir, `set-family ${fingerprint} claude-3`)
+    );
+
+    expect(result.text).toContain('claude-3');
+    const record = getDatasetRecord(tmpDir, fingerprint);
+    expect(record?.targetModelFamily).toBe('claude-3');
+  });
+
+  it('updates existing family', () => {
+    const { fingerprint } = setupSample(tmpDir, 'art-family-update-test', 'gpt-4');
+
+    const result = handleNocturnalReviewCommand(
+      makeCtx(tmpDir, `set-family ${fingerprint} gpt-4o`)
+    );
+
+    expect(result.text).toContain('gpt-4o');
+    const record = getDatasetRecord(tmpDir, fingerprint);
+    expect(record?.targetModelFamily).toBe('gpt-4o');
+  });
+
+  it('returns error for unknown fingerprint', () => {
+    const result = handleNocturnalReviewCommand(
+      makeCtx(tmpDir, 'set-family unknown-fingerprint gpt-4')
+    );
+
+    expect(result.text).toContain('not found');
+  });
+
+  it('returns error when missing args', () => {
+    const { fingerprint } = setupSample(tmpDir, 'art-family-missing-test');
+
+    const result = handleNocturnalReviewCommand(
+      makeCtx(tmpDir, `set-family ${fingerprint}`)
+    );
+
+    expect(result.text).toContain('Usage');
+  });
+});
+
+// ---------------------------------------------------------------------------
+// Tests: stats
+// ---------------------------------------------------------------------------
+
+describe('NocturnalReviewCommand stats', () => {
+  let tmpDir: string;
+
+  beforeEach(() => {
+    tmpDir = makeTmpDir();
+  });
+
+  afterEach(() => {
+    rmdir(tmpDir);
+  });
+
+  it('shows dataset statistics', () => {
+    setupSample(tmpDir, 'art-stats-1', 'gpt-4');
+    const { fingerprint: fp2 } = setupSample(tmpDir, 'art-stats-2', 'gpt-4');
+    updateReviewStatus(tmpDir, fp2, 'approved_for_training', 'Approved');
+
+    const result = handleNocturnalReviewCommand(makeCtx(tmpDir, 'stats'));
+
+    expect(result.text).toContain('Total');
+    expect(result.text).toContain('2');
+  });
+
+  it('shows export-ready counts by family', () => {
+    const { fingerprint: fp1 } = setupSample(tmpDir, 'art-stats-family-1', 'gpt-4');
+    updateReviewStatus(tmpDir, fp1, 'approved_for_training', 'Approved');
+
+    const result = handleNocturnalReviewCommand(makeCtx(tmpDir, 'stats'));
+
+    expect(result.text).toContain('gpt-4');
+    expect(result.text).toContain('1');
+  });
+});
+
+// ---------------------------------------------------------------------------
+// Integration: full review flow
+// ---------------------------------------------------------------------------
+
+describe('NocturnalReviewCommand full review flow', () => {
+  let tmpDir: string;
+
+  beforeEach(() => {
+    tmpDir = makeTmpDir();
+  });
+
+  afterEach(() => {
+    rmdir(tmpDir);
+  });
+
+  it('full flow: list → set-family → approve → export-ready', () => {
+    // 1. Register sample without family
+    const { fingerprint } = setupSample(tmpDir, 'art-full-flow', null);
+
+    // 2. Verify it's pending
+    let result = handleNocturnalReviewCommand(makeCtx(tmpDir, 'list'));
+    expect(result.text).toContain(fingerprint.substring(0, 16));
+
+    // 3. Set family
+    result = handleNocturnalReviewCommand(
+      makeCtx(tmpDir, `set-family ${fingerprint} gpt-4`)
+    );
+    expect(result.text).toContain('gpt-4');
+
+    // 4. Approve
+    result = handleNocturnalReviewCommand(
+      makeCtx(tmpDir, `approve ${fingerprint} Good sample`)
+    );
+    expect(result.text).toContain('approved for training');
+
+    // 5. Verify stats show approved
+    result = handleNocturnalReviewCommand(makeCtx(tmpDir, 'stats'));
+    expect(result.text).toContain('Approved for training');
+
+    // 6. Verify not in pending list anymore
+    result = handleNocturnalReviewCommand(makeCtx(tmpDir, 'list'));
+    expect(result.text).not.toContain(fingerprint.substring(0, 16));
+  });
+});

package/tests/commands/nocturnal-train.test.ts

@@ -0,0 +1,97 @@
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import * as fs from 'fs';
+import * as path from 'path';
+import * as os from 'os';
+import { handleNocturnalTrainCommand } from '../../src/commands/nocturnal-train.js';
+import type { PluginCommandContext } from '../../src/openclaw-sdk.js';
+
+function makeTmpDir(): string {
+  return fs.mkdtempSync(path.join(os.tmpdir(), 'pd-nocturnal-train-test-'));
+}
+
+function rmdir(dir: string): void {
+  try {
+    if (fs.existsSync(dir)) {
+      fs.rmSync(dir, { recursive: true, force: true });
+    }
+  } catch {
+    // ignore cleanup errors
+  }
+}
+
+function makeCtx(workspaceDir: string, args = ''): PluginCommandContext {
+  return {
+    config: { workspaceDir, language: 'en' },
+    args,
+  } as unknown as PluginCommandContext;
+}
+
+function setupExport(workspaceDir: string, exportId = 'export-123'): void {
+  const exportDir = path.join(workspaceDir, '.state', 'exports', 'orpo');
+  fs.mkdirSync(exportDir, { recursive: true });
+  const exportPath = path.join(exportDir, `${exportId}.jsonl`);
+  fs.writeFileSync(
+    exportPath,
+    JSON.stringify({
+      sampleFingerprint: 'sf-1',
+      prompt: 'p',
+      chosen: 'c',
+      rejected: 'r',
+      rationale: 'why',
+    }) + '\n',
+    'utf-8'
+  );
+  fs.writeFileSync(
+    path.join(exportDir, `${exportId}-manifest.json`),
+    JSON.stringify({
+      exportId,
+      datasetFingerprint: 'dataset-fp-123',
+      exportPath,
+      targetModelFamily: 'qwen2.5-7b-reader',
+      sampleCount: 1,
+      createdAt: new Date().toISOString(),
+    }),
+    'utf-8'
+  );
+}
+
+describe('nocturnal-train command', () => {
+  let tmpDir: string;
+
+  beforeEach(() => {
+    tmpDir = makeTmpDir();
+    setupExport(tmpDir);
+  });
+
+  afterEach(() => {
+    rmdir(tmpDir);
+  });
+
+  it('persists durable spec files for manual create-experiment flow', async () => {
+    const result = await handleNocturnalTrainCommand(
+      makeCtx(
+        tmpDir,
+        'create-experiment --backend=peft-trl-orpo --family=qwen2.5-7b-reader --dataset=export-123'
+      )
+    );
+
+    expect(result.text).toContain('Experiment created');
+
+    const match = result.text.match(/Experiment ID:\s+([^\s]+)/);
+    expect(match?.[1]).toBeTruthy();
+    const experimentId = match![1];
+
+    const pathLines = result.text
+      .split('\n')
+      .map((line) => line.trim())
+      .map((line) => line.replace(/^-+ \s*/, ''))
+      .filter((line) => path.isAbsolute(line));
+
+    expect(pathLines).toHaveLength(2);
+    const [trainerSpecPath, workspaceSpecPath] = pathLines;
+
+    expect(fs.existsSync(trainerSpecPath)).toBe(true);
+    expect(fs.existsSync(workspaceSpecPath)).toBe(true);
+    expect(result.text).toContain(trainerSpecPath);
+  });
+});

package/tests/commands/pain.test.ts

@@ -0,0 +1,108 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { handlePainCommand } from '../../src/commands/pain.js';
+import * as sessionTracker from '../../src/core/session-tracker.js';
+import { WorkspaceContext } from '../../src/core/workspace-context.js';
+
+vi.mock('../../src/core/session-tracker.js');
+vi.mock('../../src/core/workspace-context.js');
+
+describe('Pain Command', () => {
+    const workspaceDir = '/mock/workspace';
+    const sessionId = 's1';
+
+    const mockDictionary = {
+        getStats: vi.fn().mockReturnValue({ totalRules: 10, totalHits: 5 })
+    };
+
+    const mockEventLog = {
+        getEmpathyStats: vi.fn().mockReturnValue({
+            totalEvents: 0,
+            dedupedCount: 0,
+            dedupeHitRate: 0,
+            totalPenaltyScore: 0,
+            rolledBackScore: 0,
+            rollbackCount: 0,
+            bySeverity: { mild: 0, moderate: 0, severe: 0 },
+            scoreBySeverity: { mild: 0, moderate: 0, severe: 0 },
+            byDetectionMode: { structured: 0, legacy_tag: 0 },
+            byOrigin: { assistant_self_report: 0, user_manual: 0, system_infer: 0 },
+            confidenceDistribution: { high: 0, medium: 0, low: 0 },
+            dailyTrend: [],
+        })
+    };
+
+    const mockConfig = {
+        get: vi.fn().mockImplementation((key: string) => {
+            if (key === 'language') return 'en';
+            return undefined;
+        })
+    };
+
+    const mockWctx = {
+        workspaceDir,
+        dictionary: mockDictionary,
+        eventLog: mockEventLog,
+        config: mockConfig,
+        trajectory: {
+            getDataStats: vi.fn().mockReturnValue({
+                dbPath: '/mock/workspace/.state/trajectory.db',
+                dbSizeBytes: 2048,
+                assistantTurns: 2,
+                userTurns: 3,
+                toolCalls: 4,
+                painEvents: 1,
+                pendingSamples: 1,
+                approvedSamples: 2,
+                blobBytes: 1024,
+                lastIngestAt: '2026-03-19T10:00:00.000Z',
+            })
+        }
+    };
+
+    beforeEach(() => {
+        vi.clearAllMocks();
+        vi.mocked(WorkspaceContext.fromHookContext).mockReturnValue(mockWctx as any);
+    });
+
+    it('should format a comprehensive pain report', () => {
+        vi.mocked(sessionTracker.getSession).mockReturnValue({ currentGfi: 45 } as any);
+        
+        const result = handlePainCommand({ 
+            args: '', 
+            config: { workspaceDir, language: 'en' },
+            sessionId 
+        } as any);
+
+        expect(result.text).toContain('Friction (GFI)**: [');
+        expect(result.text).toContain('] 45/100');
+        expect(result.text).toContain('Dictionary**: 10');
+        expect(result.text).toContain('blocked 5');
+    });
+
+    it('should show 🟢 status for low GFI', () => {
+        vi.mocked(sessionTracker.getSession).mockReturnValue({ currentGfi: 10 } as any);
+        const result = handlePainCommand({ config: { workspaceDir }, sessionId } as any);
+        expect(result.text).toContain('10/100');
+    });
+
+    it('should show 🔴 status for high GFI', () => {
+        vi.mocked(sessionTracker.getSession).mockReturnValue({ currentGfi: 85 } as any);
+        const result = handlePainCommand({ config: { workspaceDir }, sessionId } as any);
+        expect(result.text).toContain('85/100');
+    });
+
+    it('shows trajectory data stats for the data subcommand', () => {
+        const result = handlePainCommand({
+            args: 'data',
+            config: { workspaceDir, language: 'en' },
+            sessionId
+        } as any);
+
+        expect(result.text).toContain('trajectory.db');
+        expect(result.text).toContain('assistant turns: 2');
+        expect(result.text).toContain('blob bytes: 1024');
+        expect(result.text).toContain('last ingest: 2026-03-19T10:00:00.000Z');
+        expect(result.text).toContain('pending samples');
+        expect(result.text).toContain('approved samples');
+    });
+});