principles-disciple 1.11.0 → 1.13.0

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

@@ -0,0 +1,195 @@
+/**
+ * Principle Tree Migration — Migrates trainingStore to tree.principles
+ *
+ * This migration handles the Phase 11 gap: existing principles in trainingStore
+ * were never written to tree.principles, blocking the Rule/Implementation layer.
+ *
+ * Usage:
+ *   - Called automatically by migratePrincipleTree() during plugin initialization
+ *   - Or run manually: node scripts/migrate-principle-tree.mjs <workspace-dir>
+ */
+
+import * as fs from 'fs';
+import * as path from 'path';
+import {
+  loadLedger,
+  createPrinciple,
+  type LedgerPrinciple,
+} from './principle-tree-ledger.js';
+import type { LegacyPrincipleTrainingState } from './principle-tree-ledger.js';
+import { SystemLogger } from './system-logger.js';
+
+export interface PrincipleTreeMigrationResult {
+  migratedCount: number;
+  skippedCount: number;
+  errorCount: number;
+  details: Array<{
+    principleId: string;
+    status: 'migrated' | 'skipped' | 'error';
+    reason?: string;
+  }>;
+}
+
+/**
+ * Check if migration is needed by comparing trainingStore and tree.principles
+ */
+export function needsMigration(stateDir: string): boolean {
+  const ledger = loadLedger(stateDir);
+  const trainingStoreCount = Object.keys(ledger.trainingStore).length;
+  const treePrinciplesCount = Object.keys(ledger.tree.principles).length;
+
+  // Migration needed if trainingStore has more principles than tree.principles
+  return trainingStoreCount > treePrinciplesCount;
+}
+
+/**
+ * Create a minimal LedgerPrinciple from LegacyPrincipleTrainingState
+ */
+function trainingStateToTreePrinciple(
+  principleId: string,
+  state: LegacyPrincipleTrainingState,
+  now: string
+): LedgerPrinciple {
+  return {
+    id: principleId,
+    version: 1,
+    text: `Principle ${principleId}`, // Minimal text, will be enriched from PRINCIPLES.md if available
+    triggerPattern: '', // Unknown from legacy data
+    action: '', // Unknown from legacy data
+    status: mapInternalizationStatusToPrincipleStatus(state.internalizationStatus),
+    priority: 'P1', // Default priority
+    scope: 'general',
+    evaluability: state.evaluability,
+    valueScore: 0,
+    adherenceRate: state.complianceRate * 100, // Convert 0-1 to 0-100
+    painPreventedCount: 0,
+    derivedFromPainIds: [],
+    ruleIds: [],
+    conflictsWithPrincipleIds: [],
+    createdAt: now,
+    updatedAt: now,
+  };
+}
+
+/**
+ * Map internalization status to principle status
+ */
+function mapInternalizationStatusToPrincipleStatus(
+  status: LegacyPrincipleTrainingState['internalizationStatus']
+): 'candidate' | 'active' | 'deprecated' {
+  switch (status) {
+    case 'internalized':
+    case 'deployed_pending_eval':
+      return 'active';
+    case 'regressed':
+    case 'needs_training':
+      return 'candidate';
+    case 'prompt_only':
+    case 'in_training':
+      return 'candidate';
+    default:
+      return 'candidate';
+  }
+}
+
+/**
+ * Migrate trainingStore principles to tree.principles
+ *
+ * This function is idempotent: it only migrates principles that don't exist
+ * in tree.principles yet.
+ */
+export function migratePrincipleTree(
+  stateDir: string,
+  workspaceDir?: string
+): PrincipleTreeMigrationResult {
+  const result: PrincipleTreeMigrationResult = {
+    migratedCount: 0,
+    skippedCount: 0,
+    errorCount: 0,
+    details: [],
+  };
+
+  try {
+    const ledger = loadLedger(stateDir);
+    const now = new Date().toISOString();
+
+    for (const [principleId, state] of Object.entries(ledger.trainingStore)) {
+      // Skip if already exists in tree.principles
+      if (ledger.tree.principles[principleId]) {
+        result.skippedCount++;
+        result.details.push({
+          principleId,
+          status: 'skipped',
+          reason: 'Already exists in tree.principles',
+        });
+        continue;
+      }
+
+      try {
+        const treePrinciple = trainingStateToTreePrinciple(principleId, state, now);
+        createPrinciple(stateDir, treePrinciple);
+
+        result.migratedCount++;
+        result.details.push({
+          principleId,
+          status: 'migrated',
+        });
+
+        if (workspaceDir) {
+          SystemLogger.log(
+            workspaceDir,
+            'PRINCIPLE_TREE_MIGRATED',
+            `Migrated ${principleId} from trainingStore to tree.principles`
+          );
+        }
+      } catch (err) {
+        result.errorCount++;
+        result.details.push({
+          principleId,
+          status: 'error',
+          reason: String(err),
+        });
+
+        if (workspaceDir) {
+          SystemLogger.log(
+            workspaceDir,
+            'PRINCIPLE_TREE_MIGRATION_ERROR',
+            `Failed to migrate ${principleId}: ${String(err)}`
+          );
+        }
+      }
+    }
+
+    if (workspaceDir && result.migratedCount > 0) {
+      SystemLogger.log(
+        workspaceDir,
+        'PRINCIPLE_TREE_MIGRATION_COMPLETE',
+        `Migrated ${result.migratedCount} principles to tree.principles (${result.skippedCount} skipped, ${result.errorCount} errors)`
+      );
+    }
+  } catch (err) {
+    if (workspaceDir) {
+      SystemLogger.log(
+        workspaceDir,
+        'PRINCIPLE_TREE_MIGRATION_FAILED',
+        `Migration failed: ${String(err)}`
+      );
+    }
+  }
+
+  return result;
+}
+
+/**
+ * Run migration if needed (called during plugin initialization)
+ */
+export function runMigrationIfNeeded(
+  stateDir: string,
+  workspaceDir?: string
+): PrincipleTreeMigrationResult | null {
+  if (!needsMigration(stateDir)) {
+    return null;
+  }
+
+  return migratePrincipleTree(stateDir, workspaceDir);
+}

package/src/core/profile.ts

@@ -54,9 +54,11 @@ export const PROFILE_DEFAULTS = {
     window_ms: 5 * 60 * 1000, // 5 minute window
   high_risk_tools: ['run_shell_command', 'delete_file', 'move_file'],
   },
-  custom_guards: [] as Array<{ pattern: string; message: string; severity: string }>,
+  custom_guards: [] as { pattern: string; message: string; severity: string }[],
 };
 
+/* eslint-disable @typescript-eslint/no-explicit-any */
+// Reason: normalizeProfile handles arbitrary JSON profile shapes where static typing cannot capture runtime field existence
 export function normalizeProfile(rawProfile: any): any {
   const defaults = JSON.parse(JSON.stringify(PROFILE_DEFAULTS));
   const warnings: string[] = [];

package/src/core/promotion-gate.ts

@@ -44,25 +44,12 @@ import * as fs from 'fs';
 import * as path from 'path';
 import * as crypto from 'crypto';
 import { withLock } from '../utils/file-lock.js';
-import type { WorkerProfile } from './model-deployment-registry.js';
 import {
   getCheckpoint,
   getEvalSummary,
-  listEvalSummaries,
-  getCheckpointLineage,
 } from './model-training-registry.js';
-import {
-  getDeployment,
-  getActiveCheckpointForProfile,
-  rollbackDeployment,
-} from './model-deployment-registry.js';
-import {
-  type TrainableWorkerProfile,
-} from './external-training-contract.js';
-import {
-  computeShadowStats,
-  type ShadowStats,
-} from './shadow-observation-registry.js';
+import { type TrainableWorkerProfile } from './external-training-contract.js';
+import { computeShadowStats } from './shadow-observation-registry.js';
 
 // ---------------------------------------------------------------------------
 // Constants
@@ -83,6 +70,7 @@ export const DEFAULT_ALLOWED_MARGIN = 0.05;
  * Allowed worker profiles for Phase 7 shadow rollout.
  * Only bounded local workers eligible. local-reader first, local-editor deferred.
  */
+// eslint-disable-next-line no-unused-vars, @typescript-eslint/no-unused-vars -- Reason: reserved for Phase 7 shadow rollout profile validation
 const ALLOWED_ROLLOUT_PROFILES: readonly TrainableWorkerProfile[] = ['local-reader'];
 
 /**
@@ -245,7 +233,8 @@ function writeRegistry(stateDir: string, registry: PromotionRegistry): void {
  */
 function withPromotionRegistryLock<T>(
   stateDir: string,
-  fn: (registry: PromotionRegistry) => T
+  // eslint-disable-next-line no-unused-vars -- Reason: callback parameter name is type documentation, actual value passed at call site
+  fn: (_registry: PromotionRegistry) => T
 ): T {
   const registryPath = getRegistryPath(stateDir);
   return withLock(registryPath, () => {
@@ -329,7 +318,8 @@ export function evaluatePromotionGate(
 ): PromotionGateResult {
   const {
     checkpointId,
-    targetProfile,
+    // eslint-disable-next-line no-unused-vars, @typescript-eslint/no-unused-vars -- Reason: reserved for Phase 7 profile-based targeting
+    targetProfile: _targetProfile,
     baselineMetrics,
     minDelta = DEFAULT_MIN_DELTA,
     allowedMargin = DEFAULT_ALLOWED_MARGIN,
@@ -380,7 +370,7 @@ export function evaluatePromotionGate(
   }
 
   // --- Check 4: Delta must be positive and above threshold ---
-  const delta = evalSummary.delta;
+  const {delta} = evalSummary;
   const deltaCheck = {
     actual: delta,
     threshold: minDelta,
@@ -398,7 +388,9 @@ export function evaluatePromotionGate(
   // PREFER real shadow evidence over eval verdict proxy
   // Shadow evidence comes from actual runtime routing decisions
   const shadowStats = computeShadowStats(stateDir, { checkpointId });
+  // eslint-disable-next-line @typescript-eslint/init-declarations -- assigned in both if/else branches
   let arbiterRejectRate: number;
+  // eslint-disable-next-line @typescript-eslint/init-declarations -- assigned in both if/else branches
   let arbiterRejectSource: 'shadow' | 'eval-proxy';
 
   if (shadowStats && shadowStats.isStatisticallySignificant) {
@@ -432,7 +424,9 @@ export function evaluatePromotionGate(
 
   // --- Check 6: Executability reject rate constraint ---
   // PREFER real shadow evidence: escalation rate + profile rejection rate
+  // eslint-disable-next-line @typescript-eslint/init-declarations -- assigned in both if/else branches
   let executabilityRejectRate: number;
+  // eslint-disable-next-line @typescript-eslint/init-declarations -- assigned in both if/else branches
   let executabilityRejectSource: 'shadow' | 'eval-proxy';
 
   if (shadowStats && shadowStats.isStatisticallySignificant) {
@@ -490,6 +484,7 @@ export function evaluatePromotionGate(
     qualityCheck.passed;
 
   // --- Suggest state based on checks ---
+  // eslint-disable-next-line @typescript-eslint/init-declarations -- assigned in all branches
   let suggestedState: PromotionState | undefined;
   if (allPassed) {
     suggestedState = 'candidate_only';
@@ -590,6 +585,7 @@ export function advancePromotion(
     // - rejected → candidate_only/shadow_ready: allowed via re-evaluation
     //   (new eval data may reverse a previous rejection)
     //
+    // eslint-disable-next-line @typescript-eslint/init-declarations -- assigned in all branches
     let targetState: PromotionState;
     if (!gateResult.passes) {
       targetState = 'rejected';