create-principles-disciple 1.93.0 → 1.95.0

package/plugin/dist/core/paths.js

@@ -64,7 +64,8 @@ export const PD_FILES = {
     CURRENT_FOCUS: posixJoin(PD_DIRS.OKR, 'CURRENT_FOCUS.md'),
     WEEK_STATE: posixJoin(PD_DIRS.OKR, 'WEEK_STATE.json'),
     THINKING_OS_CANDIDATES: posixJoin(PD_DIRS.MEMORY, 'THINKING_OS_CANDIDATES.md'),
-    SEMANTIC_PAIN: posixJoin(PD_DIRS.PAIN_SAMPLES, 'confusion_samples.md'),
+    // SEMANTIC_PAIN (confusion_samples.md) removed (PRI-451 Wave 1): the file
+    // had zero readers. The lifecycle write that populated it was also removed.
     EVOLUTION_STREAM: posixJoin(PD_DIRS.MEMORY, 'evolution.jsonl'),
     EVOLUTION_LOCK: posixJoin(PD_DIRS.LOCKS, 'evolution'),
 };

package/plugin/dist/core/principle-tree-ledger.d.ts

@@ -1,82 +1,30 @@
-import type { Implementation, ImplementationLifecycleState, Principle, PrincipleTreeStore, PrincipleValueMetrics, Rule } from '../types/principle-tree-schema.js';
-export declare const TREE_NAMESPACE = "_tree";
-export interface LegacyPrincipleTrainingState {
-    principleId: string;
-    evaluability: 'deterministic' | 'weak_heuristic' | 'manual_only';
-    applicableOpportunityCount: number;
-    observedViolationCount: number;
-    complianceRate: number;
-    violationTrend: number;
-    generatedSampleCount: number;
-    approvedSampleCount: number;
-    includedTrainRunIds: string[];
-    deployedCheckpointIds: string[];
-    lastEvalScore?: number;
-    internalizationStatus: 'prompt_only' | 'needs_training' | 'in_training' | 'deployed_pending_eval' | 'internalized' | 'regressed';
-}
-export type LegacyPrincipleTrainingStore = Record<string, LegacyPrincipleTrainingState>;
-export interface LedgerPrinciple extends Principle {
-    suggestedRules?: string[];
-}
-export interface LedgerRule extends Rule {
-    implementationIds: string[];
-}
-export interface LedgerTreeStore extends Omit<PrincipleTreeStore, 'principles' | 'rules'> {
-    principles: Record<string, LedgerPrinciple>;
-    rules: Record<string, LedgerRule>;
-}
-export interface HybridLedgerStore {
-    trainingStore: LegacyPrincipleTrainingStore;
-    tree: LedgerTreeStore;
-}
-export interface PrincipleSubtree {
-    principle: LedgerPrinciple;
-    rules: {
-        rule: LedgerRule;
-        implementations: Implementation[];
-    }[];
-}
-export declare function getLedgerFilePath(stateDir: string): string;
-export declare function loadLedger(stateDir: string): HybridLedgerStore;
-export declare function saveLedger(stateDir: string, store: HybridLedgerStore): void;
-export declare function saveLedgerAsync(stateDir: string, store: HybridLedgerStore): Promise<void>;
-export declare function updateTrainingStore(stateDir: string, mutate: (store: LegacyPrincipleTrainingStore) => void): void;
 /**
- * Add a new principle directly to the ledger tree.
- * This is the companion to updatePrinciple() — use this when creating a NEW
- * principle so the compiler can find it in tree.principles.
+ * Principle Tree Ledger — plugin adapter (re-export) over @principles/core.
  *
- * Idempotent: if the principle already exists, overwrites (update semantics).
- */
-export declare function addPrincipleToLedger(stateDir: string, principle: LedgerPrinciple): LedgerPrinciple;
-export declare function createRule(stateDir: string, rule: LedgerRule): LedgerRule;
-export declare function createImplementation(stateDir: string, implementation: Implementation): Implementation;
-export declare function updatePrinciple(stateDir: string, principleId: string, updates: Partial<LedgerPrinciple>): LedgerPrinciple;
-export declare function updateRule(stateDir: string, ruleId: string, updates: Partial<LedgerRule>): LedgerRule;
-export declare function deleteRule(stateDir: string, ruleId: string): LedgerRule | undefined;
-export declare function updateImplementation(stateDir: string, implementationId: string, updates: Partial<Implementation>): Implementation;
-export declare function deleteImplementation(stateDir: string, implementationId: string): Implementation | undefined;
-export declare function listImplementationsForRule(stateDir: string, ruleId: string): Implementation[];
-export declare function getPrincipleSubtree(stateDir: string, principleId: string): PrincipleSubtree | undefined;
-export declare function updatePrincipleValueMetrics(stateDir: string, principleId: string, metrics: PrincipleValueMetrics): PrincipleValueMetrics;
-/**
- * Validate a lifecycle state transition.
- * Returns true if the transition is valid, false otherwise.
- */
-export declare function isValidLifecycleTransition(from: ImplementationLifecycleState, to: ImplementationLifecycleState): boolean;
-/**
- * Get allowed transitions for a given lifecycle state.
- */
-export declare function getAllowedTransitions(from: ImplementationLifecycleState): ImplementationLifecycleState[];
-/**
- * Transition an implementation's lifecycle state with validation.
- * Throws on invalid transitions */
-export declare function transitionImplementationState(stateDir: string, implementationId: string, newState: ImplementationLifecycleState): Implementation;
-/**
- * Get implementations in a specific lifecycle state for a given rule.
- */
-export declare function listRuleImplementationsByState(stateDir: string, ruleId: string, state: ImplementationLifecycleState): Implementation[];
-/**
- * Find active implementation for a rule (helper for rule host lookup).
+ * PRI-459: This file WAS a full duplicate implementation of
+ * principle_training_state.json parsing / serialization / mutation (~600
+ * lines of inlined parsers, serializers, mutators, and a parallel codec).
+ * That dual ownership caused two real failure classes:
+ *
+ *   1. Lost updates — core wrote the file UNLOCKED, the plugin wrote it WITH
+ *      a lock, and neither knew the other's lock. Concurrent writers (e.g.
+ *      evolution-worker async + a pd-cli command) could silently drop edits.
+ *   2. Silent field loss — the two codecs parsed the same bytes at different
+ *      strictness; a field one side persisted could be dropped on the next
+ *      load by the other.
+ *
+ * Both are now fixed by converging on a SINGLE source of truth in core:
+ *   - parse/serialize: @principles/core/runtime-v2/principle-tree/ledger-codec
+ *   - mutation (with cross-process file lock): @principles/core/principle-tree-ledger
+ *
+ * This file is now a thin re-export so existing relative imports
+ * (`from './principle-tree-ledger.js'`) keep resolving. Consumers get the
+ * exact same API surface, now backed by the locked core implementation.
+ *
+ * Do NOT reintroduce parsing / serialization / mutation logic here. The
+ * architecture-regression guard "PRI-459: single principle_training_state
+ * ledger implementation" enforces this.
  */
-export declare function findActiveImplementation(stateDir: string, ruleId: string): Implementation | null;
+export { type Principle, type Rule, type Implementation, type PrincipleValueMetrics, type LedgerPrinciple, type LedgerRule, type LedgerTreeStore, type LegacyPrincipleTrainingState, type LegacyPrincipleTrainingStore, type HybridLedgerStore, type ImplementationLifecycleState, type PrincipleSubtree, TREE_NAMESPACE, LockAcquisitionError, loadLedger, saveLedger, saveLedgerAsync, updateTrainingStore, addPrincipleToLedger, createRule, createImplementation, updatePrinciple, updateRule, deleteRule, updateImplementation, deleteImplementation, listImplementationsForRule, getPrincipleSubtree, updatePrincipleValueMetrics, isValidLifecycleTransition, getAllowedTransitions, transitionImplementationState, listRuleImplementationsByState, findActiveImplementation, } from '@principles/core/principle-tree-ledger';
+import { getLedgerFilePathPublic } from '@principles/core/principle-tree-ledger';
+export declare const getLedgerFilePath: typeof getLedgerFilePathPublic;