principles-disciple 1.57.0 → 1.59.0

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.57.0",
+  "version": "1.59.0",
   "skills": [
     "./skills"
   ],
@@ -76,8 +76,8 @@
     }
   },
   "buildFingerprint": {
-    "gitSha": "70500e1475ef",
-    "bundleMd5": "607cfbcb4534d2cfdc45cb0cd019cd0b",
-    "builtAt": "2026-04-16T03:41:17.317Z"
+    "gitSha": "f37ee1dec538",
+    "bundleMd5": "f578c460a9849e9b6e6c573d13e48f12",
+    "builtAt": "2026-04-18T07:51:05.292Z"
   }
 }

package/package.json

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

package/scripts/sync-plugin.mjs

@@ -644,11 +644,22 @@ function injectLocalWorkspacePackages() {
     console.log('  📦 Injecting local workspace packages (@principles/core)...');
     mkdirSync(dirname(targetModules), { recursive: true });
     // cpSync creates symlinks on Windows for symlinked dirs — use cp -rL (dereference) via exec
+    let injected = false;
     try {
         execSync(`cp -rL "${monorepoModules}" "${targetModules}"`, { stdio: 'ignore' });
+        injected = true;
     } catch {
         // Fallback: manual copy via node (Windows-compatible)
-        copyDir(monorepoModules, targetModules);
+        try {
+            copyDir(monorepoModules, targetModules);
+            injected = true;
+        } catch (copyErr) {
+            console.warn('  ⚠️ Failed to inject @principles/core from monorepo: ' + copyErr.message);
+            console.warn('  ⚠️ npm install --production may fail if @principles/core is not published');
+        }
+    }
+    if (injected && !existsSync(targetModules)) {
+        console.warn('  ⚠️ Injection reported success but target not found: ' + targetModules);
     }
 }
 

package/src/commands/evolution-status.ts

@@ -74,6 +74,14 @@ function buildEnglishOutput(
     `- Phase 3: ready ${summary.phase3.phase3ShadowEligible ? 'yes' : 'no'}, queueTruthReady ${summary.phase3.queueTruthReady ? 'yes' : 'no'}, eligible ${summary.phase3.evolutionEligible}, reference_only ${summary.phase3.evolutionReferenceOnly}, rejected ${summary.phase3.evolutionRejected}${summary.phase3.evolutionReferenceOnlyReasons.length > 0 ? ` (reference ${summary.phase3.evolutionReferenceOnlyReasons.slice(0, 2).join(', ')})` : ''}${summary.phase3.evolutionRejectedReasons.length > 0 ? ` (${summary.phase3.evolutionRejectedReasons.slice(0, 3).join(', ')})` : ''}`,
     `- Phase 3 Legacy Directive File: ${summary.phase3.directiveStatus} (${summary.phase3.directiveIgnoredReason})`,
     '',
+    // D: Heartbeat Diagnostician chain — separated from evolution/nocturnal
+    'Heartbeat Diagnostician (Pain → Principle)',
+    `- Pending tasks: ${summary.heartbeatDiagnosis.pendingTasks}`,
+    `- Tasks written today: ${summary.heartbeatDiagnosis.tasksWrittenToday}`,
+    `- Reports written today: ${summary.heartbeatDiagnosis.reportsWrittenToday}`,
+    `- Candidates created today: ${summary.heartbeatDiagnosis.candidatesCreatedToday}`,
+    `- Heartbeats injected today: ${summary.heartbeatDiagnosis.heartbeatsInjectedToday}`,
+    '',
     'Principles',
     `- candidate principles: ${stats.candidateCount}`,
     `- probation principles: ${stats.probationCount}`,
@@ -127,6 +135,14 @@ function buildChineseOutput(
     `- Phase 3: ready ${summary.phase3.phase3ShadowEligible ? 'yes' : 'no'}，queueTruthReady ${summary.phase3.queueTruthReady ? 'yes' : 'no'}，eligible ${summary.phase3.evolutionEligible}，reference_only ${summary.phase3.evolutionReferenceOnly}，rejected ${summary.phase3.evolutionRejected}${summary.phase3.evolutionReferenceOnlyReasons.length > 0 ? ` (reference ${summary.phase3.evolutionReferenceOnlyReasons.slice(0, 2).join(', ')})` : ''}${summary.phase3.evolutionRejectedReasons.length > 0 ? ` (${summary.phase3.evolutionRejectedReasons.slice(0, 3).join(', ')})` : ''}`,
     `- Phase 3 Legacy Directive File: ${summary.phase3.directiveStatus} (${summary.phase3.directiveIgnoredReason})`,
     '',
+    // D: Heartbeat Diagnostician chain — separated from evolution/nocturnal
+    '心跳诊断链路（Pain → 原则）',
+    `- 等待处理: ${summary.heartbeatDiagnosis.pendingTasks}`,
+    `- 今日写入任务: ${summary.heartbeatDiagnosis.tasksWrittenToday}`,
+    `- 今日写入报告: ${summary.heartbeatDiagnosis.reportsWrittenToday}`,
+    `- 今日创建候选: ${summary.heartbeatDiagnosis.candidatesCreatedToday}`,
+    `- 今日心跳注入: ${summary.heartbeatDiagnosis.heartbeatsInjectedToday}`,
+    '',
     '原则统计',
     `- 候选原则: ${stats.candidateCount}`,
     `- 观察期原则: ${stats.probationCount}`,

package/src/core/event-log.ts

@@ -18,6 +18,12 @@ import type {
   EvolutionTaskEventData,
   DeepReflectionEventData,
   EmpathyRollbackEventData,
+  // C: New event data types
+  DiagnosisTaskEventData,
+  HeartbeatDiagnosisEventData,
+  DiagnosticianReportEventData,
+  PrincipleCandidateEventData,
+  RuleEnforcedEventData,
 } from '../types/event-types.js';
 import { createEmptyDailyStats } from '../types/event-types.js';
 import { atomicWriteFileSync } from '../utils/io.js';
@@ -180,9 +186,28 @@ export class EventLog {
   recordWarn(sessionId: string | undefined, message: string, context?: Record<string, unknown>): void {
     this.record('warn', 'failure', sessionId, { message, ...context });
   }
-  
-   
-   
+
+  // C: Diagnostician heartbeat chain event recorders
+  recordDiagnosisTask(data: DiagnosisTaskEventData): void {
+    this.record('diagnosis_task', 'written', undefined, data);
+  }
+
+  recordHeartbeatDiagnosis(data: HeartbeatDiagnosisEventData): void {
+    this.record('heartbeat_diagnosis', 'injected', undefined, data);
+  }
+
+  recordDiagnosticianReport(data: DiagnosticianReportEventData): void {
+    this.record('diagnostician_report', data.success ? 'completed' : 'failure', undefined, data);
+  }
+
+  recordPrincipleCandidate(data: PrincipleCandidateEventData): void {
+    this.record('principle_candidate', 'created', undefined, data);
+  }
+
+  recordRuleEnforced(data: RuleEnforcedEventData): void {
+    this.record('rule_enforced', 'matched', undefined, data);
+  }
+
   private record(
     type: EventType, 
     category: EventCategory, 
@@ -325,6 +350,20 @@ export class EventLog {
         stats.evolution.tasksEnqueued++;
       }
     }
+    // C: Diagnostician heartbeat chain event counters
+    else if (entry.type === 'diagnosis_task') {
+      stats.evolution.diagnosisTasksWritten++;
+    } else if (entry.type === 'heartbeat_diagnosis') {
+      stats.evolution.heartbeatsInjected++;
+    } else if (entry.type === 'diagnostician_report') {
+      if (entry.category === 'completed') {
+        stats.evolution.diagnosticianReportsWritten++;
+      }
+    } else if (entry.type === 'principle_candidate') {
+      stats.evolution.principleCandidatesCreated++;
+    } else if (entry.type === 'rule_enforced') {
+      stats.evolution.rulesEnforced++;
+    }
   }
 
   private startFlushTimer(): void {

package/src/core/init.ts

@@ -192,7 +192,7 @@ export function ensureCorePrinciples(stateDir: string, logger: PluginLogger): bo
     for (const model of CORE_THINKING_MODELS) {
       const state: PrincipleTrainingState = {
         principleId: model.id,
-        evaluability: 'manual_only',
+        evaluability: 'deterministic',
         applicableOpportunityCount: 0,
         observedViolationCount: 0,
         complianceRate: 0,
@@ -217,7 +217,7 @@ export function ensureCorePrinciples(stateDir: string, logger: PluginLogger): bo
         status: 'active',
         priority: 'P1',
         scope: 'general',
-        evaluability: 'manual_only',
+        evaluability: 'deterministic',
         valueScore: 0,
         adherenceRate: 0,
         painPreventedCount: 0,

package/src/core/principle-compiler/ledger-registrar.ts

@@ -52,6 +52,11 @@ export function registerCompiledRule(stateDir: string, input: RegisterInput): Re
   const now = new Date().toISOString();
 
   // Step 1: Create the rule
+  // FIX: Auto-generated rules default to 'warn' enforcement (not 'block') until:
+  // - replay evaluation passes
+  // - coverage confirmation
+  // - human approval
+  // This prevents P_001-style false positives from blocking normal edits.
   const rule: LedgerRule = {
     id: ruleId,
     version: 1,
@@ -59,7 +64,7 @@ export function registerCompiledRule(stateDir: string, input: RegisterInput): Re
     description: `Automatically compiled gate rule generated from principle ${principleId}`,
     type: 'gate',
     triggerCondition: coversCondition,
-    enforcement: 'block',
+    enforcement: 'warn',
     action: codeContent,
     principleId,
     status: 'proposed',
@@ -82,7 +87,11 @@ export function registerCompiledRule(stateDir: string, input: RegisterInput): Re
       version: '1',
       coversCondition,
       coveragePercentage: 100,
-      lifecycleState: 'active' as const,
+      // FIX: Start as 'candidate' instead of 'active'.
+      // RuleHost only loads lifecycleState='active' implementations.
+      // This means auto-generated rules will NOT block until explicitly
+      // promoted to 'active' after replay evaluation + human approval.
+      lifecycleState: 'candidate' as const,
       createdAt: now,
       updatedAt: now,
     };

package/src/core/rule-host-types.ts

@@ -66,6 +66,10 @@ export interface RuleHostResult {
   matched: boolean;
   reason: string;
   diagnostics?: Record<string, unknown>;
+  /** C: Rule ID that produced this result (for observability events) */
+  ruleId?: string;
+  /** C: Principle ID that this rule implements (for observability events) */
+  principleId?: string;
 }
 
 // ---------------------------------------------------------------------------

package/src/core/rule-host.ts

@@ -234,7 +234,13 @@ export class RuleHost {
         meta,
         evaluate: (input: RuleHostInput): RuleHostResult => {
           const frozenHelpers = createRuleHostHelpers(input);
-          return rawEvaluate(input, frozenHelpers);
+          const result = rawEvaluate(input, frozenHelpers);
+          // C: Enrich result with rule/principle IDs for observability
+          if (result.matched && (result.decision === 'block' || result.decision === 'requireApproval')) {
+            result.ruleId = impl.ruleId;
+            result.principleId = meta.ruleId ?? impl.ruleId;
+          }
+          return result;
         },
       };
     } catch (compileError: unknown) {

package/src/hooks/gate.ts

@@ -39,6 +39,7 @@ import {
 } from '../constants/tools.js';
 import { getSession, hasRecentThinking } from '../core/session-tracker.js';
 import { getEvolutionEngine } from '../core/evolution-engine.js';
+import { EventLogService } from '../core/event-log.js';
 
 export function handleBeforeToolCall(
   event: PluginHookBeforeToolCallEvent,
@@ -205,6 +206,20 @@ export function handleBeforeToolCall(
 
     const hostResult = ruleHost.evaluate(hostInput);
     if (hostResult?.decision === 'block' || hostResult?.decision === 'requireApproval') {
+      // C: Record rule_enforced event for matched rules
+      try {
+        const eventLog = EventLogService.get(wctx.stateDir, logger as PluginLogger | undefined);
+        eventLog.recordRuleEnforced({
+          ruleId: hostResult.ruleId || 'unknown',
+          principleId: hostResult.principleId || 'unknown',
+          enforcement: hostResult.decision === 'requireApproval' ? 'requireApproval' : 'block',
+          toolName: event.toolName,
+          filePath: relPath,
+        });
+      } catch (evErr) {
+        logger?.warn?.(`[PD_GATE] Failed to record rule_enforced event: ${String(evErr)}`);
+      }
+
       const reason = hostResult.decision === 'requireApproval'
         ? `[Rule Host] Approval required: ${hostResult.reason}`
         : hostResult.reason;

package/src/hooks/prompt.ts

@@ -23,6 +23,7 @@ import {
 } from '../core/empathy-keyword-matcher.js';
 import { severityToPenalty, DEFAULT_EMPATHY_KEYWORD_CONFIG } from '../core/empathy-types.js';
 import { CorrectionCueLearner } from '../core/correction-cue-learner.js';
+import { EventLogService } from '../core/event-log.js';
 import type { PluginRuntimeSubagent } from '../service/subagent-workflow/runtime-direct-driver.js';
 
 /**
@@ -755,6 +756,18 @@ ${taskBlocks}${processingNote}
 </diagnostician_tasks>\n`;
 
         logger?.info?.(`[PD:Prompt] Injected ${Math.min(pendingCount, 3)}/${pendingCount} pending diagnostician task(s) into heartbeat prompt`);
+
+        // C: Record heartbeat_diagnosis event for observability
+        try {
+          const eventLog = EventLogService.get(wctx.stateDir, logger);
+          eventLog.recordHeartbeatDiagnosis({
+            taskCount: pendingCount,
+            taskIds: pendingTasks.slice(0, 3).map(t => t.id),
+            trigger: 'heartbeat',
+          });
+        } catch (evErr) {
+          logger?.warn?.(`[PD:Prompt] Failed to record heartbeat_diagnosis event: ${String(evErr)}`);
+        }
       }
     } catch (e) {
       logger?.warn?.(`[PD:Prompt] Failed to read diagnostician tasks: ${String(e)}`);

package/src/index.ts

@@ -262,8 +262,13 @@ const plugin = {
        
       (event: PluginHookSubagentSpawningEvent, _ctx: PluginHookSubagentContext): void | PluginHookSubagentSpawningResult => {
         try {
-          // Resolve workspace via official API, falling back to PathResolver
-          const workspaceDir = resolveWorkspaceDirFromApi(api, event.agentId) || '.';
+          // FIX (B): Never fall back to '.' — fail-fast with ERROR log if workspaceDir cannot be resolved.
+          // For subagent hooks, we use event.agentId as the target agent for workspace resolution.
+          const workspaceDir = resolveWorkspaceDirFromApi(api, event.agentId);
+          if (!workspaceDir) {
+            api.logger.error(`[PD] subagent_spawning: cannot resolve workspaceDir for agent "${event.agentId}" — skipping shadow routing`);
+            return { status: 'ok' };
+          }
           api.logger?.debug?.(`[PD] workspaceDir resolved for subagent_spawning: ${workspaceDir}`);
           const { agentId, childSessionKey } = event;
           // Only handle PD local worker profiles
@@ -301,8 +306,12 @@ const plugin = {
       'subagent_ended',
       (event: PluginHookSubagentEndedEvent, ctx: PluginHookSubagentContext): void => {
         try {
-          // Resolve workspace via official API, falling back to PathResolver
-          const workspaceDir = resolveWorkspaceDirFromApi(api, undefined) || '.';
+          // FIX (B): Never fall back to '.' — fail-fast with ERROR log if workspaceDir cannot be resolved.
+          const workspaceDir = resolveWorkspaceDirFromApi(api, undefined);
+          if (!workspaceDir) {
+            api.logger.error(`[PD] subagent_ended: cannot resolve workspaceDir — skipping shadow observation completion`);
+            return;
+          }
           api.logger?.debug?.(`[PD] workspaceDir resolved for subagent_ended: ${workspaceDir}`);
           // Complete any pending shadow observation for this subagent session
           const shadowObsId = pendingShadowObservations.get(event.targetSessionKey);

package/src/service/evolution-worker.ts

@@ -922,6 +922,8 @@ async function processEvolutionQueue(wctx: WorkspaceContext, logger: PluginLogge
                 if (logger) logger.info(`[PD:EvolutionWorker] Task ${task.id} completed - marker file detected`);
 
                 let principlesGenerated = 0;
+                // C: Track report success for event recording
+                let reportSuccess = false;
                 // Create principle from the diagnostician's JSON report.
                 const reportPath = path.join(wctx.stateDir, `.diagnostician_report_${task.id}.json`);
                 if (fs.existsSync(reportPath)) {
@@ -1023,6 +1025,14 @@ async function processEvolutionQueue(wctx: WorkspaceContext, logger: PluginLogge
                                     if (principleId) {
                                         logger.info(`[PD:EvolutionWorker] Created principle ${principleId} from marker fallback for task ${task.id}`);
                                         principlesGenerated = 1;
+                                        // C: Record principle_candidate_created event for observability
+                                        if (eventLog) {
+                                            eventLog.recordPrincipleCandidate({
+                                                principleId,
+                                                taskId: task.id,
+                                                source: 'diagnostician',
+                                            });
+                                        }
                                     } else {
                                         logger.warn(`[PD:EvolutionWorker] createPrincipleFromDiagnosis returned null for task ${task.id} (may be duplicate or blacklisted)`);
                                     }
@@ -1038,6 +1048,8 @@ async function processEvolutionQueue(wctx: WorkspaceContext, logger: PluginLogge
                     } catch (err) {
                         logger.warn(`[PD:EvolutionWorker] Failed to parse diagnostician report for task ${task.id}: ${String(err)}`);
                     }
+                    // C: Report was found and processed (try block succeeded or had non-fatal issues)
+                    reportSuccess = true;
                 } else {
                     logger.warn(`[PD:EvolutionWorker] No diagnostician report found for completed task ${task.id} (expected: .diagnostician_report_${task.id}.json)`);
                 }
@@ -1059,6 +1071,15 @@ async function processEvolutionQueue(wctx: WorkspaceContext, logger: PluginLogge
                 // FIX (#187): Remove the task from the diagnostician task store
                 await completeDiagnosticianTask(wctx.stateDir, task.id);
 
+                // C: Record diagnostician_report event for observability
+                if (eventLog) {
+                    eventLog.recordDiagnosticianReport({
+                        taskId: task.id,
+                        reportPath,
+                        success: reportSuccess,
+                    });
+                }
+
                 // Log to EvolutionLogger
                 const durationMs = task.started_at
                     ? Date.now() - new Date(task.started_at).getTime()
@@ -1349,6 +1370,15 @@ async function processEvolutionQueue(wctx: WorkspaceContext, logger: PluginLogge
                 await addDiagnosticianTask(wctx.stateDir, highestScoreTask.id, heartbeatContent);
                 if (logger) logger.info(`[PD:EvolutionWorker] Wrote diagnostician task to diagnostician_tasks.json for task ${highestScoreTask.id}`);
 
+                // C: Record diagnosis_task_written event for observability
+                if (eventLog) {
+                    eventLog.recordDiagnosisTask({
+                        taskId: highestScoreTask.id,
+                        painEventId: highestScoreTask.painEventId !== undefined ? String(highestScoreTask.painEventId) : undefined,
+                        sessionId: highestScoreTask.session_id,
+                    });
+                }
+
                 // Task store write succeeded, now mark task as in_progress
                 highestScoreTask.task = taskDescription;
                 highestScoreTask.status = 'in_progress';

package/src/service/runtime-summary-service.ts

@@ -5,6 +5,7 @@ import { listSessions } from '../core/session-tracker.js';
 import { WorkspaceContext } from '../core/workspace-context.js';
 import { evaluatePhase3Inputs } from './phase3-input-filter.js';
 import { TrajectoryRegistry } from '../core/trajectory.js';
+import { getPendingDiagnosticianTasks } from '../core/diagnostician-task-store.js';
 import type { RuntimeTruth, AnalyticsTruth } from '../types/runtime-summary.js';
 
 export type RuntimeDataQuality = 'authoritative' | 'partial';
@@ -60,6 +61,19 @@ export interface RuntimeSummary {
     };
     dataQuality: RuntimeDataQuality;
   };
+  // D: Heartbeat Diagnostician chain — separate from evolution/nocturnal chain
+  heartbeatDiagnosis: {
+    /** Tasks pending in diagnostician_tasks.json (not yet processed by heartbeat) */
+    pendingTasks: number;
+    /** Total diagnosis tasks written by evolution worker (today from event log) */
+    tasksWrittenToday: number;
+    /** Total diagnostician reports written (today from event log) */
+    reportsWrittenToday: number;
+    /** Total principle candidates created from heartbeat chain (today from event log) */
+    candidatesCreatedToday: number;
+    /** Heartbeats that injected diagnostician tasks (today from event log) */
+    heartbeatsInjectedToday: number;
+  };
   phase3: {
     queueTruthReady: boolean;
     phase3ShadowEligible: boolean;
@@ -177,6 +191,14 @@ export class RuntimeSummaryService {
       toolCalls?: number;
       painSignals?: number;
       evolutionTasks?: number;
+      evolution?: {
+        diagnosisTasksWritten?: number;
+        diagnosticianReportsWritten?: number;
+        principleCandidatesCreated?: number;
+        heartbeatsInjected?: number;
+        [key: string]: unknown;
+      };
+      [key: string]: unknown;
     }>>(
       path.join(wctx.stateDir, 'logs', 'daily-stats.json'),
       warnings,
@@ -233,6 +255,20 @@ export class RuntimeSummaryService {
     const gfiSources = this.buildGfiSources(events, selectedSessionId);
     const gateStats = this.buildGateStats(events, selectedSessionId, warnings);
 
+    // D: Heartbeat Diagnostician chain — separate from evolution/nocturnal chain
+    // Read pending tasks from the diagnostician task store
+    const pendingDiagTasks = getPendingDiagnosticianTasks(wctx.stateDir);
+    // Read heartbeat diagnosis stats from daily event log
+    const todayStr = generatedAt.slice(0, 10);
+    const diagDailyStats = dailyStats?.[todayStr]?.evolution;
+    const heartbeatDiagnosis = {
+      pendingTasks: pendingDiagTasks.length,
+      tasksWrittenToday: diagDailyStats?.diagnosisTasksWritten ?? 0,
+      reportsWrittenToday: diagDailyStats?.diagnosticianReportsWritten ?? 0,
+      candidatesCreatedToday: diagDailyStats?.principleCandidatesCreated ?? 0,
+      heartbeatsInjectedToday: diagDailyStats?.heartbeatsInjected ?? 0,
+    };
+
     // Read trajectory analytics data (historical data, NOT runtime truth)
     const trajectoryStats = this.readTrajectoryStats(workspaceDir, warnings);
 
@@ -310,6 +346,8 @@ export class RuntimeSummaryService {
         lastSignal: lastPainSignal,
       },
       gate: gateStats,
+      // D: Heartbeat Diagnostician chain — separate from evolution/nocturnal
+      heartbeatDiagnosis,
       metadata: {
         generatedAt,
         workspaceDir,

package/src/tools/critique-prompt.ts

@@ -29,11 +29,10 @@ export function buildCritiquePromptV2(
 ): string {
     const { context, depth = 2, workspaceDir, api } = params;
     
-    // 1. 确定工作区目录 (优先级：显式传入 > api.config > official API)
-    const effectiveWorkspaceDir = workspaceDir
-        || (api?.config?.workspaceDir as string)
-        || resolveWorkspaceDirFromApi(api);
-    
+    // FIX (B): Priority: explicitly passed workspaceDir > official API resolution
+    // Do NOT chain through api.config?.workspaceDir which may be stale.
+    const effectiveWorkspaceDir = workspaceDir || resolveWorkspaceDirFromApi(api);
+
     if (!effectiveWorkspaceDir) {
         throw new Error('Workspace directory is required for deep reflection.');
     }

package/src/tools/deep-reflect.ts

@@ -148,10 +148,11 @@ export function createDeepReflectTool(api: OpenClawPluginApi) {
  * Resolve workspace directory for deep reflection tool.
  */
 function resolveReflectionWorkspace(api: OpenClawPluginApi): string {
-    const dir = (api.config?.workspaceDir as string)
-        || resolveWorkspaceDirFromApi(api);
+    // FIX (B): Only use resolveWorkspaceDirFromApi — do not chain through api.config?.workspaceDir
+    // which may be stale. Fail-fast if workspace cannot be resolved.
+    const dir = resolveWorkspaceDirFromApi(api);
     if (!dir) {
-        throw new WorkspaceNotFoundError('deep-reflect: workspace directory could not be resolved via API or config');
+        throw new WorkspaceNotFoundError('deep-reflect: workspace directory could not be resolved via API');
     }
     return dir;
 }

package/src/types/event-types.ts

@@ -15,10 +15,15 @@ export type EventType =
   | 'plan_approval'
   | 'evolution_task'
   | 'deep_reflection'
-
   | 'empathy_rollback'
   | 'error'
-  | 'warn';
+  | 'warn'
+  // C: Diagnostician heartbeat chain events
+  | 'diagnosis_task'        // Diagnostician task written to task store
+  | 'heartbeat_diagnosis'  // Heartbeat injected diagnostician tasks
+  | 'diagnostician_report' // Diagnostician completed and wrote report
+  | 'principle_candidate'  // Principle candidate created from report
+  | 'rule_enforced';       // Rule enforced (matched) during tool call
 
 export type EventCategory =
   | 'success'
@@ -32,7 +37,12 @@ export type EventCategory =
   | 'promoted'
   | 'passed'
   | 'changed'
-  | 'rolled_back';
+  | 'rolled_back'
+  // C: New categories for diagnostician heartbeat chain
+  | 'written'
+  | 'injected'
+  | 'created'
+  | 'matched';
 
 /**
  * Base event structure for JSONL logging.
@@ -174,6 +184,54 @@ export interface EmpathyRollbackEventData {
   triggeredBy: 'user_command' | 'natural_language' | 'system';
 }
 
+/**
+ * C: New event data types for diagnostician heartbeat chain observability.
+ * Maps heartbeat_injected -> when prompt.ts injects diagnostician tasks into heartbeat
+ */
+export interface HeartbeatDiagnosisEventData {
+  taskCount: number;
+  taskIds: string[];
+  trigger: 'heartbeat' | 'immediate';
+}
+
+/**
+ * Maps diagnosis_task_written -> when evolution-worker writes to diagnostician_tasks.json
+ */
+export interface DiagnosisTaskEventData {
+  taskId: string;
+  painEventId?: string;
+  sessionId?: string;
+}
+
+/**
+ * Maps diagnostician_report_written -> when diagnostician completes and writes report
+ */
+export interface DiagnosticianReportEventData {
+  taskId: string;
+  reportPath: string;
+  success: boolean;
+}
+
+/**
+ * Maps principle_candidate_created -> when evolution-worker extracts principle from report
+ */
+export interface PrincipleCandidateEventData {
+  principleId: string;
+  taskId: string;
+  source: 'diagnostician' | 'nocturnal' | 'manual';
+}
+
+/**
+ * Maps rule_enforced -> when RuleHost evaluate() returns matched during tool call
+ */
+export interface RuleEnforcedEventData {
+  ruleId: string;
+  principleId: string;
+  enforcement: 'warn' | 'block' | 'requireApproval';
+  toolName: string;
+  filePath: string;
+}
+
 // ============== Daily Statistics ==============
 
 export interface ToolCallStats {
@@ -264,6 +322,12 @@ export interface EvolutionStats {
   tasksEnqueued: number;
   tasksCompleted: number;
   rulesPromoted: number;
+  // C: Diagnostician heartbeat chain counters
+  diagnosisTasksWritten: number;
+  heartbeatsInjected: number;
+  diagnosticianReportsWritten: number;
+  principleCandidatesCreated: number;
+  rulesEnforced: number;
 }
 
 export interface HookStats {
@@ -422,6 +486,12 @@ export function createEmptyDailyStats(date: string): DailyStats {
       tasksEnqueued: 0,
       tasksCompleted: 0,
       rulesPromoted: 0,
+      // C: Diagnostician heartbeat chain counters
+      diagnosisTasksWritten: 0,
+      heartbeatsInjected: 0,
+      diagnosticianReportsWritten: 0,
+      principleCandidatesCreated: 0,
+      rulesEnforced: 0,
     },
     hooks: {
       total: 0,

package/tests/core/bootstrap-rules.test.ts

@@ -235,6 +235,20 @@ describe('bootstrap-rules', () => {
       // Act & Assert: Should throw
       expect(() => selectPrinciplesForBootstrap(stateDir, 3)).toThrow('No deterministic principles');
     });
+
+    // Regression test for Issue #356
+    it('T-01..T-10 as deterministic — no crash on fresh workspace', () => {
+      const trainingStates = [
+        { principleId: 'T-01', evaluability: 'deterministic', applicableOpportunityCount: 0, observedViolationCount: 0, complianceRate: 1, violationTrend: 0, generatedSampleCount: 0, approvedSampleCount: 0, includedTrainRunIds: [], deployedCheckpointIds: [], internalizationStatus: 'needs_training' },
+        { principleId: 'T-02', evaluability: 'deterministic', applicableOpportunityCount: 0, observedViolationCount: 0, complianceRate: 1, violationTrend: 0, generatedSampleCount: 0, approvedSampleCount: 0, includedTrainRunIds: [], deployedCheckpointIds: [], internalizationStatus: 'needs_training' },
+      ];
+      const principles = trainingStates.map((s) => createLedgerPrinciple(s.principleId, { evaluability: s.evaluability }));
+      setupLedger(trainingStates, principles);
+      const selected = selectPrinciplesForBootstrap(stateDir, 3);
+      expect(selected).toHaveLength(2);
+      expect(selected).toContain('T-01');
+      expect(selected).toContain('T-02');
+    });
   });
 
   describe('bootstrapRules', () => {

package/tests/core/evolution-reducer.compilation-retry.test.ts

@@ -4,6 +4,7 @@ import * as path from 'path';
 import { afterEach, describe, expect, it } from 'vitest';
 import { EvolutionReducerImpl } from '../../src/core/evolution-reducer.js';
 import { loadLedger } from '../../src/core/principle-tree-ledger.js';
+import { safeRmDir } from '../test-utils.js';
 
 const tempDirs: string[] = [];
 
@@ -29,7 +30,7 @@ function makeStateDir(workspace: string): string {
 
 afterEach(() => {
   for (const dir of tempDirs.splice(0)) {
-    fs.rmSync(dir, { recursive: true, force: true });
+    safeRmDir(dir);
   }
 });
 

package/tests/core/ledger-registrar.test.ts

@@ -106,7 +106,10 @@ describe('ledger-registrar', () => {
       expect(rule).toBeDefined();
       expect(rule.id).toBe('R_P_001_auto');
       expect(rule.type).toBe('gate');
-      expect(rule.enforcement).toBe('block');
+      // FIX: Auto-generated rules default to 'warn' enforcement (not 'block')
+      // to prevent false positives like P_001 mis-blocking normal edits.
+      // They also start as 'candidate' lifecycle until replay evaluation passes.
+      expect(rule.enforcement).toBe('warn');
       expect(rule.status).toBe('proposed');
       expect(rule.principleId).toBe('P_001');
       expect(rule.implementationIds).toContain('IMPL_P_001_auto');
@@ -118,7 +121,7 @@ describe('ledger-registrar', () => {
       expect(impl.ruleId).toBe('R_P_001_auto');
       expect(impl.type).toBe('code');
       expect(impl.coversCondition).toBe('file_write');
-      expect(impl.lifecycleState).toBe('active');
+      expect(impl.lifecycleState).toBe('candidate');
 
       // Verify principle linked to rule
       const principle = ledger.tree.principles['P_001'];

package/tests/core/principle-compiler.test.ts

@@ -127,12 +127,14 @@ describe('PrincipleCompiler', () => {
     const rule = ledger.tree.rules['R_P_066_auto'];
     expect(rule).toBeDefined();
     expect(rule.type).toBe('gate');
-    expect(rule.enforcement).toBe('block');
+    // FIX: Auto-generated rules default to 'warn' enforcement
+    expect(rule.enforcement).toBe('warn');
     expect(rule.status).toBe('proposed');
 
     const impl = ledger.tree.implementations['IMPL_P_066_auto'];
     expect(impl).toBeDefined();
-    expect(impl.lifecycleState).toBe('active');
+    // FIX: Auto-generated implementations start as 'candidate' (not 'active')
+    expect(impl.lifecycleState).toBe('candidate');
   });
 
   // -----------------------------------------------------------------------

package/tests/core/regression-v1-9-1.test.ts

@@ -21,6 +21,7 @@ import {
 } from '../../src/core/principle-training-state.js';
 import { isExpectedSubagentError } from '../../src/service/subagent-workflow/subagent-error-utils.js';
 import { WorkspaceContext } from '../../src/core/workspace-context.js';
+import { safeRmDir } from '../test-utils.js';
 
 const tempDirs: string[] = [];
 
@@ -32,7 +33,7 @@ function makeTempDir(): string {
 
 afterEach(() => {
   for (const dir of tempDirs.splice(0)) {
-    fs.rmSync(dir, { recursive: true, force: true });
+    safeRmDir(dir);
   }
 });
 

package/tests/integration/gate-real-io.e2e.test.ts

@@ -16,6 +16,7 @@ import * as os from 'os';
 import * as path from 'path';
 import { TrajectoryDatabase } from '../../src/core/trajectory.js';
 import { EventLog } from '../../src/core/event-log.js';
+import { safeRmDir } from '../test-utils.js';
 
 // ─────────────────────────────────────────────────────────────────────
 // Helper functions
@@ -83,12 +84,8 @@ function createTestWorkspace(): TestWorkspace {
 
 function cleanupWorkspace(ws: TestWorkspace | null): void {
   if (!ws) return;
-  try {
-    ws.trajectory?.dispose();
-    fs.rmSync(ws.workspaceDir, { recursive: true, force: true });
-  } catch {
-    // ignore
-  }
+  ws.trajectory?.dispose();
+  safeRmDir(ws.workspaceDir);
 }
 
 // ─────────────────────────────────────────────────────────────────────
@@ -237,8 +234,8 @@ describe('Gate: Resilience', () => {
 
   describe('RESILIENCE: Missing state directory', () => {
     it('EventLog MUST handle missing logs directory', () => {
-      // Remove state directory
-      fs.rmSync(ws!.stateDir, { recursive: true, force: true });
+      // Remove state directory (safeRmDir handles Windows EPERM from held handles)
+      safeRmDir(ws!.stateDir);
 
       // Attempt to create event log
       // Should recreate the directory

package/tests/integration/pain-id-chain-e2e.test.ts

@@ -5,8 +5,9 @@
  *   1. recordPainEvent() returns AUTOINCREMENT row ID as number
  *   2. createPrincipleFromDiagnosis(painId: String(painEventId))
  *   3. derivedFromPainIds stores the stringified numeric ID
- *   4. PrincipleCompiler.compileOne() succeeds (registers active implementation)
- *   5. RuleHost.evaluate(matching input) → block
+ *   4. PrincipleCompiler.compileOne() succeeds (registers candidate implementation)
+ *   5. Promote to active
+ *   6. RuleHost.evaluate(matching input) → block
  *   6. RuleHost.evaluate(non-matching input) → undefined (passthrough)
  *
  * Pain ID chain fixed in commits 4b0dce59 and 0146bbb7:
@@ -25,7 +26,9 @@ import { RuleHost } from '../../src/core/rule-host.js';
 import { EvolutionReducerImpl } from '../../src/core/evolution-reducer.js';
 import {
   loadLedger,
+  transitionImplementationState,
 } from '../../src/core/principle-tree-ledger.js';
+import { safeRmDir } from '../test-utils.js';
 import type { RuleHostInput } from '../../src/core/rule-host-types.js';
 
 // ---------------------------------------------------------------------------
@@ -52,7 +55,7 @@ function createTestWorkspace(): TestWorkspace {
 
 function disposeTestWorkspace(ws: TestWorkspace): void {
   ws.trajectory.dispose();
-  fs.rmSync(ws.workspaceDir, { recursive: true, force: true });
+  safeRmDir(ws.workspaceDir);
 }
 
 // ---------------------------------------------------------------------------
@@ -131,12 +134,15 @@ describe('Pain ID Chain E2E: pain event → principle → compile → RuleHost',
     expect(compileResult.ruleId).toBeDefined();
     expect(compileResult.implementationId).toBeDefined();
 
-    // Verify implementation is active
+    // Verify implementation is candidate (not active — must be promoted before enforcing)
     const updatedLedger = loadLedger(ws.stateDir);
     const impl = updatedLedger.tree.implementations[compileResult.implementationId!];
-    expect(impl.lifecycleState).toBe('active');
+    expect(impl.lifecycleState).toBe('candidate');
 
-    // ── Step 5: RuleHost.evaluate(matching input) → block ──
+    // ── Step 5: Promote to active so RuleHost will enforce ──
+    transitionImplementationState(ws.stateDir, compileResult.implementationId!, 'active');
+
+    // ── Step 6: RuleHost.evaluate(matching input) → block ──
     const host = new RuleHost(ws.stateDir, { warn: () => {} });
 
     const matchingInput: RuleHostInput = {

package/tests/integration/principle-compiler-e2e.test.ts

@@ -4,9 +4,11 @@
  * Tests the full chain:
  *   1. Set up principle in ledger with derivedFromPainIds
  *   2. Record tool call (bash, failure) and pain event in trajectory DB
- *   3. Compile principle via PrincipleCompiler (registers as active + persists code)
- *   4. RuleHost.evaluate(matching input) → block
- *   5. RuleHost.evaluate(non-matching input) → undefined (passthrough)
+ *   3. Compile principle via PrincipleCompiler (registers as 'candidate' — NOT 'active')
+ *   4. RuleHost.evaluate(matching input) → NO block yet (candidate not loaded)
+ *   5. Promote implementation to 'active'
+ *   6. RuleHost.evaluate(matching input) → block
+ *   7. RuleHost.evaluate(non-matching input) → undefined (passthrough)
  */
 
 import { describe, it, expect, beforeEach, afterEach } from 'vitest';
@@ -19,6 +21,7 @@ import { RuleHost } from '../../src/core/rule-host.js';
 import {
   loadLedger,
   saveLedger,
+  transitionImplementationState,
 } from '../../src/core/principle-tree-ledger.js';
 import type { RuleHostInput } from '../../src/core/rule-host-types.js';
 
@@ -132,15 +135,14 @@ describe('Principle Compiler E2E: compile → promote → RuleHost blocks', () =
 
     const implId = result.implementationId!;
 
-    // Verify the implementation was registered as active (not candidate)
+    // Verify the implementation was registered as 'candidate' (not 'active')
+    // FIX: Auto-generated implementations start as 'candidate' until explicitly promoted
+    // after replay evaluation and human approval. This prevents false-positive blocks.
     const ledger = loadLedger(ws.stateDir);
     const impl = ledger.tree.implementations[implId];
-    expect(impl.lifecycleState).toBe('active');
+    expect(impl.lifecycleState).toBe('candidate');
 
-    // ── Step 4: Create RuleHost and evaluate with matching input ──
-    const host = new RuleHost(ws.stateDir, { warn: () => {} });
-
-    // Matching input: bash tool with a heartbeat command
+    // Define matching input for RuleHost evaluation (used in both Step 4 and Step 6)
     const matchingInput: RuleHostInput = {
       action: {
         toolName: 'bash',
@@ -166,6 +168,23 @@ describe('Principle Compiler E2E: compile → promote → RuleHost blocks', () =
       },
     };
 
+    // ── Step 4: RuleHost should NOT block yet (candidate not loaded) ──
+    const hostBeforePromote = new RuleHost(ws.stateDir, { warn: () => {} });
+    const noBlockResult = hostBeforePromote.evaluate(matchingInput);
+    expect(noBlockResult).toBeUndefined(); // candidate not loaded → no block
+
+    // ── Step 5: Promote to 'active' so RuleHost will enforce ──
+    transitionImplementationState(ws.stateDir, implId, 'active');
+
+    // Verify promotion
+    const ledgerAfterPromote = loadLedger(ws.stateDir);
+    const implAfterPromote = ledgerAfterPromote.tree.implementations[implId];
+    expect(implAfterPromote.lifecycleState).toBe('active');
+
+    // ── Step 6: Create RuleHost and evaluate with matching input ──
+    const host = new RuleHost(ws.stateDir, { warn: () => {} });
+
+    // Matching input: bash tool with a heartbeat command (defined in Step 4)
     const blockResult = host.evaluate(matchingInput);
 
     // Verify RuleHost blocks the matching input

package/tests/integration/principle-lifecycle.e2e.test.ts

@@ -19,6 +19,7 @@ import { EvolutionReducerImpl } from '../../src/core/evolution-reducer.js';
 import { listEvaluablePrinciples, loadStore } from '../../src/core/principle-training-state.js';
 import { updateTrainingStore } from '../../src/core/principle-tree-ledger.js';
 import { PathResolver } from '../../src/core/path-resolver.js';
+import { safeRmDir } from '../test-utils.js';
 
 describe('Principle Lifecycle E2E', () => {
   let tempDir: string;
@@ -40,7 +41,7 @@ describe('Principle Lifecycle E2E', () => {
   });
 
   afterEach(() => {
-    fs.rmSync(tempDir, { recursive: true, force: true });
+    safeRmDir(tempDir);
   });
 
   describe('Training Store Integration (#204)', () => {