principles-disciple 1.72.0 → 1.74.0

package/src/core/principle-compiler/template-generator.ts

@@ -1,108 +1,8 @@
 /**
- * Template Generator for Principle Compiler
+ * Template Generator — Re-export from @principles/core
  *
- * Generates RuleHost sandbox code from PainPattern descriptors.
- * Produces self-contained JS modules with `export const meta` and
- * `export function evaluate(input)` that can be loaded at runtime.
- *
- * SECURITY: All interpolated values use JSON.stringify or safe helpers
- * to prevent code injection through principleId, coversCondition, or regex patterns.
- */
-
-export interface PainPattern {
-  toolName: string;
-  pathRegex?: string;
-  commandRegex?: string;
-  contentRegex?: string;
-  errorType?: string;
-}
-
-/**
- * Derives the auto-rule display name from a principle ID.
- */
-function toAutoName(principleId: string): string {
-  return `Auto_${principleId}`;
-}
-
-/**
- * Derives the auto-rule ID from a principle ID.
- * Must match ledger-registrar convention: "P_066" => "R_P_066_auto"
- */
-function toAutoRuleId(principleId: string): string {
-  return `R_${principleId}_auto`;
-}
-
-/**
- * Builds a single `if` branch for a pain pattern.
- *
- * SECURITY: Uses `new RegExp(JSON.stringify(...))` instead of regex literals
- * to prevent code injection through pathRegex/commandRegex/contentRegex values.
- * principleId in reason uses JSON.stringify to prevent string breakout.
+ * PRI-44: Pure template generation logic moved to core.
+ * This file re-exports for backward compatibility.
  */
-function buildBranch(principleId: string, pattern: PainPattern): string {
-  const conditions: string[] = [];
-
-  conditions.push(`input.action.toolName === ${JSON.stringify(pattern.toolName)}`);
-
-  if (pattern.pathRegex) {
-    conditions.push(`new RegExp(${JSON.stringify(pattern.pathRegex)}).test(input.action.normalizedPath || '')`);
-  }
-
-  if (pattern.commandRegex) {
-    conditions.push(`new RegExp(${JSON.stringify(pattern.commandRegex)}).test(input.action.paramsSummary.command || '')`);
-  }
-
-  if (pattern.contentRegex) {
-    conditions.push(
-      `new RegExp(${JSON.stringify(pattern.contentRegex)}).test(input.action.paramsSummary.content || input.action.paramsSummary.new_string || '')`,
-    );
-  }
-
-  const guard = conditions.join(' && ');
-  const reason = `[${principleId}] Blocked by auto-generated rule`;
-
-  return (
-    `  if (${guard}) {\n` +
-    `    return { decision: 'block', matched: true, reason: ${JSON.stringify(reason)} };\n` +
-    `  }`
-  );
-}
-
-/**
- * Generates sandbox-ready JS code from a principle ID and pain patterns.
- *
- * Returns `null` when `patterns` is empty.
- */
-export function generateFromTemplate(
-  principleId: string,
-  coversCondition: string,
-  patterns: PainPattern[],
-): string | null {
-  if (patterns.length === 0) {
-    return null;
-  }
-
-  const name = toAutoName(principleId);
-  const ruleId = toAutoRuleId(principleId);
-  const compiledAt = new Date().toISOString();
-
-  const branches = patterns
-    .map((p) => buildBranch(principleId, p))
-    .join('\n');
 
-  return (
-    `// Auto-generated by Principle Compiler\n` +
-    `export const meta = {\n` +
-    `  name: ${JSON.stringify(name)},\n` +
-    `  version: '1.0.0',\n` +
-    `  ruleId: ${JSON.stringify(ruleId)},\n` +
-    `  coversCondition: ${JSON.stringify(coversCondition)},\n` +
-    `  compiledAt: ${JSON.stringify(compiledAt)},\n` +
-    `  sourcePrincipleId: ${JSON.stringify(principleId)},\n` +
-    `};\n\n` +
-    `export function evaluate(input) {\n` +
-    `${branches}\n` +
-    `  return { matched: false };\n` +
-    `}\n`
-  );
-}
+export { generateFromTemplate, type PainPattern } from '@principles/core/runtime-v2';

package/src/core/principle-injection.ts

@@ -1,208 +1,16 @@
 /**
  * Principle Injection — Budget-Aware Principle Selection
- * ========================================================
  *
- * PURPOSE: Select principles for prompt injection within a character budget,
- * prioritizing by priority tier (P0 > P1 > P2) and recency, while ensuring
- * at least one P0 principle is included when available.
+ * Phase: PRI-75 Prompt Injection SDK Migration Phase 2
  *
- * DESIGN:
- *  - Sorts principles by priority (P0 first, then P1, then P2)
- *  - Within same priority, sorts by recency (createdAt descending)
- *  - Selects principles until the cumulative character budget is exceeded
- *  - Guarantees at least one P0 principle is included if any exist
- *  - Returns the selected principles and total character usage
- *
- * This replaces the previous hardcoded slice(-3)/slice(0,5) approach in
- * prompt.ts with a budget-aware, priority-respecting selection algorithm.
- */
-
-import type { PrinciplePriority } from '../types/principle-tree-schema.js';
-
-// ---------------------------------------------------------------------------
-// Types
-// ---------------------------------------------------------------------------
-
-/**
- * Minimal principle shape required for injection selection.
- * Accepts both evolution-types.Principle and principle-tree-schema.Principle.
- */
-export interface InjectablePrinciple {
-  id: string;
-  text: string;
-  /** Priority level. Defaults to 'P1' if not set by the source. */
-  priority?: PrinciplePriority;
-  createdAt: string;
-}
-
-/**
- * Result of principle selection for injection.
- */
-export interface PrincipleSelectionResult {
-  /** Selected principles in injection order (priority-first, then recency) */
-  selected: InjectablePrinciple[];
-  /** Total character count of selected principles' formatted output */
-  totalChars: number;
-  /** Number of principles by priority tier */
-  breakdown: {
-    p0: number;
-    p1: number;
-    p2: number;
-  };
-  /** Whether at least one P0 principle was included */
-  hasP0: boolean;
-  /** Whether the selection was truncated due to budget */
-  wasTruncated: boolean;
-}
-
-// ---------------------------------------------------------------------------
-// Priority Ordering
-// ---------------------------------------------------------------------------
-
-const PRIORITY_ORDER: Record<PrinciplePriority, number> = {
-  P0: 0,
-  P1: 1,
-  P2: 2,
-};
-
-/**
- * Compare two principles for sorting.
- * Primary: priority (P0 < P1 < P2 — lower is higher priority).
- * Secondary: recency (newer createdAt first).
- */
-function comparePrinciples(a: InjectablePrinciple, b: InjectablePrinciple): number {
-  const priorityA = PRIORITY_ORDER[a.priority ?? 'P1'] ?? 99;
-  const priorityB = PRIORITY_ORDER[b.priority ?? 'P1'] ?? 99;
-
-  if (priorityA !== priorityB) {
-    return priorityA - priorityB;
-  }
-
-  // Same priority: sort by recency (newer first)
-  return b.createdAt.localeCompare(a.createdAt);
-}
-
-// ---------------------------------------------------------------------------
-// Formatting
-// ---------------------------------------------------------------------------
-
-/**
- * Format a single principle for injection.
- * Returns the formatted string including ID and text.
- *
- * Format: "- [ID] text" (matches existing prompt.ts format)
+ * This file is now a thin re-export layer.
+ * All pure logic lives in @principles/core/prompt-builder/principle-selection.ts.
  */
-export function formatPrinciple(p: InjectablePrinciple): string {
-  return `- [${p.id}] ${p.text}`;
-}
 
-/**
- * Calculate the character length of a formatted principle, including newline.
- */
-function formattedLength(p: InjectablePrinciple): number {
-  return formatPrinciple(p).length + 1; // +1 for newline separator
-}
-
-// ---------------------------------------------------------------------------
-// Selection Algorithm
-// ---------------------------------------------------------------------------
-
-/**
- * Select principles for prompt injection within a character budget.
- *
- * Algorithm:
- *  1. Sort all principles by priority (P0 > P1 > P2), then by recency
- *  2. Iterate through sorted principles, accumulating character count
- *  3. Stop when adding the next principle would exceed budgetChars
- *  4. Ensure at least one P0 principle is included (even if it exceeds budget)
- *
- * @param principles - All available principles to select from
- * @param budgetChars - Maximum character budget for formatted output
- * @returns Selection result with chosen principles and metadata
- */
-export function selectPrinciplesForInjection(
-  principles: InjectablePrinciple[],
-  budgetChars: number,
-): PrincipleSelectionResult {
-  if (principles.length === 0) {
-    return {
-      selected: [],
-      totalChars: 0,
-      breakdown: { p0: 0, p1: 0, p2: 0 },
-      hasP0: false,
-      wasTruncated: false,
-    };
-  }
-
-  // Sort by priority then recency
-  const sorted = [...principles].sort(comparePrinciples);
-
-  const selected: InjectablePrinciple[] = [];
-  let totalChars = 0;
-  let p0Included = false;
-  let wasTruncated = false;
-
-  for (const principle of sorted) {
-    const cost = formattedLength(principle);
-
-    // Check if adding this principle would exceed budget
-    if (totalChars + cost > budgetChars) {
-      // Special case: if no P0 has been included yet, force-include the first P0
-      // even if it exceeds the budget (P0 principles are critical)
-      if (!p0Included && principle.priority === 'P0') {
-        selected.push(principle);
-        totalChars += cost;
-        p0Included = true;
-        wasTruncated = true;
-        // Continue to try to fit more principles after this forced inclusion
-        continue;
-      }
-
-      wasTruncated = true;
-      break;
-    }
-
-    selected.push(principle);
-    totalChars += cost;
-    if (principle.priority === 'P0') {
-      p0Included = true;
-    }
-  }
-
-  // Safety net: if we went through all principles and still no P0 included
-  // (because P0 was beyond budget threshold), force-include the first P0
-  if (!p0Included) {
-    const firstP0 = sorted.find(p => p.priority === 'P0');
-    if (firstP0 && !selected.includes(firstP0)) {
-      // Insert P0 at the beginning of selected (highest priority)
-      selected.unshift(firstP0);
-      totalChars += formattedLength(firstP0);
-      p0Included = true;
-    }
-  }
-
-  const breakdown = {
-    p0: selected.filter(p => (p.priority ?? 'P1') === 'P0').length,
-    p1: selected.filter(p => (p.priority ?? 'P1') === 'P1').length,
-    p2: selected.filter(p => (p.priority ?? 'P1') === 'P2').length,
-  };
-
-  return {
-    selected,
-    totalChars,
-    breakdown,
-    hasP0: p0Included,
-    wasTruncated,
-  };
-}
-
-// ---------------------------------------------------------------------------
-// Default Budget
-// ---------------------------------------------------------------------------
-
-/**
- * Default character budget for principle injection.
- * 4000 characters is ~800 tokens, leaving ample room for other prompt sections
- * within the 10K character injection limit.
- */
-export const DEFAULT_PRINCIPLE_BUDGET = 4000;
+// Re-exported from core for backward compatibility with existing imports
+export {
+  formatPrinciple,
+  selectPrinciplesForInjection,
+  DEFAULT_PRINCIPLE_BUDGET,
+} from '@principles/core/prompt-builder';
+export type { InjectablePrinciple, PrincipleSelectionResult } from '@principles/core/prompt-builder';

package/src/core/principle-internalization/filesystem-lifecycle-datasource.ts

@@ -0,0 +1,42 @@
+import type { LifecycleDatasource } from '@principles/core/runtime-v2';
+import type { LedgerTreeStore, ReplayReport, ArtifactLineageRecord } from '@principles/core/runtime-v2';
+import { loadLedger } from '../principle-tree-ledger.js';
+import { ReplayEngine } from '../replay-engine.js';
+
+export class LineageSourceRetiredError extends Error {
+  constructor() {
+    super(
+      'Artifact lineage source retired in PRI-230. ' +
+      'The nocturnal-artifact-lineage module has been deleted; ' +
+      'this datasource cannot provide lineage records. ' +
+      'Callers must handle this error explicitly rather than interpreting an empty result as "no lineage".'
+    );
+    this.name = 'LineageSourceRetiredError';
+  }
+}
+
+export class FilesystemLifecycleDatasource implements LifecycleDatasource {
+  private _engine?: ReplayEngine;
+
+  constructor(
+    private readonly workspaceDir: string,
+    private readonly stateDir: string,
+  ) {}
+
+  private get engine(): ReplayEngine {
+    if (!this._engine) this._engine = new ReplayEngine(this.workspaceDir, this.stateDir);
+    return this._engine;
+  }
+
+  loadLedger(): LedgerTreeStore {
+    return loadLedger(this.stateDir).tree as unknown as LedgerTreeStore;
+  }
+
+  listReplayReports(implementationId: string): ReplayReport[] {
+    return this.engine.listReports(implementationId);
+  }
+
+  listLineageRecords(_kind: 'behavioral-sample' | 'rule-implementation-candidate'): ArtifactLineageRecord[] {
+    throw new LineageSourceRetiredError();
+  }
+}

package/src/core/principle-internalization/lifecycle-read-model.ts

@@ -1,243 +1,40 @@
-import { loadLedger, type LedgerPrinciple, type LedgerRule } from '../principle-tree-ledger.js';
-import { listArtifactLineageRecords, type ArtifactLineageRecord } from '../nocturnal-artifact-lineage.js';
-import { ReplayEngine, type ClassificationSummary, type ReplayReport } from '../replay-engine.js';
-import type { Implementation, ImplementationLifecycleState } from '../../types/principle-tree-schema.js';
-
-export interface LifecycleClassificationTotals {
-  total: number;
-  passed: number;
-  failed: number;
-}
-
-export interface RuleReplayEvidence {
-  reportCount: number;
-  latestReports: ReplayReport[];
-  painNegative: LifecycleClassificationTotals;
-  successPositive: LifecycleClassificationTotals;
-  principleAnchor: LifecycleClassificationTotals;
-  passingImplementationIds: string[];
-  failingImplementationIds: string[];
-  needsReviewImplementationIds: string[];
-}
-
-export interface RuleLiveEvidence {
-  activeCount: number;
-  candidateCount: number;
-  disabledCount: number;
-  archivedCount: number;
-  durablePenaltyCount: number;
-  rollbackEvidenceCount: number;
-  hasActiveImplementation: boolean;
-  hasPassingActiveImplementation: boolean;
-}
-
-export interface RuleLineageEvidence {
-  records: ArtifactLineageRecord[];
-  distinctPainSignalCount: number;
-  distinctGateBlockCount: number;
-  repeatedErrorSignal: number;
-  latestCreatedAt?: string;
-}
-
-export interface ImplementationLifecycleEvidence {
-  implementation: Implementation;
-  latestReplayReport: ReplayReport | null;
-  replayHistoryCount: number;
-  lineageRecords: ArtifactLineageRecord[];
-}
-
-export interface RuleLifecycleEvidence {
-  rule: LedgerRule;
-  implementations: ImplementationLifecycleEvidence[];
-  replayEvidence: RuleReplayEvidence;
-  liveEvidence: RuleLiveEvidence;
-  lineageEvidence: RuleLineageEvidence;
-}
-
-export interface PrincipleLifecycleEvidence {
-  principle: LedgerPrinciple;
-  rules: RuleLifecycleEvidence[];
-  summary: {
-    replayReportCount: number;
-    activeImplementationCount: number;
-    candidateImplementationCount: number;
-    disabledImplementationCount: number;
-    archivedImplementationCount: number;
-    distinctPainSignalCount: number;
-    distinctGateBlockCount: number;
-    repeatedErrorSignal: number;
-  };
-}
-
-export interface LifecycleReadModel {
-  generatedAt: string;
-  principles: PrincipleLifecycleEvidence[];
-}
-
-function toClassificationTotals(summary: ClassificationSummary[]): LifecycleClassificationTotals {
-  return summary.reduce<LifecycleClassificationTotals>(
-    (totals, entry) => ({
-      total: totals.total + entry.total,
-      passed: totals.passed + entry.passed,
-      failed: totals.failed + entry.failed,
-    }),
-    { total: 0, passed: 0, failed: 0 },
-  );
-}
-
-function countByLifecycle(implementations: Implementation[], lifecycleState: ImplementationLifecycleState): number {
-  return implementations.filter((implementation) => implementation.lifecycleState === lifecycleState).length;
-}
-
-function hasDurablePenalty(implementation: Implementation): boolean {
-  if (implementation.lifecycleState === 'disabled' || implementation.lifecycleState === 'archived') {
-    return true;
-  }
-
-  return typeof implementation.disabledReason === 'string' && implementation.disabledReason.trim().length > 0;
-}
-
-function hasRollbackEvidence(implementation: Implementation): boolean {
-  return typeof implementation.previousActive === 'string' && implementation.previousActive.length > 0;
-}
-
-function createRuleReplayEvidence(reports: { implementationId: string; report: ReplayReport }[]): RuleReplayEvidence {
-  return {
-    reportCount: reports.length,
-    latestReports: reports.map((entry) => entry.report),
-    painNegative: toClassificationTotals(reports.map((entry) => entry.report.replayResults.painNegative)),
-    successPositive: toClassificationTotals(reports.map((entry) => entry.report.replayResults.successPositive)),
-    principleAnchor: toClassificationTotals(reports.map((entry) => entry.report.replayResults.principleAnchor)),
-    passingImplementationIds: reports
-      .filter((entry) => entry.report.overallDecision === 'pass')
-      .map((entry) => entry.implementationId),
-    failingImplementationIds: reports
-      .filter((entry) => entry.report.overallDecision === 'fail')
-      .map((entry) => entry.implementationId),
-    needsReviewImplementationIds: reports
-      .filter((entry) => entry.report.overallDecision === 'needs-review')
-      .map((entry) => entry.implementationId),
-  };
-}
-
-function createRuleLineageEvidence(records: ArtifactLineageRecord[]): RuleLineageEvidence {
-  const painIds = new Set<string>();
-  const gateBlockIds = new Set<string>();
-
-  for (const record of records) {
-    for (const painId of record.sourcePainIds) {
-      painIds.add(painId);
-    }
-    for (const gateBlockId of record.sourceGateBlockIds) {
-      gateBlockIds.add(gateBlockId);
-    }
-  }
-
-  const latestCreatedAt =
-    records.length > 0
-      ? records
-          .map((record) => record.createdAt)
-          .sort((left, right) => new Date(right).getTime() - new Date(left).getTime())[0]
-      : undefined;
-
-  return {
-    records,
-    distinctPainSignalCount: painIds.size,
-    distinctGateBlockCount: gateBlockIds.size,
-    repeatedErrorSignal: painIds.size + gateBlockIds.size,
-    latestCreatedAt,
-  };
-}
-
-function createRuleLiveEvidence(
-  implementations: Implementation[],
-  replayEvidence: RuleReplayEvidence,
-): RuleLiveEvidence {
-  const activeImplementations = implementations.filter((implementation) => implementation.lifecycleState === 'active');
-
-  return {
-    activeCount: countByLifecycle(implementations, 'active'),
-    candidateCount: countByLifecycle(implementations, 'candidate'),
-    disabledCount: countByLifecycle(implementations, 'disabled'),
-    archivedCount: countByLifecycle(implementations, 'archived'),
-    durablePenaltyCount: implementations.filter((implementation) => hasDurablePenalty(implementation)).length,
-    rollbackEvidenceCount: implementations.filter((implementation) => hasRollbackEvidence(implementation)).length,
-    hasActiveImplementation: activeImplementations.length > 0,
-    hasPassingActiveImplementation: activeImplementations.some((implementation) =>
-      replayEvidence.passingImplementationIds.includes(implementation.id),
-    ),
-  };
-}
-
-export function buildLifecycleReadModel(workspaceDir: string, stateDir: string): LifecycleReadModel {
-  const ledger = loadLedger(stateDir);
-  const replayEngine = new ReplayEngine(workspaceDir, stateDir);
-  const lineageRecords = listArtifactLineageRecords(workspaceDir, 'rule-implementation-candidate');
-
-  const principles = Object.values(ledger.tree.principles)
-    .map((principle): PrincipleLifecycleEvidence => {
-      const rules = principle.ruleIds
-        .map((ruleId) => ledger.tree.rules[ruleId])
-        .filter((rule): rule is LedgerRule => rule !== undefined)
-        .map((rule): RuleLifecycleEvidence => {
-          const implementations = rule.implementationIds
-            .map((implementationId) => ledger.tree.implementations[implementationId])
-            .filter((implementation): implementation is Implementation => implementation !== undefined);
-
-          const implementationEvidence: ImplementationLifecycleEvidence[] = implementations.map((implementation) => {
-            const reports = replayEngine.listReports(implementation.id);
-            const implementationLineage = lineageRecords.filter(
-              (record) => record.ruleId === rule.id || record.implementationId === implementation.id,
-            );
-
-            return {
-              implementation,
-              latestReplayReport: reports[0] ?? null,
-              replayHistoryCount: reports.length,
-              lineageRecords: implementationLineage,
-            };
-          });
-
-          const replayEvidence = createRuleReplayEvidence(
-            implementationEvidence
-              .filter((entry) => entry.latestReplayReport !== null)
-              .map((entry) => ({
-                implementationId: entry.implementation.id,
-                report: entry.latestReplayReport as ReplayReport,
-              })),
-          );
-          const ruleLineageRecords = lineageRecords.filter((record) => record.ruleId === rule.id);
-          const lineageEvidence = createRuleLineageEvidence(ruleLineageRecords);
-          const liveEvidence = createRuleLiveEvidence(implementations, replayEvidence);
-
-          return {
-            rule,
-            implementations: implementationEvidence,
-            replayEvidence,
-            liveEvidence,
-            lineageEvidence,
-          };
-        });
-
-      return {
-        principle,
-        rules,
-        summary: {
-          replayReportCount: rules.reduce((sum, rule) => sum + rule.replayEvidence.reportCount, 0),
-          activeImplementationCount: rules.reduce((sum, rule) => sum + rule.liveEvidence.activeCount, 0),
-          candidateImplementationCount: rules.reduce((sum, rule) => sum + rule.liveEvidence.candidateCount, 0),
-          disabledImplementationCount: rules.reduce((sum, rule) => sum + rule.liveEvidence.disabledCount, 0),
-          archivedImplementationCount: rules.reduce((sum, rule) => sum + rule.liveEvidence.archivedCount, 0),
-          distinctPainSignalCount: rules.reduce((sum, rule) => sum + rule.lineageEvidence.distinctPainSignalCount, 0),
-          distinctGateBlockCount: rules.reduce((sum, rule) => sum + rule.lineageEvidence.distinctGateBlockCount, 0),
-          repeatedErrorSignal: rules.reduce((sum, rule) => sum + rule.lineageEvidence.repeatedErrorSignal, 0),
-        },
-      };
-    })
-    .sort((left, right) => left.principle.id.localeCompare(right.principle.id));
-
-  return {
-    generatedAt: new Date().toISOString(),
-    principles,
-  };
+/**
+ * Lifecycle read model — re-export facade (PRI-56).
+ *
+ * All computation lives in @principles/core/runtime-v2.
+ * This file re-exports types, the core builder, and provides
+ * a backward-compatible path-based wrapper for existing consumers.
+ */
+
+// Re-export lifecycle types from core (PRI-51)
+export type {
+  LifecycleClassificationTotals,
+  RuleReplayEvidence,
+  RuleLiveEvidence,
+  RuleLineageEvidence,
+  ImplementationLifecycleEvidence,
+  RuleLifecycleEvidence,
+  PrincipleLifecycleEvidence,
+  LifecycleReadModel,
+} from '@principles/core/runtime-v2';
+
+// Re-export core builder (PRI-56)
+export { buildLifecycleReadModel } from '@principles/core/runtime-v2';
+
+// Re-export adapter interface (PRI-56)
+export type { LifecycleDatasource } from '@principles/core/runtime-v2';
+
+// Re-export filesystem implementation (PRI-56)
+export { FilesystemLifecycleDatasource, LineageSourceRetiredError } from './filesystem-lifecycle-datasource.js';
+
+import { buildLifecycleReadModel } from '@principles/core/runtime-v2';
+import { FilesystemLifecycleDatasource } from './filesystem-lifecycle-datasource.js';
+
+/**
+ * Backward-compatible wrapper — accepts directory paths like the original API.
+ * Existing consumers (lifecycle-refresh, evolution-status, nocturnal-service)
+ * continue using this without changes.
+ */
+export function buildLifecycleReadModelFromPaths(workspaceDir: string, stateDir: string) {
+  return buildLifecycleReadModel(new FilesystemLifecycleDatasource(workspaceDir, stateDir));
 }