principles-disciple 1.126.0 → 1.128.0

package/src/config/errors.ts

@@ -1,180 +0,0 @@
-/**
- * Domain-Specific Errors for Principles Disciple
- *
- * These errors provide semantic meaning to failure modes,
- * making it easier to distinguish between:
- * - Lock contention (resource busy)
- * - Parse/validation failures
- * - Derived state mismatches
- * - Configuration issues
- */
-
-import type { PDErrorCategory } from '@principles/core';
-
-/** Maps legacy PdError codes to canonical PDErrorCategory values. */
-const codeToCategory: Record<string, PDErrorCategory> = {
-  LOCK_UNAVAILABLE: 'lease_conflict',
-  PATH_RESOLUTION_ERROR: 'workspace_invalid',
-  WORKSPACE_NOT_FOUND: 'workspace_invalid',
-  SAMPLE_NOT_FOUND: 'storage_unavailable',
-  CONFIGURATION_ERROR: 'input_invalid',
-  DEPENDENCY_ERROR: 'runtime_unavailable',
-  EVOLUTION_PROCESSING_ERROR: 'execution_failed',
-  TRAJECTORY_ERROR: 'storage_unavailable',
-};
-
-/**
- * Base class for all Principles Disciple errors
- */
-export class PdError extends Error {
-  readonly category: PDErrorCategory;
-
-  constructor(
-    message: string,
-    public readonly code: string,
-    options?: { cause?: unknown }
-  ) {
-    super(message, options);
-    this.name = 'PdError';
-    this.category = codeToCategory[code] ?? 'execution_failed';
-  }
-}
-
-/**
- * Thrown when a resource lock cannot be acquired
- * (e.g., queue, trajectory, evolution file)
- */
-export class LockUnavailableError extends PdError {
-  constructor(
-    resource: string,
-    scope: string,
-    options?: { cause?: unknown }
-  ) {
-    super(
-      `[PD:Lock] ${scope}: queue lock unavailable for ${resource}`,
-      'LOCK_UNAVAILABLE',
-      options
-    );
-    this.name = 'LockUnavailableError';
-  }
-}
-
-/**
- * Thrown when a path key cannot be resolved
- */
-export class PathResolutionError extends PdError {
-  constructor(
-    key: string,
-    options?: { cause?: unknown }
-  ) {
-    super(
-      `[PD:Path] Unknown path key: ${key}`,
-      'PATH_RESOLUTION_ERROR',
-      options
-    );
-    this.name = 'PathResolutionError';
-  }
-}
-
-/**
- * Thrown when a workspace cannot be found
- */
-export class WorkspaceNotFoundError extends PdError {
-  constructor(
-    workspace: string,
-    options?: { cause?: unknown }
-  ) {
-    super(
-      `[PD:Workspace] Workspace not found: ${workspace}`,
-      'WORKSPACE_NOT_FOUND',
-      options
-    );
-    this.name = 'WorkspaceNotFoundError';
-  }
-}
-
-/**
- * Thrown when a required sample cannot be found
- */
-export class SampleNotFoundError extends PdError {
-  constructor(
-    sampleId: string,
-    options?: { cause?: unknown }
-  ) {
-    super(
-      `[PD:Sample] Correction sample not found: ${sampleId}`,
-      'SAMPLE_NOT_FOUND',
-      options
-    );
-    this.name = 'SampleNotFoundError';
-  }
-}
-
-/**
- * Thrown when configuration is invalid or missing required fields
- */
-export class ConfigurationError extends PdError {
-  constructor(
-    message: string,
-    options?: { cause?: unknown }
-  ) {
-    super(
-      `[PD:Config] ${message}`,
-      'CONFIGURATION_ERROR',
-      options
-    );
-    this.name = 'ConfigurationError';
-  }
-}
-
-/**
- * Thrown when prompt/logger dependencies are unavailable
- */
-export class DependencyError extends PdError {
-  constructor(
-    component: string,
-    message: string,
-    options?: { cause?: unknown }
-  ) {
-    super(
-      `[PD:${component}] ${message}`,
-      'DEPENDENCY_ERROR',
-      options
-    );
-    this.name = 'DependencyError';
-  }
-}
-
-/**
- * Thrown when evolution worker encounters a processing error
- */
-export class EvolutionProcessingError extends PdError {
-  constructor(
-    message: string,
-    options?: { cause?: unknown }
-  ) {
-    super(
-      `[PD:Evolution] ${message}`,
-      'EVOLUTION_PROCESSING_ERROR',
-      options
-    );
-    this.name = 'EvolutionProcessingError';
-  }
-}
-
-/**
- * Thrown when trajectory operations fail
- */
-export class TrajectoryError extends PdError {
-  constructor(
-    message: string,
-    options?: { cause?: unknown }
-  ) {
-    super(
-      `[PD:Trajectory] ${message}`,
-      'TRAJECTORY_ERROR',
-      options
-    );
-    this.name = 'TrajectoryError';
-  }
-}

package/src/constants/tools.ts

@@ -1,62 +0,0 @@
-export const READ_ONLY_TOOL_NAMES = [
-  'read', 'read_file', 'read_many_files', 'image_read',
-  'search_file_content', 'grep', 'grep_search', 'list_directory', 'ls', 'glob',
-  'lsp_hover', 'lsp_goto_definition', 'lsp_find_references',
-  'web_fetch', 'web_search', 'ref_search_documentation', 'ref_read_url',
-  'resolve-library-id', 'get-library-docs',
-  'memory_recall', 'save_memory', 'todo_read', 'todo_write',
-  'ask_user', 'ask_user_question',
-  'pd-status', 'report',
-] as const;
-
-export const LOW_RISK_WRITE_TOOL_NAMES = [
-  'write', 'write_file',
-  'edit', 'edit_file', 'replace', 'apply_patch', 'insert', 'patch',
-] as const;
-
-// BASH aliases must be defined before HIGH_RISK_TOOL_NAMES
-export const BASH_TOOL_NAMES = [
-  'bash', 'run_shell_command', 'exec', 'execute', 'shell', 'cmd',
-] as const;
-
-export const HIGH_RISK_TOOL_NAMES = [
-  'delete_file', 'move_file',
-  // Include all BASH aliases for consistent high-risk classification
-  ...BASH_TOOL_NAMES,
-] as const;
-
-export const AGENT_TOOL_NAMES = [
-  'sessions_spawn',
-] as const;
-
-export const CONTENT_LIMITED_TOOL_NAMES = [
-  ...LOW_RISK_WRITE_TOOL_NAMES,
-] as const;
-
-export const CONSTRUCTIVE_TOOL_NAMES = [
-  ...LOW_RISK_WRITE_TOOL_NAMES,
-  'delete_file', 'move_file',
-  // Include all BASH aliases for consistent constructive classification
-  ...BASH_TOOL_NAMES,
-  ...AGENT_TOOL_NAMES,
-  'evolve-task', 'init-strategy',
-] as const;
-
-export const EXPLORATORY_TOOL_NAMES = [
-  ...READ_ONLY_TOOL_NAMES,
-] as const;
-
-export const READ_ONLY_TOOLS = new Set<string>(READ_ONLY_TOOL_NAMES);
-export const LOW_RISK_WRITE_TOOLS = new Set<string>(LOW_RISK_WRITE_TOOL_NAMES);
-export const HIGH_RISK_TOOLS = new Set<string>(HIGH_RISK_TOOL_NAMES);
-export const BASH_TOOLS_SET = new Set<string>(BASH_TOOL_NAMES);
-export const AGENT_TOOLS = new Set<string>(AGENT_TOOL_NAMES);
-export const CONTENT_LIMITED_TOOLS = new Set<string>(CONTENT_LIMITED_TOOL_NAMES);
-export const CONSTRUCTIVE_TOOLS = new Set<string>(CONSTRUCTIVE_TOOL_NAMES);
-export const EXPLORATORY_TOOLS = new Set<string>(EXPLORATORY_TOOL_NAMES);
-export const WRITE_TOOLS = new Set<string>([
-  ...LOW_RISK_WRITE_TOOL_NAMES,
-  'delete_file',
-  'move_file',
-]);
-

package/src/core/AGENTS.md

@@ -1,34 +0,0 @@
-# src/core/ — Domain Core
-
-**27 TypeScript files.** Trust engine, evolution pipeline, pain calculation, config, trajectory DB, event log, hygiene tracking.
-
-## WHERE TO LOOK
-
-| Task | File | Notes |
-|------|------|-------|
-| Trust permissions | `trust-engine.ts` | 4-stage model, score floor=30, cold-start grace |
-| Evolution points | `evolution-engine.ts` | 5-tier EP system (Seed→Forest), double-reward after recovery |
-| Principle lifecycle | `evolution-reducer.ts` | Event sourcing → `evolution.jsonl` stream |
-| Pain scoring | `pain.ts` | Tool failures + gate blocks → pain score |
-| Config management | `config.ts`, `config-service.ts` | PainConfig, dot-notation `get()`, singleton factory |
-| Trajectory analytics | `trajectory.ts` | SQLite (better-sqlite3), sessions/turns/tool_calls |
-| Event logging | `event-log.ts` | JSONL buffered writes (20 entries or 30s flush) |
-| Pain patterns | `dictionary.ts`, `dictionary-service.ts` | Regex + exact_match rules |
-| Detection funnel | `detection-funnel.ts`, `detection-service.ts` | Text input queue |
-| Session state | `session-tracker.ts` | GFI, token usage, stuck loop detection |
-| Central facade | `workspace-context.ts` | `WorkspaceContext.fromHookContext(ctx)` — all services flow through here |
-| Path resolution | `paths.ts`, `path-resolver.ts` | `api.resolvePath()` is the only compliant entry |
-
-## CONVENTIONS
-
-- **Singleton factory**: `XxxService.get(stateDir)` — cached per stateDir
-- **WorkspaceContext facade**: lazy-initializes config, trust, eventLog, dictionary, hygiene, evolutionReducer, trajectory
-- **Event sourcing**: EvolutionReducerImpl appends events → in-memory state update
-- **File locking**: `withLock()` / `withLockAsync()` for critical state (evolution, trajectory, trust)
-- **Buffered flush**: EventLog batches 20 entries or flushes every 30s
-
-## ANTI-PATTERNS
-
-- ❌ Never bypass WorkspaceContext — always go through the facade
-- ❌ Never write to `.state/` files directly — use the service layer
-- ❌ Never hardcode paths — use `paths.ts` / `path-resolver.ts`

package/src/core/__tests__/focus-history.test.ts

@@ -1,210 +0,0 @@
-import { describe, it, expect, beforeEach, afterEach } from 'vitest';
-import * as fs from 'fs';
-import * as path from 'path';
-import * as os from 'os';
-import { autoCompressFocus, cleanupStaleInfo } from '../focus-history.js';
-
-function makeFocusContent(artifactRows: string[], extraLines = 0): string {
-  const lines: string[] = [
-    '# CURRENT_FOCUS',
-    '',
-    '**版本**: v1',
-    '**更新**: 2026-05-09',
-    '',
-    '## 📍 状态快照',
-    '',
-    '当前聚焦于核心功能开发。',
-    '',
-    '## 🔄 当前任务',
-    '',
-    '- [ ] 实现新功能',
-    '- [ ] 修复已知问题',
-    '- [ ] 完善测试覆盖',
-    '',
-    '## ➡️ 下一步',
-    '',
-    '1. 完成 PRI-82 E2E 测试',
-    '2. 提交代码审查',
-    '',
-    '## 🧠 Working Memory',
-    '',
-    '> Last updated: 2026-05-09T12:00:00Z',
-    '',
-    '### 📁 文件输出记录',
-    '',
-    '| 文件路径 | 操作 | 描述 |',
-    '|----------|------|------|',
-  ];
-
-  for (const row of artifactRows) {
-    lines.push(row);
-  }
-
-  lines.push('');
-  lines.push('### ⚠️ 活动问题');
-  lines.push('- 测试覆盖不足 → 增加E2E测试');
-  lines.push('');
-  lines.push('### ➡️ 下一步行动');
-  lines.push('1. 完成回归测试');
-  lines.push('2. 提交PR');
-  lines.push('');
-
-  for (let i = 0; i < extraLines; i++) {
-    lines.push(`<!-- padding line ${i} -->`);
-  }
-
-  return lines.join('\n');
-}
-
-describe('autoCompressFocus E2E regression (PRI-82)', () => {
-  let tmpDir: string;
-  let workspaceDir: string;
-  let stateDir: string;
-  let focusPath: string;
-
-  beforeEach(() => {
-    tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'pd-focus-e2e-'));
-    workspaceDir = tmpDir;
-    stateDir = path.join(tmpDir, '.state');
-    fs.mkdirSync(stateDir, { recursive: true });
-
-    const focusDir = path.join(tmpDir, 'okr');
-    fs.mkdirSync(focusDir, { recursive: true });
-    focusPath = path.join(focusDir, 'CURRENT_FOCUS.md');
-  });
-
-  afterEach(() => {
-    fs.rmSync(tmpDir, { recursive: true, force: true });
-  });
-
-  it('removes missing-file artifact rows via filesystem filtering before core compression', () => {
-    const existingFile = path.join(workspaceDir, 'src', 'existing-module.ts');
-
-    fs.mkdirSync(path.join(workspaceDir, 'src'), { recursive: true });
-    fs.writeFileSync(existingFile, 'export const x = 1;');
-
-    const existingRow = '| `src/existing-module.ts` | modified | 核心模块 |';
-    const missingRow = '| `src/deleted-module.ts` | modified | 已删除模块 |';
-
-    const content = makeFocusContent([existingRow, missingRow], 90);
-
-    fs.writeFileSync(focusPath, content);
-
-    const result = autoCompressFocus(focusPath, workspaceDir, stateDir);
-
-    expect(result.compressed).toBe(true);
-    expect(result.newContent).toBeDefined();
-
-    expect(result.newContent!).not.toContain('deleted-module.ts');
-
-    expect(result.newLines).toBeLessThan(result.oldLines);
-
-    expect(result.reason).toContain('Auto-compressed');
-  });
-
-  it('goes through core compressFocusContent path when threshold is exceeded', () => {
-    const content = makeFocusContent([
-      '| `src/utils.ts` | created | 工具函数 |',
-    ], 90);
-
-    fs.writeFileSync(focusPath, content);
-
-    const result = autoCompressFocus(focusPath, workspaceDir, stateDir);
-
-    expect(result.compressed).toBe(true);
-
-    expect(result.reason).toContain('Auto-compressed');
-
-    const writtenContent = fs.readFileSync(focusPath, 'utf-8');
-    expect(writtenContent).not.toBe(content);
-    expect(writtenContent.split('\n').length).toBeLessThan(content.split('\n').length);
-  });
-
-  it('does not compress when below threshold', () => {
-    const content = makeFocusContent([
-      '| `src/utils.ts` | created | 工具函数 |',
-    ], 0);
-
-    fs.writeFileSync(focusPath, content);
-
-    const result = autoCompressFocus(focusPath, workspaceDir, stateDir);
-
-    expect(result.compressed).toBe(false);
-    expect(result.reason).toBe('Below threshold');
-  });
-
-  it('creates backup in history when compressing', () => {
-    const content = makeFocusContent([
-      '| `src/utils.ts` | created | 工具函数 |',
-    ], 90);
-
-    fs.writeFileSync(focusPath, content);
-
-    const result = autoCompressFocus(focusPath, workspaceDir, stateDir);
-
-    expect(result.compressed).toBe(true);
-    expect(result.backupPath).not.toBeNull();
-
-    const historyDir = path.join(path.dirname(focusPath), '.history');
-    expect(fs.existsSync(historyDir)).toBe(true);
-
-    const historyFiles = fs.readdirSync(historyDir).filter(f => f.startsWith('CURRENT_FOCUS.v'));
-    expect(historyFiles.length).toBeGreaterThanOrEqual(1);
-  });
-
-  it('handles workspace without existing files gracefully', () => {
-    const content = makeFocusContent([
-      '| `src/ghost-file.ts` | modified | 不存在的文件 |',
-    ], 90);
-
-    fs.writeFileSync(focusPath, content);
-
-    const result = autoCompressFocus(focusPath, workspaceDir, stateDir);
-
-    expect(result.compressed).toBe(true);
-
-    expect(result.newContent!).not.toContain('ghost-file.ts');
-  });
-});
-
-describe('cleanupStaleInfo filesystem filtering (PRI-82)', () => {
-  let tmpDir: string;
-  let workspaceDir: string;
-
-  beforeEach(() => {
-    tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'pd-cleanup-'));
-    workspaceDir = tmpDir;
-  });
-
-  afterEach(() => {
-    fs.rmSync(tmpDir, { recursive: true, force: true });
-  });
-
-  it('preserves artifact row for existing file and removes row for missing file', () => {
-    const existingFile = path.join(workspaceDir, 'src', 'real.ts');
-    fs.mkdirSync(path.join(workspaceDir, 'src'), { recursive: true });
-    fs.writeFileSync(existingFile, 'export const a = 1;');
-
-    const content = makeFocusContent([
-      '| `src/real.ts` | modified | 真实文件 |',
-      '| `src/phantom.ts` | modified | 幽灵文件 |',
-    ], 0);
-
-    const result = cleanupStaleInfo(content, workspaceDir);
-
-    expect(result).toContain('real.ts');
-    expect(result).not.toContain('phantom.ts');
-  });
-
-  it('preserves all artifact rows when no workspaceDir provided', () => {
-    const content = makeFocusContent([
-      '| `src/real.ts` | modified | 真实文件 |',
-      '| `src/phantom.ts` | modified | 幽灵文件 |',
-    ], 0);
-
-    const result = cleanupStaleInfo(content);
-
-    expect(result).toContain('real.ts');
-    expect(result).toContain('phantom.ts');
-  });
-});

package/src/core/bootstrap-rules.ts

@@ -1,216 +0,0 @@
-/**
- * Minimal Rule Bootstrap (Phase 17)
- *
- * Bootstraps 1-3 stub Rule entities for high-value deterministic principles.
- * Selected by: observedViolationCount (descending) + evaluability=deterministic.
- * Falls back to all deterministic principles if violation data is sparse.
- *
- * Rule ID format: {principleId}_stub_bootstrap
- * Scope: BOOT-03 — bounded, no mass migration, no implementations.
- *
- * Usage:
- *   npx vitest run tests/core/bootstrap-rules.test.ts   (tests)
- *   npm run bootstrap-rules                               (production)
- */
-
-import { loadLedger, createRule, updatePrinciple, addPrincipleToLedger } from './principle-tree-ledger.js';
-import type { LedgerPrinciple } from './principle-tree-ledger.js';
-import { loadStore } from './principle-training-state.js';
-import { CORE_THINKING_MODELS } from './init.js';
-
-export interface BootstrapResult {
-  principleId: string;
-  ruleId: string;
-  status: 'created' | 'skipped';
-}
-
-/**
- * Select principles for bootstrap based on violation count and evaluability.
- *
- * @param stateDir - State directory path
- * @param limit - Maximum number of principles to select (default: 3)
- * @returns Array of principle IDs sorted by observedViolationCount (descending)
- * @throws Error if no deterministic principles found
- */
-export function selectPrinciplesForBootstrap(stateDir: string, limit = 3): string[] {
-  // Load training store to get evaluability and violation data
-  const store = loadStore(stateDir);
-
-  // Filter for deterministic principles only
-  const deterministicEntries = Object.values(store).filter(
-    (entry) => entry.evaluability === 'deterministic'
-  );
-
-  if (deterministicEntries.length === 0) {
-    throw new Error('No deterministic principles found in training store');
-  }
-
-  // Sort by observedViolationCount descending, then by principleId for tiebreaker
-  const sorted = deterministicEntries.sort((a, b) => {
-    const violationDiff = b.observedViolationCount - a.observedViolationCount;
-    if (violationDiff !== 0) {
-      return violationDiff;
-    }
-    // Alphabetical tiebreaker
-    return a.principleId.localeCompare(b.principleId);
-  });
-
-  // Check if we have sparse violation data (all zeros or very low)
-  const hasViolations = sorted.some((entry) => entry.observedViolationCount > 0);
-  if (!hasViolations) {
-    // Log warning and use all deterministic principles
-    console.warn('[bootstrap] No violation data found, using all deterministic principles');
-  }
-
-  // Return top N
-  return sorted.slice(0, limit).map((entry) => entry.principleId);
-}
-
-/**
- * Bootstrap stub rules for selected principles.
- *
- * Creates stub Rule entities with format {principleId}_stub_bootstrap.
- * Links rules to principles via suggestedRules array.
- * Idempotent: skips existing rules.
- *
- * @param stateDir - State directory path
- * @param limit - Maximum number of principles to bootstrap (default: 3)
- * @returns Array of results indicating created or skipped status
- * @throws Error if no deterministic principles found
- */
-export function bootstrapRules(stateDir: string, limit = 3): BootstrapResult[] {
-  // Migration: if T-01..T-10 exist in Training Store but not in Ledger Tree, backfill.
-  // This handles workspaces initialized before Ledger Tree was added.
-  const store = loadStore(stateDir);
-  let ledger = loadLedger(stateDir);
-  const hasTrainingT = Object.keys(store).some((id) => id.startsWith('T-'));
-  const hasAnyLedgerT = Object.keys(ledger.tree.principles).some((id) => id.startsWith('T-'));
-  if (hasTrainingT && !hasAnyLedgerT) {
-    console.warn('[bootstrap] Migrating T-01..T-10 from Training Store to Ledger Tree');
-    const now = new Date().toISOString();
-    for (const [id, entry] of Object.entries(store)) {
-      if (!id.startsWith('T-')) continue;
-      const model = CORE_THINKING_MODELS.find((m) => m.id === id);
-      if (!model) continue;
-      const lp: LedgerPrinciple = {
-        id,
-        version: 1,
-        text: model.description,
-        coreAxiomId: id,
-        triggerPattern: '',
-        action: '',
-        status: 'active',
-        priority: 'P1',
-        scope: 'general',
-        evaluability: entry.evaluability,
-        valueScore: 0,
-        adherenceRate: 0,
-        painPreventedCount: 0,
-        derivedFromPainIds: [],
-        ruleIds: [],
-        conflictsWithPrincipleIds: [],
-        createdAt: now,
-        updatedAt: now,
-        suggestedRules: [],
-      };
-      addPrincipleToLedger(stateDir, lp);
-    }
-    // Reload ledger after migration so subsequent reads see the new data.
-    ledger = loadLedger(stateDir);
-  }
-
-  // Select principles for bootstrap
-  const selectedPrincipleIds = selectPrinciplesForBootstrap(stateDir, limit);
-
-  const results: BootstrapResult[] = [];
-
-  for (const principleId of selectedPrincipleIds) {
-    // Verify principle exists in ledger
-    const principle = ledger.tree.principles[principleId];
-    if (!principle) {
-      throw new Error(`Principle ${principleId} not found in ledger tree`);
-    }
-
-    // Compute rule ID
-    const ruleId = `${principleId}_stub_bootstrap`;
-
-    // Check if rule already exists
-    if (ledger.tree.rules[ruleId]) {
-      results.push({
-        principleId,
-        ruleId,
-        status: 'skipped',
-      });
-      continue;
-    }
-
-    // Create stub rule
-    const now = new Date().toISOString();
-    createRule(stateDir, {
-      id: ruleId,
-      version: 1,
-      name: `Stub bootstrap rule for ${principleId}`,
-      description: `Placeholder rule for principle-internalization bootstrap`,
-      type: 'hook',
-      triggerCondition: 'stub: bootstrap placeholder',
-      enforcement: 'warn',
-      action: 'allow (stub)',
-      principleId,
-      status: 'proposed',
-      coverageRate: 0,
-      falsePositiveRate: 0,
-      implementationIds: [],
-      createdAt: now,
-      updatedAt: now,
-    });
-
-    // Link rule to principle via suggestedRules
-    const existingSuggested = principle.suggestedRules || [];
-    updatePrinciple(stateDir, principleId, {
-      suggestedRules: [...existingSuggested, ruleId],
-    });
-
-    results.push({
-      principleId,
-      ruleId,
-      status: 'created',
-    });
-  }
-
-  return results;
-}
-
-/**
- * Validate that bootstrapped state is correct.
- *
- * @param stateDir - State directory path
- * @param expectedPrincipleIds - Principle IDs that should be bootstrapped
- * @returns true if validation passes
- * @throws Error if validation fails
- */
-export function validateBootstrap(stateDir: string, expectedPrincipleIds: string[]): boolean {
-  const ledger = loadLedger(stateDir);
-
-  for (const principleId of expectedPrincipleIds) {
-    // Verify principle exists
-    const principle = ledger.tree.principles[principleId];
-    if (!principle) {
-      throw new Error(`Principle ${principleId} not found in ledger tree`);
-    }
-
-    // Verify suggestedRules exists and is not empty
-    if (!principle.suggestedRules || principle.suggestedRules.length === 0) {
-      throw new Error(`Principle ${principleId} has empty or missing suggestedRules`);
-    }
-
-    // Verify each suggested rule exists in ledger
-    for (const ruleId of principle.suggestedRules) {
-      const rule = ledger.tree.rules[ruleId];
-      if (!rule) {
-        throw new Error(`Rule ${ruleId} referenced by principle ${principleId} not found in ledger`);
-      }
-    }
-  }
-
-  return true;
-}