principles-disciple 1.28.0 → 1.28.1

package/src/core/pain-context-extractor.ts

@@ -235,11 +235,9 @@ export async function extractRecentConversation(
 /**
  * Extracts failed tool call context with argument correlation.
  */
-  // Reason: breaking API change - default param must precede required params for type inference compatibility
- 
 export async function extractFailedToolContext(
   sessionId: string,
-  agentId = 'main',
+  agentId: string,
   toolName: string,
   filePath?: string,
 ): Promise<string> {

package/src/core/principle-tree-migration.ts

@@ -9,8 +9,6 @@
  *   - Or run manually: node scripts/migrate-principle-tree.mjs <workspace-dir>
  */
 
-import * as fs from 'fs';
-import * as path from 'path';
 import {
   loadLedger,
   saveLedger,
@@ -23,11 +21,11 @@ export interface PrincipleTreeMigrationResult {
   migratedCount: number;
   skippedCount: number;
   errorCount: number;
-  details: Array<{
+  details: {
     principleId: string;
     status: 'migrated' | 'skipped' | 'error';
     reason?: string;
-  }>;
+  }[];
 }
 
 /**

package/src/core/thinking-os-parser.ts

@@ -45,10 +45,10 @@ export function parseThinkingOsMd(content: string): ThinkingOsDirective[] {
   // Match all <directive ...> ... </directive> blocks
   const directiveRegex = /<directive\s+([^>]*)>([\s\S]*?)<\/directive>/gi;
    
-  let match: RegExpExecArray | null = null;
+  let _match: RegExpExecArray | null = null;
 
-  while ((match = directiveRegex.exec(content)) !== null) {
-    const [, attrs, body] = match;
+  while ((_match = directiveRegex.exec(content)) !== null) {
+    const [, attrs, body] = _match;
 
     const idMatch = /id="([^"]+)"/i.exec(attrs);
     const nameMatch = /name="([^"]+)"/i.exec(attrs);

package/src/hooks/bash-risk.ts

@@ -66,7 +66,7 @@ export function analyzeBashCommand(
   // - Word joiner (U+2060)
   // - Zero-width invisible separator (U+FEFF)
    
-  const ZERO_WIDTH_CHARS = /[\u200B\u200C\u200D\u2060\uFEFF]/g;
+  const ZERO_WIDTH_CHARS = /\u200B|\u200C|\u200D|\u2060|\uFEFF/g;
   if (ZERO_WIDTH_CHARS.test(command)) {
     logger?.warn?.(`[PD_GATE] Bash command contains zero-width characters — blocking as dangerous`);
     return 'dangerous'; // Fail-closed: zero-width chars are suspicious

package/src/hooks/gfi-gate.ts

@@ -65,7 +65,7 @@ function block(
     sessionId,
     blockSource: 'gfi-gate',
   }, logger ||  
-  { warn: () => {}, error: () => {} } as const);
+  { warn: () => { /* no-op */ }, error: () => { /* no-op */ } } as const);
 }
 
  

package/src/hooks/pain.ts

@@ -191,7 +191,7 @@ export function handleAfterToolCall(
     // Only reduce tool_failure source GFI by 50%, preserve user_empathy and other sources
     // This prevents "read file success" from wiping user frustration signals
     const session = getSession(sessionId);
-    const toolFailureGfi = session?.gfiBySource?.['tool_failure'] || 0;
+    const toolFailureGfi = session?.gfiBySource?.tool_failure || 0;
     
     let resetState: SessionState;
     if (toolFailureGfi > 0) {

package/src/hooks/prompt.ts

@@ -10,6 +10,7 @@ import { extractSummary, getHistoryVersions, parseWorkingMemorySection, workingM
 import { EmpathyObserverWorkflowManager, empathyObserverWorkflowSpec, isExpectedSubagentError } from '../service/subagent-workflow/index.js';
 import { PathResolver } from '../core/path-resolver.js';
 import { isSubagentRuntimeAvailable } from '../utils/subagent-probe.js';
+import { getPendingDiagnosticianTasks } from '../core/diagnostician-task-store.js';
 import {
   matchEmpathyKeywords,
   loadKeywordStore,
@@ -366,7 +367,7 @@ export async function handleBeforePromptBuild(
   // prependContext: Only short dynamic directives: evolutionDirective + heartbeat
 
    
-  let prependSystemContext = '';
+  let prependSystemContext: string;
   let prependContext = '';
   let appendSystemContext = '';
 
@@ -644,11 +645,44 @@ ACTION: Run self-audit. If stable, reply ONLY with "HEARTBEAT_OK".
         logger?.error(`[PD:Prompt] Failed to read HEARTBEAT: ${String(e)}`);
       }
     }
+
+    // ──── 4b. Inject pending diagnostician tasks ────
+    // FIX (#283): The evolution worker writes pain diagnosis tasks to
+    // diagnostician_tasks.json. The heartbeat prompt hook must read and inject
+    // them so the LLM (acting as diagnostician) can process them.
+    try {
+      const pendingTasks = getPendingDiagnosticianTasks(wctx.stateDir);
+      if (pendingTasks.length > 0) {
+        const taskBlocks = pendingTasks
+          .slice(0, 3)
+          .map(({ id, task }) => `<diagnostician_task id="${id}">\n${task.prompt}\n</diagnostician_task>`)
+          .join('\n\n');
+
+        const pendingCount = pendingTasks.length;
+        const processingNote = pendingCount > 3
+          ? `\n\nNOTE: ${pendingCount - 3} more tasks are queued. Process these 3 first; remaining tasks will be handled on subsequent heartbeats.`
+          : '';
+
+        prependContext += `<diagnostician_tasks pending="${pendingCount}">
+You are acting as a **Pain Diagnostician**. Process the following task(s) by:
+1. Analyzing the pain signal and its context
+2. Identifying the root cause and violated principles
+3. Writing a completion marker file: .evolution_complete_<TASK_ID>
+4. Writing a diagnostic report: .diagnostician_report_<TASK_ID>.json
+
+${taskBlocks}${processingNote}
+</diagnostician_tasks>\n`;
+
+        logger?.info?.(`[PD:Prompt] Injected ${Math.min(pendingCount, 3)}/${pendingCount} pending diagnostician task(s) into heartbeat prompt`);
+      }
+    } catch (e) {
+      logger?.warn?.(`[PD:Prompt] Failed to read diagnostician tasks: ${String(e)}`);
+    }
   }
 
   // ──── 6. Dynamic Attitude Matrix (based on GFI) ────
    
-  let attitudeDirective = '';
+  let attitudeDirective: string;
   const currentGfi = session?.currentGfi || 0;
   
   if (currentGfi >= 70) {

package/src/hooks/subagent.ts

@@ -25,7 +25,7 @@ function createWorkflowManagerForType(
         warn: (m: string) => logger.warn(String(m)),
         error: (m: string) => logger.error(String(m)),
          
-        debug: () => {},
+        debug: () => { /* no-op */ },
     } as unknown as PluginLogger;
 
     switch (workflowType) {

package/src/index.ts

@@ -118,7 +118,7 @@ function computeRuntimeShadowTaskFingerprint(event: PluginHookSubagentSpawningEv
   return crypto.createHash('sha256').update(JSON.stringify(payload)).digest('hex').slice(0, 16);
 }
 
-function resolveCommandWorkspaceDirStrict(
+function _resolveCommandWorkspaceDirStrict(
   api: OpenClawPluginApi,
   ctx: WorkspaceResolutionContext,
 ): string {

package/src/service/evolution-worker.ts

@@ -382,7 +382,7 @@ function buildFallbackNocturnalSnapshot(
             // #246-fix: Use minToolCalls=0 to avoid filtering out sessions with 0 tool calls.
             // The pain-triggering session may have no tool calls but still be worth tracking.
             const summaries = extractor.listRecentNocturnalCandidateSessions({ limit: 300, minToolCalls: 0 });
-            const match = summaries.find(s => s.sessionId === painContext.mostRecent!.sessionId);
+            const match = summaries.find(s => s.sessionId === painContext.mostRecent?.sessionId);
             if (match) {
                 realStats = {
                     totalAssistantTurns: match.assistantTurnCount,

package/src/service/health-query-service.ts

@@ -553,8 +553,8 @@ export class HealthQueryService {
     const streamPath = resolvePdPath(this.workspaceDir, 'EVOLUTION_STREAM');
     if (!fs.existsSync(streamPath)) return [];
 
-     
-    let lines: string[] = [];
+    // eslint-disable-next-line @typescript-eslint/init-declarations
+    let lines: string[];
     try {
       const raw = fs.readFileSync(streamPath, 'utf8').trim();
       if (!raw) return [];
@@ -565,8 +565,9 @@ export class HealthQueryService {
 
     const records: RecentPrincipleChange[] = [];
     for (const line of lines) {
-       
-      let event: EvolutionStreamRecord | null = null;
+
+      // eslint-disable-next-line @typescript-eslint/init-declarations
+      let event: EvolutionStreamRecord | null;
       try {
         event = JSON.parse(line) as EvolutionStreamRecord;
       } catch {
@@ -784,6 +785,7 @@ export class HealthQueryService {
   }
 
    
+  // eslint-disable-next-line @typescript-eslint/class-methods-use-this
   private getEventDedupKey(entry: EventLogEntry): string {
     const eventId = typeof entry.data?.eventId === 'string' ? entry.data.eventId : null;
     if (eventId) {
@@ -854,6 +856,7 @@ export class HealthQueryService {
   }
 
    
+  // eslint-disable-next-line @typescript-eslint/class-methods-use-this
   private resolveGateType(row: GateBlockRow): string {
     if (typeof row.gate_type === 'string' && row.gate_type.trim().length > 0) {
       return row.gate_type;
@@ -878,6 +881,7 @@ export class HealthQueryService {
   }
 
    
+  // eslint-disable-next-line @typescript-eslint/class-methods-use-this
   private scoreToStatus(score: number): string {
     if (score >= 70) return 'healthy';
     if (score >= 40) return 'warning';
@@ -885,6 +889,7 @@ export class HealthQueryService {
   }
 
    
+  // eslint-disable-next-line @typescript-eslint/class-methods-use-this
   private evolutionToStatus(tier: string, points: number): string {
     const lower = tier.toLowerCase();
     if (lower === 'forest' || lower === 'tree') return 'healthy';
@@ -893,6 +898,7 @@ export class HealthQueryService {
   }
 
    
+  // eslint-disable-next-line @typescript-eslint/class-methods-use-this
   private safeListFiles(dirPath: string, predicate: (_name: string) => boolean): string[] {
     if (!fs.existsSync(dirPath)) return [];
     try {
@@ -905,6 +911,7 @@ export class HealthQueryService {
   }
 
    
+  // eslint-disable-next-line @typescript-eslint/class-methods-use-this
   private readJsonFile<T>(filePath: string, fallback: T): T {
     if (!fs.existsSync(filePath)) return fallback;
     try {
@@ -915,11 +922,13 @@ export class HealthQueryService {
   }
 
    
+  // eslint-disable-next-line @typescript-eslint/class-methods-use-this
   private asNumber(value: unknown, fallback: number): number {
     return Number.isFinite(value) ? Number(value) : fallback;
   }
 
    
+  // eslint-disable-next-line @typescript-eslint/class-methods-use-this
   private asNullableNumber(value: unknown): number | null {
     if (Number.isFinite(value)) return Number(value);
     if (typeof value === 'string' && value.trim().length > 0) {
@@ -954,7 +963,7 @@ export class HealthQueryService {
         dailyGfiPeak,
         today,
       );
-    } catch (err) {
+    } catch {
       // Non-critical: GFI sync failure should not block queries
     }
   }
@@ -1015,7 +1024,7 @@ export class HealthQueryService {
       }
 
       return latest;
-    } catch (err) {
+    } catch {
       // Non-critical: failure to read session files should not crash the service
       return null;
     }

package/src/service/subagent-workflow/nocturnal-workflow-manager.ts

@@ -36,7 +36,6 @@ import {
 } from '../nocturnal-service.js';
 import { type TrinityStageFailure, type TrinityResult } from '../../core/nocturnal-trinity.js';
 import type { TrinityRuntimeAdapter } from '../../core/nocturnal-trinity.js';
-import type { NocturnalSessionSnapshot } from '../../core/nocturnal-trajectory-extractor.js';
 import type { RecentPainContext } from '../evolution-worker.js';
 import * as fs from 'fs';
 import * as path from 'path';

package/tests/core/nocturnal-candidate-scoring.test.ts

@@ -5,6 +5,7 @@ import {
   rankCandidates,
   runTournament,
   DEFAULT_SCORING_WEIGHTS,
+  validateCandidateDiversity,
 } from '../../src/core/nocturnal-candidate-scoring.js';
 import type { DreamerCandidate, PhilosopherJudgment } from '../../src/core/nocturnal-trinity.js';
 import type { ThresholdValues } from '../../src/core/adaptive-thresholds.js';
@@ -398,3 +399,134 @@ describe('DEFAULT_SCORING_WEIGHTS', () => {
     }
   });
 });
+
+// ---------------------------------------------------------------------------
+// Tests: validateCandidateDiversity
+// ---------------------------------------------------------------------------
+
+describe('validateCandidateDiversity', () => {
+  it('passes when candidates have 2+ distinct risk levels and low keyword overlap', () => {
+    const candidates: DreamerCandidate[] = [
+      makeCandidate({ candidateIndex: 0, riskLevel: 'low', betterDecision: 'Read config.json to verify settings' }),
+      makeCandidate({ candidateIndex: 1, riskLevel: 'high', betterDecision: 'Refactor the entire authentication module from scratch' }),
+    ];
+    const result = validateCandidateDiversity(candidates);
+    expect(result.diversityCheckPassed).toBe(true);
+    expect(result.riskLevelDiversity).toBe(true);
+    expect(result.keywordOverlapPassed).toBe(true);
+  });
+
+  it('fails when all candidates have the same risk level', () => {
+    const candidates: DreamerCandidate[] = [
+      makeCandidate({ candidateIndex: 0, riskLevel: 'low', betterDecision: 'Read file A to check settings' }),
+      makeCandidate({ candidateIndex: 1, riskLevel: 'low', betterDecision: 'Review file completely different approach' }),
+      makeCandidate({ candidateIndex: 2, riskLevel: 'low', betterDecision: 'Inspect another unique diagnostic method' }),
+    ];
+    const result = validateCandidateDiversity(candidates);
+    expect(result.diversityCheckPassed).toBe(false);
+    expect(result.riskLevelDiversity).toBe(false);
+  });
+
+  it('fails when candidate pair has keyword overlap > 0.8', () => {
+    const candidates: DreamerCandidate[] = [
+      makeCandidate({ candidateIndex: 0, riskLevel: 'low', betterDecision: 'Review the authentication configuration file before making any changes to the system' }),
+      makeCandidate({ candidateIndex: 1, riskLevel: 'high', betterDecision: 'Review the authentication configuration file before making any changes to the system' }),
+    ];
+    const result = validateCandidateDiversity(candidates);
+    expect(result.diversityCheckPassed).toBe(false);
+    expect(result.keywordOverlapPassed).toBe(false);
+    expect(result.maxOverlapScore).toBeGreaterThan(0.8);
+  });
+
+  it('passes for single candidate', () => {
+    const candidates: DreamerCandidate[] = [
+      makeCandidate({ candidateIndex: 0, riskLevel: 'low' }),
+    ];
+    const result = validateCandidateDiversity(candidates);
+    expect(result.diversityCheckPassed).toBe(true);
+    expect(result.details).toContain('Single candidate');
+  });
+
+  it('passes for empty array', () => {
+    const result = validateCandidateDiversity([]);
+    expect(result.diversityCheckPassed).toBe(true);
+    expect(result.details).toContain('No candidates');
+  });
+
+  it('passes when candidates lack riskLevel (graceful degradation)', () => {
+    const candidates: DreamerCandidate[] = [
+      makeCandidate({ candidateIndex: 0, betterDecision: 'Read config.json to verify settings' }),
+      makeCandidate({ candidateIndex: 1, betterDecision: 'Refactor the entire authentication module from scratch' }),
+    ];
+    // No riskLevel on any candidate - should pass (no risk levels to check)
+    const result = validateCandidateDiversity(candidates);
+    expect(result.diversityCheckPassed).toBe(true);
+    expect(result.riskLevelDiversity).toBe(true);
+  });
+
+  it('fails when some candidates have riskLevel but fewer than 2 distinct values', () => {
+    const candidates: DreamerCandidate[] = [
+      makeCandidate({ candidateIndex: 0, riskLevel: 'medium', betterDecision: 'Read config.json to verify settings' }),
+      makeCandidate({ candidateIndex: 1, betterDecision: 'Refactor the entire authentication module from scratch' }),
+    ];
+    // Only 1 candidate has riskLevel, so only 1 distinct value → fail
+    const result = validateCandidateDiversity(candidates);
+    expect(result.diversityCheckPassed).toBe(false);
+    expect(result.riskLevelDiversity).toBe(false);
+  });
+
+  it('uses max(|A|, |B|) as denominator for keyword overlap', () => {
+    // Short text A, long text B - overlap should use max as denominator
+    const candidates: DreamerCandidate[] = [
+      makeCandidate({ candidateIndex: 0, riskLevel: 'low', betterDecision: 'review authentication configuration' }),
+      makeCandidate({ candidateIndex: 1, riskLevel: 'high', betterDecision: 'review authentication configuration before proceeding with changes to the deployment pipeline infrastructure' }),
+    ];
+    const result = validateCandidateDiversity(candidates);
+    // "review", "authentication", "configuration" overlap in both
+    // Set A = {review, authentication, configuration} = 3
+    // Set B = {review, authentication, configuration, before, proceeding, with, changes, deployment, pipeline, infrastructure} = 10
+    // intersection = 3, max(3, 10) = 10, overlap = 3/10 = 0.3
+    expect(result.maxOverlapScore).toBeLessThanOrEqual(0.4);
+  });
+
+  it('ignores words <= 3 characters in keyword overlap', () => {
+    const candidates: DreamerCandidate[] = [
+      makeCandidate({ candidateIndex: 0, riskLevel: 'low', betterDecision: 'the and but for' }),
+      makeCandidate({ candidateIndex: 1, riskLevel: 'high', betterDecision: 'the and but for' }),
+    ];
+    // All words are <= 3 chars, so no keywords extracted → overlap = 0
+    const result = validateCandidateDiversity(candidates);
+    expect(result.keywordOverlapPassed).toBe(true);
+    expect(result.maxOverlapScore).toBe(0);
+  });
+
+  it('never throws on malformed input', () => {
+    // Undefined candidates
+    expect(() => validateCandidateDiversity(undefined as unknown as DreamerCandidate[])).not.toThrow();
+    // Null candidates
+    expect(() => validateCandidateDiversity(null as unknown as DreamerCandidate[])).not.toThrow();
+    // Candidates with undefined fields
+    expect(() => validateCandidateDiversity([
+      { candidateIndex: 0 } as DreamerCandidate,
+    ])).not.toThrow();
+    // Mixed valid and malformed
+    expect(() => validateCandidateDiversity([
+      makeCandidate({ candidateIndex: 0, riskLevel: 'low' }),
+      { candidateIndex: 1 } as DreamerCandidate,
+    ])).not.toThrow();
+  });
+
+  it('returns correct maxOverlapScore rounded to 2 decimal places', () => {
+    const candidates: DreamerCandidate[] = [
+      makeCandidate({ candidateIndex: 0, riskLevel: 'low', betterDecision: 'Review configuration settings before deployment' }),
+      makeCandidate({ candidateIndex: 1, riskLevel: 'high', betterDecision: 'Review configuration settings before deployment testing' }),
+    ];
+    const result = validateCandidateDiversity(candidates);
+    // Verify the maxOverlapScore is a number with at most 2 decimal places
+    const decimalPart = result.maxOverlapScore.toString().split('.')[1];
+    if (decimalPart) {
+      expect(decimalPart.length).toBeLessThanOrEqual(2);
+    }
+    expect(typeof result.maxOverlapScore).toBe('number');
+  });
+});